From 567a944d6f3a08e000d746a032953a6777f8da06 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 11:09:17 -0500 Subject: [PATCH 01/16] Code organization Turning AirBNB lint and Babel on Webpack DEV enhanced Tempo function draft --- .eslintrc | 23 + dist/app.css | 555 + dist/app.css.map | 1 + .../audio/acoustic => dist/audio}/hihat1.mp3 | Bin .../audio/acoustic => dist/audio}/hihat2.mp3 | Bin .../acoustic => dist/audio}/hihat_open1.mp3 | Bin .../acoustic => dist/audio}/hihat_open2.mp3 | Bin .../acoustic => dist/audio}/hihat_open3.mp3 | Bin .../audio/acoustic => dist/audio}/kick1.mp3 | Bin .../audio/acoustic => dist/audio}/kick2.mp3 | Bin .../audio/acoustic => dist/audio}/kick3.mp3 | Bin .../audio/acoustic => dist/audio}/rim1.mp3 | Bin .../audio/acoustic => dist/audio}/snare1.mp3 | Bin .../audio/acoustic => dist/audio}/snare2.mp3 | Bin .../audio/acoustic => dist/audio}/snare3.mp3 | Bin dist/img/logo.svg | 27 + dist/index.html | 32 + dist/slang.app.js | 47832 ++++++++++++++++ dist/slang.app.js.map | 1 + helpers/drumMap.js | 52 - package-lock.json | 2491 +- package.json | 14 +- packing/server.js | 41 + packing/webpack.config.js | 135 + webpack.prod.js => packing/webpack.prod.js | 2 +- public/index.html | 60 - {classes => src/classes}/ADSR.js | 0 {classes => src/classes}/Block.js | 0 {classes => src/classes}/Delay.js | 0 {classes => src/classes}/Drums.js | 0 {classes => src/classes}/Filter.js | 0 {classes => src/classes}/Gain.js | 0 {classes => src/classes}/Osc.js | 0 {classes => src/classes}/Pan.js | 0 {classes => src/classes}/PolyBlock.js | 0 {classes => src/classes}/Scheduler.js | 0 {classes => src/classes}/Sound.js | 0 {classes => src/classes}/classMap.js | 0 editor.js => src/editor.js | 10 +- {functions => src/functions}/FunctionCall.js | 0 {functions => src/functions}/chord.js | 0 {functions => src/functions}/flatten.js | 0 {functions => src/functions}/index.js | 0 {functions => src/functions}/interpolate.js | 0 {functions => src/functions}/random.js | 0 {functions => src/functions}/repeat.js | 0 {functions => src/functions}/reverse.js | 0 {functions => src/functions}/shuffle.js | 0 {functions => src/functions}/transpose.js | 0 {helpers => src/helpers}/BufferLoader.js | 0 {helpers => src/helpers}/FunctionCall.js | 0 {helpers => src/helpers}/List.js | 0 {helpers => src/helpers}/context.js | 0 src/helpers/drumMap.js | 65 + {helpers => src/helpers}/mtof.js | 0 {helpers => src/helpers}/parseArguments.js | 0 {helpers => src/helpers}/tuna.js | 0 runtime.js => src/runtime.js | 0 slang-grammar.js => src/slang-grammar.js | 12 +- slang.js => src/slang.js | 8 +- slang.ohm => src/slang.ohm | 12 +- src/static/audio/acoustic/hihat1.mp3 | Bin 0 -> 21342 bytes src/static/audio/acoustic/hihat2.mp3 | Bin 0 -> 19358 bytes src/static/audio/acoustic/hihat_open1.mp3 | Bin 0 -> 21445 bytes src/static/audio/acoustic/hihat_open2.mp3 | Bin 0 -> 26562 bytes src/static/audio/acoustic/hihat_open3.mp3 | Bin 0 -> 53361 bytes src/static/audio/acoustic/kick1.mp3 | Bin 0 -> 17165 bytes src/static/audio/acoustic/kick2.mp3 | Bin 0 -> 20555 bytes src/static/audio/acoustic/kick3.mp3 | Bin 0 -> 26609 bytes src/static/audio/acoustic/rim1.mp3 | Bin 0 -> 26113 bytes src/static/audio/acoustic/snare1.mp3 | Bin 0 -> 20142 bytes src/static/audio/acoustic/snare2.mp3 | Bin 0 -> 29323 bytes src/static/audio/acoustic/snare3.mp3 | Bin 0 -> 27055 bytes public/index.css => src/static/css/editor.css | 0 src/static/editor.html | 32 + src/static/img/logo.svg | 27 + webpack.config.js | 16 - 77 files changed, 51243 insertions(+), 205 deletions(-) create mode 100644 dist/app.css create mode 100644 dist/app.css.map rename {public/audio/acoustic => dist/audio}/hihat1.mp3 (100%) rename {public/audio/acoustic => dist/audio}/hihat2.mp3 (100%) rename {public/audio/acoustic => dist/audio}/hihat_open1.mp3 (100%) rename {public/audio/acoustic => dist/audio}/hihat_open2.mp3 (100%) rename {public/audio/acoustic => dist/audio}/hihat_open3.mp3 (100%) rename {public/audio/acoustic => dist/audio}/kick1.mp3 (100%) rename {public/audio/acoustic => dist/audio}/kick2.mp3 (100%) rename {public/audio/acoustic => dist/audio}/kick3.mp3 (100%) rename {public/audio/acoustic => dist/audio}/rim1.mp3 (100%) rename {public/audio/acoustic => dist/audio}/snare1.mp3 (100%) rename {public/audio/acoustic => dist/audio}/snare2.mp3 (100%) rename {public/audio/acoustic => dist/audio}/snare3.mp3 (100%) create mode 100644 dist/img/logo.svg create mode 100644 dist/index.html create mode 100644 dist/slang.app.js create mode 100644 dist/slang.app.js.map delete mode 100644 helpers/drumMap.js create mode 100644 packing/server.js create mode 100644 packing/webpack.config.js rename webpack.prod.js => packing/webpack.prod.js (94%) delete mode 100644 public/index.html rename {classes => src/classes}/ADSR.js (100%) rename {classes => src/classes}/Block.js (100%) rename {classes => src/classes}/Delay.js (100%) rename {classes => src/classes}/Drums.js (100%) rename {classes => src/classes}/Filter.js (100%) rename {classes => src/classes}/Gain.js (100%) rename {classes => src/classes}/Osc.js (100%) rename {classes => src/classes}/Pan.js (100%) rename {classes => src/classes}/PolyBlock.js (100%) rename {classes => src/classes}/Scheduler.js (100%) rename {classes => src/classes}/Sound.js (100%) rename {classes => src/classes}/classMap.js (100%) rename editor.js => src/editor.js (96%) rename {functions => src/functions}/FunctionCall.js (100%) rename {functions => src/functions}/chord.js (100%) rename {functions => src/functions}/flatten.js (100%) rename {functions => src/functions}/index.js (100%) rename {functions => src/functions}/interpolate.js (100%) rename {functions => src/functions}/random.js (100%) rename {functions => src/functions}/repeat.js (100%) rename {functions => src/functions}/reverse.js (100%) rename {functions => src/functions}/shuffle.js (100%) rename {functions => src/functions}/transpose.js (100%) rename {helpers => src/helpers}/BufferLoader.js (100%) rename {helpers => src/helpers}/FunctionCall.js (100%) rename {helpers => src/helpers}/List.js (100%) rename {helpers => src/helpers}/context.js (100%) create mode 100644 src/helpers/drumMap.js rename {helpers => src/helpers}/mtof.js (100%) rename {helpers => src/helpers}/parseArguments.js (100%) rename {helpers => src/helpers}/tuna.js (100%) rename runtime.js => src/runtime.js (100%) rename slang-grammar.js => src/slang-grammar.js (92%) rename slang.js => src/slang.js (98%) rename slang.ohm => src/slang.ohm (92%) create mode 100644 src/static/audio/acoustic/hihat1.mp3 create mode 100644 src/static/audio/acoustic/hihat2.mp3 create mode 100644 src/static/audio/acoustic/hihat_open1.mp3 create mode 100644 src/static/audio/acoustic/hihat_open2.mp3 create mode 100644 src/static/audio/acoustic/hihat_open3.mp3 create mode 100644 src/static/audio/acoustic/kick1.mp3 create mode 100644 src/static/audio/acoustic/kick2.mp3 create mode 100644 src/static/audio/acoustic/kick3.mp3 create mode 100644 src/static/audio/acoustic/rim1.mp3 create mode 100644 src/static/audio/acoustic/snare1.mp3 create mode 100644 src/static/audio/acoustic/snare2.mp3 create mode 100644 src/static/audio/acoustic/snare3.mp3 rename public/index.css => src/static/css/editor.css (100%) create mode 100644 src/static/editor.html create mode 100644 src/static/img/logo.svg delete mode 100644 webpack.config.js diff --git a/.eslintrc b/.eslintrc index 2216763..4ffd05e 100644 --- a/.eslintrc +++ b/.eslintrc @@ -1,4 +1,5 @@ { + "extends": "airbnb", "parserOptions": { "ecmaFeatures": { "experimentalObjectRestSpread": true @@ -9,5 +10,27 @@ "es6": true }, "rules": { + "indent": [ + "error", + 4 + ], + "linebreak-style": [ + "error", + "unix" + ], + "quotes": 1, + "semi": [ + "error", + "always" + ], + "no-console": 0, + "import/no-extraneous-dependencies": [ + "error", + { + "devDependencies": [ + "dist/*.js" + ] + } + ] } } diff --git a/dist/app.css b/dist/app.css new file mode 100644 index 0000000..ed026a1 --- /dev/null +++ b/dist/app.css @@ -0,0 +1,555 @@ +/* BASICS */ + +.CodeMirror { + /* Set height, width, borders, and global font properties here */ + font-family: monospace; + height: 300px; + color: black; + direction: ltr; +} + +/* PADDING */ + +.CodeMirror-lines { + padding: 4px 0; /* Vertical padding around content */ +} +.CodeMirror pre { + padding: 0 4px; /* Horizontal padding of content */ +} + +.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler { + background-color: white; /* The little square between H and V scrollbars */ +} + +/* GUTTER */ + +.CodeMirror-gutters { + border-right: 1px solid #ddd; + background-color: #f7f7f7; + white-space: nowrap; +} +.CodeMirror-linenumbers {} +.CodeMirror-linenumber { + padding: 0 3px 0 5px; + min-width: 20px; + text-align: right; + color: #999; + white-space: nowrap; +} + +.CodeMirror-guttermarker { color: black; } +.CodeMirror-guttermarker-subtle { color: #999; } + +/* CURSOR */ + +.CodeMirror-cursor { + border-left: 1px solid black; + border-right: none; + width: 0; +} +/* Shown when moving in bi-directional text */ +.CodeMirror div.CodeMirror-secondarycursor { + border-left: 1px solid silver; +} +.cm-fat-cursor .CodeMirror-cursor { + width: auto; + border: 0 !important; + background: #7e7; +} +.cm-fat-cursor div.CodeMirror-cursors { + z-index: 1; +} +.cm-fat-cursor-mark { + background-color: rgba(20, 255, 20, 0.5); + -webkit-animation: blink 1.06s steps(1) infinite; + -moz-animation: blink 1.06s steps(1) infinite; + animation: blink 1.06s steps(1) infinite; +} +.cm-animate-fat-cursor { + width: auto; + border: 0; + -webkit-animation: blink 1.06s steps(1) infinite; + -moz-animation: blink 1.06s steps(1) infinite; + animation: blink 1.06s steps(1) infinite; + background-color: #7e7; +} +@-moz-keyframes blink { + 0% {} + 50% { background-color: transparent; } + 100% {} +} +@-webkit-keyframes blink { + 0% {} + 50% { background-color: transparent; } + 100% {} +} +@keyframes blink { + 0% {} + 50% { background-color: transparent; } + 100% {} +} + +/* Can style cursor different in overwrite (non-insert) mode */ +.CodeMirror-overwrite .CodeMirror-cursor {} + +.cm-tab { display: inline-block; text-decoration: inherit; } + +.CodeMirror-rulers { + position: absolute; + left: 0; right: 0; top: -50px; bottom: -20px; + overflow: hidden; +} +.CodeMirror-ruler { + border-left: 1px solid #ccc; + top: 0; bottom: 0; + position: absolute; +} + +/* DEFAULT THEME */ + +.cm-s-default .cm-header {color: blue;} +.cm-s-default .cm-quote {color: #090;} +.cm-negative {color: #d44;} +.cm-positive {color: #292;} +.cm-header, .cm-strong {font-weight: bold;} +.cm-em {font-style: italic;} +.cm-link {text-decoration: underline;} +.cm-strikethrough {text-decoration: line-through;} + +.cm-s-default .cm-keyword {color: #708;} +.cm-s-default .cm-atom {color: #219;} +.cm-s-default .cm-number {color: #164;} +.cm-s-default .cm-def {color: #00f;} +.cm-s-default .cm-variable, +.cm-s-default .cm-punctuation, +.cm-s-default .cm-property, +.cm-s-default .cm-operator {} +.cm-s-default .cm-variable-2 {color: #05a;} +.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;} +.cm-s-default .cm-comment {color: #a50;} +.cm-s-default .cm-string {color: #a11;} +.cm-s-default .cm-string-2 {color: #f50;} +.cm-s-default .cm-meta {color: #555;} +.cm-s-default .cm-qualifier {color: #555;} +.cm-s-default .cm-builtin {color: #30a;} +.cm-s-default .cm-bracket {color: #997;} +.cm-s-default .cm-tag {color: #170;} +.cm-s-default .cm-attribute {color: #00c;} +.cm-s-default .cm-hr {color: #999;} +.cm-s-default .cm-link {color: #00c;} + +.cm-s-default .cm-error {color: #f00;} +.cm-invalidchar {color: #f00;} + +.CodeMirror-composing { border-bottom: 2px solid; } + +/* Default styles for common addons */ + +div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;} +div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;} +.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); } +.CodeMirror-activeline-background {background: #e8f2ff;} + +/* STOP */ + +/* The rest of this file contains styles related to the mechanics of + the editor. You probably shouldn't touch them. */ + +.CodeMirror { + position: relative; + overflow: hidden; + background: white; +} + +.CodeMirror-scroll { + overflow: scroll !important; /* Things will break if this is overridden */ + /* 30px is the magic margin used to hide the element's real scrollbars */ + /* See overflow: hidden in .CodeMirror */ + margin-bottom: -30px; margin-right: -30px; + padding-bottom: 30px; + height: 100%; + outline: none; /* Prevent dragging from highlighting the element */ + position: relative; +} +.CodeMirror-sizer { + position: relative; + border-right: 30px solid transparent; +} + +/* The fake, visible scrollbars. Used to force redraw during scrolling + before actual scrolling happens, thus preventing shaking and + flickering artifacts. */ +.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler { + position: absolute; + z-index: 6; + display: none; +} +.CodeMirror-vscrollbar { + right: 0; top: 0; + overflow-x: hidden; + overflow-y: scroll; +} +.CodeMirror-hscrollbar { + bottom: 0; left: 0; + overflow-y: hidden; + overflow-x: scroll; +} +.CodeMirror-scrollbar-filler { + right: 0; bottom: 0; +} +.CodeMirror-gutter-filler { + left: 0; bottom: 0; +} + +.CodeMirror-gutters { + position: absolute; left: 0; top: 0; + min-height: 100%; + z-index: 3; +} +.CodeMirror-gutter { + white-space: normal; + height: 100%; + display: inline-block; + vertical-align: top; + margin-bottom: -30px; +} +.CodeMirror-gutter-wrapper { + position: absolute; + z-index: 4; + background: none !important; + border: none !important; +} +.CodeMirror-gutter-background { + position: absolute; + top: 0; bottom: 0; + z-index: 4; +} +.CodeMirror-gutter-elt { + position: absolute; + cursor: default; + z-index: 4; +} +.CodeMirror-gutter-wrapper ::selection { background-color: transparent } +.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent } + +.CodeMirror-lines { + cursor: text; + min-height: 1px; /* prevents collapsing before first draw */ +} +.CodeMirror pre { + /* Reset some styles that the rest of the page might have set */ + -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0; + border-width: 0; + background: transparent; + font-family: inherit; + font-size: inherit; + margin: 0; + white-space: pre; + word-wrap: normal; + line-height: inherit; + color: inherit; + z-index: 2; + position: relative; + overflow: visible; + -webkit-tap-highlight-color: transparent; + -webkit-font-variant-ligatures: contextual; + font-variant-ligatures: contextual; +} +.CodeMirror-wrap pre { + word-wrap: break-word; + white-space: pre-wrap; + word-break: normal; +} + +.CodeMirror-linebackground { + position: absolute; + left: 0; right: 0; top: 0; bottom: 0; + z-index: 0; +} + +.CodeMirror-linewidget { + position: relative; + z-index: 2; + padding: 0.1px; /* Force widget margins to stay inside of the container */ +} + +.CodeMirror-widget {} + +.CodeMirror-rtl pre { direction: rtl; } + +.CodeMirror-code { + outline: none; +} + +/* Force content-box sizing for the elements where we expect it */ +.CodeMirror-scroll, +.CodeMirror-sizer, +.CodeMirror-gutter, +.CodeMirror-gutters, +.CodeMirror-linenumber { + -moz-box-sizing: content-box; + box-sizing: content-box; +} + +.CodeMirror-measure { + position: absolute; + width: 100%; + height: 0; + overflow: hidden; + visibility: hidden; +} + +.CodeMirror-cursor { + position: absolute; + pointer-events: none; +} +.CodeMirror-measure pre { position: static; } + +div.CodeMirror-cursors { + visibility: hidden; + position: relative; + z-index: 3; +} +div.CodeMirror-dragcursors { + visibility: visible; +} + +.CodeMirror-focused div.CodeMirror-cursors { + visibility: visible; +} + +.CodeMirror-selected { background: #d9d9d9; } +.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; } +.CodeMirror-crosshair { cursor: crosshair; } +.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; } +.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; } + +.cm-searching { + background-color: #ffa; + background-color: rgba(255, 255, 0, .4); +} + +/* Used to force a border model for a node */ +.cm-force-border { padding-right: .1px; } + +@media print { + /* Hide the cursor when printing */ + .CodeMirror div.CodeMirror-cursors { + visibility: hidden; + } +} + +/* See issue #2901 */ +.cm-tab-wrap-hack:after { content: ''; } + +/* Help users use markselection to safely style text background */ +span.CodeMirror-selectedtext { background: none; } + +/* +Name: DuoTone-Light +Author: by Bram de Haan, adapted from DuoTone themes by Simurai (http://simurai.com/projects/2016/01/01/duotone-themes) + +CodeMirror template by Jan T. Sott (https://github.com/idleberg), adapted by Bram de Haan (https://github.com/atelierbram/) +*/ + +.cm-s-duotone-light.CodeMirror { background: #faf8f5; color: #b29762; } +.cm-s-duotone-light div.CodeMirror-selected { background: #e3dcce !important; } +.cm-s-duotone-light .CodeMirror-gutters { background: #faf8f5; border-right: 0px; } +.cm-s-duotone-light .CodeMirror-linenumber { color: #cdc4b1; } + +/* begin cursor */ +.cm-s-duotone-light .CodeMirror-cursor { border-left: 1px solid #93abdc; /* border-left: 1px solid #93abdc80; */ border-right: .5em solid #93abdc; /* border-right: .5em solid #93abdc80; */ opacity: .5; } +.cm-s-duotone-light .CodeMirror-activeline-background { background: #e3dcce; /* background: #e3dcce80; */ opacity: .5; } +.cm-s-duotone-light .cm-fat-cursor .CodeMirror-cursor { background: #93abdc; /* #93abdc80; */ opacity: .5; } +/* end cursor */ + +.cm-s-duotone-light span.cm-atom, .cm-s-duotone-light span.cm-number, .cm-s-duotone-light span.cm-keyword, .cm-s-duotone-light span.cm-variable, .cm-s-duotone-light span.cm-attribute, .cm-s-duotone-light span.cm-quote, .cm-s-duotone-light-light span.cm-hr, .cm-s-duotone-light-light span.cm-link { color: #063289; } + +.cm-s-duotone-light span.cm-property { color: #b29762; } +.cm-s-duotone-light span.cm-punctuation, .cm-s-duotone-light span.cm-unit, .cm-s-duotone-light span.cm-negative { color: #063289; } +.cm-s-duotone-light span.cm-string, .cm-s-duotone-light span.cm-operator { color: #1659df; } +.cm-s-duotone-light span.cm-positive { color: #896724; } + +.cm-s-duotone-light span.cm-variable-2, .cm-s-duotone-light span.cm-variable-3, .cm-s-duotone-light span.cm-type, .cm-s-duotone-light span.cm-string-2, .cm-s-duotone-light span.cm-url { color: #896724; } +.cm-s-duotone-light span.cm-def, .cm-s-duotone-light span.cm-tag, .cm-s-duotone-light span.cm-builtin, .cm-s-duotone-light span.cm-qualifier, .cm-s-duotone-light span.cm-header, .cm-s-duotone-light span.cm-em { color: #2d2006; } +.cm-s-duotone-light span.cm-bracket, .cm-s-duotone-light span.cm-comment { color: #b6ad9a; } + +/* using #f00 red for errors, don't think any of the colorscheme variables will stand out enough, ... maybe by giving it a background-color ... */ +/* .cm-s-duotone-light span.cm-error { background: #896724; color: #728fcb; } */ +.cm-s-duotone-light span.cm-error, .cm-s-duotone-light span.cm-invalidchar { color: #f00; } + +.cm-s-duotone-light span.cm-header { font-weight: normal; } +.cm-s-duotone-light .CodeMirror-matchingbracket { text-decoration: underline; color: #faf8f5 !important; } + + +* { + box-sizing: border-box; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +body, html { + height: 100%; + margin: 0; +} + +body { + display: flex; + flex-direction: column; + padding: 24px; + font-family: 'Roboto Mono', 'Andale Mono', monospace; +} + +#editor { + position: relative; + flex: 1 0 auto; + display: flex; + flex-direction: column; +} + +/* The top flex column that holds the SVG and the error box */ +.banner { + position: relative; +} + +#svg-title { + flex: 0 0 auto; + display: block; + width: 100%; + max-width: 628px; + max-height: 80px; + height: auto; + margin: 12px auto 24px auto; +} + +#error { + position: absolute; + top: 0; + left: 0; + right: 0; + padding: 12px; + height: 100%; + pointer-events: none; + opacity: 0; + transition: opacity 0.1s; + background-color: white; + border: 1px dashed #fc5e39; + color: #fc5e39; + white-space: pre; + overflow-y: scroll; +} + +#error.show { + opacity: 1; + pointer-events: auto; +} + +#error-content { + position: absolute; + top: 12px; + left: 12px; + right: 24px; +} + +#dismiss { + position: absolute; + top: 12px; + right: 12px; + line-height: 10px; + font-size: 20px; + cursor: pointer; +} + +footer { + position: relative; + top: 10px; + font-size: 12px; + text-align: center; + color: #28bed4; +} + +footer a { + text-decoration: none; + color: #28bed4; +} + +footer a:hover { + text-decoration: underline; +} + +/* +--------------------------------- CONTROLS -------------------------------- +*/ + +#controls { + display: flex; + padding: 6px; + background-color: #eee7dd; +} + +#controls > * { + flex: 0 0 33.33%; +} + +.controls-center { + text-align: center; + color: rgba(0, 0, 0, 0.25); +} + +.controls-right { + text-align: right; +} + +.button { + display: inline-block; + padding: 2px 6px; + border-radius: 2px; + line-height: 22px; + background-color: #8dc154; + color: white; + cursor: pointer; + text-decoration: none; +} + +.button.red { + background-color: #fb5e39; +} + +.button.gray { + background-color: gray; +} + +/* +--------------------------------- EDITOR --------------------------------- +*/ + +.CodeMirror { + flex: 1 0 auto; + padding: 12px; + font-size: 18px; + font-family: 'Roboto Mono', 'Andale Mono', monospace !important; +} + +.cm-note { + color: #8BC34A; +} +.cm-variable { + color: #FF5722 !important; +} +.cm-number { + color: #00BCD4 !important; +} +.cm-pipe { + color: #9c27b0; +} +.cm-comment { + color: #d3ccbb !important; +} +.cm-beat { + color: #ff9800; +} +.cm-rest { + color: #ff980085; +} + +/*# sourceMappingURL=app.css.map*/ \ No newline at end of file diff --git a/dist/app.css.map b/dist/app.css.map new file mode 100644 index 0000000..c7e722e --- /dev/null +++ b/dist/app.css.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack:///./node_modules/codemirror/lib/codemirror.css","webpack:///./node_modules/codemirror/theme/duotone-light.css","webpack:///./src/static/css/editor.css"],"names":[],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;;AAEA;AACA,0BAA0B;AAC1B;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0BAA0B,cAAc;AACxC,iCAAiC,aAAa;;AAE9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,+BAA+B;AACtC;AACA;AACA;AACA;AACA,OAAO,+BAA+B;AACtC;AACA;AACA;AACA;AACA,OAAO,+BAA+B;AACtC;AACA;;AAEA;AACA;;AAEA,SAAS,uBAAuB,0BAA0B;;AAE1D;AACA;AACA,UAAU,UAAU,YAAY;AAChC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;;AAEA,0BAA0B;AAC1B,yBAAyB;AACzB,cAAc;AACd,cAAc;AACd,wBAAwB;AACxB,QAAQ;AACR,UAAU;AACV,mBAAmB;;AAEnB,2BAA2B;AAC3B,wBAAwB;AACxB,0BAA0B;AAC1B,uBAAuB;AACvB;AACA;AACA;AACA;AACA,8BAA8B;AAC9B,sDAAsD;AACtD,2BAA2B;AAC3B,0BAA0B;AAC1B,4BAA4B;AAC5B,wBAAwB;AACxB,6BAA6B;AAC7B,2BAA2B;AAC3B,2BAA2B;AAC3B,uBAAuB;AACvB,6BAA6B;AAC7B,sBAAsB;AACtB,wBAAwB;;AAExB,yBAAyB;AACzB,iBAAiB;;AAEjB,uBAAuB,0BAA0B;;AAEjD;;AAEA,gDAAgD;AAChD,mDAAmD;AACnD,yBAAyB,mCAAmC;AAC5D,mCAAmC;;AAEnC;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,8BAA8B;AAC9B;AACA;AACA,uBAAuB;AACvB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA,UAAU;AACV;;AAEA;AACA,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC,6CAA6C;;AAE7C;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,wBAAwB,0BAA0B;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAU,UAAU,QAAQ;AAC5B;AACA;;AAEA;AACA;AACA;AACA,iBAAiB;AACjB;;AAEA;;AAEA,qBAAqB,gBAAgB;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,yBAAyB,kBAAkB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,sBAAsB,qBAAqB;AAC3C,0CAA0C,qBAAqB;AAC/D,uBAAuB,mBAAmB;AAC1C,4GAA4G,qBAAqB;AACjI,2HAA2H,qBAAqB;;AAEhJ;AACA;AACA;AACA;;AAEA;AACA,kBAAkB,qBAAqB;;AAEvC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,aAAa;;AAEtC;AACA,8BAA8B,kBAAkB;;ACzVhD;AACA;AACA;;AAEA;AACA;;AAEA,gCAAgC,qBAAqB,gBAAgB;AACrE,6CAA6C,gCAAgC;AAC7E,yCAAyC,qBAAqB,mBAAmB;AACjF,4CAA4C,gBAAgB;;AAE5D;AACA,wCAAwC,gCAAgC,qCAAqC,qCAAqC,uCAAuC,gBAAgB;AACzM,uDAAuD,qBAAqB,2BAA2B,gBAAgB;AACvH,uDAAuD,qBAAqB,cAAc,gBAAgB;AAC1G;;AAEA,ySAAyS,gBAAgB;;AAEzT,sCAAsC,gBAAgB;AACtD,iHAAiH,gBAAgB;AACjI,0EAA0E,gBAAgB;AAC1F,sCAAsC,gBAAgB;;AAEtD,yLAAyL,gBAAgB;AACzM,kNAAkN,gBAAgB;AAClO,0EAA0E,gBAAgB;;AAE1F;AACA,sCAAsC,qBAAqB,gBAAgB,EAAE;AAC7E,4EAA4E,aAAa;;AAEzF,oCAAoC,qBAAqB;AACzD,iDAAiD,4BAA4B,2BAA2B;;;AClCxG;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,C","file":"app.css","sourcesContent":["/* BASICS */\n\n.CodeMirror {\n /* Set height, width, borders, and global font properties here */\n font-family: monospace;\n height: 300px;\n color: black;\n direction: ltr;\n}\n\n/* PADDING */\n\n.CodeMirror-lines {\n padding: 4px 0; /* Vertical padding around content */\n}\n.CodeMirror pre {\n padding: 0 4px; /* Horizontal padding of content */\n}\n\n.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n background-color: white; /* The little square between H and V scrollbars */\n}\n\n/* GUTTER */\n\n.CodeMirror-gutters {\n border-right: 1px solid #ddd;\n background-color: #f7f7f7;\n white-space: nowrap;\n}\n.CodeMirror-linenumbers {}\n.CodeMirror-linenumber {\n padding: 0 3px 0 5px;\n min-width: 20px;\n text-align: right;\n color: #999;\n white-space: nowrap;\n}\n\n.CodeMirror-guttermarker { color: black; }\n.CodeMirror-guttermarker-subtle { color: #999; }\n\n/* CURSOR */\n\n.CodeMirror-cursor {\n border-left: 1px solid black;\n border-right: none;\n width: 0;\n}\n/* Shown when moving in bi-directional text */\n.CodeMirror div.CodeMirror-secondarycursor {\n border-left: 1px solid silver;\n}\n.cm-fat-cursor .CodeMirror-cursor {\n width: auto;\n border: 0 !important;\n background: #7e7;\n}\n.cm-fat-cursor div.CodeMirror-cursors {\n z-index: 1;\n}\n.cm-fat-cursor-mark {\n background-color: rgba(20, 255, 20, 0.5);\n -webkit-animation: blink 1.06s steps(1) infinite;\n -moz-animation: blink 1.06s steps(1) infinite;\n animation: blink 1.06s steps(1) infinite;\n}\n.cm-animate-fat-cursor {\n width: auto;\n border: 0;\n -webkit-animation: blink 1.06s steps(1) infinite;\n -moz-animation: blink 1.06s steps(1) infinite;\n animation: blink 1.06s steps(1) infinite;\n background-color: #7e7;\n}\n@-moz-keyframes blink {\n 0% {}\n 50% { background-color: transparent; }\n 100% {}\n}\n@-webkit-keyframes blink {\n 0% {}\n 50% { background-color: transparent; }\n 100% {}\n}\n@keyframes blink {\n 0% {}\n 50% { background-color: transparent; }\n 100% {}\n}\n\n/* Can style cursor different in overwrite (non-insert) mode */\n.CodeMirror-overwrite .CodeMirror-cursor {}\n\n.cm-tab { display: inline-block; text-decoration: inherit; }\n\n.CodeMirror-rulers {\n position: absolute;\n left: 0; right: 0; top: -50px; bottom: -20px;\n overflow: hidden;\n}\n.CodeMirror-ruler {\n border-left: 1px solid #ccc;\n top: 0; bottom: 0;\n position: absolute;\n}\n\n/* DEFAULT THEME */\n\n.cm-s-default .cm-header {color: blue;}\n.cm-s-default .cm-quote {color: #090;}\n.cm-negative {color: #d44;}\n.cm-positive {color: #292;}\n.cm-header, .cm-strong {font-weight: bold;}\n.cm-em {font-style: italic;}\n.cm-link {text-decoration: underline;}\n.cm-strikethrough {text-decoration: line-through;}\n\n.cm-s-default .cm-keyword {color: #708;}\n.cm-s-default .cm-atom {color: #219;}\n.cm-s-default .cm-number {color: #164;}\n.cm-s-default .cm-def {color: #00f;}\n.cm-s-default .cm-variable,\n.cm-s-default .cm-punctuation,\n.cm-s-default .cm-property,\n.cm-s-default .cm-operator {}\n.cm-s-default .cm-variable-2 {color: #05a;}\n.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}\n.cm-s-default .cm-comment {color: #a50;}\n.cm-s-default .cm-string {color: #a11;}\n.cm-s-default .cm-string-2 {color: #f50;}\n.cm-s-default .cm-meta {color: #555;}\n.cm-s-default .cm-qualifier {color: #555;}\n.cm-s-default .cm-builtin {color: #30a;}\n.cm-s-default .cm-bracket {color: #997;}\n.cm-s-default .cm-tag {color: #170;}\n.cm-s-default .cm-attribute {color: #00c;}\n.cm-s-default .cm-hr {color: #999;}\n.cm-s-default .cm-link {color: #00c;}\n\n.cm-s-default .cm-error {color: #f00;}\n.cm-invalidchar {color: #f00;}\n\n.CodeMirror-composing { border-bottom: 2px solid; }\n\n/* Default styles for common addons */\n\ndiv.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}\ndiv.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}\n.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }\n.CodeMirror-activeline-background {background: #e8f2ff;}\n\n/* STOP */\n\n/* The rest of this file contains styles related to the mechanics of\n the editor. You probably shouldn't touch them. */\n\n.CodeMirror {\n position: relative;\n overflow: hidden;\n background: white;\n}\n\n.CodeMirror-scroll {\n overflow: scroll !important; /* Things will break if this is overridden */\n /* 30px is the magic margin used to hide the element's real scrollbars */\n /* See overflow: hidden in .CodeMirror */\n margin-bottom: -30px; margin-right: -30px;\n padding-bottom: 30px;\n height: 100%;\n outline: none; /* Prevent dragging from highlighting the element */\n position: relative;\n}\n.CodeMirror-sizer {\n position: relative;\n border-right: 30px solid transparent;\n}\n\n/* The fake, visible scrollbars. Used to force redraw during scrolling\n before actual scrolling happens, thus preventing shaking and\n flickering artifacts. */\n.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n position: absolute;\n z-index: 6;\n display: none;\n}\n.CodeMirror-vscrollbar {\n right: 0; top: 0;\n overflow-x: hidden;\n overflow-y: scroll;\n}\n.CodeMirror-hscrollbar {\n bottom: 0; left: 0;\n overflow-y: hidden;\n overflow-x: scroll;\n}\n.CodeMirror-scrollbar-filler {\n right: 0; bottom: 0;\n}\n.CodeMirror-gutter-filler {\n left: 0; bottom: 0;\n}\n\n.CodeMirror-gutters {\n position: absolute; left: 0; top: 0;\n min-height: 100%;\n z-index: 3;\n}\n.CodeMirror-gutter {\n white-space: normal;\n height: 100%;\n display: inline-block;\n vertical-align: top;\n margin-bottom: -30px;\n}\n.CodeMirror-gutter-wrapper {\n position: absolute;\n z-index: 4;\n background: none !important;\n border: none !important;\n}\n.CodeMirror-gutter-background {\n position: absolute;\n top: 0; bottom: 0;\n z-index: 4;\n}\n.CodeMirror-gutter-elt {\n position: absolute;\n cursor: default;\n z-index: 4;\n}\n.CodeMirror-gutter-wrapper ::selection { background-color: transparent }\n.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }\n\n.CodeMirror-lines {\n cursor: text;\n min-height: 1px; /* prevents collapsing before first draw */\n}\n.CodeMirror pre {\n /* Reset some styles that the rest of the page might have set */\n -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;\n border-width: 0;\n background: transparent;\n font-family: inherit;\n font-size: inherit;\n margin: 0;\n white-space: pre;\n word-wrap: normal;\n line-height: inherit;\n color: inherit;\n z-index: 2;\n position: relative;\n overflow: visible;\n -webkit-tap-highlight-color: transparent;\n -webkit-font-variant-ligatures: contextual;\n font-variant-ligatures: contextual;\n}\n.CodeMirror-wrap pre {\n word-wrap: break-word;\n white-space: pre-wrap;\n word-break: normal;\n}\n\n.CodeMirror-linebackground {\n position: absolute;\n left: 0; right: 0; top: 0; bottom: 0;\n z-index: 0;\n}\n\n.CodeMirror-linewidget {\n position: relative;\n z-index: 2;\n padding: 0.1px; /* Force widget margins to stay inside of the container */\n}\n\n.CodeMirror-widget {}\n\n.CodeMirror-rtl pre { direction: rtl; }\n\n.CodeMirror-code {\n outline: none;\n}\n\n/* Force content-box sizing for the elements where we expect it */\n.CodeMirror-scroll,\n.CodeMirror-sizer,\n.CodeMirror-gutter,\n.CodeMirror-gutters,\n.CodeMirror-linenumber {\n -moz-box-sizing: content-box;\n box-sizing: content-box;\n}\n\n.CodeMirror-measure {\n position: absolute;\n width: 100%;\n height: 0;\n overflow: hidden;\n visibility: hidden;\n}\n\n.CodeMirror-cursor {\n position: absolute;\n pointer-events: none;\n}\n.CodeMirror-measure pre { position: static; }\n\ndiv.CodeMirror-cursors {\n visibility: hidden;\n position: relative;\n z-index: 3;\n}\ndiv.CodeMirror-dragcursors {\n visibility: visible;\n}\n\n.CodeMirror-focused div.CodeMirror-cursors {\n visibility: visible;\n}\n\n.CodeMirror-selected { background: #d9d9d9; }\n.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }\n.CodeMirror-crosshair { cursor: crosshair; }\n.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }\n.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }\n\n.cm-searching {\n background-color: #ffa;\n background-color: rgba(255, 255, 0, .4);\n}\n\n/* Used to force a border model for a node */\n.cm-force-border { padding-right: .1px; }\n\n@media print {\n /* Hide the cursor when printing */\n .CodeMirror div.CodeMirror-cursors {\n visibility: hidden;\n }\n}\n\n/* See issue #2901 */\n.cm-tab-wrap-hack:after { content: ''; }\n\n/* Help users use markselection to safely style text background */\nspan.CodeMirror-selectedtext { background: none; }\n","/*\nName: DuoTone-Light\nAuthor: by Bram de Haan, adapted from DuoTone themes by Simurai (http://simurai.com/projects/2016/01/01/duotone-themes)\n\nCodeMirror template by Jan T. Sott (https://github.com/idleberg), adapted by Bram de Haan (https://github.com/atelierbram/)\n*/\n\n.cm-s-duotone-light.CodeMirror { background: #faf8f5; color: #b29762; }\n.cm-s-duotone-light div.CodeMirror-selected { background: #e3dcce !important; }\n.cm-s-duotone-light .CodeMirror-gutters { background: #faf8f5; border-right: 0px; }\n.cm-s-duotone-light .CodeMirror-linenumber { color: #cdc4b1; }\n\n/* begin cursor */\n.cm-s-duotone-light .CodeMirror-cursor { border-left: 1px solid #93abdc; /* border-left: 1px solid #93abdc80; */ border-right: .5em solid #93abdc; /* border-right: .5em solid #93abdc80; */ opacity: .5; }\n.cm-s-duotone-light .CodeMirror-activeline-background { background: #e3dcce; /* background: #e3dcce80; */ opacity: .5; }\n.cm-s-duotone-light .cm-fat-cursor .CodeMirror-cursor { background: #93abdc; /* #93abdc80; */ opacity: .5; }\n/* end cursor */\n\n.cm-s-duotone-light span.cm-atom, .cm-s-duotone-light span.cm-number, .cm-s-duotone-light span.cm-keyword, .cm-s-duotone-light span.cm-variable, .cm-s-duotone-light span.cm-attribute, .cm-s-duotone-light span.cm-quote, .cm-s-duotone-light-light span.cm-hr, .cm-s-duotone-light-light span.cm-link { color: #063289; }\n\n.cm-s-duotone-light span.cm-property { color: #b29762; }\n.cm-s-duotone-light span.cm-punctuation, .cm-s-duotone-light span.cm-unit, .cm-s-duotone-light span.cm-negative { color: #063289; }\n.cm-s-duotone-light span.cm-string, .cm-s-duotone-light span.cm-operator { color: #1659df; }\n.cm-s-duotone-light span.cm-positive { color: #896724; }\n\n.cm-s-duotone-light span.cm-variable-2, .cm-s-duotone-light span.cm-variable-3, .cm-s-duotone-light span.cm-type, .cm-s-duotone-light span.cm-string-2, .cm-s-duotone-light span.cm-url { color: #896724; }\n.cm-s-duotone-light span.cm-def, .cm-s-duotone-light span.cm-tag, .cm-s-duotone-light span.cm-builtin, .cm-s-duotone-light span.cm-qualifier, .cm-s-duotone-light span.cm-header, .cm-s-duotone-light span.cm-em { color: #2d2006; }\n.cm-s-duotone-light span.cm-bracket, .cm-s-duotone-light span.cm-comment { color: #b6ad9a; }\n\n/* using #f00 red for errors, don't think any of the colorscheme variables will stand out enough, ... maybe by giving it a background-color ... */\n/* .cm-s-duotone-light span.cm-error { background: #896724; color: #728fcb; } */\n.cm-s-duotone-light span.cm-error, .cm-s-duotone-light span.cm-invalidchar { color: #f00; }\n\n.cm-s-duotone-light span.cm-header { font-weight: normal; }\n.cm-s-duotone-light .CodeMirror-matchingbracket { text-decoration: underline; color: #faf8f5 !important; }\n\n","* {\n\tbox-sizing: border-box;\n\t-webkit-font-smoothing: antialiased;\n\t-moz-osx-font-smoothing: grayscale;\n}\n\nbody, html {\n\theight: 100%;\n\tmargin: 0;\n}\n\nbody {\n\tdisplay: flex;\n\tflex-direction: column;\n\tpadding: 24px;\n\tfont-family: 'Roboto Mono', 'Andale Mono', monospace;\n}\n\n#editor {\n\tposition: relative;\n\tflex: 1 0 auto;\n\tdisplay: flex;\n\tflex-direction: column;\n}\n\n/* The top flex column that holds the SVG and the error box */\n.banner {\n\tposition: relative;\n}\n\n#svg-title {\n\tflex: 0 0 auto;\n\tdisplay: block;\n\twidth: 100%;\n\tmax-width: 628px;\n\tmax-height: 80px;\n\theight: auto;\n\tmargin: 12px auto 24px auto;\n}\n\n#error {\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\tright: 0;\n\tpadding: 12px;\n\theight: 100%;\n\tpointer-events: none;\n\topacity: 0;\n\ttransition: opacity 0.1s;\n\tbackground-color: white;\n\tborder: 1px dashed #fc5e39;\n\tcolor: #fc5e39;\n\twhite-space: pre;\n\toverflow-y: scroll;\n}\n\n#error.show {\n\topacity: 1;\n\tpointer-events: auto;\n}\n\n#error-content {\n\tposition: absolute;\n\ttop: 12px;\n\tleft: 12px;\n\tright: 24px;\n}\n\n#dismiss {\n\tposition: absolute;\n\ttop: 12px;\n\tright: 12px;\n\tline-height: 10px;\n\tfont-size: 20px;\n\tcursor: pointer;\n}\n\nfooter {\n\tposition: relative;\n\ttop: 10px;\n\tfont-size: 12px;\n\ttext-align: center;\n\tcolor: #28bed4;\n}\n\nfooter a {\n\ttext-decoration: none;\n\tcolor: #28bed4;\n}\n\nfooter a:hover {\n\ttext-decoration: underline;\n}\n\n/*\n--------------------------------- CONTROLS --------------------------------\n*/\n\n#controls {\n\tdisplay: flex;\n\tpadding: 6px;\n\tbackground-color: #eee7dd;\n}\n\n#controls > * {\n\tflex: 0 0 33.33%;\n}\n\n.controls-center {\n\ttext-align: center;\n\tcolor: rgba(0, 0, 0, 0.25);\n}\n\n.controls-right {\n\ttext-align: right;\n}\n\n.button {\n\tdisplay: inline-block;\n\tpadding: 2px 6px;\n\tborder-radius: 2px;\n\tline-height: 22px;\n\tbackground-color: #8dc154;\n\tcolor: white;\n\tcursor: pointer;\n\ttext-decoration: none;\n}\n\n.button.red {\n\tbackground-color: #fb5e39;\n}\n\n.button.gray {\n\tbackground-color: gray;\n}\n\n/*\n--------------------------------- EDITOR ---------------------------------\n*/\n\n.CodeMirror {\n\tflex: 1 0 auto;\n\tpadding: 12px;\n\tfont-size: 18px;\n\tfont-family: 'Roboto Mono', 'Andale Mono', monospace !important;\n}\n\n.cm-note {\n\tcolor: #8BC34A;\n}\n.cm-variable {\n\tcolor: #FF5722 !important;\n}\n.cm-number {\n\tcolor: #00BCD4 !important;\n}\n.cm-pipe {\n\tcolor: #9c27b0;\n}\n.cm-comment {\n\tcolor: #d3ccbb !important;\n}\n.cm-beat {\n\tcolor: #ff9800;\n}\n.cm-rest {\n\tcolor: #ff980085;\n}"],"sourceRoot":""} \ No newline at end of file diff --git a/public/audio/acoustic/hihat1.mp3 b/dist/audio/hihat1.mp3 similarity index 100% rename from public/audio/acoustic/hihat1.mp3 rename to dist/audio/hihat1.mp3 diff --git a/public/audio/acoustic/hihat2.mp3 b/dist/audio/hihat2.mp3 similarity index 100% rename from public/audio/acoustic/hihat2.mp3 rename to dist/audio/hihat2.mp3 diff --git a/public/audio/acoustic/hihat_open1.mp3 b/dist/audio/hihat_open1.mp3 similarity index 100% rename from public/audio/acoustic/hihat_open1.mp3 rename to dist/audio/hihat_open1.mp3 diff --git a/public/audio/acoustic/hihat_open2.mp3 b/dist/audio/hihat_open2.mp3 similarity index 100% rename from public/audio/acoustic/hihat_open2.mp3 rename to dist/audio/hihat_open2.mp3 diff --git a/public/audio/acoustic/hihat_open3.mp3 b/dist/audio/hihat_open3.mp3 similarity index 100% rename from public/audio/acoustic/hihat_open3.mp3 rename to dist/audio/hihat_open3.mp3 diff --git a/public/audio/acoustic/kick1.mp3 b/dist/audio/kick1.mp3 similarity index 100% rename from public/audio/acoustic/kick1.mp3 rename to dist/audio/kick1.mp3 diff --git a/public/audio/acoustic/kick2.mp3 b/dist/audio/kick2.mp3 similarity index 100% rename from public/audio/acoustic/kick2.mp3 rename to dist/audio/kick2.mp3 diff --git a/public/audio/acoustic/kick3.mp3 b/dist/audio/kick3.mp3 similarity index 100% rename from public/audio/acoustic/kick3.mp3 rename to dist/audio/kick3.mp3 diff --git a/public/audio/acoustic/rim1.mp3 b/dist/audio/rim1.mp3 similarity index 100% rename from public/audio/acoustic/rim1.mp3 rename to dist/audio/rim1.mp3 diff --git a/public/audio/acoustic/snare1.mp3 b/dist/audio/snare1.mp3 similarity index 100% rename from public/audio/acoustic/snare1.mp3 rename to dist/audio/snare1.mp3 diff --git a/public/audio/acoustic/snare2.mp3 b/dist/audio/snare2.mp3 similarity index 100% rename from public/audio/acoustic/snare2.mp3 rename to dist/audio/snare2.mp3 diff --git a/public/audio/acoustic/snare3.mp3 b/dist/audio/snare3.mp3 similarity index 100% rename from public/audio/acoustic/snare3.mp3 rename to dist/audio/snare3.mp3 diff --git a/dist/img/logo.svg b/dist/img/logo.svg new file mode 100644 index 0000000..b996054 --- /dev/null +++ b/dist/img/logo.svg @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/dist/index.html b/dist/index.html new file mode 100644 index 0000000..fc2ff57 --- /dev/null +++ b/dist/index.html @@ -0,0 +1,32 @@ + + + + + + + +
+
+
Run
+
Stop
+
+
+
Stopped
+
+
+ Docs +
+
+
+ + + diff --git a/dist/slang.app.js b/dist/slang.app.js new file mode 100644 index 0000000..2f4f509 --- /dev/null +++ b/dist/slang.app.js @@ -0,0 +1,47832 @@ +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = "/"; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = "./src/editor.js"); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ "./node_modules/adsr-envelope/index.js": +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__("./node_modules/adsr-envelope/lib/index.js"); + + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/ADSREnvelope.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })(); + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _ADSRParams = __webpack_require__("./node_modules/adsr-envelope/lib/ADSRParams.js"); + +var _ADSRParams2 = _interopRequireDefault(_ADSRParams); + +var ADSREnvelope = (function () { + function ADSREnvelope(opts) { + _classCallCheck(this, ADSREnvelope); + + this._ = new _ADSRParams2["default"](opts); + } + + _createClass(ADSREnvelope, [{ + key: "valueAt", + value: function valueAt() { + var time = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; + + return this._.valueAt(time); + } + }, { + key: "applyTo", + value: function applyTo(audioParam, playbackTime) { + this.getWebAudioAPIMethods(playbackTime).forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 3); + + var method = _ref2[0]; + var value = _ref2[1]; + var time = _ref2[2]; + + audioParam[method](value, time); + }); + + return this; + } + }, { + key: "getWebAudioAPIMethods", + value: function getWebAudioAPIMethods() { + var playbackTime = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; + + return this._.methods(playbackTime); + } + }, { + key: "clone", + value: function clone() { + return new ADSREnvelope({ + attackTime: this._.attackTime, + decayTime: this._.decayTime, + sustainLevel: this._.sustainLevel, + releaseTime: this._.releaseTime, + gateTime: this._.gateTime, + peakLevel: this._.peakLevel, + epsilon: this._.epsilon, + attackCurve: this._.attackCurve, + decayCurve: this._.decayCurve, + releaseCurve: this._.releaseCurve + }); + } + }, { + key: "duration", + set: function set(value) { + this._.setDuration(value); + }, + get: function get() { + return this._.duration; + } + }, { + key: "attackTime", + set: function set(value) { + this._.setAttackTime(value); + }, + get: function get() { + return this._.attackTime; + } + }, { + key: "decayTime", + set: function set(value) { + this._.setDecayTime(value); + }, + get: function get() { + return this._.decayTime; + } + }, { + key: "sustainTime", + set: function set(value) { + this._.setSustainTime(value); + }, + get: function get() { + return this._.sustainTime; + } + }, { + key: "sustainLevel", + set: function set(value) { + this._.setSustainLevel(value); + }, + get: function get() { + return this._.sustainLevel; + } + }, { + key: "releaseTime", + set: function set(value) { + this._.setReleaseTime(value); + }, + get: function get() { + return this._.releaseTime; + } + }, { + key: "gateTime", + set: function set(value) { + this._.setGateTime(value); + }, + get: function get() { + return this._.gateTime; + } + }, { + key: "peakLevel", + set: function set(value) { + this._.setPeakLevel(value); + }, + get: function get() { + return this._.peakLevel; + } + }, { + key: "epsilon", + set: function set(value) { + this._.setEpsilon(value); + }, + get: function get() { + return this._.epsilon; + } + }, { + key: "attackCurve", + set: function set(value) { + this._.setAttackCurve(value); + }, + get: function get() { + return this._.attackCurve; + } + }, { + key: "decayCurve", + set: function set(value) { + this._.setDecayCurve(value); + }, + get: function get() { + return this._.decayCurve; + } + }, { + key: "releaseCurve", + set: function set(value) { + this._.setReleaseCurve(value); + }, + get: function get() { + return this._.releaseCurve; + } + }]); + + return ADSREnvelope; +})(); + +exports["default"] = ADSREnvelope; +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/ADSRParams.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })(); + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _EnvelopeBuilder = __webpack_require__("./node_modules/adsr-envelope/lib/EnvelopeBuilder.js"); + +var _EnvelopeBuilder2 = _interopRequireDefault(_EnvelopeBuilder); + +var _EnvelopeValue = __webpack_require__("./node_modules/adsr-envelope/lib/EnvelopeValue.js"); + +var _EnvelopeValue2 = _interopRequireDefault(_EnvelopeValue); + +var _defaultValues = __webpack_require__("./node_modules/adsr-envelope/lib/defaultValues.js"); + +var _defaultValues2 = _interopRequireDefault(_defaultValues); + +var _utilsDefaults = __webpack_require__("./node_modules/adsr-envelope/lib/utils/defaults.js"); + +var _utilsDefaults2 = _interopRequireDefault(_utilsDefaults); + +var _utilsConstrain = __webpack_require__("./node_modules/adsr-envelope/lib/utils/constrain.js"); + +var _utilsConstrain2 = _interopRequireDefault(_utilsConstrain); + +var _utilsIsFiniteNumber = __webpack_require__("./node_modules/adsr-envelope/lib/utils/isFiniteNumber.js"); + +var _utilsIsFiniteNumber2 = _interopRequireDefault(_utilsIsFiniteNumber); + +var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); + +var EPSILON = 2.220446049250313e-16; + +var ADSRParams = (function () { + function ADSRParams() { + var opts = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + + _classCallCheck(this, ADSRParams); + + this.attackTime = time((0, _utilsDefaults2["default"])(opts.attackTime, _defaultValues2["default"].attackTime)); + this.decayTime = time((0, _utilsDefaults2["default"])(opts.decayTime, _defaultValues2["default"].decayTime)); + this.sustainLevel = level((0, _utilsDefaults2["default"])(opts.sustainLevel, _defaultValues2["default"].sustainLevel)); + this.releaseTime = time((0, _utilsDefaults2["default"])(opts.releaseTime, _defaultValues2["default"].releaseTime)); + this.peakLevel = time((0, _utilsDefaults2["default"])(opts.peakLevel, _defaultValues2["default"].peakLevel)); + this.epsilon = epsilon((0, _utilsDefaults2["default"])(opts.epsilon, _defaultValues2["default"].epsilon)); + this.attackCurve = curve((0, _utilsDefaults2["default"])(opts.attackCurve, _defaultValues2["default"].attackCurve)); + this.decayCurve = curve((0, _utilsDefaults2["default"])(opts.decayCurve, _defaultValues2["default"].decayCurve)); + this.releaseCurve = curve((0, _utilsDefaults2["default"])(opts.releaseCurve, _defaultValues2["default"].releaseCurve)); + this.gateTime = _defaultValues2["default"].gateTime; + + if ((0, _utilsIsFiniteNumber2["default"])(opts.sustainTime)) { + this.setSustainTime(opts.sustainTime); + } + if ((0, _utilsIsFiniteNumber2["default"])(opts.gateTime)) { + this.setGateTime(opts.gateTime); + } + if ((0, _utilsIsFiniteNumber2["default"])(opts.duration)) { + this.setDuration(opts.duration); + } + + this.update(); + } + + _createClass(ADSRParams, [{ + key: "valueAt", + value: function valueAt(time) { + return _EnvelopeValue2["default"].at(this.envelope, time); + } + }, { + key: "methods", + value: function methods(playbackTime) { + return this.envelope.map(function (_ref) { + var _ref2 = _slicedToArray(_ref, 3); + + var type = _ref2[0]; + var value = _ref2[1]; + var time = _ref2[2]; + + return [method(type), value, playbackTime + time]; + }); + } + }, { + key: "setDuration", + value: function setDuration(value) { + var duration = time(value); + + this.setGateTime(duration - this.releaseTime); + } + }, { + key: "setAttackTime", + value: function setAttackTime(value) { + this.attackTime = time(value); + this.update(); + } + }, { + key: "setDecayTime", + value: function setDecayTime(value) { + this.decayTime = time(value); + this.update(); + } + }, { + key: "setSustainTime", + value: function setSustainTime(value) { + var sustainTime = time(value); + + this.setGateTime(this.attackTime + this.decayTime + sustainTime); + } + }, { + key: "setSustainLevel", + value: function setSustainLevel(value) { + this.sustainLevel = level(value); + this.update(); + } + }, { + key: "setReleaseTime", + value: function setReleaseTime(value) { + this.releaseTime = time(value); + this.update(); + } + }, { + key: "setGateTime", + value: function setGateTime(value) { + this.gateTime = time(value); + this.update(); + } + }, { + key: "setPeakLevel", + value: function setPeakLevel(value) { + this.peakLevel = time(value); + this.update(); + } + }, { + key: "setEpsilon", + value: function setEpsilon(value) { + this.epsilon = epsilon(value); + this.update(); + } + }, { + key: "setAttackCurve", + value: function setAttackCurve(value) { + this.attackCurve = curve(value); + this.update(); + } + }, { + key: "setDecayCurve", + value: function setDecayCurve(value) { + this.decayCurve = curve(value); + this.update(); + } + }, { + key: "setReleaseCurve", + value: function setReleaseCurve(value) { + this.releaseCurve = curve(value); + this.update(); + } + }, { + key: "update", + value: function update() { + this.sustainTime = Math.max(0, this.gateTime - this.attackTime - this.decayTime); + this.duration = this.gateTime + this.releaseTime; + this.envelope = _EnvelopeBuilder2["default"].build(this); + } + }]); + + return ADSRParams; +})(); + +exports["default"] = ADSRParams; + +function time(value) { + return Math.max(0, value) || 0; +} + +function level(value) { + return (0, _utilsConstrain2["default"])(+value, 0, 1) || 0; +} + +function epsilon(value) { + return (0, _utilsConstrain2["default"])(+value, EPSILON, 1e-2) || 1e-3; +} + +function curve(type) { + return type === "exp" ? "exp" : "lin"; +} + +function method(type) { + switch (type) { + case _constants.SET: + return "setValueAtTime"; + case _constants.LIN: + return "linearRampToValueAtTime"; + case _constants.EXP: + return "exponentialRampToValueAtTime"; + default: + // do nothing + } +} +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/EnvelopeBuilder.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var _EnvelopeReducer = __webpack_require__("./node_modules/adsr-envelope/lib/EnvelopeReducer.js"); + +var _EnvelopeReducer2 = _interopRequireDefault(_EnvelopeReducer); + +var _utilsLinlin = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linlin.js"); + +var _utilsLinlin2 = _interopRequireDefault(_utilsLinlin); + +var _utilsLinexp = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linexp.js"); + +var _utilsLinexp2 = _interopRequireDefault(_utilsLinexp); + +var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); + +function build(params) { + var envelope = buildEnvelope(params); + + envelope = _EnvelopeReducer2["default"].reduce(envelope); + + return envelope; +} + +function getCurveItems(curveType, epsilon) { + if (curveType === "exp") { + return { zero: epsilon, calc: _utilsLinexp2["default"], type: _constants.EXP }; + } + return { zero: 0, calc: _utilsLinlin2["default"], type: _constants.LIN }; +} + +function buildEnvelope(params) { + var attackTime = params.attackTime; + var decayTime = params.decayTime; + var gateTime = params.gateTime; + var releaseTime = params.releaseTime; + + var envType = 0; + + envType += 0 < attackTime ? 4 : 0; + envType += 0 < decayTime ? 2 : 0; + envType += 0 < releaseTime ? 1 : 0; + + switch (envType) { + case 0: + return buildSustainEnvelope(params); + case 1: + return buildSustainReleaseEnvelope(params); + case 2: + if (gateTime <= decayTime) { + return buildDecayEnvelope(params); + } + return buildDecaySustainEnvelope(params); + case 3: + if (gateTime <= decayTime) { + return buildDecayReleaseEnvelope(params); + } + return buildDecaySustainReleaseEnvelope(params); + case 4: + if (gateTime <= attackTime) { + return buildAttackEnvelope(params); + } + return buildAttackSustainEnvelope(params); + case 5: + if (gateTime <= attackTime) { + return buildAttackReleaseEnvelope(params); + } + return buildAttackSustainReleaseEnvelope(params); + case 6: + if (gateTime <= attackTime) { + return buildAttackEnvelope(params); + } + if (gateTime <= attackTime + decayTime) { + return buildAttackDecayEnvelope(params); + } + return buildAttackDecaySustainEnvelope(params); + case 7: + if (gateTime <= attackTime) { + return buildAttackReleaseEnvelope(params); + } + if (gateTime <= attackTime + decayTime) { + return buildAttackDecayReleaseEnvelope(params); + } + return buildAttackDecaySustainReleaseEnvelope(params); + default: + // do nothing + } +} + +function buildSustainEnvelope(params) { + // + // + // ----------* + // | + // +--------- + // 0 12 + // + var result = []; + var t0 = 0; + var t1 = params.gateTime; + var t2 = params.gateTime; + var v0 = params.sustainLevel * params.peakLevel; + var v1 = params.sustainLevel * params.peakLevel; + var v2 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([_constants.SET, v1, t1]); + result.push([_constants.SET, v2, t2]); + + return result; +} + +function buildSustainReleaseEnvelope(params) { + // + // + // ----------* + // \ + // +------- + // 0 1 2 + var result = []; + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.gateTime; + var t2 = params.gateTime + params.releaseTime; + var v0 = Math.max(r.zero, params.sustainLevel * params.peakLevel); + var v1 = Math.max(r.zero, params.sustainLevel * params.peakLevel); + var v2 = r.zero; + + result.push([_constants.SET, v0, t0]); + result.push([_constants.SET, v1, t1]); + result.push([r.type, v2, t2]); + + return result; +} + +function buildDecaySustainEnvelope(params) { + // + + // \ + // +-------* + // | + // +--------- + // 0 1 23 + var result = []; + var d = getCurveItems(params.decayCurve, params.epsilon); + var t0 = 0; + var t1 = params.decayTime; + var t2 = params.gateTime; + var t3 = params.gateTime; + var v0 = Math.max(d.zero, params.peakLevel); + var v1 = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v2 = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v3 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([d.type, v1, t1]); + result.push([_constants.SET, v2, t2]); + result.push([_constants.SET, v3, t3]); + + return result; +} + +function buildDecayEnvelope(params) { + // + + // \ + // * + // | + // +----------------- + // 0 12 + var result = []; + var d = getCurveItems(params.decayCurve, params.epsilon); + var t0 = 0; + var t1 = params.gateTime; + var t2 = params.gateTime; + var v0 = Math.max(d.zero, params.peakLevel); + var vx = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v1 = d.calc(t1, 0, params.decayTime, v0, vx); + var v2 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([d.type, v1, t1]); + result.push([_constants.SET, v2, t2]); + + return result; +} + +function buildDecaySustainReleaseEnvelope(params) { + // + + // \ + // +-------* + // \ + // +------- + // 0 1 2 3 + var result = []; + var d = getCurveItems(params.decayCurve, params.epsilon); + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.decayTime; + var t2 = params.gateTime; + var t3 = params.gateTime + params.releaseTime; + var v0 = Math.max(d.zero, r.zero, params.peakLevel); + var v1 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); + var v2 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); + var v3 = r.zero; + + result.push([_constants.SET, v0, t0]); + result.push([d.type, v1, t1]); + result.push([_constants.SET, v2, t2]); + result.push([r.type, v3, t3]); + + return result; +} + +function buildDecayReleaseEnvelope(params) { + // + + // \ + // * + // \ + // +--------------- + // 0 1 2 + var result = []; + var d = getCurveItems(params.decayCurve, params.epsilon); + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.gateTime; + var t2 = params.gateTime + params.releaseTime; + var v0 = Math.max(d.zero, r.zero, params.peakLevel); + var vx = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); + var v1 = d.calc(t1, 0, params.decayTime, v0, vx); + var v2 = Math.max(d.zero, r.zero); + + result.push([_constants.SET, v0, t0]); + result.push([d.type, v1, t1]); + result.push([r.type, v2, t2]); + + return result; +} + +function buildAttackSustainEnvelope(params) { + // + + // /| + // / +-----* + // / | + // + +--------- + // 0 12 34 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var t0 = 0; + var t1 = params.attackTime; + var t2 = params.attackTime; + var t3 = params.gateTime; + var t4 = params.gateTime; + var v0 = a.zero; + var v1 = Math.max(a.zero, params.peakLevel); + var v2 = params.sustainLevel * params.peakLevel; + var v3 = params.sustainLevel * params.peakLevel; + var v4 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([_constants.SET, v2, t2]); + result.push([_constants.SET, v3, t3]); + result.push([_constants.SET, v4, t4]); + + return result; +} + +function buildAttackEnvelope(params) { + // + // + // * + // /| + // + +----------------- + // 0 12 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var t0 = 0; + var t1 = params.gateTime; + var t2 = params.gateTime; + var v0 = a.zero; + var vx = Math.max(a.zero, params.peakLevel); + var v1 = a.calc(t1, 0, params.attackTime, v0, vx); + var v2 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([_constants.SET, v2, t2]); + + return result; +} + +function buildAttackSustainReleaseEnvelope(params) { + // + + // /| + // / +-----* + // / \ + // + +------- + // 0 12 3 4 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.attackTime; + var t2 = params.attackTime; + var t3 = params.gateTime; + var t4 = params.gateTime + params.releaseTime; + var v0 = a.zero; + var v1 = Math.max(a.zero, params.peakLevel); + var v2 = Math.max(r.zero, params.sustainLevel * params.peakLevel); + var v3 = Math.max(r.zero, params.sustainLevel * params.peakLevel); + var v4 = r.zero; + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([_constants.SET, v2, t2]); + result.push([_constants.SET, v3, t3]); + result.push([r.type, v4, t4]); + + return result; +} + +function buildAttackReleaseEnvelope(params) { + // + // + // * + // / \ + // + +--------------- + // 0 1 2 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.gateTime; + var t2 = params.gateTime + params.releaseTime; + var v0 = a.zero; + var vx = Math.max(a.zero, params.peakLevel); + var v1 = a.calc(t1, 0, params.attackTime, v0, vx); + var v2 = r.zero; + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([r.type, v2, t2]); + + return result; +} + +function buildAttackDecaySustainEnvelope(params) { + // + + // / \ + // / +---* + // / | + // + +--------- + // 0 1 2 34 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var d = getCurveItems(params.decayCurve, params.epsilon); + var t0 = 0; + var t1 = params.attackTime; + var t2 = params.attackTime + params.decayTime; + var t3 = params.gateTime; + var t4 = params.gateTime; + var v0 = a.zero; + var v1 = Math.max(a.zero, d.zero, params.peakLevel); + var v2 = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v3 = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v4 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([d.type, v2, t2]); + result.push([_constants.SET, v3, t3]); + result.push([_constants.SET, v4, t4]); + + return result; +} + +function buildAttackDecayEnvelope(params) { + // + + // / \ + // / * + // / | + // + +------------- + // 0 1 23 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var d = getCurveItems(params.decayCurve, params.epsilon); + var t0 = 0; + var t1 = params.attackTime; + var t2 = params.gateTime; + var t3 = params.gateTime; + var v0 = a.zero; + var v1 = Math.max(a.zero, d.zero, params.peakLevel); + var vx = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v2 = d.calc(t2, params.attackTime, params.attackTime + params.decayTime, v1, vx); + var v3 = 0; + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([d.type, v2, t2]); + result.push([_constants.SET, v3, t3]); + + return result; +} + +function buildAttackDecaySustainReleaseEnvelope(params) { + // + + // / \ + // / +---* + // / \ + // + +------- + // 0 1 2 3 4 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var d = getCurveItems(params.decayCurve, params.epsilon); + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.attackTime; + var t2 = params.attackTime + params.decayTime; + var t3 = params.gateTime; + var t4 = params.gateTime + params.releaseTime; + var v0 = a.zero; + var v1 = Math.max(a.zero, d.zero, params.peakLevel); + var v2 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); + var v3 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); + var v4 = Math.max(d.zero, r.zero); + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([d.type, v2, t2]); + result.push([_constants.SET, v3, t3]); + result.push([r.type, v4, t4]); + + return result; +} + +function buildAttackDecayReleaseEnvelope(params) { + // + + // / \ + // / * + // / \ + // + +----------- + // 0 1 2 3 + var result = []; + var a = getCurveItems(params.attackCurve, params.epsilon); + var d = getCurveItems(params.decayCurve, params.epsilon); + var r = getCurveItems(params.releaseCurve, params.epsilon); + var t0 = 0; + var t1 = params.attackTime; + var t2 = params.gateTime; + var t3 = params.gateTime + params.releaseTime; + var v0 = a.zero; + var v1 = Math.max(a.zero, d.zero, params.peakLevel); + var vx = Math.max(d.zero, params.sustainLevel * params.peakLevel); + var v2 = d.calc(t2, params.attackTime, params.attackTime + params.decayTime, v1, vx); + var v3 = Math.max(d.zero, r.zero); + + result.push([_constants.SET, v0, t0]); + result.push([a.type, v1, t1]); + result.push([d.type, v2, t2]); + result.push([r.type, v3, t3]); + + return result; +} + +exports["default"] = { build: build }; +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/EnvelopeReducer.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); + +function reduce(envelope) { + envelope = envelope.filter(function (items) { + return isFinite(items[_constants.TIME]); + }); + + var changed = undefined; + + do { + changed = false; + + if (2 <= envelope.length) { + var a = envelope[envelope.length - 2]; + var b = envelope[envelope.length - 1]; + + if (a[_constants.VALUE] === b[_constants.VALUE]) { + envelope.pop(); + } + } + + for (var i = envelope.length - 2; i >= 0; i--) { + var a = envelope[i]; + var b = envelope[i + 1]; + + if (a[_constants.TYPE] === _constants.SET) { + if (b[_constants.TYPE] !== _constants.SET) { + if (a[_constants.VALUE] === b[_constants.VALUE] || a[_constants.TIME] === b[_constants.TIME]) { + b[_constants.TYPE] = _constants.SET; + changed = true; + } + } else if (a[_constants.TIME] === b[_constants.TIME]) { + envelope.splice(i, 1); + changed = true; + } + } + } + } while (changed && envelope.length); + + return envelope; +} + +exports["default"] = { reduce: reduce }; +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/EnvelopeValue.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var _utilsLinlin = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linlin.js"); + +var _utilsLinlin2 = _interopRequireDefault(_utilsLinlin); + +var _utilsLinexp = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linexp.js"); + +var _utilsLinexp2 = _interopRequireDefault(_utilsLinexp); + +var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); + +function at(envelope, time) { + for (var i = 0, imax = envelope.length - 1; i < imax; i++) { + var e0 = envelope[i]; + var e1 = envelope[i + 1]; + + if (e0[_constants.TIME] <= time && time < e1[_constants.TIME]) { + switch (e1[_constants.TYPE]) { + case _constants.LIN: + return (0, _utilsLinlin2["default"])(time, e0[_constants.TIME], e1[_constants.TIME], e0[_constants.VALUE], e1[_constants.VALUE]); + case _constants.EXP: + return (0, _utilsLinexp2["default"])(time, e0[_constants.TIME], e1[_constants.TIME], e0[_constants.VALUE], e1[_constants.VALUE]); + default: + return e0[_constants.VALUE]; + } + } + } + + return envelope.length ? envelope[envelope.length - 1][_constants.VALUE] : 0; +} + +exports["default"] = { at: at }; +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/constants.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var SET = 0; +exports.SET = SET; +var LIN = 1; +exports.LIN = LIN; +var EXP = 2; + +exports.EXP = EXP; +var TYPE = 0; +exports.TYPE = TYPE; +var VALUE = 1; +exports.VALUE = VALUE; +var TIME = 2; +exports.TIME = TIME; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/defaultValues.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = { + attackTime: 0.01, + decayTime: 0.3, + sustainLevel: 0.5, + releaseTime: 1, + gateTime: Infinity, + peakLevel: 1, + epsilon: 1e-3, + attackCurve: "lin", + decayCurve: "lin", + releaseCurve: "lin" +}; +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/index.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var _ADSREnvelope = __webpack_require__("./node_modules/adsr-envelope/lib/ADSREnvelope.js"); + +var _ADSREnvelope2 = _interopRequireDefault(_ADSREnvelope); + +exports["default"] = _ADSREnvelope2["default"]; +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/utils/constrain.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = constrain; + +function constrain(value, minValue, maxValue) { + return Math.max(minValue, Math.min(value, maxValue)); +} + +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/utils/defaults.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = defaults; + +function defaults(value, defaultValue) { + return typeof value !== "undefined" ? value : defaultValue; +} + +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/utils/isFiniteNumber.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = isFiniteNumber; + +function isFiniteNumber(value) { + return typeof value === "number" && isFinite(value); +} + +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/utils/linexp.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = linexp; + +function linexp(value, inMin, inMax, outMin, outMax) { + return Math.pow(outMax / outMin, (value - inMin) / (inMax - inMin)) * outMin; +} + +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/adsr-envelope/lib/utils/linlin.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = linlin; + +function linlin(value, inMin, inMax, outMin, outMax) { + return (value - inMin) / (inMax - inMin) * (outMax - outMin) + outMin; +} + +module.exports = exports["default"]; + +/***/ }), + +/***/ "./node_modules/base-audio-context/index.js": +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(global) {var AudioContext = global.AudioContext || global.webkitAudioContext; +var OfflineAudioContext = global.OfflineAudioContext || global.webkitOfflineAudioContext; +var BaseAudioContext = global.BaseAudioContext || (OfflineAudioContext && Object.getPrototypeOf(OfflineAudioContext)); + +module.exports = (typeof BaseAudioContext === "function" && BaseAudioContext.prototype) ? BaseAudioContext : AudioContext; + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/global.js"))) + +/***/ }), + +/***/ "./node_modules/codemirror/addon/mode/simple.js": +/***/ (function(module, exports, __webpack_require__) { + +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: http://codemirror.net/LICENSE + +(function(mod) { + if (true) // CommonJS + mod(__webpack_require__("./node_modules/codemirror/lib/codemirror.js")); + else {} +})(function(CodeMirror) { + "use strict"; + + CodeMirror.defineSimpleMode = function(name, states) { + CodeMirror.defineMode(name, function(config) { + return CodeMirror.simpleMode(config, states); + }); + }; + + CodeMirror.simpleMode = function(config, states) { + ensureState(states, "start"); + var states_ = {}, meta = states.meta || {}, hasIndentation = false; + for (var state in states) if (state != meta && states.hasOwnProperty(state)) { + var list = states_[state] = [], orig = states[state]; + for (var i = 0; i < orig.length; i++) { + var data = orig[i]; + list.push(new Rule(data, states)); + if (data.indent || data.dedent) hasIndentation = true; + } + } + var mode = { + startState: function() { + return {state: "start", pending: null, + local: null, localState: null, + indent: hasIndentation ? [] : null}; + }, + copyState: function(state) { + var s = {state: state.state, pending: state.pending, + local: state.local, localState: null, + indent: state.indent && state.indent.slice(0)}; + if (state.localState) + s.localState = CodeMirror.copyState(state.local.mode, state.localState); + if (state.stack) + s.stack = state.stack.slice(0); + for (var pers = state.persistentStates; pers; pers = pers.next) + s.persistentStates = {mode: pers.mode, + spec: pers.spec, + state: pers.state == state.localState ? s.localState : CodeMirror.copyState(pers.mode, pers.state), + next: s.persistentStates}; + return s; + }, + token: tokenFunction(states_, config), + innerMode: function(state) { return state.local && {mode: state.local.mode, state: state.localState}; }, + indent: indentFunction(states_, meta) + }; + if (meta) for (var prop in meta) if (meta.hasOwnProperty(prop)) + mode[prop] = meta[prop]; + return mode; + }; + + function ensureState(states, name) { + if (!states.hasOwnProperty(name)) + throw new Error("Undefined state " + name + " in simple mode"); + } + + function toRegex(val, caret) { + if (!val) return /(?:)/; + var flags = ""; + if (val instanceof RegExp) { + if (val.ignoreCase) flags = "i"; + val = val.source; + } else { + val = String(val); + } + return new RegExp((caret === false ? "" : "^") + "(?:" + val + ")", flags); + } + + function asToken(val) { + if (!val) return null; + if (val.apply) return val + if (typeof val == "string") return val.replace(/\./g, " "); + var result = []; + for (var i = 0; i < val.length; i++) + result.push(val[i] && val[i].replace(/\./g, " ")); + return result; + } + + function Rule(data, states) { + if (data.next || data.push) ensureState(states, data.next || data.push); + this.regex = toRegex(data.regex); + this.token = asToken(data.token); + this.data = data; + } + + function tokenFunction(states, config) { + return function(stream, state) { + if (state.pending) { + var pend = state.pending.shift(); + if (state.pending.length == 0) state.pending = null; + stream.pos += pend.text.length; + return pend.token; + } + + if (state.local) { + if (state.local.end && stream.match(state.local.end)) { + var tok = state.local.endToken || null; + state.local = state.localState = null; + return tok; + } else { + var tok = state.local.mode.token(stream, state.localState), m; + if (state.local.endScan && (m = state.local.endScan.exec(stream.current()))) + stream.pos = stream.start + m.index; + return tok; + } + } + + var curState = states[state.state]; + for (var i = 0; i < curState.length; i++) { + var rule = curState[i]; + var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex); + if (matches) { + if (rule.data.next) { + state.state = rule.data.next; + } else if (rule.data.push) { + (state.stack || (state.stack = [])).push(state.state); + state.state = rule.data.push; + } else if (rule.data.pop && state.stack && state.stack.length) { + state.state = state.stack.pop(); + } + + if (rule.data.mode) + enterLocalMode(config, state, rule.data.mode, rule.token); + if (rule.data.indent) + state.indent.push(stream.indentation() + config.indentUnit); + if (rule.data.dedent) + state.indent.pop(); + var token = rule.token + if (token && token.apply) token = token(matches) + if (matches.length > 2 && rule.token && typeof rule.token != "string") { + state.pending = []; + for (var j = 2; j < matches.length; j++) + if (matches[j]) + state.pending.push({text: matches[j], token: rule.token[j - 1]}); + stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0)); + return token[0]; + } else if (token && token.join) { + return token[0]; + } else { + return token; + } + } + } + stream.next(); + return null; + }; + } + + function cmp(a, b) { + if (a === b) return true; + if (!a || typeof a != "object" || !b || typeof b != "object") return false; + var props = 0; + for (var prop in a) if (a.hasOwnProperty(prop)) { + if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop])) return false; + props++; + } + for (var prop in b) if (b.hasOwnProperty(prop)) props--; + return props == 0; + } + + function enterLocalMode(config, state, spec, token) { + var pers; + if (spec.persistent) for (var p = state.persistentStates; p && !pers; p = p.next) + if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode) pers = p; + var mode = pers ? pers.mode : spec.mode || CodeMirror.getMode(config, spec.spec); + var lState = pers ? pers.state : CodeMirror.startState(mode); + if (spec.persistent && !pers) + state.persistentStates = {mode: mode, spec: spec.spec, state: lState, next: state.persistentStates}; + + state.localState = lState; + state.local = {mode: mode, + end: spec.end && toRegex(spec.end), + endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false), + endToken: token && token.join ? token[token.length - 1] : token}; + } + + function indexOf(val, arr) { + for (var i = 0; i < arr.length; i++) if (arr[i] === val) return true; + } + + function indentFunction(states, meta) { + return function(state, textAfter, line) { + if (state.local && state.local.mode.indent) + return state.local.mode.indent(state.localState, textAfter, line); + if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1) + return CodeMirror.Pass; + + var pos = state.indent.length - 1, rules = states[state.state]; + scan: for (;;) { + for (var i = 0; i < rules.length; i++) { + var rule = rules[i]; + if (rule.data.dedent && rule.data.dedentIfLineStart !== false) { + var m = rule.regex.exec(textAfter); + if (m && m[0]) { + pos--; + if (rule.next || rule.push) rules = states[rule.next || rule.push]; + textAfter = textAfter.slice(m[0].length); + continue scan; + } + } + } + break; + } + return pos < 0 ? 0 : state.indent[pos]; + }; + } +}); + + +/***/ }), + +/***/ "./node_modules/codemirror/lib/codemirror.css": +/***/ (function(module, exports, __webpack_require__) { + +// extracted by mini-css-extract-plugin + +/***/ }), + +/***/ "./node_modules/codemirror/lib/codemirror.js": +/***/ (function(module, exports, __webpack_require__) { + +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: http://codemirror.net/LICENSE + +// This is CodeMirror (http://codemirror.net), a code editor +// implemented in JavaScript on top of the browser's DOM. +// +// You can find some technical background for some of the code below +// at http://marijnhaverbeke.nl/blog/#cm-internals . + +(function (global, factory) { + true ? module.exports = factory() : + undefined; +}(this, (function () { 'use strict'; + +// Kludges for bugs and behavior differences that can't be feature +// detected are enabled based on userAgent etc sniffing. +var userAgent = navigator.userAgent; +var platform = navigator.platform; + +var gecko = /gecko\/\d/i.test(userAgent); +var ie_upto10 = /MSIE \d/.test(userAgent); +var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent); +var edge = /Edge\/(\d+)/.exec(userAgent); +var ie = ie_upto10 || ie_11up || edge; +var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]); +var webkit = !edge && /WebKit\//.test(userAgent); +var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent); +var chrome = !edge && /Chrome\//.test(userAgent); +var presto = /Opera\//.test(userAgent); +var safari = /Apple Computer/.test(navigator.vendor); +var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent); +var phantom = /PhantomJS/.test(userAgent); + +var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent); +var android = /Android/.test(userAgent); +// This is woefully incomplete. Suggestions for alternative methods welcome. +var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent); +var mac = ios || /Mac/.test(platform); +var chromeOS = /\bCrOS\b/.test(userAgent); +var windows = /win/i.test(platform); + +var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/); +if (presto_version) { presto_version = Number(presto_version[1]); } +if (presto_version && presto_version >= 15) { presto = false; webkit = true; } +// Some browsers use the wrong event properties to signal cmd/ctrl on OS X +var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11)); +var captureRightClick = gecko || (ie && ie_version >= 9); + +function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") } + +var rmClass = function(node, cls) { + var current = node.className; + var match = classTest(cls).exec(current); + if (match) { + var after = current.slice(match.index + match[0].length); + node.className = current.slice(0, match.index) + (after ? match[1] + after : ""); + } +}; + +function removeChildren(e) { + for (var count = e.childNodes.length; count > 0; --count) + { e.removeChild(e.firstChild); } + return e +} + +function removeChildrenAndAdd(parent, e) { + return removeChildren(parent).appendChild(e) +} + +function elt(tag, content, className, style) { + var e = document.createElement(tag); + if (className) { e.className = className; } + if (style) { e.style.cssText = style; } + if (typeof content == "string") { e.appendChild(document.createTextNode(content)); } + else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]); } } + return e +} +// wrapper for elt, which removes the elt from the accessibility tree +function eltP(tag, content, className, style) { + var e = elt(tag, content, className, style); + e.setAttribute("role", "presentation"); + return e +} + +var range; +if (document.createRange) { range = function(node, start, end, endNode) { + var r = document.createRange(); + r.setEnd(endNode || node, end); + r.setStart(node, start); + return r +}; } +else { range = function(node, start, end) { + var r = document.body.createTextRange(); + try { r.moveToElementText(node.parentNode); } + catch(e) { return r } + r.collapse(true); + r.moveEnd("character", end); + r.moveStart("character", start); + return r +}; } + +function contains(parent, child) { + if (child.nodeType == 3) // Android browser always returns false when child is a textnode + { child = child.parentNode; } + if (parent.contains) + { return parent.contains(child) } + do { + if (child.nodeType == 11) { child = child.host; } + if (child == parent) { return true } + } while (child = child.parentNode) +} + +function activeElt() { + // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement. + // IE < 10 will throw when accessed while the page is loading or in an iframe. + // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable. + var activeElement; + try { + activeElement = document.activeElement; + } catch(e) { + activeElement = document.body || null; + } + while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement) + { activeElement = activeElement.shadowRoot.activeElement; } + return activeElement +} + +function addClass(node, cls) { + var current = node.className; + if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls; } +} +function joinClasses(a, b) { + var as = a.split(" "); + for (var i = 0; i < as.length; i++) + { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i]; } } + return b +} + +var selectInput = function(node) { node.select(); }; +if (ios) // Mobile Safari apparently has a bug where select() is broken. + { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; }; } +else if (ie) // Suppress mysterious IE10 errors + { selectInput = function(node) { try { node.select(); } catch(_e) {} }; } + +function bind(f) { + var args = Array.prototype.slice.call(arguments, 1); + return function(){return f.apply(null, args)} +} + +function copyObj(obj, target, overwrite) { + if (!target) { target = {}; } + for (var prop in obj) + { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop))) + { target[prop] = obj[prop]; } } + return target +} + +// Counts the column offset in a string, taking tabs into account. +// Used mostly to find indentation. +function countColumn(string, end, tabSize, startIndex, startValue) { + if (end == null) { + end = string.search(/[^\s\u00a0]/); + if (end == -1) { end = string.length; } + } + for (var i = startIndex || 0, n = startValue || 0;;) { + var nextTab = string.indexOf("\t", i); + if (nextTab < 0 || nextTab >= end) + { return n + (end - i) } + n += nextTab - i; + n += tabSize - (n % tabSize); + i = nextTab + 1; + } +} + +var Delayed = function() {this.id = null;}; +Delayed.prototype.set = function (ms, f) { + clearTimeout(this.id); + this.id = setTimeout(f, ms); +}; + +function indexOf(array, elt) { + for (var i = 0; i < array.length; ++i) + { if (array[i] == elt) { return i } } + return -1 +} + +// Number of pixels added to scroller and sizer to hide scrollbar +var scrollerGap = 30; + +// Returned or thrown by various protocols to signal 'I'm not +// handling this'. +var Pass = {toString: function(){return "CodeMirror.Pass"}}; + +// Reused option objects for setSelection & friends +var sel_dontScroll = {scroll: false}; +var sel_mouse = {origin: "*mouse"}; +var sel_move = {origin: "+move"}; + +// The inverse of countColumn -- find the offset that corresponds to +// a particular column. +function findColumn(string, goal, tabSize) { + for (var pos = 0, col = 0;;) { + var nextTab = string.indexOf("\t", pos); + if (nextTab == -1) { nextTab = string.length; } + var skipped = nextTab - pos; + if (nextTab == string.length || col + skipped >= goal) + { return pos + Math.min(skipped, goal - col) } + col += nextTab - pos; + col += tabSize - (col % tabSize); + pos = nextTab + 1; + if (col >= goal) { return pos } + } +} + +var spaceStrs = [""]; +function spaceStr(n) { + while (spaceStrs.length <= n) + { spaceStrs.push(lst(spaceStrs) + " "); } + return spaceStrs[n] +} + +function lst(arr) { return arr[arr.length-1] } + +function map(array, f) { + var out = []; + for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i); } + return out +} + +function insertSorted(array, value, score) { + var pos = 0, priority = score(value); + while (pos < array.length && score(array[pos]) <= priority) { pos++; } + array.splice(pos, 0, value); +} + +function nothing() {} + +function createObj(base, props) { + var inst; + if (Object.create) { + inst = Object.create(base); + } else { + nothing.prototype = base; + inst = new nothing(); + } + if (props) { copyObj(props, inst); } + return inst +} + +var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/; +function isWordCharBasic(ch) { + return /\w/.test(ch) || ch > "\x80" && + (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch)) +} +function isWordChar(ch, helper) { + if (!helper) { return isWordCharBasic(ch) } + if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true } + return helper.test(ch) +} + +function isEmpty(obj) { + for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } } + return true +} + +// Extending unicode characters. A series of a non-extending char + +// any number of extending chars is treated as a single unit as far +// as editing and measuring is concerned. This is not fully correct, +// since some scripts/fonts/browsers also treat other configurations +// of code points as a group. +var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/; +function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) } + +// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range. +function skipExtendingChars(str, pos, dir) { + while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir; } + return pos +} + +// Returns the value from the range [`from`; `to`] that satisfies +// `pred` and is closest to `from`. Assumes that at least `to` +// satisfies `pred`. Supports `from` being greater than `to`. +function findFirst(pred, from, to) { + // At any point we are certain `to` satisfies `pred`, don't know + // whether `from` does. + var dir = from > to ? -1 : 1; + for (;;) { + if (from == to) { return from } + var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF); + if (mid == from) { return pred(mid) ? from : to } + if (pred(mid)) { to = mid; } + else { from = mid + dir; } + } +} + +// The display handles the DOM integration, both for input reading +// and content drawing. It holds references to DOM nodes and +// display-related state. + +function Display(place, doc, input) { + var d = this; + this.input = input; + + // Covers bottom-right square when both scrollbars are present. + d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler"); + d.scrollbarFiller.setAttribute("cm-not-content", "true"); + // Covers bottom of gutter when coverGutterNextToScrollbar is on + // and h scrollbar is present. + d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler"); + d.gutterFiller.setAttribute("cm-not-content", "true"); + // Will contain the actual code, positioned to cover the viewport. + d.lineDiv = eltP("div", null, "CodeMirror-code"); + // Elements are added to these to represent selection and cursors. + d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1"); + d.cursorDiv = elt("div", null, "CodeMirror-cursors"); + // A visibility: hidden element used to find the size of things. + d.measure = elt("div", null, "CodeMirror-measure"); + // When lines outside of the viewport are measured, they are drawn in this. + d.lineMeasure = elt("div", null, "CodeMirror-measure"); + // Wraps everything that needs to exist inside the vertically-padded coordinate system + d.lineSpace = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv], + null, "position: relative; outline: none"); + var lines = eltP("div", [d.lineSpace], "CodeMirror-lines"); + // Moved around its parent to cover visible view. + d.mover = elt("div", [lines], null, "position: relative"); + // Set to the height of the document, allowing scrolling. + d.sizer = elt("div", [d.mover], "CodeMirror-sizer"); + d.sizerWidth = null; + // Behavior of elts with overflow: auto and padding is + // inconsistent across browsers. This is used to ensure the + // scrollable area is big enough. + d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;"); + // Will contain the gutters, if any. + d.gutters = elt("div", null, "CodeMirror-gutters"); + d.lineGutter = null; + // Actual scrollable element. + d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll"); + d.scroller.setAttribute("tabIndex", "-1"); + // The element in which the editor lives. + d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror"); + + // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported) + if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; } + if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true; } + + if (place) { + if (place.appendChild) { place.appendChild(d.wrapper); } + else { place(d.wrapper); } + } + + // Current rendered range (may be bigger than the view window). + d.viewFrom = d.viewTo = doc.first; + d.reportedViewFrom = d.reportedViewTo = doc.first; + // Information about the rendered lines. + d.view = []; + d.renderedView = null; + // Holds info about a single rendered line when it was rendered + // for measurement, while not in view. + d.externalMeasured = null; + // Empty space (in pixels) above the view + d.viewOffset = 0; + d.lastWrapHeight = d.lastWrapWidth = 0; + d.updateLineNumbers = null; + + d.nativeBarWidth = d.barHeight = d.barWidth = 0; + d.scrollbarsClipped = false; + + // Used to only resize the line number gutter when necessary (when + // the amount of lines crosses a boundary that makes its width change) + d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null; + // Set to true when a non-horizontal-scrolling line widget is + // added. As an optimization, line widget aligning is skipped when + // this is false. + d.alignWidgets = false; + + d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null; + + // Tracks the maximum line length so that the horizontal scrollbar + // can be kept static when scrolling. + d.maxLine = null; + d.maxLineLength = 0; + d.maxLineChanged = false; + + // Used for measuring wheel scrolling granularity + d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null; + + // True when shift is held down. + d.shift = false; + + // Used to track whether anything happened since the context menu + // was opened. + d.selForContextMenu = null; + + d.activeTouch = null; + + input.init(d); +} + +// Find the line object corresponding to the given line number. +function getLine(doc, n) { + n -= doc.first; + if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") } + var chunk = doc; + while (!chunk.lines) { + for (var i = 0;; ++i) { + var child = chunk.children[i], sz = child.chunkSize(); + if (n < sz) { chunk = child; break } + n -= sz; + } + } + return chunk.lines[n] +} + +// Get the part of a document between two positions, as an array of +// strings. +function getBetween(doc, start, end) { + var out = [], n = start.line; + doc.iter(start.line, end.line + 1, function (line) { + var text = line.text; + if (n == end.line) { text = text.slice(0, end.ch); } + if (n == start.line) { text = text.slice(start.ch); } + out.push(text); + ++n; + }); + return out +} +// Get the lines between from and to, as array of strings. +function getLines(doc, from, to) { + var out = []; + doc.iter(from, to, function (line) { out.push(line.text); }); // iter aborts when callback returns truthy value + return out +} + +// Update the height of a line, propagating the height change +// upwards to parent nodes. +function updateLineHeight(line, height) { + var diff = height - line.height; + if (diff) { for (var n = line; n; n = n.parent) { n.height += diff; } } +} + +// Given a line object, find its line number by walking up through +// its parent links. +function lineNo(line) { + if (line.parent == null) { return null } + var cur = line.parent, no = indexOf(cur.lines, line); + for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) { + for (var i = 0;; ++i) { + if (chunk.children[i] == cur) { break } + no += chunk.children[i].chunkSize(); + } + } + return no + cur.first +} + +// Find the line at the given vertical position, using the height +// information in the document tree. +function lineAtHeight(chunk, h) { + var n = chunk.first; + outer: do { + for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) { + var child = chunk.children[i$1], ch = child.height; + if (h < ch) { chunk = child; continue outer } + h -= ch; + n += child.chunkSize(); + } + return n + } while (!chunk.lines) + var i = 0; + for (; i < chunk.lines.length; ++i) { + var line = chunk.lines[i], lh = line.height; + if (h < lh) { break } + h -= lh; + } + return n + i +} + +function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size} + +function lineNumberFor(options, i) { + return String(options.lineNumberFormatter(i + options.firstLineNumber)) +} + +// A Pos instance represents a position within the text. +function Pos(line, ch, sticky) { + if ( sticky === void 0 ) sticky = null; + + if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) } + this.line = line; + this.ch = ch; + this.sticky = sticky; +} + +// Compare two positions, return 0 if they are the same, a negative +// number when a is less, and a positive number otherwise. +function cmp(a, b) { return a.line - b.line || a.ch - b.ch } + +function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 } + +function copyPos(x) {return Pos(x.line, x.ch)} +function maxPos(a, b) { return cmp(a, b) < 0 ? b : a } +function minPos(a, b) { return cmp(a, b) < 0 ? a : b } + +// Most of the external API clips given positions to make sure they +// actually exist within the document. +function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))} +function clipPos(doc, pos) { + if (pos.line < doc.first) { return Pos(doc.first, 0) } + var last = doc.first + doc.size - 1; + if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) } + return clipToLen(pos, getLine(doc, pos.line).text.length) +} +function clipToLen(pos, linelen) { + var ch = pos.ch; + if (ch == null || ch > linelen) { return Pos(pos.line, linelen) } + else if (ch < 0) { return Pos(pos.line, 0) } + else { return pos } +} +function clipPosArray(doc, array) { + var out = []; + for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]); } + return out +} + +// Optimize some code when these features are not used. +var sawReadOnlySpans = false; +var sawCollapsedSpans = false; + +function seeReadOnlySpans() { + sawReadOnlySpans = true; +} + +function seeCollapsedSpans() { + sawCollapsedSpans = true; +} + +// TEXTMARKER SPANS + +function MarkedSpan(marker, from, to) { + this.marker = marker; + this.from = from; this.to = to; +} + +// Search an array of spans for a span matching the given marker. +function getMarkedSpanFor(spans, marker) { + if (spans) { for (var i = 0; i < spans.length; ++i) { + var span = spans[i]; + if (span.marker == marker) { return span } + } } +} +// Remove a span from an array, returning undefined if no spans are +// left (we don't store arrays for lines without spans). +function removeMarkedSpan(spans, span) { + var r; + for (var i = 0; i < spans.length; ++i) + { if (spans[i] != span) { (r || (r = [])).push(spans[i]); } } + return r +} +// Add a span to a line. +function addMarkedSpan(line, span) { + line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]; + span.marker.attachLine(line); +} + +// Used for the algorithm that adjusts markers for a change in the +// document. These functions cut an array of spans at a given +// character position, returning an array of remaining chunks (or +// undefined if nothing remains). +function markedSpansBefore(old, startCh, isInsert) { + var nw; + if (old) { for (var i = 0; i < old.length; ++i) { + var span = old[i], marker = span.marker; + var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh); + if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) { + var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh);(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to)); + } + } } + return nw +} +function markedSpansAfter(old, endCh, isInsert) { + var nw; + if (old) { for (var i = 0; i < old.length; ++i) { + var span = old[i], marker = span.marker; + var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh); + if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) { + var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh, + span.to == null ? null : span.to - endCh)); + } + } } + return nw +} + +// Given a change object, compute the new set of marker spans that +// cover the line in which the change took place. Removes spans +// entirely within the change, reconnects spans belonging to the +// same marker that appear on both sides of the change, and cuts off +// spans partially within the change. Returns an array of span +// arrays with one element for each line in (after) the change. +function stretchSpansOverChange(doc, change) { + if (change.full) { return null } + var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans; + var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans; + if (!oldFirst && !oldLast) { return null } + + var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0; + // Get the spans that 'stick out' on both sides + var first = markedSpansBefore(oldFirst, startCh, isInsert); + var last = markedSpansAfter(oldLast, endCh, isInsert); + + // Next, merge those two ends + var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0); + if (first) { + // Fix up .to properties of first + for (var i = 0; i < first.length; ++i) { + var span = first[i]; + if (span.to == null) { + var found = getMarkedSpanFor(last, span.marker); + if (!found) { span.to = startCh; } + else if (sameLine) { span.to = found.to == null ? null : found.to + offset; } + } + } + } + if (last) { + // Fix up .from in last (or move them into first in case of sameLine) + for (var i$1 = 0; i$1 < last.length; ++i$1) { + var span$1 = last[i$1]; + if (span$1.to != null) { span$1.to += offset; } + if (span$1.from == null) { + var found$1 = getMarkedSpanFor(first, span$1.marker); + if (!found$1) { + span$1.from = offset; + if (sameLine) { (first || (first = [])).push(span$1); } + } + } else { + span$1.from += offset; + if (sameLine) { (first || (first = [])).push(span$1); } + } + } + } + // Make sure we didn't create any zero-length spans + if (first) { first = clearEmptySpans(first); } + if (last && last != first) { last = clearEmptySpans(last); } + + var newMarkers = [first]; + if (!sameLine) { + // Fill gap with whole-line-spans + var gap = change.text.length - 2, gapMarkers; + if (gap > 0 && first) + { for (var i$2 = 0; i$2 < first.length; ++i$2) + { if (first[i$2].to == null) + { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)); } } } + for (var i$3 = 0; i$3 < gap; ++i$3) + { newMarkers.push(gapMarkers); } + newMarkers.push(last); + } + return newMarkers +} + +// Remove spans that are empty and don't have a clearWhenEmpty +// option of false. +function clearEmptySpans(spans) { + for (var i = 0; i < spans.length; ++i) { + var span = spans[i]; + if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false) + { spans.splice(i--, 1); } + } + if (!spans.length) { return null } + return spans +} + +// Used to 'clip' out readOnly ranges when making a change. +function removeReadOnlyRanges(doc, from, to) { + var markers = null; + doc.iter(from.line, to.line + 1, function (line) { + if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) { + var mark = line.markedSpans[i].marker; + if (mark.readOnly && (!markers || indexOf(markers, mark) == -1)) + { (markers || (markers = [])).push(mark); } + } } + }); + if (!markers) { return null } + var parts = [{from: from, to: to}]; + for (var i = 0; i < markers.length; ++i) { + var mk = markers[i], m = mk.find(0); + for (var j = 0; j < parts.length; ++j) { + var p = parts[j]; + if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue } + var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to); + if (dfrom < 0 || !mk.inclusiveLeft && !dfrom) + { newParts.push({from: p.from, to: m.from}); } + if (dto > 0 || !mk.inclusiveRight && !dto) + { newParts.push({from: m.to, to: p.to}); } + parts.splice.apply(parts, newParts); + j += newParts.length - 3; + } + } + return parts +} + +// Connect or disconnect spans from a line. +function detachMarkedSpans(line) { + var spans = line.markedSpans; + if (!spans) { return } + for (var i = 0; i < spans.length; ++i) + { spans[i].marker.detachLine(line); } + line.markedSpans = null; +} +function attachMarkedSpans(line, spans) { + if (!spans) { return } + for (var i = 0; i < spans.length; ++i) + { spans[i].marker.attachLine(line); } + line.markedSpans = spans; +} + +// Helpers used when computing which overlapping collapsed span +// counts as the larger one. +function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 } +function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 } + +// Returns a number indicating which of two overlapping collapsed +// spans is larger (and thus includes the other). Falls back to +// comparing ids when the spans cover exactly the same range. +function compareCollapsedMarkers(a, b) { + var lenDiff = a.lines.length - b.lines.length; + if (lenDiff != 0) { return lenDiff } + var aPos = a.find(), bPos = b.find(); + var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b); + if (fromCmp) { return -fromCmp } + var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b); + if (toCmp) { return toCmp } + return b.id - a.id +} + +// Find out whether a line ends or starts in a collapsed span. If +// so, return the marker for that span. +function collapsedSpanAtSide(line, start) { + var sps = sawCollapsedSpans && line.markedSpans, found; + if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) { + sp = sps[i]; + if (sp.marker.collapsed && (start ? sp.from : sp.to) == null && + (!found || compareCollapsedMarkers(found, sp.marker) < 0)) + { found = sp.marker; } + } } + return found +} +function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) } +function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) } + +function collapsedSpanAround(line, ch) { + var sps = sawCollapsedSpans && line.markedSpans, found; + if (sps) { for (var i = 0; i < sps.length; ++i) { + var sp = sps[i]; + if (sp.marker.collapsed && (sp.from == null || sp.from < ch) && (sp.to == null || sp.to > ch) && + (!found || compareCollapsedMarkers(found, sp.marker) < 0)) { found = sp.marker; } + } } + return found +} + +// Test whether there exists a collapsed span that partially +// overlaps (covers the start or end, but not both) of a new span. +// Such overlap is not allowed. +function conflictingCollapsedRange(doc, lineNo$$1, from, to, marker) { + var line = getLine(doc, lineNo$$1); + var sps = sawCollapsedSpans && line.markedSpans; + if (sps) { for (var i = 0; i < sps.length; ++i) { + var sp = sps[i]; + if (!sp.marker.collapsed) { continue } + var found = sp.marker.find(0); + var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker); + var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker); + if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue } + if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) || + fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0)) + { return true } + } } +} + +// A visual line is a line as drawn on the screen. Folding, for +// example, can cause multiple logical lines to appear on the same +// visual line. This finds the start of the visual line that the +// given line is part of (usually that is the line itself). +function visualLine(line) { + var merged; + while (merged = collapsedSpanAtStart(line)) + { line = merged.find(-1, true).line; } + return line +} + +function visualLineEnd(line) { + var merged; + while (merged = collapsedSpanAtEnd(line)) + { line = merged.find(1, true).line; } + return line +} + +// Returns an array of logical lines that continue the visual line +// started by the argument, or undefined if there are no such lines. +function visualLineContinued(line) { + var merged, lines; + while (merged = collapsedSpanAtEnd(line)) { + line = merged.find(1, true).line + ;(lines || (lines = [])).push(line); + } + return lines +} + +// Get the line number of the start of the visual line that the +// given line number is part of. +function visualLineNo(doc, lineN) { + var line = getLine(doc, lineN), vis = visualLine(line); + if (line == vis) { return lineN } + return lineNo(vis) +} + +// Get the line number of the start of the next visual line after +// the given line. +function visualLineEndNo(doc, lineN) { + if (lineN > doc.lastLine()) { return lineN } + var line = getLine(doc, lineN), merged; + if (!lineIsHidden(doc, line)) { return lineN } + while (merged = collapsedSpanAtEnd(line)) + { line = merged.find(1, true).line; } + return lineNo(line) + 1 +} + +// Compute whether a line is hidden. Lines count as hidden when they +// are part of a visual line that starts with another line, or when +// they are entirely covered by collapsed, non-widget span. +function lineIsHidden(doc, line) { + var sps = sawCollapsedSpans && line.markedSpans; + if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) { + sp = sps[i]; + if (!sp.marker.collapsed) { continue } + if (sp.from == null) { return true } + if (sp.marker.widgetNode) { continue } + if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp)) + { return true } + } } +} +function lineIsHiddenInner(doc, line, span) { + if (span.to == null) { + var end = span.marker.find(1, true); + return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker)) + } + if (span.marker.inclusiveRight && span.to == line.text.length) + { return true } + for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) { + sp = line.markedSpans[i]; + if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to && + (sp.to == null || sp.to != span.from) && + (sp.marker.inclusiveLeft || span.marker.inclusiveRight) && + lineIsHiddenInner(doc, line, sp)) { return true } + } +} + +// Find the height above the given line. +function heightAtLine(lineObj) { + lineObj = visualLine(lineObj); + + var h = 0, chunk = lineObj.parent; + for (var i = 0; i < chunk.lines.length; ++i) { + var line = chunk.lines[i]; + if (line == lineObj) { break } + else { h += line.height; } + } + for (var p = chunk.parent; p; chunk = p, p = chunk.parent) { + for (var i$1 = 0; i$1 < p.children.length; ++i$1) { + var cur = p.children[i$1]; + if (cur == chunk) { break } + else { h += cur.height; } + } + } + return h +} + +// Compute the character length of a line, taking into account +// collapsed ranges (see markText) that might hide parts, and join +// other lines onto it. +function lineLength(line) { + if (line.height == 0) { return 0 } + var len = line.text.length, merged, cur = line; + while (merged = collapsedSpanAtStart(cur)) { + var found = merged.find(0, true); + cur = found.from.line; + len += found.from.ch - found.to.ch; + } + cur = line; + while (merged = collapsedSpanAtEnd(cur)) { + var found$1 = merged.find(0, true); + len -= cur.text.length - found$1.from.ch; + cur = found$1.to.line; + len += cur.text.length - found$1.to.ch; + } + return len +} + +// Find the longest line in the document. +function findMaxLine(cm) { + var d = cm.display, doc = cm.doc; + d.maxLine = getLine(doc, doc.first); + d.maxLineLength = lineLength(d.maxLine); + d.maxLineChanged = true; + doc.iter(function (line) { + var len = lineLength(line); + if (len > d.maxLineLength) { + d.maxLineLength = len; + d.maxLine = line; + } + }); +} + +// BIDI HELPERS + +function iterateBidiSections(order, from, to, f) { + if (!order) { return f(from, to, "ltr", 0) } + var found = false; + for (var i = 0; i < order.length; ++i) { + var part = order[i]; + if (part.from < to && part.to > from || from == to && part.to == from) { + f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr", i); + found = true; + } + } + if (!found) { f(from, to, "ltr"); } +} + +var bidiOther = null; +function getBidiPartAt(order, ch, sticky) { + var found; + bidiOther = null; + for (var i = 0; i < order.length; ++i) { + var cur = order[i]; + if (cur.from < ch && cur.to > ch) { return i } + if (cur.to == ch) { + if (cur.from != cur.to && sticky == "before") { found = i; } + else { bidiOther = i; } + } + if (cur.from == ch) { + if (cur.from != cur.to && sticky != "before") { found = i; } + else { bidiOther = i; } + } + } + return found != null ? found : bidiOther +} + +// Bidirectional ordering algorithm +// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm +// that this (partially) implements. + +// One-char codes used for character types: +// L (L): Left-to-Right +// R (R): Right-to-Left +// r (AL): Right-to-Left Arabic +// 1 (EN): European Number +// + (ES): European Number Separator +// % (ET): European Number Terminator +// n (AN): Arabic Number +// , (CS): Common Number Separator +// m (NSM): Non-Spacing Mark +// b (BN): Boundary Neutral +// s (B): Paragraph Separator +// t (S): Segment Separator +// w (WS): Whitespace +// N (ON): Other Neutrals + +// Returns null if characters are ordered as they appear +// (left-to-right), or an array of sections ({from, to, level} +// objects) in the order in which they occur visually. +var bidiOrdering = (function() { + // Character types for codepoints 0 to 0xff + var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN"; + // Character types for codepoints 0x600 to 0x6f9 + var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111"; + function charType(code) { + if (code <= 0xf7) { return lowTypes.charAt(code) } + else if (0x590 <= code && code <= 0x5f4) { return "R" } + else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) } + else if (0x6ee <= code && code <= 0x8ac) { return "r" } + else if (0x2000 <= code && code <= 0x200b) { return "w" } + else if (code == 0x200c) { return "b" } + else { return "L" } + } + + var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/; + var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/; + + function BidiSpan(level, from, to) { + this.level = level; + this.from = from; this.to = to; + } + + return function(str, direction) { + var outerType = direction == "ltr" ? "L" : "R"; + + if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false } + var len = str.length, types = []; + for (var i = 0; i < len; ++i) + { types.push(charType(str.charCodeAt(i))); } + + // W1. Examine each non-spacing mark (NSM) in the level run, and + // change the type of the NSM to the type of the previous + // character. If the NSM is at the start of the level run, it will + // get the type of sor. + for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) { + var type = types[i$1]; + if (type == "m") { types[i$1] = prev; } + else { prev = type; } + } + + // W2. Search backwards from each instance of a European number + // until the first strong type (R, L, AL, or sor) is found. If an + // AL is found, change the type of the European number to Arabic + // number. + // W3. Change all ALs to R. + for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) { + var type$1 = types[i$2]; + if (type$1 == "1" && cur == "r") { types[i$2] = "n"; } + else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R"; } } + } + + // W4. A single European separator between two European numbers + // changes to a European number. A single common separator between + // two numbers of the same type changes to that type. + for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) { + var type$2 = types[i$3]; + if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1"; } + else if (type$2 == "," && prev$1 == types[i$3+1] && + (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1; } + prev$1 = type$2; + } + + // W5. A sequence of European terminators adjacent to European + // numbers changes to all European numbers. + // W6. Otherwise, separators and terminators change to Other + // Neutral. + for (var i$4 = 0; i$4 < len; ++i$4) { + var type$3 = types[i$4]; + if (type$3 == ",") { types[i$4] = "N"; } + else if (type$3 == "%") { + var end = (void 0); + for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {} + var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N"; + for (var j = i$4; j < end; ++j) { types[j] = replace; } + i$4 = end - 1; + } + } + + // W7. Search backwards from each instance of a European number + // until the first strong type (R, L, or sor) is found. If an L is + // found, then change the type of the European number to L. + for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) { + var type$4 = types[i$5]; + if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L"; } + else if (isStrong.test(type$4)) { cur$1 = type$4; } + } + + // N1. A sequence of neutrals takes the direction of the + // surrounding strong text if the text on both sides has the same + // direction. European and Arabic numbers act as if they were R in + // terms of their influence on neutrals. Start-of-level-run (sor) + // and end-of-level-run (eor) are used at level run boundaries. + // N2. Any remaining neutrals take the embedding direction. + for (var i$6 = 0; i$6 < len; ++i$6) { + if (isNeutral.test(types[i$6])) { + var end$1 = (void 0); + for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {} + var before = (i$6 ? types[i$6-1] : outerType) == "L"; + var after = (end$1 < len ? types[end$1] : outerType) == "L"; + var replace$1 = before == after ? (before ? "L" : "R") : outerType; + for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; } + i$6 = end$1 - 1; + } + } + + // Here we depart from the documented algorithm, in order to avoid + // building up an actual levels array. Since there are only three + // levels (0, 1, 2) in an implementation that doesn't take + // explicit embedding into account, we can build up the order on + // the fly, without following the level-based algorithm. + var order = [], m; + for (var i$7 = 0; i$7 < len;) { + if (countsAsLeft.test(types[i$7])) { + var start = i$7; + for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {} + order.push(new BidiSpan(0, start, i$7)); + } else { + var pos = i$7, at = order.length; + for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {} + for (var j$2 = pos; j$2 < i$7;) { + if (countsAsNum.test(types[j$2])) { + if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); } + var nstart = j$2; + for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {} + order.splice(at, 0, new BidiSpan(2, nstart, j$2)); + pos = j$2; + } else { ++j$2; } + } + if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); } + } + } + if (direction == "ltr") { + if (order[0].level == 1 && (m = str.match(/^\s+/))) { + order[0].from = m[0].length; + order.unshift(new BidiSpan(0, 0, m[0].length)); + } + if (lst(order).level == 1 && (m = str.match(/\s+$/))) { + lst(order).to -= m[0].length; + order.push(new BidiSpan(0, len - m[0].length, len)); + } + } + + return direction == "rtl" ? order.reverse() : order + } +})(); + +// Get the bidi ordering for the given line (and cache it). Returns +// false for lines that are fully left-to-right, and an array of +// BidiSpan objects otherwise. +function getOrder(line, direction) { + var order = line.order; + if (order == null) { order = line.order = bidiOrdering(line.text, direction); } + return order +} + +// EVENT HANDLING + +// Lightweight event framework. on/off also work on DOM nodes, +// registering native DOM handlers. + +var noHandlers = []; + +var on = function(emitter, type, f) { + if (emitter.addEventListener) { + emitter.addEventListener(type, f, false); + } else if (emitter.attachEvent) { + emitter.attachEvent("on" + type, f); + } else { + var map$$1 = emitter._handlers || (emitter._handlers = {}); + map$$1[type] = (map$$1[type] || noHandlers).concat(f); + } +}; + +function getHandlers(emitter, type) { + return emitter._handlers && emitter._handlers[type] || noHandlers +} + +function off(emitter, type, f) { + if (emitter.removeEventListener) { + emitter.removeEventListener(type, f, false); + } else if (emitter.detachEvent) { + emitter.detachEvent("on" + type, f); + } else { + var map$$1 = emitter._handlers, arr = map$$1 && map$$1[type]; + if (arr) { + var index = indexOf(arr, f); + if (index > -1) + { map$$1[type] = arr.slice(0, index).concat(arr.slice(index + 1)); } + } + } +} + +function signal(emitter, type /*, values...*/) { + var handlers = getHandlers(emitter, type); + if (!handlers.length) { return } + var args = Array.prototype.slice.call(arguments, 2); + for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args); } +} + +// The DOM events that CodeMirror handles can be overridden by +// registering a (non-DOM) handler on the editor for the event name, +// and preventDefault-ing the event in that handler. +function signalDOMEvent(cm, e, override) { + if (typeof e == "string") + { e = {type: e, preventDefault: function() { this.defaultPrevented = true; }}; } + signal(cm, override || e.type, cm, e); + return e_defaultPrevented(e) || e.codemirrorIgnore +} + +function signalCursorActivity(cm) { + var arr = cm._handlers && cm._handlers.cursorActivity; + if (!arr) { return } + var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []); + for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1) + { set.push(arr[i]); } } +} + +function hasHandler(emitter, type) { + return getHandlers(emitter, type).length > 0 +} + +// Add on and off methods to a constructor's prototype, to make +// registering events on such objects more convenient. +function eventMixin(ctor) { + ctor.prototype.on = function(type, f) {on(this, type, f);}; + ctor.prototype.off = function(type, f) {off(this, type, f);}; +} + +// Due to the fact that we still support jurassic IE versions, some +// compatibility wrappers are needed. + +function e_preventDefault(e) { + if (e.preventDefault) { e.preventDefault(); } + else { e.returnValue = false; } +} +function e_stopPropagation(e) { + if (e.stopPropagation) { e.stopPropagation(); } + else { e.cancelBubble = true; } +} +function e_defaultPrevented(e) { + return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false +} +function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);} + +function e_target(e) {return e.target || e.srcElement} +function e_button(e) { + var b = e.which; + if (b == null) { + if (e.button & 1) { b = 1; } + else if (e.button & 2) { b = 3; } + else if (e.button & 4) { b = 2; } + } + if (mac && e.ctrlKey && b == 1) { b = 3; } + return b +} + +// Detect drag-and-drop +var dragAndDrop = function() { + // There is *some* kind of drag-and-drop support in IE6-8, but I + // couldn't get it to work yet. + if (ie && ie_version < 9) { return false } + var div = elt('div'); + return "draggable" in div || "dragDrop" in div +}(); + +var zwspSupported; +function zeroWidthElement(measure) { + if (zwspSupported == null) { + var test = elt("span", "\u200b"); + removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")])); + if (measure.firstChild.offsetHeight != 0) + { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8); } + } + var node = zwspSupported ? elt("span", "\u200b") : + elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px"); + node.setAttribute("cm-text", ""); + return node +} + +// Feature-detect IE's crummy client rect reporting for bidi text +var badBidiRects; +function hasBadBidiRects(measure) { + if (badBidiRects != null) { return badBidiRects } + var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA")); + var r0 = range(txt, 0, 1).getBoundingClientRect(); + var r1 = range(txt, 1, 2).getBoundingClientRect(); + removeChildren(measure); + if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780) + return badBidiRects = (r1.right - r0.right < 3) +} + +// See if "".split is the broken IE version, if so, provide an +// alternative way to split lines. +var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) { + var pos = 0, result = [], l = string.length; + while (pos <= l) { + var nl = string.indexOf("\n", pos); + if (nl == -1) { nl = string.length; } + var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl); + var rt = line.indexOf("\r"); + if (rt != -1) { + result.push(line.slice(0, rt)); + pos += rt + 1; + } else { + result.push(line); + pos = nl + 1; + } + } + return result +} : function (string) { return string.split(/\r\n?|\n/); }; + +var hasSelection = window.getSelection ? function (te) { + try { return te.selectionStart != te.selectionEnd } + catch(e) { return false } +} : function (te) { + var range$$1; + try {range$$1 = te.ownerDocument.selection.createRange();} + catch(e) {} + if (!range$$1 || range$$1.parentElement() != te) { return false } + return range$$1.compareEndPoints("StartToEnd", range$$1) != 0 +}; + +var hasCopyEvent = (function () { + var e = elt("div"); + if ("oncopy" in e) { return true } + e.setAttribute("oncopy", "return;"); + return typeof e.oncopy == "function" +})(); + +var badZoomedRects = null; +function hasBadZoomedRects(measure) { + if (badZoomedRects != null) { return badZoomedRects } + var node = removeChildrenAndAdd(measure, elt("span", "x")); + var normal = node.getBoundingClientRect(); + var fromRange = range(node, 0, 1).getBoundingClientRect(); + return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1 +} + +// Known modes, by name and by MIME +var modes = {}; +var mimeModes = {}; + +// Extra arguments are stored as the mode's dependencies, which is +// used by (legacy) mechanisms like loadmode.js to automatically +// load a mode. (Preferred mechanism is the require/define calls.) +function defineMode(name, mode) { + if (arguments.length > 2) + { mode.dependencies = Array.prototype.slice.call(arguments, 2); } + modes[name] = mode; +} + +function defineMIME(mime, spec) { + mimeModes[mime] = spec; +} + +// Given a MIME type, a {name, ...options} config object, or a name +// string, return a mode config object. +function resolveMode(spec) { + if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) { + spec = mimeModes[spec]; + } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) { + var found = mimeModes[spec.name]; + if (typeof found == "string") { found = {name: found}; } + spec = createObj(found, spec); + spec.name = found.name; + } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) { + return resolveMode("application/xml") + } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) { + return resolveMode("application/json") + } + if (typeof spec == "string") { return {name: spec} } + else { return spec || {name: "null"} } +} + +// Given a mode spec (anything that resolveMode accepts), find and +// initialize an actual mode object. +function getMode(options, spec) { + spec = resolveMode(spec); + var mfactory = modes[spec.name]; + if (!mfactory) { return getMode(options, "text/plain") } + var modeObj = mfactory(options, spec); + if (modeExtensions.hasOwnProperty(spec.name)) { + var exts = modeExtensions[spec.name]; + for (var prop in exts) { + if (!exts.hasOwnProperty(prop)) { continue } + if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop]; } + modeObj[prop] = exts[prop]; + } + } + modeObj.name = spec.name; + if (spec.helperType) { modeObj.helperType = spec.helperType; } + if (spec.modeProps) { for (var prop$1 in spec.modeProps) + { modeObj[prop$1] = spec.modeProps[prop$1]; } } + + return modeObj +} + +// This can be used to attach properties to mode objects from +// outside the actual mode definition. +var modeExtensions = {}; +function extendMode(mode, properties) { + var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {}); + copyObj(properties, exts); +} + +function copyState(mode, state) { + if (state === true) { return state } + if (mode.copyState) { return mode.copyState(state) } + var nstate = {}; + for (var n in state) { + var val = state[n]; + if (val instanceof Array) { val = val.concat([]); } + nstate[n] = val; + } + return nstate +} + +// Given a mode and a state (for that mode), find the inner mode and +// state at the position that the state refers to. +function innerMode(mode, state) { + var info; + while (mode.innerMode) { + info = mode.innerMode(state); + if (!info || info.mode == mode) { break } + state = info.state; + mode = info.mode; + } + return info || {mode: mode, state: state} +} + +function startState(mode, a1, a2) { + return mode.startState ? mode.startState(a1, a2) : true +} + +// STRING STREAM + +// Fed to the mode parsers, provides helper functions to make +// parsers more succinct. + +var StringStream = function(string, tabSize, lineOracle) { + this.pos = this.start = 0; + this.string = string; + this.tabSize = tabSize || 8; + this.lastColumnPos = this.lastColumnValue = 0; + this.lineStart = 0; + this.lineOracle = lineOracle; +}; + +StringStream.prototype.eol = function () {return this.pos >= this.string.length}; +StringStream.prototype.sol = function () {return this.pos == this.lineStart}; +StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined}; +StringStream.prototype.next = function () { + if (this.pos < this.string.length) + { return this.string.charAt(this.pos++) } +}; +StringStream.prototype.eat = function (match) { + var ch = this.string.charAt(this.pos); + var ok; + if (typeof match == "string") { ok = ch == match; } + else { ok = ch && (match.test ? match.test(ch) : match(ch)); } + if (ok) {++this.pos; return ch} +}; +StringStream.prototype.eatWhile = function (match) { + var start = this.pos; + while (this.eat(match)){} + return this.pos > start +}; +StringStream.prototype.eatSpace = function () { + var this$1 = this; + + var start = this.pos; + while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos; } + return this.pos > start +}; +StringStream.prototype.skipToEnd = function () {this.pos = this.string.length;}; +StringStream.prototype.skipTo = function (ch) { + var found = this.string.indexOf(ch, this.pos); + if (found > -1) {this.pos = found; return true} +}; +StringStream.prototype.backUp = function (n) {this.pos -= n;}; +StringStream.prototype.column = function () { + if (this.lastColumnPos < this.start) { + this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue); + this.lastColumnPos = this.start; + } + return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0) +}; +StringStream.prototype.indentation = function () { + return countColumn(this.string, null, this.tabSize) - + (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0) +}; +StringStream.prototype.match = function (pattern, consume, caseInsensitive) { + if (typeof pattern == "string") { + var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }; + var substr = this.string.substr(this.pos, pattern.length); + if (cased(substr) == cased(pattern)) { + if (consume !== false) { this.pos += pattern.length; } + return true + } + } else { + var match = this.string.slice(this.pos).match(pattern); + if (match && match.index > 0) { return null } + if (match && consume !== false) { this.pos += match[0].length; } + return match + } +}; +StringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)}; +StringStream.prototype.hideFirstChars = function (n, inner) { + this.lineStart += n; + try { return inner() } + finally { this.lineStart -= n; } +}; +StringStream.prototype.lookAhead = function (n) { + var oracle = this.lineOracle; + return oracle && oracle.lookAhead(n) +}; +StringStream.prototype.baseToken = function () { + var oracle = this.lineOracle; + return oracle && oracle.baseToken(this.pos) +}; + +var SavedContext = function(state, lookAhead) { + this.state = state; + this.lookAhead = lookAhead; +}; + +var Context = function(doc, state, line, lookAhead) { + this.state = state; + this.doc = doc; + this.line = line; + this.maxLookAhead = lookAhead || 0; + this.baseTokens = null; + this.baseTokenPos = 1; +}; + +Context.prototype.lookAhead = function (n) { + var line = this.doc.getLine(this.line + n); + if (line != null && n > this.maxLookAhead) { this.maxLookAhead = n; } + return line +}; + +Context.prototype.baseToken = function (n) { + var this$1 = this; + + if (!this.baseTokens) { return null } + while (this.baseTokens[this.baseTokenPos] <= n) + { this$1.baseTokenPos += 2; } + var type = this.baseTokens[this.baseTokenPos + 1]; + return {type: type && type.replace(/( |^)overlay .*/, ""), + size: this.baseTokens[this.baseTokenPos] - n} +}; + +Context.prototype.nextLine = function () { + this.line++; + if (this.maxLookAhead > 0) { this.maxLookAhead--; } +}; + +Context.fromSaved = function (doc, saved, line) { + if (saved instanceof SavedContext) + { return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead) } + else + { return new Context(doc, copyState(doc.mode, saved), line) } +}; + +Context.prototype.save = function (copy) { + var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state; + return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state +}; + + +// Compute a style array (an array starting with a mode generation +// -- for invalidation -- followed by pairs of end positions and +// style strings), which is used to highlight the tokens on the +// line. +function highlightLine(cm, line, context, forceToEnd) { + // A styles array always starts with a number identifying the + // mode/overlays that it is based on (for easy invalidation). + var st = [cm.state.modeGen], lineClasses = {}; + // Compute the base array of styles + runMode(cm, line.text, cm.doc.mode, context, function (end, style) { return st.push(end, style); }, + lineClasses, forceToEnd); + var state = context.state; + + // Run overlays, adjust style array. + var loop = function ( o ) { + context.baseTokens = st; + var overlay = cm.state.overlays[o], i = 1, at = 0; + context.state = true; + runMode(cm, line.text, overlay.mode, context, function (end, style) { + var start = i; + // Ensure there's a token end at the current position, and that i points at it + while (at < end) { + var i_end = st[i]; + if (i_end > end) + { st.splice(i, 1, end, st[i+1], i_end); } + i += 2; + at = Math.min(end, i_end); + } + if (!style) { return } + if (overlay.opaque) { + st.splice(start, i - start, end, "overlay " + style); + i = start + 2; + } else { + for (; start < i; start += 2) { + var cur = st[start+1]; + st[start+1] = (cur ? cur + " " : "") + "overlay " + style; + } + } + }, lineClasses); + context.state = state; + context.baseTokens = null; + context.baseTokenPos = 1; + }; + + for (var o = 0; o < cm.state.overlays.length; ++o) loop( o ); + + return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null} +} + +function getLineStyles(cm, line, updateFrontier) { + if (!line.styles || line.styles[0] != cm.state.modeGen) { + var context = getContextBefore(cm, lineNo(line)); + var resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state); + var result = highlightLine(cm, line, context); + if (resetState) { context.state = resetState; } + line.stateAfter = context.save(!resetState); + line.styles = result.styles; + if (result.classes) { line.styleClasses = result.classes; } + else if (line.styleClasses) { line.styleClasses = null; } + if (updateFrontier === cm.doc.highlightFrontier) + { cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier); } + } + return line.styles +} + +function getContextBefore(cm, n, precise) { + var doc = cm.doc, display = cm.display; + if (!doc.mode.startState) { return new Context(doc, true, n) } + var start = findStartLine(cm, n, precise); + var saved = start > doc.first && getLine(doc, start - 1).stateAfter; + var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start); + + doc.iter(start, n, function (line) { + processLine(cm, line.text, context); + var pos = context.line; + line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null; + context.nextLine(); + }); + if (precise) { doc.modeFrontier = context.line; } + return context +} + +// Lightweight form of highlight -- proceed over this line and +// update state, but don't save a style array. Used for lines that +// aren't currently visible. +function processLine(cm, text, context, startAt) { + var mode = cm.doc.mode; + var stream = new StringStream(text, cm.options.tabSize, context); + stream.start = stream.pos = startAt || 0; + if (text == "") { callBlankLine(mode, context.state); } + while (!stream.eol()) { + readToken(mode, stream, context.state); + stream.start = stream.pos; + } +} + +function callBlankLine(mode, state) { + if (mode.blankLine) { return mode.blankLine(state) } + if (!mode.innerMode) { return } + var inner = innerMode(mode, state); + if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) } +} + +function readToken(mode, stream, state, inner) { + for (var i = 0; i < 10; i++) { + if (inner) { inner[0] = innerMode(mode, state).mode; } + var style = mode.token(stream, state); + if (stream.pos > stream.start) { return style } + } + throw new Error("Mode " + mode.name + " failed to advance stream.") +} + +var Token = function(stream, type, state) { + this.start = stream.start; this.end = stream.pos; + this.string = stream.current(); + this.type = type || null; + this.state = state; +}; + +// Utility for getTokenAt and getLineTokens +function takeToken(cm, pos, precise, asArray) { + var doc = cm.doc, mode = doc.mode, style; + pos = clipPos(doc, pos); + var line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise); + var stream = new StringStream(line.text, cm.options.tabSize, context), tokens; + if (asArray) { tokens = []; } + while ((asArray || stream.pos < pos.ch) && !stream.eol()) { + stream.start = stream.pos; + style = readToken(mode, stream, context.state); + if (asArray) { tokens.push(new Token(stream, style, copyState(doc.mode, context.state))); } + } + return asArray ? tokens : new Token(stream, style, context.state) +} + +function extractLineClasses(type, output) { + if (type) { for (;;) { + var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/); + if (!lineClass) { break } + type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length); + var prop = lineClass[1] ? "bgClass" : "textClass"; + if (output[prop] == null) + { output[prop] = lineClass[2]; } + else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop])) + { output[prop] += " " + lineClass[2]; } + } } + return type +} + +// Run the given mode's parser over a line, calling f for each token. +function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) { + var flattenSpans = mode.flattenSpans; + if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans; } + var curStart = 0, curStyle = null; + var stream = new StringStream(text, cm.options.tabSize, context), style; + var inner = cm.options.addModeClass && [null]; + if (text == "") { extractLineClasses(callBlankLine(mode, context.state), lineClasses); } + while (!stream.eol()) { + if (stream.pos > cm.options.maxHighlightLength) { + flattenSpans = false; + if (forceToEnd) { processLine(cm, text, context, stream.pos); } + stream.pos = text.length; + style = null; + } else { + style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses); + } + if (inner) { + var mName = inner[0].name; + if (mName) { style = "m-" + (style ? mName + " " + style : mName); } + } + if (!flattenSpans || curStyle != style) { + while (curStart < stream.start) { + curStart = Math.min(stream.start, curStart + 5000); + f(curStart, curStyle); + } + curStyle = style; + } + stream.start = stream.pos; + } + while (curStart < stream.pos) { + // Webkit seems to refuse to render text nodes longer than 57444 + // characters, and returns inaccurate measurements in nodes + // starting around 5000 chars. + var pos = Math.min(stream.pos, curStart + 5000); + f(pos, curStyle); + curStart = pos; + } +} + +// Finds the line to start with when starting a parse. Tries to +// find a line with a stateAfter, so that it can start with a +// valid state. If that fails, it returns the line with the +// smallest indentation, which tends to need the least context to +// parse correctly. +function findStartLine(cm, n, precise) { + var minindent, minline, doc = cm.doc; + var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100); + for (var search = n; search > lim; --search) { + if (search <= doc.first) { return doc.first } + var line = getLine(doc, search - 1), after = line.stateAfter; + if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier)) + { return search } + var indented = countColumn(line.text, null, cm.options.tabSize); + if (minline == null || minindent > indented) { + minline = search - 1; + minindent = indented; + } + } + return minline +} + +function retreatFrontier(doc, n) { + doc.modeFrontier = Math.min(doc.modeFrontier, n); + if (doc.highlightFrontier < n - 10) { return } + var start = doc.first; + for (var line = n - 1; line > start; line--) { + var saved = getLine(doc, line).stateAfter; + // change is on 3 + // state on line 1 looked ahead 2 -- so saw 3 + // test 1 + 2 < 3 should cover this + if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) { + start = line + 1; + break + } + } + doc.highlightFrontier = Math.min(doc.highlightFrontier, start); +} + +// LINE DATA STRUCTURE + +// Line objects. These hold state related to a line, including +// highlighting info (the styles array). +var Line = function(text, markedSpans, estimateHeight) { + this.text = text; + attachMarkedSpans(this, markedSpans); + this.height = estimateHeight ? estimateHeight(this) : 1; +}; + +Line.prototype.lineNo = function () { return lineNo(this) }; +eventMixin(Line); + +// Change the content (text, markers) of a line. Automatically +// invalidates cached information and tries to re-estimate the +// line's height. +function updateLine(line, text, markedSpans, estimateHeight) { + line.text = text; + if (line.stateAfter) { line.stateAfter = null; } + if (line.styles) { line.styles = null; } + if (line.order != null) { line.order = null; } + detachMarkedSpans(line); + attachMarkedSpans(line, markedSpans); + var estHeight = estimateHeight ? estimateHeight(line) : 1; + if (estHeight != line.height) { updateLineHeight(line, estHeight); } +} + +// Detach a line from the document tree and its markers. +function cleanUpLine(line) { + line.parent = null; + detachMarkedSpans(line); +} + +// Convert a style as returned by a mode (either null, or a string +// containing one or more styles) to a CSS style. This is cached, +// and also looks for line-wide styles. +var styleToClassCache = {}; +var styleToClassCacheWithMode = {}; +function interpretTokenStyle(style, options) { + if (!style || /^\s*$/.test(style)) { return null } + var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache; + return cache[style] || + (cache[style] = style.replace(/\S+/g, "cm-$&")) +} + +// Render the DOM representation of the text of a line. Also builds +// up a 'line map', which points at the DOM nodes that represent +// specific stretches of text, and is used by the measuring code. +// The returned object contains the DOM node, this map, and +// information about line-wide styles that were set by the mode. +function buildLineContent(cm, lineView) { + // The padding-right forces the element to have a 'border', which + // is needed on Webkit to be able to get line-level bounding + // rectangles for it (in measureChar). + var content = eltP("span", null, null, webkit ? "padding-right: .1px" : null); + var builder = {pre: eltP("pre", [content], "CodeMirror-line"), content: content, + col: 0, pos: 0, cm: cm, + trailingSpace: false, + splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")}; + lineView.measure = {}; + + // Iterate over the logical lines that make up this visual line. + for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) { + var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0); + builder.pos = 0; + builder.addToken = buildToken; + // Optionally wire in some hacks into the token-rendering + // algorithm, to deal with browser quirks. + if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction))) + { builder.addToken = buildTokenBadBidi(builder.addToken, order); } + builder.map = []; + var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line); + insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate)); + if (line.styleClasses) { + if (line.styleClasses.bgClass) + { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || ""); } + if (line.styleClasses.textClass) + { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || ""); } + } + + // Ensure at least a single node is present, for measuring. + if (builder.map.length == 0) + { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))); } + + // Store the map and a cache object for the current logical line + if (i == 0) { + lineView.measure.map = builder.map; + lineView.measure.cache = {}; + } else { + (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map) + ;(lineView.measure.caches || (lineView.measure.caches = [])).push({}); + } + } + + // See issue #2901 + if (webkit) { + var last = builder.content.lastChild; + if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab"))) + { builder.content.className = "cm-tab-wrap-hack"; } + } + + signal(cm, "renderLine", cm, lineView.line, builder.pre); + if (builder.pre.className) + { builder.textClass = joinClasses(builder.pre.className, builder.textClass || ""); } + + return builder +} + +function defaultSpecialCharPlaceholder(ch) { + var token = elt("span", "\u2022", "cm-invalidchar"); + token.title = "\\u" + ch.charCodeAt(0).toString(16); + token.setAttribute("aria-label", token.title); + return token +} + +// Build up the DOM representation for a single token, and add it to +// the line map. Takes care to render special characters separately. +function buildToken(builder, text, style, startStyle, endStyle, title, css) { + if (!text) { return } + var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text; + var special = builder.cm.state.specialChars, mustWrap = false; + var content; + if (!special.test(text)) { + builder.col += text.length; + content = document.createTextNode(displayText); + builder.map.push(builder.pos, builder.pos + text.length, content); + if (ie && ie_version < 9) { mustWrap = true; } + builder.pos += text.length; + } else { + content = document.createDocumentFragment(); + var pos = 0; + while (true) { + special.lastIndex = pos; + var m = special.exec(text); + var skipped = m ? m.index - pos : text.length - pos; + if (skipped) { + var txt = document.createTextNode(displayText.slice(pos, pos + skipped)); + if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])); } + else { content.appendChild(txt); } + builder.map.push(builder.pos, builder.pos + skipped, txt); + builder.col += skipped; + builder.pos += skipped; + } + if (!m) { break } + pos += skipped + 1; + var txt$1 = (void 0); + if (m[0] == "\t") { + var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize; + txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab")); + txt$1.setAttribute("role", "presentation"); + txt$1.setAttribute("cm-text", "\t"); + builder.col += tabWidth; + } else if (m[0] == "\r" || m[0] == "\n") { + txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar")); + txt$1.setAttribute("cm-text", m[0]); + builder.col += 1; + } else { + txt$1 = builder.cm.options.specialCharPlaceholder(m[0]); + txt$1.setAttribute("cm-text", m[0]); + if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])); } + else { content.appendChild(txt$1); } + builder.col += 1; + } + builder.map.push(builder.pos, builder.pos + 1, txt$1); + builder.pos++; + } + } + builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32; + if (style || startStyle || endStyle || mustWrap || css) { + var fullStyle = style || ""; + if (startStyle) { fullStyle += startStyle; } + if (endStyle) { fullStyle += endStyle; } + var token = elt("span", [content], fullStyle, css); + if (title) { token.title = title; } + return builder.content.appendChild(token) + } + builder.content.appendChild(content); +} + +function splitSpaces(text, trailingBefore) { + if (text.length > 1 && !/ /.test(text)) { return text } + var spaceBefore = trailingBefore, result = ""; + for (var i = 0; i < text.length; i++) { + var ch = text.charAt(i); + if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32)) + { ch = "\u00a0"; } + result += ch; + spaceBefore = ch == " "; + } + return result +} + +// Work around nonsense dimensions being reported for stretches of +// right-to-left text. +function buildTokenBadBidi(inner, order) { + return function (builder, text, style, startStyle, endStyle, title, css) { + style = style ? style + " cm-force-border" : "cm-force-border"; + var start = builder.pos, end = start + text.length; + for (;;) { + // Find the part that overlaps with the start of this text + var part = (void 0); + for (var i = 0; i < order.length; i++) { + part = order[i]; + if (part.to > start && part.from <= start) { break } + } + if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) } + inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css); + startStyle = null; + text = text.slice(part.to - start); + start = part.to; + } + } +} + +function buildCollapsedSpan(builder, size, marker, ignoreWidget) { + var widget = !ignoreWidget && marker.widgetNode; + if (widget) { builder.map.push(builder.pos, builder.pos + size, widget); } + if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) { + if (!widget) + { widget = builder.content.appendChild(document.createElement("span")); } + widget.setAttribute("cm-marker", marker.id); + } + if (widget) { + builder.cm.display.input.setUneditable(widget); + builder.content.appendChild(widget); + } + builder.pos += size; + builder.trailingSpace = false; +} + +// Outputs a number of spans to make up a line, taking highlighting +// and marked text into account. +function insertLineContent(line, builder, styles) { + var spans = line.markedSpans, allText = line.text, at = 0; + if (!spans) { + for (var i$1 = 1; i$1 < styles.length; i$1+=2) + { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)); } + return + } + + var len = allText.length, pos = 0, i = 1, text = "", style, css; + var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed; + for (;;) { + if (nextChange == pos) { // Update current marker set + spanStyle = spanEndStyle = spanStartStyle = title = css = ""; + collapsed = null; nextChange = Infinity; + var foundBookmarks = [], endStyles = (void 0); + for (var j = 0; j < spans.length; ++j) { + var sp = spans[j], m = sp.marker; + if (m.type == "bookmark" && sp.from == pos && m.widgetNode) { + foundBookmarks.push(m); + } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) { + if (sp.to != null && sp.to != pos && nextChange > sp.to) { + nextChange = sp.to; + spanEndStyle = ""; + } + if (m.className) { spanStyle += " " + m.className; } + if (m.css) { css = (css ? css + ";" : "") + m.css; } + if (m.startStyle && sp.from == pos) { spanStartStyle += " " + m.startStyle; } + if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to); } + if (m.title && !title) { title = m.title; } + if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0)) + { collapsed = sp; } + } else if (sp.from > pos && nextChange > sp.from) { + nextChange = sp.from; + } + } + if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2) + { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += " " + endStyles[j$1]; } } } + + if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2) + { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]); } } + if (collapsed && (collapsed.from || 0) == pos) { + buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos, + collapsed.marker, collapsed.from == null); + if (collapsed.to == null) { return } + if (collapsed.to == pos) { collapsed = false; } + } + } + if (pos >= len) { break } + + var upto = Math.min(len, nextChange); + while (true) { + if (text) { + var end = pos + text.length; + if (!collapsed) { + var tokenText = end > upto ? text.slice(0, upto - pos) : text; + builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle, + spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css); + } + if (end >= upto) {text = text.slice(upto - pos); pos = upto; break} + pos = end; + spanStartStyle = ""; + } + text = allText.slice(at, at = styles[i++]); + style = interpretTokenStyle(styles[i++], builder.cm.options); + } + } +} + + +// These objects are used to represent the visible (currently drawn) +// part of the document. A LineView may correspond to multiple +// logical lines, if those are connected by collapsed ranges. +function LineView(doc, line, lineN) { + // The starting line + this.line = line; + // Continuing lines, if any + this.rest = visualLineContinued(line); + // Number of logical lines in this visual line + this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1; + this.node = this.text = null; + this.hidden = lineIsHidden(doc, line); +} + +// Create a range of LineView objects for the given lines. +function buildViewArray(cm, from, to) { + var array = [], nextPos; + for (var pos = from; pos < to; pos = nextPos) { + var view = new LineView(cm.doc, getLine(cm.doc, pos), pos); + nextPos = pos + view.size; + array.push(view); + } + return array +} + +var operationGroup = null; + +function pushOperation(op) { + if (operationGroup) { + operationGroup.ops.push(op); + } else { + op.ownsGroup = operationGroup = { + ops: [op], + delayedCallbacks: [] + }; + } +} + +function fireCallbacksForOps(group) { + // Calls delayed callbacks and cursorActivity handlers until no + // new ones appear + var callbacks = group.delayedCallbacks, i = 0; + do { + for (; i < callbacks.length; i++) + { callbacks[i].call(null); } + for (var j = 0; j < group.ops.length; j++) { + var op = group.ops[j]; + if (op.cursorActivityHandlers) + { while (op.cursorActivityCalled < op.cursorActivityHandlers.length) + { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm); } } + } + } while (i < callbacks.length) +} + +function finishOperation(op, endCb) { + var group = op.ownsGroup; + if (!group) { return } + + try { fireCallbacksForOps(group); } + finally { + operationGroup = null; + endCb(group); + } +} + +var orphanDelayedCallbacks = null; + +// Often, we want to signal events at a point where we are in the +// middle of some work, but don't want the handler to start calling +// other methods on the editor, which might be in an inconsistent +// state or simply not expect any other events to happen. +// signalLater looks whether there are any handlers, and schedules +// them to be executed when the last operation ends, or, if no +// operation is active, when a timeout fires. +function signalLater(emitter, type /*, values...*/) { + var arr = getHandlers(emitter, type); + if (!arr.length) { return } + var args = Array.prototype.slice.call(arguments, 2), list; + if (operationGroup) { + list = operationGroup.delayedCallbacks; + } else if (orphanDelayedCallbacks) { + list = orphanDelayedCallbacks; + } else { + list = orphanDelayedCallbacks = []; + setTimeout(fireOrphanDelayed, 0); + } + var loop = function ( i ) { + list.push(function () { return arr[i].apply(null, args); }); + }; + + for (var i = 0; i < arr.length; ++i) + loop( i ); +} + +function fireOrphanDelayed() { + var delayed = orphanDelayedCallbacks; + orphanDelayedCallbacks = null; + for (var i = 0; i < delayed.length; ++i) { delayed[i](); } +} + +// When an aspect of a line changes, a string is added to +// lineView.changes. This updates the relevant part of the line's +// DOM structure. +function updateLineForChanges(cm, lineView, lineN, dims) { + for (var j = 0; j < lineView.changes.length; j++) { + var type = lineView.changes[j]; + if (type == "text") { updateLineText(cm, lineView); } + else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims); } + else if (type == "class") { updateLineClasses(cm, lineView); } + else if (type == "widget") { updateLineWidgets(cm, lineView, dims); } + } + lineView.changes = null; +} + +// Lines with gutter elements, widgets or a background class need to +// be wrapped, and have the extra elements added to the wrapper div +function ensureLineWrapped(lineView) { + if (lineView.node == lineView.text) { + lineView.node = elt("div", null, null, "position: relative"); + if (lineView.text.parentNode) + { lineView.text.parentNode.replaceChild(lineView.node, lineView.text); } + lineView.node.appendChild(lineView.text); + if (ie && ie_version < 8) { lineView.node.style.zIndex = 2; } + } + return lineView.node +} + +function updateLineBackground(cm, lineView) { + var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass; + if (cls) { cls += " CodeMirror-linebackground"; } + if (lineView.background) { + if (cls) { lineView.background.className = cls; } + else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; } + } else if (cls) { + var wrap = ensureLineWrapped(lineView); + lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild); + cm.display.input.setUneditable(lineView.background); + } +} + +// Wrapper around buildLineContent which will reuse the structure +// in display.externalMeasured when possible. +function getLineContent(cm, lineView) { + var ext = cm.display.externalMeasured; + if (ext && ext.line == lineView.line) { + cm.display.externalMeasured = null; + lineView.measure = ext.measure; + return ext.built + } + return buildLineContent(cm, lineView) +} + +// Redraw the line's text. Interacts with the background and text +// classes because the mode may output tokens that influence these +// classes. +function updateLineText(cm, lineView) { + var cls = lineView.text.className; + var built = getLineContent(cm, lineView); + if (lineView.text == lineView.node) { lineView.node = built.pre; } + lineView.text.parentNode.replaceChild(built.pre, lineView.text); + lineView.text = built.pre; + if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) { + lineView.bgClass = built.bgClass; + lineView.textClass = built.textClass; + updateLineClasses(cm, lineView); + } else if (cls) { + lineView.text.className = cls; + } +} + +function updateLineClasses(cm, lineView) { + updateLineBackground(cm, lineView); + if (lineView.line.wrapClass) + { ensureLineWrapped(lineView).className = lineView.line.wrapClass; } + else if (lineView.node != lineView.text) + { lineView.node.className = ""; } + var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass; + lineView.text.className = textClass || ""; +} + +function updateLineGutter(cm, lineView, lineN, dims) { + if (lineView.gutter) { + lineView.node.removeChild(lineView.gutter); + lineView.gutter = null; + } + if (lineView.gutterBackground) { + lineView.node.removeChild(lineView.gutterBackground); + lineView.gutterBackground = null; + } + if (lineView.line.gutterClass) { + var wrap = ensureLineWrapped(lineView); + lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass, + ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px; width: " + (dims.gutterTotalWidth) + "px")); + cm.display.input.setUneditable(lineView.gutterBackground); + wrap.insertBefore(lineView.gutterBackground, lineView.text); + } + var markers = lineView.line.gutterMarkers; + if (cm.options.lineNumbers || markers) { + var wrap$1 = ensureLineWrapped(lineView); + var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px")); + cm.display.input.setUneditable(gutterWrap); + wrap$1.insertBefore(gutterWrap, lineView.text); + if (lineView.line.gutterClass) + { gutterWrap.className += " " + lineView.line.gutterClass; } + if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"])) + { lineView.lineNumber = gutterWrap.appendChild( + elt("div", lineNumberFor(cm.options, lineN), + "CodeMirror-linenumber CodeMirror-gutter-elt", + ("left: " + (dims.gutterLeft["CodeMirror-linenumbers"]) + "px; width: " + (cm.display.lineNumInnerWidth) + "px"))); } + if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) { + var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]; + if (found) + { gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", + ("left: " + (dims.gutterLeft[id]) + "px; width: " + (dims.gutterWidth[id]) + "px"))); } + } } + } +} + +function updateLineWidgets(cm, lineView, dims) { + if (lineView.alignable) { lineView.alignable = null; } + for (var node = lineView.node.firstChild, next = (void 0); node; node = next) { + next = node.nextSibling; + if (node.className == "CodeMirror-linewidget") + { lineView.node.removeChild(node); } + } + insertLineWidgets(cm, lineView, dims); +} + +// Build a line's DOM representation from scratch +function buildLineElement(cm, lineView, lineN, dims) { + var built = getLineContent(cm, lineView); + lineView.text = lineView.node = built.pre; + if (built.bgClass) { lineView.bgClass = built.bgClass; } + if (built.textClass) { lineView.textClass = built.textClass; } + + updateLineClasses(cm, lineView); + updateLineGutter(cm, lineView, lineN, dims); + insertLineWidgets(cm, lineView, dims); + return lineView.node +} + +// A lineView may contain multiple logical lines (when merged by +// collapsed spans). The widgets for all of them need to be drawn. +function insertLineWidgets(cm, lineView, dims) { + insertLineWidgetsFor(cm, lineView.line, lineView, dims, true); + if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++) + { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false); } } +} + +function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) { + if (!line.widgets) { return } + var wrap = ensureLineWrapped(lineView); + for (var i = 0, ws = line.widgets; i < ws.length; ++i) { + var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget"); + if (!widget.handleMouseEvents) { node.setAttribute("cm-ignore-events", "true"); } + positionLineWidget(widget, node, lineView, dims); + cm.display.input.setUneditable(node); + if (allowAbove && widget.above) + { wrap.insertBefore(node, lineView.gutter || lineView.text); } + else + { wrap.appendChild(node); } + signalLater(widget, "redraw"); + } +} + +function positionLineWidget(widget, node, lineView, dims) { + if (widget.noHScroll) { + (lineView.alignable || (lineView.alignable = [])).push(node); + var width = dims.wrapperWidth; + node.style.left = dims.fixedPos + "px"; + if (!widget.coverGutter) { + width -= dims.gutterTotalWidth; + node.style.paddingLeft = dims.gutterTotalWidth + "px"; + } + node.style.width = width + "px"; + } + if (widget.coverGutter) { + node.style.zIndex = 5; + node.style.position = "relative"; + if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + "px"; } + } +} + +function widgetHeight(widget) { + if (widget.height != null) { return widget.height } + var cm = widget.doc.cm; + if (!cm) { return 0 } + if (!contains(document.body, widget.node)) { + var parentStyle = "position: relative;"; + if (widget.coverGutter) + { parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;"; } + if (widget.noHScroll) + { parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;"; } + removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle)); + } + return widget.height = widget.node.parentNode.offsetHeight +} + +// Return true when the given mouse event happened in a widget +function eventInWidget(display, e) { + for (var n = e_target(e); n != display.wrapper; n = n.parentNode) { + if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") || + (n.parentNode == display.sizer && n != display.mover)) + { return true } + } +} + +// POSITION MEASUREMENT + +function paddingTop(display) {return display.lineSpace.offsetTop} +function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight} +function paddingH(display) { + if (display.cachedPaddingH) { return display.cachedPaddingH } + var e = removeChildrenAndAdd(display.measure, elt("pre", "x")); + var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle; + var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}; + if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data; } + return data +} + +function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth } +function displayWidth(cm) { + return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth +} +function displayHeight(cm) { + return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight +} + +// Ensure the lineView.wrapping.heights array is populated. This is +// an array of bottom offsets for the lines that make up a drawn +// line. When lineWrapping is on, there might be more than one +// height. +function ensureLineHeights(cm, lineView, rect) { + var wrapping = cm.options.lineWrapping; + var curWidth = wrapping && displayWidth(cm); + if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) { + var heights = lineView.measure.heights = []; + if (wrapping) { + lineView.measure.width = curWidth; + var rects = lineView.text.firstChild.getClientRects(); + for (var i = 0; i < rects.length - 1; i++) { + var cur = rects[i], next = rects[i + 1]; + if (Math.abs(cur.bottom - next.bottom) > 2) + { heights.push((cur.bottom + next.top) / 2 - rect.top); } + } + } + heights.push(rect.bottom - rect.top); + } +} + +// Find a line map (mapping character offsets to text nodes) and a +// measurement cache for the given line number. (A line view might +// contain multiple lines when collapsed ranges are present.) +function mapFromLineView(lineView, line, lineN) { + if (lineView.line == line) + { return {map: lineView.measure.map, cache: lineView.measure.cache} } + for (var i = 0; i < lineView.rest.length; i++) + { if (lineView.rest[i] == line) + { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } } + for (var i$1 = 0; i$1 < lineView.rest.length; i$1++) + { if (lineNo(lineView.rest[i$1]) > lineN) + { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } } +} + +// Render a line into the hidden node display.externalMeasured. Used +// when measurement is needed for a line that's not in the viewport. +function updateExternalMeasurement(cm, line) { + line = visualLine(line); + var lineN = lineNo(line); + var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN); + view.lineN = lineN; + var built = view.built = buildLineContent(cm, view); + view.text = built.pre; + removeChildrenAndAdd(cm.display.lineMeasure, built.pre); + return view +} + +// Get a {top, bottom, left, right} box (in line-local coordinates) +// for a given character. +function measureChar(cm, line, ch, bias) { + return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias) +} + +// Find a line view that corresponds to the given line number. +function findViewForLine(cm, lineN) { + if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo) + { return cm.display.view[findViewIndex(cm, lineN)] } + var ext = cm.display.externalMeasured; + if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size) + { return ext } +} + +// Measurement can be split in two steps, the set-up work that +// applies to the whole line, and the measurement of the actual +// character. Functions like coordsChar, that need to do a lot of +// measurements in a row, can thus ensure that the set-up work is +// only done once. +function prepareMeasureForLine(cm, line) { + var lineN = lineNo(line); + var view = findViewForLine(cm, lineN); + if (view && !view.text) { + view = null; + } else if (view && view.changes) { + updateLineForChanges(cm, view, lineN, getDimensions(cm)); + cm.curOp.forceUpdate = true; + } + if (!view) + { view = updateExternalMeasurement(cm, line); } + + var info = mapFromLineView(view, line, lineN); + return { + line: line, view: view, rect: null, + map: info.map, cache: info.cache, before: info.before, + hasHeights: false + } +} + +// Given a prepared measurement object, measures the position of an +// actual character (or fetches it from the cache). +function measureCharPrepared(cm, prepared, ch, bias, varHeight) { + if (prepared.before) { ch = -1; } + var key = ch + (bias || ""), found; + if (prepared.cache.hasOwnProperty(key)) { + found = prepared.cache[key]; + } else { + if (!prepared.rect) + { prepared.rect = prepared.view.text.getBoundingClientRect(); } + if (!prepared.hasHeights) { + ensureLineHeights(cm, prepared.view, prepared.rect); + prepared.hasHeights = true; + } + found = measureCharInner(cm, prepared, ch, bias); + if (!found.bogus) { prepared.cache[key] = found; } + } + return {left: found.left, right: found.right, + top: varHeight ? found.rtop : found.top, + bottom: varHeight ? found.rbottom : found.bottom} +} + +var nullRect = {left: 0, right: 0, top: 0, bottom: 0}; + +function nodeAndOffsetInLineMap(map$$1, ch, bias) { + var node, start, end, collapse, mStart, mEnd; + // First, search the line map for the text node corresponding to, + // or closest to, the target character. + for (var i = 0; i < map$$1.length; i += 3) { + mStart = map$$1[i]; + mEnd = map$$1[i + 1]; + if (ch < mStart) { + start = 0; end = 1; + collapse = "left"; + } else if (ch < mEnd) { + start = ch - mStart; + end = start + 1; + } else if (i == map$$1.length - 3 || ch == mEnd && map$$1[i + 3] > ch) { + end = mEnd - mStart; + start = end - 1; + if (ch >= mEnd) { collapse = "right"; } + } + if (start != null) { + node = map$$1[i + 2]; + if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right")) + { collapse = bias; } + if (bias == "left" && start == 0) + { while (i && map$$1[i - 2] == map$$1[i - 3] && map$$1[i - 1].insertLeft) { + node = map$$1[(i -= 3) + 2]; + collapse = "left"; + } } + if (bias == "right" && start == mEnd - mStart) + { while (i < map$$1.length - 3 && map$$1[i + 3] == map$$1[i + 4] && !map$$1[i + 5].insertLeft) { + node = map$$1[(i += 3) + 2]; + collapse = "right"; + } } + break + } + } + return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd} +} + +function getUsefulRect(rects, bias) { + var rect = nullRect; + if (bias == "left") { for (var i = 0; i < rects.length; i++) { + if ((rect = rects[i]).left != rect.right) { break } + } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) { + if ((rect = rects[i$1]).left != rect.right) { break } + } } + return rect +} + +function measureCharInner(cm, prepared, ch, bias) { + var place = nodeAndOffsetInLineMap(prepared.map, ch, bias); + var node = place.node, start = place.start, end = place.end, collapse = place.collapse; + + var rect; + if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates. + for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned + while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start; } + while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end; } + if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart) + { rect = node.parentNode.getBoundingClientRect(); } + else + { rect = getUsefulRect(range(node, start, end).getClientRects(), bias); } + if (rect.left || rect.right || start == 0) { break } + end = start; + start = start - 1; + collapse = "right"; + } + if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect); } + } else { // If it is a widget, simply get the box for the whole widget. + if (start > 0) { collapse = bias = "right"; } + var rects; + if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1) + { rect = rects[bias == "right" ? rects.length - 1 : 0]; } + else + { rect = node.getBoundingClientRect(); } + } + if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) { + var rSpan = node.parentNode.getClientRects()[0]; + if (rSpan) + { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom}; } + else + { rect = nullRect; } + } + + var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top; + var mid = (rtop + rbot) / 2; + var heights = prepared.view.measure.heights; + var i = 0; + for (; i < heights.length - 1; i++) + { if (mid < heights[i]) { break } } + var top = i ? heights[i - 1] : 0, bot = heights[i]; + var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left, + right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left, + top: top, bottom: bot}; + if (!rect.left && !rect.right) { result.bogus = true; } + if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; } + + return result +} + +// Work around problem with bounding client rects on ranges being +// returned incorrectly when zoomed on IE10 and below. +function maybeUpdateRectForZooming(measure, rect) { + if (!window.screen || screen.logicalXDPI == null || + screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure)) + { return rect } + var scaleX = screen.logicalXDPI / screen.deviceXDPI; + var scaleY = screen.logicalYDPI / screen.deviceYDPI; + return {left: rect.left * scaleX, right: rect.right * scaleX, + top: rect.top * scaleY, bottom: rect.bottom * scaleY} +} + +function clearLineMeasurementCacheFor(lineView) { + if (lineView.measure) { + lineView.measure.cache = {}; + lineView.measure.heights = null; + if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++) + { lineView.measure.caches[i] = {}; } } + } +} + +function clearLineMeasurementCache(cm) { + cm.display.externalMeasure = null; + removeChildren(cm.display.lineMeasure); + for (var i = 0; i < cm.display.view.length; i++) + { clearLineMeasurementCacheFor(cm.display.view[i]); } +} + +function clearCaches(cm) { + clearLineMeasurementCache(cm); + cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null; + if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true; } + cm.display.lineNumChars = null; +} + +function pageScrollX() { + // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206 + // which causes page_Offset and bounding client rects to use + // different reference viewports and invalidate our calculations. + if (chrome && android) { return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft)) } + return window.pageXOffset || (document.documentElement || document.body).scrollLeft +} +function pageScrollY() { + if (chrome && android) { return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop)) } + return window.pageYOffset || (document.documentElement || document.body).scrollTop +} + +function widgetTopHeight(lineObj) { + var height = 0; + if (lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) + { height += widgetHeight(lineObj.widgets[i]); } } } + return height +} + +// Converts a {top, bottom, left, right} box from line-local +// coordinates into another coordinate system. Context may be one of +// "line", "div" (display.lineDiv), "local"./null (editor), "window", +// or "page". +function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) { + if (!includeWidgets) { + var height = widgetTopHeight(lineObj); + rect.top += height; rect.bottom += height; + } + if (context == "line") { return rect } + if (!context) { context = "local"; } + var yOff = heightAtLine(lineObj); + if (context == "local") { yOff += paddingTop(cm.display); } + else { yOff -= cm.display.viewOffset; } + if (context == "page" || context == "window") { + var lOff = cm.display.lineSpace.getBoundingClientRect(); + yOff += lOff.top + (context == "window" ? 0 : pageScrollY()); + var xOff = lOff.left + (context == "window" ? 0 : pageScrollX()); + rect.left += xOff; rect.right += xOff; + } + rect.top += yOff; rect.bottom += yOff; + return rect +} + +// Coverts a box from "div" coords to another coordinate system. +// Context may be "window", "page", "div", or "local"./null. +function fromCoordSystem(cm, coords, context) { + if (context == "div") { return coords } + var left = coords.left, top = coords.top; + // First move into "page" coordinate system + if (context == "page") { + left -= pageScrollX(); + top -= pageScrollY(); + } else if (context == "local" || !context) { + var localBox = cm.display.sizer.getBoundingClientRect(); + left += localBox.left; + top += localBox.top; + } + + var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect(); + return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top} +} + +function charCoords(cm, pos, context, lineObj, bias) { + if (!lineObj) { lineObj = getLine(cm.doc, pos.line); } + return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context) +} + +// Returns a box for a given cursor position, which may have an +// 'other' property containing the position of the secondary cursor +// on a bidi boundary. +// A cursor Pos(line, char, "before") is on the same visual line as `char - 1` +// and after `char - 1` in writing order of `char - 1` +// A cursor Pos(line, char, "after") is on the same visual line as `char` +// and before `char` in writing order of `char` +// Examples (upper-case letters are RTL, lower-case are LTR): +// Pos(0, 1, ...) +// before after +// ab a|b a|b +// aB a|B aB| +// Ab |Ab A|b +// AB B|A B|A +// Every position after the last character on a line is considered to stick +// to the last character on the line. +function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) { + lineObj = lineObj || getLine(cm.doc, pos.line); + if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); } + function get(ch, right) { + var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight); + if (right) { m.left = m.right; } else { m.right = m.left; } + return intoCoordSystem(cm, lineObj, m, context) + } + var order = getOrder(lineObj, cm.doc.direction), ch = pos.ch, sticky = pos.sticky; + if (ch >= lineObj.text.length) { + ch = lineObj.text.length; + sticky = "before"; + } else if (ch <= 0) { + ch = 0; + sticky = "after"; + } + if (!order) { return get(sticky == "before" ? ch - 1 : ch, sticky == "before") } + + function getBidi(ch, partPos, invert) { + var part = order[partPos], right = part.level == 1; + return get(invert ? ch - 1 : ch, right != invert) + } + var partPos = getBidiPartAt(order, ch, sticky); + var other = bidiOther; + var val = getBidi(ch, partPos, sticky == "before"); + if (other != null) { val.other = getBidi(ch, other, sticky != "before"); } + return val +} + +// Used to cheaply estimate the coordinates for a position. Used for +// intermediate scroll updates. +function estimateCoords(cm, pos) { + var left = 0; + pos = clipPos(cm.doc, pos); + if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch; } + var lineObj = getLine(cm.doc, pos.line); + var top = heightAtLine(lineObj) + paddingTop(cm.display); + return {left: left, right: left, top: top, bottom: top + lineObj.height} +} + +// Positions returned by coordsChar contain some extra information. +// xRel is the relative x position of the input coordinates compared +// to the found position (so xRel > 0 means the coordinates are to +// the right of the character position, for example). When outside +// is true, that means the coordinates lie outside the line's +// vertical range. +function PosWithInfo(line, ch, sticky, outside, xRel) { + var pos = Pos(line, ch, sticky); + pos.xRel = xRel; + if (outside) { pos.outside = true; } + return pos +} + +// Compute the character position closest to the given coordinates. +// Input must be lineSpace-local ("div" coordinate system). +function coordsChar(cm, x, y) { + var doc = cm.doc; + y += cm.display.viewOffset; + if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) } + var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1; + if (lineN > last) + { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) } + if (x < 0) { x = 0; } + + var lineObj = getLine(doc, lineN); + for (;;) { + var found = coordsCharInner(cm, lineObj, lineN, x, y); + var collapsed = collapsedSpanAround(lineObj, found.ch + (found.xRel > 0 ? 1 : 0)); + if (!collapsed) { return found } + var rangeEnd = collapsed.find(1); + if (rangeEnd.line == lineN) { return rangeEnd } + lineObj = getLine(doc, lineN = rangeEnd.line); + } +} + +function wrappedLineExtent(cm, lineObj, preparedMeasure, y) { + y -= widgetTopHeight(lineObj); + var end = lineObj.text.length; + var begin = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch - 1).bottom <= y; }, end, 0); + end = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch).top > y; }, begin, end); + return {begin: begin, end: end} +} + +function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) { + if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); } + var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), "line").top; + return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop) +} + +// Returns true if the given side of a box is after the given +// coordinates, in top-to-bottom, left-to-right order. +function boxIsAfter(box, x, y, left) { + return box.bottom <= y ? false : box.top > y ? true : (left ? box.left : box.right) > x +} + +function coordsCharInner(cm, lineObj, lineNo$$1, x, y) { + // Move y into line-local coordinate space + y -= heightAtLine(lineObj); + var preparedMeasure = prepareMeasureForLine(cm, lineObj); + // When directly calling `measureCharPrepared`, we have to adjust + // for the widgets at this line. + var widgetHeight$$1 = widgetTopHeight(lineObj); + var begin = 0, end = lineObj.text.length, ltr = true; + + var order = getOrder(lineObj, cm.doc.direction); + // If the line isn't plain left-to-right text, first figure out + // which bidi section the coordinates fall into. + if (order) { + var part = (cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart) + (cm, lineObj, lineNo$$1, preparedMeasure, order, x, y); + ltr = part.level != 1; + // The awkward -1 offsets are needed because findFirst (called + // on these below) will treat its first bound as inclusive, + // second as exclusive, but we want to actually address the + // characters in the part's range + begin = ltr ? part.from : part.to - 1; + end = ltr ? part.to : part.from - 1; + } + + // A binary search to find the first character whose bounding box + // starts after the coordinates. If we run across any whose box wrap + // the coordinates, store that. + var chAround = null, boxAround = null; + var ch = findFirst(function (ch) { + var box = measureCharPrepared(cm, preparedMeasure, ch); + box.top += widgetHeight$$1; box.bottom += widgetHeight$$1; + if (!boxIsAfter(box, x, y, false)) { return false } + if (box.top <= y && box.left <= x) { + chAround = ch; + boxAround = box; + } + return true + }, begin, end); + + var baseX, sticky, outside = false; + // If a box around the coordinates was found, use that + if (boxAround) { + // Distinguish coordinates nearer to the left or right side of the box + var atLeft = x - boxAround.left < boxAround.right - x, atStart = atLeft == ltr; + ch = chAround + (atStart ? 0 : 1); + sticky = atStart ? "after" : "before"; + baseX = atLeft ? boxAround.left : boxAround.right; + } else { + // (Adjust for extended bound, if necessary.) + if (!ltr && (ch == end || ch == begin)) { ch++; } + // To determine which side to associate with, get the box to the + // left of the character and compare it's vertical position to the + // coordinates + sticky = ch == 0 ? "after" : ch == lineObj.text.length ? "before" : + (measureCharPrepared(cm, preparedMeasure, ch - (ltr ? 1 : 0)).bottom + widgetHeight$$1 <= y) == ltr ? + "after" : "before"; + // Now get accurate coordinates for this place, in order to get a + // base X position + var coords = cursorCoords(cm, Pos(lineNo$$1, ch, sticky), "line", lineObj, preparedMeasure); + baseX = coords.left; + outside = y < coords.top || y >= coords.bottom; + } + + ch = skipExtendingChars(lineObj.text, ch, 1); + return PosWithInfo(lineNo$$1, ch, sticky, outside, x - baseX) +} + +function coordsBidiPart(cm, lineObj, lineNo$$1, preparedMeasure, order, x, y) { + // Bidi parts are sorted left-to-right, and in a non-line-wrapping + // situation, we can take this ordering to correspond to the visual + // ordering. This finds the first part whose end is after the given + // coordinates. + var index = findFirst(function (i) { + var part = order[i], ltr = part.level != 1; + return boxIsAfter(cursorCoords(cm, Pos(lineNo$$1, ltr ? part.to : part.from, ltr ? "before" : "after"), + "line", lineObj, preparedMeasure), x, y, true) + }, 0, order.length - 1); + var part = order[index]; + // If this isn't the first part, the part's start is also after + // the coordinates, and the coordinates aren't on the same line as + // that start, move one part back. + if (index > 0) { + var ltr = part.level != 1; + var start = cursorCoords(cm, Pos(lineNo$$1, ltr ? part.from : part.to, ltr ? "after" : "before"), + "line", lineObj, preparedMeasure); + if (boxIsAfter(start, x, y, true) && start.top > y) + { part = order[index - 1]; } + } + return part +} + +function coordsBidiPartWrapped(cm, lineObj, _lineNo, preparedMeasure, order, x, y) { + // In a wrapped line, rtl text on wrapping boundaries can do things + // that don't correspond to the ordering in our `order` array at + // all, so a binary search doesn't work, and we want to return a + // part that only spans one line so that the binary search in + // coordsCharInner is safe. As such, we first find the extent of the + // wrapped line, and then do a flat search in which we discard any + // spans that aren't on the line. + var ref = wrappedLineExtent(cm, lineObj, preparedMeasure, y); + var begin = ref.begin; + var end = ref.end; + if (/\s/.test(lineObj.text.charAt(end - 1))) { end--; } + var part = null, closestDist = null; + for (var i = 0; i < order.length; i++) { + var p = order[i]; + if (p.from >= end || p.to <= begin) { continue } + var ltr = p.level != 1; + var endX = measureCharPrepared(cm, preparedMeasure, ltr ? Math.min(end, p.to) - 1 : Math.max(begin, p.from)).right; + // Weigh against spans ending before this, so that they are only + // picked if nothing ends after + var dist = endX < x ? x - endX + 1e9 : endX - x; + if (!part || closestDist > dist) { + part = p; + closestDist = dist; + } + } + if (!part) { part = order[order.length - 1]; } + // Clip the part to the wrapped line. + if (part.from < begin) { part = {from: begin, to: part.to, level: part.level}; } + if (part.to > end) { part = {from: part.from, to: end, level: part.level}; } + return part +} + +var measureText; +// Compute the default text height. +function textHeight(display) { + if (display.cachedTextHeight != null) { return display.cachedTextHeight } + if (measureText == null) { + measureText = elt("pre"); + // Measure a bunch of lines, for browsers that compute + // fractional heights. + for (var i = 0; i < 49; ++i) { + measureText.appendChild(document.createTextNode("x")); + measureText.appendChild(elt("br")); + } + measureText.appendChild(document.createTextNode("x")); + } + removeChildrenAndAdd(display.measure, measureText); + var height = measureText.offsetHeight / 50; + if (height > 3) { display.cachedTextHeight = height; } + removeChildren(display.measure); + return height || 1 +} + +// Compute the default character width. +function charWidth(display) { + if (display.cachedCharWidth != null) { return display.cachedCharWidth } + var anchor = elt("span", "xxxxxxxxxx"); + var pre = elt("pre", [anchor]); + removeChildrenAndAdd(display.measure, pre); + var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10; + if (width > 2) { display.cachedCharWidth = width; } + return width || 10 +} + +// Do a bulk-read of the DOM positions and sizes needed to draw the +// view, so that we don't interleave reading and writing to the DOM. +function getDimensions(cm) { + var d = cm.display, left = {}, width = {}; + var gutterLeft = d.gutters.clientLeft; + for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) { + left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft; + width[cm.options.gutters[i]] = n.clientWidth; + } + return {fixedPos: compensateForHScroll(d), + gutterTotalWidth: d.gutters.offsetWidth, + gutterLeft: left, + gutterWidth: width, + wrapperWidth: d.wrapper.clientWidth} +} + +// Computes display.scroller.scrollLeft + display.gutters.offsetWidth, +// but using getBoundingClientRect to get a sub-pixel-accurate +// result. +function compensateForHScroll(display) { + return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left +} + +// Returns a function that estimates the height of a line, to use as +// first approximation until the line becomes visible (and is thus +// properly measurable). +function estimateHeight(cm) { + var th = textHeight(cm.display), wrapping = cm.options.lineWrapping; + var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3); + return function (line) { + if (lineIsHidden(cm.doc, line)) { return 0 } + + var widgetsHeight = 0; + if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) { + if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height; } + } } + + if (wrapping) + { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th } + else + { return widgetsHeight + th } + } +} + +function estimateLineHeights(cm) { + var doc = cm.doc, est = estimateHeight(cm); + doc.iter(function (line) { + var estHeight = est(line); + if (estHeight != line.height) { updateLineHeight(line, estHeight); } + }); +} + +// Given a mouse event, find the corresponding position. If liberal +// is false, it checks whether a gutter or scrollbar was clicked, +// and returns null if it was. forRect is used by rectangular +// selections, and tries to estimate a character position even for +// coordinates beyond the right of the text. +function posFromMouse(cm, e, liberal, forRect) { + var display = cm.display; + if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") { return null } + + var x, y, space = display.lineSpace.getBoundingClientRect(); + // Fails unpredictably on IE[67] when mouse is dragged around quickly. + try { x = e.clientX - space.left; y = e.clientY - space.top; } + catch (e) { return null } + var coords = coordsChar(cm, x, y), line; + if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) { + var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length; + coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff)); + } + return coords +} + +// Find the view element corresponding to a given line. Return null +// when the line isn't visible. +function findViewIndex(cm, n) { + if (n >= cm.display.viewTo) { return null } + n -= cm.display.viewFrom; + if (n < 0) { return null } + var view = cm.display.view; + for (var i = 0; i < view.length; i++) { + n -= view[i].size; + if (n < 0) { return i } + } +} + +function updateSelection(cm) { + cm.display.input.showSelection(cm.display.input.prepareSelection()); +} + +function prepareSelection(cm, primary) { + if ( primary === void 0 ) primary = true; + + var doc = cm.doc, result = {}; + var curFragment = result.cursors = document.createDocumentFragment(); + var selFragment = result.selection = document.createDocumentFragment(); + + for (var i = 0; i < doc.sel.ranges.length; i++) { + if (!primary && i == doc.sel.primIndex) { continue } + var range$$1 = doc.sel.ranges[i]; + if (range$$1.from().line >= cm.display.viewTo || range$$1.to().line < cm.display.viewFrom) { continue } + var collapsed = range$$1.empty(); + if (collapsed || cm.options.showCursorWhenSelecting) + { drawSelectionCursor(cm, range$$1.head, curFragment); } + if (!collapsed) + { drawSelectionRange(cm, range$$1, selFragment); } + } + return result +} + +// Draws a cursor for the given range +function drawSelectionCursor(cm, head, output) { + var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine); + + var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor")); + cursor.style.left = pos.left + "px"; + cursor.style.top = pos.top + "px"; + cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"; + + if (pos.other) { + // Secondary cursor, shown when on a 'jump' in bi-directional text + var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor")); + otherCursor.style.display = ""; + otherCursor.style.left = pos.other.left + "px"; + otherCursor.style.top = pos.other.top + "px"; + otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px"; + } +} + +function cmpCoords(a, b) { return a.top - b.top || a.left - b.left } + +// Draws the given range as a highlighted selection +function drawSelectionRange(cm, range$$1, output) { + var display = cm.display, doc = cm.doc; + var fragment = document.createDocumentFragment(); + var padding = paddingH(cm.display), leftSide = padding.left; + var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right; + var docLTR = doc.direction == "ltr"; + + function add(left, top, width, bottom) { + if (top < 0) { top = 0; } + top = Math.round(top); + bottom = Math.round(bottom); + fragment.appendChild(elt("div", null, "CodeMirror-selected", ("position: absolute; left: " + left + "px;\n top: " + top + "px; width: " + (width == null ? rightSide - left : width) + "px;\n height: " + (bottom - top) + "px"))); + } + + function drawForLine(line, fromArg, toArg) { + var lineObj = getLine(doc, line); + var lineLen = lineObj.text.length; + var start, end; + function coords(ch, bias) { + return charCoords(cm, Pos(line, ch), "div", lineObj, bias) + } + + function wrapX(pos, dir, side) { + var extent = wrappedLineExtentChar(cm, lineObj, null, pos); + var prop = (dir == "ltr") == (side == "after") ? "left" : "right"; + var ch = side == "after" ? extent.begin : extent.end - (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1); + return coords(ch, prop)[prop] + } + + var order = getOrder(lineObj, doc.direction); + iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir, i) { + var ltr = dir == "ltr"; + var fromPos = coords(from, ltr ? "left" : "right"); + var toPos = coords(to - 1, ltr ? "right" : "left"); + + var openStart = fromArg == null && from == 0, openEnd = toArg == null && to == lineLen; + var first = i == 0, last = !order || i == order.length - 1; + if (toPos.top - fromPos.top <= 3) { // Single line + var openLeft = (docLTR ? openStart : openEnd) && first; + var openRight = (docLTR ? openEnd : openStart) && last; + var left = openLeft ? leftSide : (ltr ? fromPos : toPos).left; + var right = openRight ? rightSide : (ltr ? toPos : fromPos).right; + add(left, fromPos.top, right - left, fromPos.bottom); + } else { // Multiple lines + var topLeft, topRight, botLeft, botRight; + if (ltr) { + topLeft = docLTR && openStart && first ? leftSide : fromPos.left; + topRight = docLTR ? rightSide : wrapX(from, dir, "before"); + botLeft = docLTR ? leftSide : wrapX(to, dir, "after"); + botRight = docLTR && openEnd && last ? rightSide : toPos.right; + } else { + topLeft = !docLTR ? leftSide : wrapX(from, dir, "before"); + topRight = !docLTR && openStart && first ? rightSide : fromPos.right; + botLeft = !docLTR && openEnd && last ? leftSide : toPos.left; + botRight = !docLTR ? rightSide : wrapX(to, dir, "after"); + } + add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom); + if (fromPos.bottom < toPos.top) { add(leftSide, fromPos.bottom, null, toPos.top); } + add(botLeft, toPos.top, botRight - botLeft, toPos.bottom); + } + + if (!start || cmpCoords(fromPos, start) < 0) { start = fromPos; } + if (cmpCoords(toPos, start) < 0) { start = toPos; } + if (!end || cmpCoords(fromPos, end) < 0) { end = fromPos; } + if (cmpCoords(toPos, end) < 0) { end = toPos; } + }); + return {start: start, end: end} + } + + var sFrom = range$$1.from(), sTo = range$$1.to(); + if (sFrom.line == sTo.line) { + drawForLine(sFrom.line, sFrom.ch, sTo.ch); + } else { + var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line); + var singleVLine = visualLine(fromLine) == visualLine(toLine); + var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end; + var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start; + if (singleVLine) { + if (leftEnd.top < rightStart.top - 2) { + add(leftEnd.right, leftEnd.top, null, leftEnd.bottom); + add(leftSide, rightStart.top, rightStart.left, rightStart.bottom); + } else { + add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom); + } + } + if (leftEnd.bottom < rightStart.top) + { add(leftSide, leftEnd.bottom, null, rightStart.top); } + } + + output.appendChild(fragment); +} + +// Cursor-blinking +function restartBlink(cm) { + if (!cm.state.focused) { return } + var display = cm.display; + clearInterval(display.blinker); + var on = true; + display.cursorDiv.style.visibility = ""; + if (cm.options.cursorBlinkRate > 0) + { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"; }, + cm.options.cursorBlinkRate); } + else if (cm.options.cursorBlinkRate < 0) + { display.cursorDiv.style.visibility = "hidden"; } +} + +function ensureFocus(cm) { + if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); } +} + +function delayBlurEvent(cm) { + cm.state.delayingBlurEvent = true; + setTimeout(function () { if (cm.state.delayingBlurEvent) { + cm.state.delayingBlurEvent = false; + onBlur(cm); + } }, 100); +} + +function onFocus(cm, e) { + if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false; } + + if (cm.options.readOnly == "nocursor") { return } + if (!cm.state.focused) { + signal(cm, "focus", cm, e); + cm.state.focused = true; + addClass(cm.display.wrapper, "CodeMirror-focused"); + // This test prevents this from firing when a context + // menu is closed (since the input reset would kill the + // select-all detection hack) + if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) { + cm.display.input.reset(); + if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20); } // Issue #1730 + } + cm.display.input.receivedFocus(); + } + restartBlink(cm); +} +function onBlur(cm, e) { + if (cm.state.delayingBlurEvent) { return } + + if (cm.state.focused) { + signal(cm, "blur", cm, e); + cm.state.focused = false; + rmClass(cm.display.wrapper, "CodeMirror-focused"); + } + clearInterval(cm.display.blinker); + setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false; } }, 150); +} + +// Read the actual heights of the rendered lines, and update their +// stored heights to match. +function updateHeightsInViewport(cm) { + var display = cm.display; + var prevBottom = display.lineDiv.offsetTop; + for (var i = 0; i < display.view.length; i++) { + var cur = display.view[i], height = (void 0); + if (cur.hidden) { continue } + if (ie && ie_version < 8) { + var bot = cur.node.offsetTop + cur.node.offsetHeight; + height = bot - prevBottom; + prevBottom = bot; + } else { + var box = cur.node.getBoundingClientRect(); + height = box.bottom - box.top; + } + var diff = cur.line.height - height; + if (height < 2) { height = textHeight(display); } + if (diff > .005 || diff < -.005) { + updateLineHeight(cur.line, height); + updateWidgetHeight(cur.line); + if (cur.rest) { for (var j = 0; j < cur.rest.length; j++) + { updateWidgetHeight(cur.rest[j]); } } + } + } +} + +// Read and store the height of line widgets associated with the +// given line. +function updateWidgetHeight(line) { + if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i) { + var w = line.widgets[i], parent = w.node.parentNode; + if (parent) { w.height = parent.offsetHeight; } + } } +} + +// Compute the lines that are visible in a given viewport (defaults +// the the current scroll position). viewport may contain top, +// height, and ensure (see op.scrollToPos) properties. +function visibleLines(display, doc, viewport) { + var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop; + top = Math.floor(top - paddingTop(display)); + var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight; + + var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom); + // Ensure is a {from: {line, ch}, to: {line, ch}} object, and + // forces those lines into the viewport (if possible). + if (viewport && viewport.ensure) { + var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line; + if (ensureFrom < from) { + from = ensureFrom; + to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight); + } else if (Math.min(ensureTo, doc.lastLine()) >= to) { + from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight); + to = ensureTo; + } + } + return {from: from, to: Math.max(to, from + 1)} +} + +// Re-align line numbers and gutter marks to compensate for +// horizontal scrolling. +function alignHorizontally(cm) { + var display = cm.display, view = display.view; + if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return } + var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft; + var gutterW = display.gutters.offsetWidth, left = comp + "px"; + for (var i = 0; i < view.length; i++) { if (!view[i].hidden) { + if (cm.options.fixedGutter) { + if (view[i].gutter) + { view[i].gutter.style.left = left; } + if (view[i].gutterBackground) + { view[i].gutterBackground.style.left = left; } + } + var align = view[i].alignable; + if (align) { for (var j = 0; j < align.length; j++) + { align[j].style.left = left; } } + } } + if (cm.options.fixedGutter) + { display.gutters.style.left = (comp + gutterW) + "px"; } +} + +// Used to ensure that the line number gutter is still the right +// size for the current document size. Returns true when an update +// is needed. +function maybeUpdateLineNumberWidth(cm) { + if (!cm.options.lineNumbers) { return false } + var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display; + if (last.length != display.lineNumChars) { + var test = display.measure.appendChild(elt("div", [elt("div", last)], + "CodeMirror-linenumber CodeMirror-gutter-elt")); + var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW; + display.lineGutter.style.width = ""; + display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1; + display.lineNumWidth = display.lineNumInnerWidth + padding; + display.lineNumChars = display.lineNumInnerWidth ? last.length : -1; + display.lineGutter.style.width = display.lineNumWidth + "px"; + updateGutterSpace(cm); + return true + } + return false +} + +// SCROLLING THINGS INTO VIEW + +// If an editor sits on the top or bottom of the window, partially +// scrolled out of view, this ensures that the cursor is visible. +function maybeScrollWindow(cm, rect) { + if (signalDOMEvent(cm, "scrollCursorIntoView")) { return } + + var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null; + if (rect.top + box.top < 0) { doScroll = true; } + else if (rect.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false; } + if (doScroll != null && !phantom) { + var scrollNode = elt("div", "\u200b", null, ("position: absolute;\n top: " + (rect.top - display.viewOffset - paddingTop(cm.display)) + "px;\n height: " + (rect.bottom - rect.top + scrollGap(cm) + display.barHeight) + "px;\n left: " + (rect.left) + "px; width: " + (Math.max(2, rect.right - rect.left)) + "px;")); + cm.display.lineSpace.appendChild(scrollNode); + scrollNode.scrollIntoView(doScroll); + cm.display.lineSpace.removeChild(scrollNode); + } +} + +// Scroll a given position into view (immediately), verifying that +// it actually became visible (as line heights are accurately +// measured, the position of something may 'drift' during drawing). +function scrollPosIntoView(cm, pos, end, margin) { + if (margin == null) { margin = 0; } + var rect; + if (!cm.options.lineWrapping && pos == end) { + // Set pos and end to the cursor positions around the character pos sticks to + // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch + // If pos == Pos(_, 0, "before"), pos and end are unchanged + pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos; + end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos; + } + for (var limit = 0; limit < 5; limit++) { + var changed = false; + var coords = cursorCoords(cm, pos); + var endCoords = !end || end == pos ? coords : cursorCoords(cm, end); + rect = {left: Math.min(coords.left, endCoords.left), + top: Math.min(coords.top, endCoords.top) - margin, + right: Math.max(coords.left, endCoords.left), + bottom: Math.max(coords.bottom, endCoords.bottom) + margin}; + var scrollPos = calculateScrollPos(cm, rect); + var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft; + if (scrollPos.scrollTop != null) { + updateScrollTop(cm, scrollPos.scrollTop); + if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true; } + } + if (scrollPos.scrollLeft != null) { + setScrollLeft(cm, scrollPos.scrollLeft); + if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true; } + } + if (!changed) { break } + } + return rect +} + +// Scroll a given set of coordinates into view (immediately). +function scrollIntoView(cm, rect) { + var scrollPos = calculateScrollPos(cm, rect); + if (scrollPos.scrollTop != null) { updateScrollTop(cm, scrollPos.scrollTop); } + if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft); } +} + +// Calculate a new scroll position needed to scroll the given +// rectangle into view. Returns an object with scrollTop and +// scrollLeft properties. When these are undefined, the +// vertical/horizontal position does not need to be adjusted. +function calculateScrollPos(cm, rect) { + var display = cm.display, snapMargin = textHeight(cm.display); + if (rect.top < 0) { rect.top = 0; } + var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop; + var screen = displayHeight(cm), result = {}; + if (rect.bottom - rect.top > screen) { rect.bottom = rect.top + screen; } + var docBottom = cm.doc.height + paddingVert(display); + var atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin; + if (rect.top < screentop) { + result.scrollTop = atTop ? 0 : rect.top; + } else if (rect.bottom > screentop + screen) { + var newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen); + if (newTop != screentop) { result.scrollTop = newTop; } + } + + var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft; + var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0); + var tooWide = rect.right - rect.left > screenw; + if (tooWide) { rect.right = rect.left + screenw; } + if (rect.left < 10) + { result.scrollLeft = 0; } + else if (rect.left < screenleft) + { result.scrollLeft = Math.max(0, rect.left - (tooWide ? 0 : 10)); } + else if (rect.right > screenw + screenleft - 3) + { result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw; } + return result +} + +// Store a relative adjustment to the scroll position in the current +// operation (to be applied when the operation finishes). +function addToScrollTop(cm, top) { + if (top == null) { return } + resolveScrollToPos(cm); + cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top; +} + +// Make sure that at the end of the operation the current cursor is +// shown. +function ensureCursorVisible(cm) { + resolveScrollToPos(cm); + var cur = cm.getCursor(); + cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin}; +} + +function scrollToCoords(cm, x, y) { + if (x != null || y != null) { resolveScrollToPos(cm); } + if (x != null) { cm.curOp.scrollLeft = x; } + if (y != null) { cm.curOp.scrollTop = y; } +} + +function scrollToRange(cm, range$$1) { + resolveScrollToPos(cm); + cm.curOp.scrollToPos = range$$1; +} + +// When an operation has its scrollToPos property set, and another +// scroll action is applied before the end of the operation, this +// 'simulates' scrolling that position into view in a cheap way, so +// that the effect of intermediate scroll commands is not ignored. +function resolveScrollToPos(cm) { + var range$$1 = cm.curOp.scrollToPos; + if (range$$1) { + cm.curOp.scrollToPos = null; + var from = estimateCoords(cm, range$$1.from), to = estimateCoords(cm, range$$1.to); + scrollToCoordsRange(cm, from, to, range$$1.margin); + } +} + +function scrollToCoordsRange(cm, from, to, margin) { + var sPos = calculateScrollPos(cm, { + left: Math.min(from.left, to.left), + top: Math.min(from.top, to.top) - margin, + right: Math.max(from.right, to.right), + bottom: Math.max(from.bottom, to.bottom) + margin + }); + scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop); +} + +// Sync the scrollable area and scrollbars, ensure the viewport +// covers the visible area. +function updateScrollTop(cm, val) { + if (Math.abs(cm.doc.scrollTop - val) < 2) { return } + if (!gecko) { updateDisplaySimple(cm, {top: val}); } + setScrollTop(cm, val, true); + if (gecko) { updateDisplaySimple(cm); } + startWorker(cm, 100); +} + +function setScrollTop(cm, val, forceScroll) { + val = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val); + if (cm.display.scroller.scrollTop == val && !forceScroll) { return } + cm.doc.scrollTop = val; + cm.display.scrollbars.setScrollTop(val); + if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val; } +} + +// Sync scroller and scrollbar, ensure the gutter elements are +// aligned. +function setScrollLeft(cm, val, isScroller, forceScroll) { + val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth); + if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) { return } + cm.doc.scrollLeft = val; + alignHorizontally(cm); + if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val; } + cm.display.scrollbars.setScrollLeft(val); +} + +// SCROLLBARS + +// Prepare DOM reads needed to update the scrollbars. Done in one +// shot to minimize update/measure roundtrips. +function measureForScrollbars(cm) { + var d = cm.display, gutterW = d.gutters.offsetWidth; + var docH = Math.round(cm.doc.height + paddingVert(cm.display)); + return { + clientHeight: d.scroller.clientHeight, + viewHeight: d.wrapper.clientHeight, + scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth, + viewWidth: d.wrapper.clientWidth, + barLeft: cm.options.fixedGutter ? gutterW : 0, + docHeight: docH, + scrollHeight: docH + scrollGap(cm) + d.barHeight, + nativeBarWidth: d.nativeBarWidth, + gutterWidth: gutterW + } +} + +var NativeScrollbars = function(place, scroll, cm) { + this.cm = cm; + var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar"); + var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar"); + vert.tabIndex = horiz.tabIndex = -1; + place(vert); place(horiz); + + on(vert, "scroll", function () { + if (vert.clientHeight) { scroll(vert.scrollTop, "vertical"); } + }); + on(horiz, "scroll", function () { + if (horiz.clientWidth) { scroll(horiz.scrollLeft, "horizontal"); } + }); + + this.checkedZeroWidth = false; + // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8). + if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = "18px"; } +}; + +NativeScrollbars.prototype.update = function (measure) { + var needsH = measure.scrollWidth > measure.clientWidth + 1; + var needsV = measure.scrollHeight > measure.clientHeight + 1; + var sWidth = measure.nativeBarWidth; + + if (needsV) { + this.vert.style.display = "block"; + this.vert.style.bottom = needsH ? sWidth + "px" : "0"; + var totalHeight = measure.viewHeight - (needsH ? sWidth : 0); + // A bug in IE8 can cause this value to be negative, so guard it. + this.vert.firstChild.style.height = + Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px"; + } else { + this.vert.style.display = ""; + this.vert.firstChild.style.height = "0"; + } + + if (needsH) { + this.horiz.style.display = "block"; + this.horiz.style.right = needsV ? sWidth + "px" : "0"; + this.horiz.style.left = measure.barLeft + "px"; + var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0); + this.horiz.firstChild.style.width = + Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + "px"; + } else { + this.horiz.style.display = ""; + this.horiz.firstChild.style.width = "0"; + } + + if (!this.checkedZeroWidth && measure.clientHeight > 0) { + if (sWidth == 0) { this.zeroWidthHack(); } + this.checkedZeroWidth = true; + } + + return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0} +}; + +NativeScrollbars.prototype.setScrollLeft = function (pos) { + if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos; } + if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz"); } +}; + +NativeScrollbars.prototype.setScrollTop = function (pos) { + if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos; } + if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert, "vert"); } +}; + +NativeScrollbars.prototype.zeroWidthHack = function () { + var w = mac && !mac_geMountainLion ? "12px" : "18px"; + this.horiz.style.height = this.vert.style.width = w; + this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none"; + this.disableHoriz = new Delayed; + this.disableVert = new Delayed; +}; + +NativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay, type) { + bar.style.pointerEvents = "auto"; + function maybeDisable() { + // To find out whether the scrollbar is still visible, we + // check whether the element under the pixel in the bottom + // right corner of the scrollbar box is the scrollbar box + // itself (when the bar is still visible) or its filler child + // (when the bar is hidden). If it is still visible, we keep + // it enabled, if it's hidden, we disable pointer events. + var box = bar.getBoundingClientRect(); + var elt$$1 = type == "vert" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2) + : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1); + if (elt$$1 != bar) { bar.style.pointerEvents = "none"; } + else { delay.set(1000, maybeDisable); } + } + delay.set(1000, maybeDisable); +}; + +NativeScrollbars.prototype.clear = function () { + var parent = this.horiz.parentNode; + parent.removeChild(this.horiz); + parent.removeChild(this.vert); +}; + +var NullScrollbars = function () {}; + +NullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} }; +NullScrollbars.prototype.setScrollLeft = function () {}; +NullScrollbars.prototype.setScrollTop = function () {}; +NullScrollbars.prototype.clear = function () {}; + +function updateScrollbars(cm, measure) { + if (!measure) { measure = measureForScrollbars(cm); } + var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight; + updateScrollbarsInner(cm, measure); + for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) { + if (startWidth != cm.display.barWidth && cm.options.lineWrapping) + { updateHeightsInViewport(cm); } + updateScrollbarsInner(cm, measureForScrollbars(cm)); + startWidth = cm.display.barWidth; startHeight = cm.display.barHeight; + } +} + +// Re-synchronize the fake scrollbars with the actual size of the +// content. +function updateScrollbarsInner(cm, measure) { + var d = cm.display; + var sizes = d.scrollbars.update(measure); + + d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px"; + d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px"; + d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"; + + if (sizes.right && sizes.bottom) { + d.scrollbarFiller.style.display = "block"; + d.scrollbarFiller.style.height = sizes.bottom + "px"; + d.scrollbarFiller.style.width = sizes.right + "px"; + } else { d.scrollbarFiller.style.display = ""; } + if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) { + d.gutterFiller.style.display = "block"; + d.gutterFiller.style.height = sizes.bottom + "px"; + d.gutterFiller.style.width = measure.gutterWidth + "px"; + } else { d.gutterFiller.style.display = ""; } +} + +var scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars}; + +function initScrollbars(cm) { + if (cm.display.scrollbars) { + cm.display.scrollbars.clear(); + if (cm.display.scrollbars.addClass) + { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass); } + } + + cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) { + cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller); + // Prevent clicks in the scrollbars from killing focus + on(node, "mousedown", function () { + if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0); } + }); + node.setAttribute("cm-not-content", "true"); + }, function (pos, axis) { + if (axis == "horizontal") { setScrollLeft(cm, pos); } + else { updateScrollTop(cm, pos); } + }, cm); + if (cm.display.scrollbars.addClass) + { addClass(cm.display.wrapper, cm.display.scrollbars.addClass); } +} + +// Operations are used to wrap a series of changes to the editor +// state in such a way that each change won't have to update the +// cursor and display (which would be awkward, slow, and +// error-prone). Instead, display updates are batched and then all +// combined and executed at once. + +var nextOpId = 0; +// Start a new operation. +function startOperation(cm) { + cm.curOp = { + cm: cm, + viewChanged: false, // Flag that indicates that lines might need to be redrawn + startHeight: cm.doc.height, // Used to detect need to update scrollbar + forceUpdate: false, // Used to force a redraw + updateInput: null, // Whether to reset the input textarea + typing: false, // Whether this reset should be careful to leave existing text (for compositing) + changeObjs: null, // Accumulated changes, for firing change events + cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on + cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already + selectionChanged: false, // Whether the selection needs to be redrawn + updateMaxLine: false, // Set when the widest line needs to be determined anew + scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet + scrollToPos: null, // Used to scroll to a specific position + focus: false, + id: ++nextOpId // Unique ID + }; + pushOperation(cm.curOp); +} + +// Finish an operation, updating the display and signalling delayed events +function endOperation(cm) { + var op = cm.curOp; + finishOperation(op, function (group) { + for (var i = 0; i < group.ops.length; i++) + { group.ops[i].cm.curOp = null; } + endOperations(group); + }); +} + +// The DOM updates done when an operation finishes are batched so +// that the minimum number of relayouts are required. +function endOperations(group) { + var ops = group.ops; + for (var i = 0; i < ops.length; i++) // Read DOM + { endOperation_R1(ops[i]); } + for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe) + { endOperation_W1(ops[i$1]); } + for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM + { endOperation_R2(ops[i$2]); } + for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe) + { endOperation_W2(ops[i$3]); } + for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM + { endOperation_finish(ops[i$4]); } +} + +function endOperation_R1(op) { + var cm = op.cm, display = cm.display; + maybeClipScrollbars(cm); + if (op.updateMaxLine) { findMaxLine(cm); } + + op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null || + op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom || + op.scrollToPos.to.line >= display.viewTo) || + display.maxLineChanged && cm.options.lineWrapping; + op.update = op.mustUpdate && + new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate); +} + +function endOperation_W1(op) { + op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update); +} + +function endOperation_R2(op) { + var cm = op.cm, display = cm.display; + if (op.updatedDisplay) { updateHeightsInViewport(cm); } + + op.barMeasure = measureForScrollbars(cm); + + // If the max line changed since it was last measured, measure it, + // and ensure the document's width matches it. + // updateDisplay_W2 will use these properties to do the actual resizing + if (display.maxLineChanged && !cm.options.lineWrapping) { + op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3; + cm.display.sizerWidth = op.adjustWidthTo; + op.barMeasure.scrollWidth = + Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth); + op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm)); + } + + if (op.updatedDisplay || op.selectionChanged) + { op.preparedSelection = display.input.prepareSelection(); } +} + +function endOperation_W2(op) { + var cm = op.cm; + + if (op.adjustWidthTo != null) { + cm.display.sizer.style.minWidth = op.adjustWidthTo + "px"; + if (op.maxScrollLeft < cm.doc.scrollLeft) + { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true); } + cm.display.maxLineChanged = false; + } + + var takeFocus = op.focus && op.focus == activeElt(); + if (op.preparedSelection) + { cm.display.input.showSelection(op.preparedSelection, takeFocus); } + if (op.updatedDisplay || op.startHeight != cm.doc.height) + { updateScrollbars(cm, op.barMeasure); } + if (op.updatedDisplay) + { setDocumentHeight(cm, op.barMeasure); } + + if (op.selectionChanged) { restartBlink(cm); } + + if (cm.state.focused && op.updateInput) + { cm.display.input.reset(op.typing); } + if (takeFocus) { ensureFocus(op.cm); } +} + +function endOperation_finish(op) { + var cm = op.cm, display = cm.display, doc = cm.doc; + + if (op.updatedDisplay) { postUpdateDisplay(cm, op.update); } + + // Abort mouse wheel delta measurement, when scrolling explicitly + if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos)) + { display.wheelStartX = display.wheelStartY = null; } + + // Propagate the scroll position to the actual DOM scroller + if (op.scrollTop != null) { setScrollTop(cm, op.scrollTop, op.forceScroll); } + + if (op.scrollLeft != null) { setScrollLeft(cm, op.scrollLeft, true, true); } + // If we need to scroll a specific position into view, do so. + if (op.scrollToPos) { + var rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from), + clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin); + maybeScrollWindow(cm, rect); + } + + // Fire events for markers that are hidden/unidden by editing or + // undoing + var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers; + if (hidden) { for (var i = 0; i < hidden.length; ++i) + { if (!hidden[i].lines.length) { signal(hidden[i], "hide"); } } } + if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1) + { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], "unhide"); } } } + + if (display.wrapper.offsetHeight) + { doc.scrollTop = cm.display.scroller.scrollTop; } + + // Fire change events, and delayed event handlers + if (op.changeObjs) + { signal(cm, "changes", cm, op.changeObjs); } + if (op.update) + { op.update.finish(); } +} + +// Run the given function in an operation +function runInOp(cm, f) { + if (cm.curOp) { return f() } + startOperation(cm); + try { return f() } + finally { endOperation(cm); } +} +// Wraps a function in an operation. Returns the wrapped function. +function operation(cm, f) { + return function() { + if (cm.curOp) { return f.apply(cm, arguments) } + startOperation(cm); + try { return f.apply(cm, arguments) } + finally { endOperation(cm); } + } +} +// Used to add methods to editor and doc instances, wrapping them in +// operations. +function methodOp(f) { + return function() { + if (this.curOp) { return f.apply(this, arguments) } + startOperation(this); + try { return f.apply(this, arguments) } + finally { endOperation(this); } + } +} +function docMethodOp(f) { + return function() { + var cm = this.cm; + if (!cm || cm.curOp) { return f.apply(this, arguments) } + startOperation(cm); + try { return f.apply(this, arguments) } + finally { endOperation(cm); } + } +} + +// Updates the display.view data structure for a given change to the +// document. From and to are in pre-change coordinates. Lendiff is +// the amount of lines added or subtracted by the change. This is +// used for changes that span multiple lines, or change the way +// lines are divided into visual lines. regLineChange (below) +// registers single-line changes. +function regChange(cm, from, to, lendiff) { + if (from == null) { from = cm.doc.first; } + if (to == null) { to = cm.doc.first + cm.doc.size; } + if (!lendiff) { lendiff = 0; } + + var display = cm.display; + if (lendiff && to < display.viewTo && + (display.updateLineNumbers == null || display.updateLineNumbers > from)) + { display.updateLineNumbers = from; } + + cm.curOp.viewChanged = true; + + if (from >= display.viewTo) { // Change after + if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo) + { resetView(cm); } + } else if (to <= display.viewFrom) { // Change before + if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) { + resetView(cm); + } else { + display.viewFrom += lendiff; + display.viewTo += lendiff; + } + } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap + resetView(cm); + } else if (from <= display.viewFrom) { // Top overlap + var cut = viewCuttingPoint(cm, to, to + lendiff, 1); + if (cut) { + display.view = display.view.slice(cut.index); + display.viewFrom = cut.lineN; + display.viewTo += lendiff; + } else { + resetView(cm); + } + } else if (to >= display.viewTo) { // Bottom overlap + var cut$1 = viewCuttingPoint(cm, from, from, -1); + if (cut$1) { + display.view = display.view.slice(0, cut$1.index); + display.viewTo = cut$1.lineN; + } else { + resetView(cm); + } + } else { // Gap in the middle + var cutTop = viewCuttingPoint(cm, from, from, -1); + var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1); + if (cutTop && cutBot) { + display.view = display.view.slice(0, cutTop.index) + .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN)) + .concat(display.view.slice(cutBot.index)); + display.viewTo += lendiff; + } else { + resetView(cm); + } + } + + var ext = display.externalMeasured; + if (ext) { + if (to < ext.lineN) + { ext.lineN += lendiff; } + else if (from < ext.lineN + ext.size) + { display.externalMeasured = null; } + } +} + +// Register a change to a single line. Type must be one of "text", +// "gutter", "class", "widget" +function regLineChange(cm, line, type) { + cm.curOp.viewChanged = true; + var display = cm.display, ext = cm.display.externalMeasured; + if (ext && line >= ext.lineN && line < ext.lineN + ext.size) + { display.externalMeasured = null; } + + if (line < display.viewFrom || line >= display.viewTo) { return } + var lineView = display.view[findViewIndex(cm, line)]; + if (lineView.node == null) { return } + var arr = lineView.changes || (lineView.changes = []); + if (indexOf(arr, type) == -1) { arr.push(type); } +} + +// Clear the view. +function resetView(cm) { + cm.display.viewFrom = cm.display.viewTo = cm.doc.first; + cm.display.view = []; + cm.display.viewOffset = 0; +} + +function viewCuttingPoint(cm, oldN, newN, dir) { + var index = findViewIndex(cm, oldN), diff, view = cm.display.view; + if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size) + { return {index: index, lineN: newN} } + var n = cm.display.viewFrom; + for (var i = 0; i < index; i++) + { n += view[i].size; } + if (n != oldN) { + if (dir > 0) { + if (index == view.length - 1) { return null } + diff = (n + view[index].size) - oldN; + index++; + } else { + diff = n - oldN; + } + oldN += diff; newN += diff; + } + while (visualLineNo(cm.doc, newN) != newN) { + if (index == (dir < 0 ? 0 : view.length - 1)) { return null } + newN += dir * view[index - (dir < 0 ? 1 : 0)].size; + index += dir; + } + return {index: index, lineN: newN} +} + +// Force the view to cover a given range, adding empty view element +// or clipping off existing ones as needed. +function adjustView(cm, from, to) { + var display = cm.display, view = display.view; + if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) { + display.view = buildViewArray(cm, from, to); + display.viewFrom = from; + } else { + if (display.viewFrom > from) + { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view); } + else if (display.viewFrom < from) + { display.view = display.view.slice(findViewIndex(cm, from)); } + display.viewFrom = from; + if (display.viewTo < to) + { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)); } + else if (display.viewTo > to) + { display.view = display.view.slice(0, findViewIndex(cm, to)); } + } + display.viewTo = to; +} + +// Count the number of lines in the view whose DOM representation is +// out of date (or nonexistent). +function countDirtyView(cm) { + var view = cm.display.view, dirty = 0; + for (var i = 0; i < view.length; i++) { + var lineView = view[i]; + if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty; } + } + return dirty +} + +// HIGHLIGHT WORKER + +function startWorker(cm, time) { + if (cm.doc.highlightFrontier < cm.display.viewTo) + { cm.state.highlight.set(time, bind(highlightWorker, cm)); } +} + +function highlightWorker(cm) { + var doc = cm.doc; + if (doc.highlightFrontier >= cm.display.viewTo) { return } + var end = +new Date + cm.options.workTime; + var context = getContextBefore(cm, doc.highlightFrontier); + var changedLines = []; + + doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) { + if (context.line >= cm.display.viewFrom) { // Visible + var oldStyles = line.styles; + var resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null; + var highlighted = highlightLine(cm, line, context, true); + if (resetState) { context.state = resetState; } + line.styles = highlighted.styles; + var oldCls = line.styleClasses, newCls = highlighted.classes; + if (newCls) { line.styleClasses = newCls; } + else if (oldCls) { line.styleClasses = null; } + var ischange = !oldStyles || oldStyles.length != line.styles.length || + oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass); + for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i]; } + if (ischange) { changedLines.push(context.line); } + line.stateAfter = context.save(); + context.nextLine(); + } else { + if (line.text.length <= cm.options.maxHighlightLength) + { processLine(cm, line.text, context); } + line.stateAfter = context.line % 5 == 0 ? context.save() : null; + context.nextLine(); + } + if (+new Date > end) { + startWorker(cm, cm.options.workDelay); + return true + } + }); + doc.highlightFrontier = context.line; + doc.modeFrontier = Math.max(doc.modeFrontier, context.line); + if (changedLines.length) { runInOp(cm, function () { + for (var i = 0; i < changedLines.length; i++) + { regLineChange(cm, changedLines[i], "text"); } + }); } +} + +// DISPLAY DRAWING + +var DisplayUpdate = function(cm, viewport, force) { + var display = cm.display; + + this.viewport = viewport; + // Store some values that we'll need later (but don't want to force a relayout for) + this.visible = visibleLines(display, cm.doc, viewport); + this.editorIsHidden = !display.wrapper.offsetWidth; + this.wrapperHeight = display.wrapper.clientHeight; + this.wrapperWidth = display.wrapper.clientWidth; + this.oldDisplayWidth = displayWidth(cm); + this.force = force; + this.dims = getDimensions(cm); + this.events = []; +}; + +DisplayUpdate.prototype.signal = function (emitter, type) { + if (hasHandler(emitter, type)) + { this.events.push(arguments); } +}; +DisplayUpdate.prototype.finish = function () { + var this$1 = this; + + for (var i = 0; i < this.events.length; i++) + { signal.apply(null, this$1.events[i]); } +}; + +function maybeClipScrollbars(cm) { + var display = cm.display; + if (!display.scrollbarsClipped && display.scroller.offsetWidth) { + display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth; + display.heightForcer.style.height = scrollGap(cm) + "px"; + display.sizer.style.marginBottom = -display.nativeBarWidth + "px"; + display.sizer.style.borderRightWidth = scrollGap(cm) + "px"; + display.scrollbarsClipped = true; + } +} + +function selectionSnapshot(cm) { + if (cm.hasFocus()) { return null } + var active = activeElt(); + if (!active || !contains(cm.display.lineDiv, active)) { return null } + var result = {activeElt: active}; + if (window.getSelection) { + var sel = window.getSelection(); + if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) { + result.anchorNode = sel.anchorNode; + result.anchorOffset = sel.anchorOffset; + result.focusNode = sel.focusNode; + result.focusOffset = sel.focusOffset; + } + } + return result +} + +function restoreSelection(snapshot) { + if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt()) { return } + snapshot.activeElt.focus(); + if (snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) { + var sel = window.getSelection(), range$$1 = document.createRange(); + range$$1.setEnd(snapshot.anchorNode, snapshot.anchorOffset); + range$$1.collapse(false); + sel.removeAllRanges(); + sel.addRange(range$$1); + sel.extend(snapshot.focusNode, snapshot.focusOffset); + } +} + +// Does the actual updating of the line display. Bails out +// (returning false) when there is nothing to be done and forced is +// false. +function updateDisplayIfNeeded(cm, update) { + var display = cm.display, doc = cm.doc; + + if (update.editorIsHidden) { + resetView(cm); + return false + } + + // Bail out if the visible area is already rendered and nothing changed. + if (!update.force && + update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo && + (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) && + display.renderedView == display.view && countDirtyView(cm) == 0) + { return false } + + if (maybeUpdateLineNumberWidth(cm)) { + resetView(cm); + update.dims = getDimensions(cm); + } + + // Compute a suitable new viewport (from & to) + var end = doc.first + doc.size; + var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first); + var to = Math.min(end, update.visible.to + cm.options.viewportMargin); + if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom); } + if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo); } + if (sawCollapsedSpans) { + from = visualLineNo(cm.doc, from); + to = visualLineEndNo(cm.doc, to); + } + + var different = from != display.viewFrom || to != display.viewTo || + display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth; + adjustView(cm, from, to); + + display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom)); + // Position the mover div to align with the current scroll position + cm.display.mover.style.top = display.viewOffset + "px"; + + var toUpdate = countDirtyView(cm); + if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view && + (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo)) + { return false } + + // For big changes, we hide the enclosing element during the + // update, since that speeds up the operations on most browsers. + var selSnapshot = selectionSnapshot(cm); + if (toUpdate > 4) { display.lineDiv.style.display = "none"; } + patchDisplay(cm, display.updateLineNumbers, update.dims); + if (toUpdate > 4) { display.lineDiv.style.display = ""; } + display.renderedView = display.view; + // There might have been a widget with a focused element that got + // hidden or updated, if so re-focus it. + restoreSelection(selSnapshot); + + // Prevent selection and cursors from interfering with the scroll + // width and height. + removeChildren(display.cursorDiv); + removeChildren(display.selectionDiv); + display.gutters.style.height = display.sizer.style.minHeight = 0; + + if (different) { + display.lastWrapHeight = update.wrapperHeight; + display.lastWrapWidth = update.wrapperWidth; + startWorker(cm, 400); + } + + display.updateLineNumbers = null; + + return true +} + +function postUpdateDisplay(cm, update) { + var viewport = update.viewport; + + for (var first = true;; first = false) { + if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) { + // Clip forced viewport to actual scrollable area. + if (viewport && viewport.top != null) + { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)}; } + // Updated line heights might result in the drawn area not + // actually covering the viewport. Keep looping until it does. + update.visible = visibleLines(cm.display, cm.doc, viewport); + if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo) + { break } + } + if (!updateDisplayIfNeeded(cm, update)) { break } + updateHeightsInViewport(cm); + var barMeasure = measureForScrollbars(cm); + updateSelection(cm); + updateScrollbars(cm, barMeasure); + setDocumentHeight(cm, barMeasure); + update.force = false; + } + + update.signal(cm, "update", cm); + if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) { + update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo); + cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo; + } +} + +function updateDisplaySimple(cm, viewport) { + var update = new DisplayUpdate(cm, viewport); + if (updateDisplayIfNeeded(cm, update)) { + updateHeightsInViewport(cm); + postUpdateDisplay(cm, update); + var barMeasure = measureForScrollbars(cm); + updateSelection(cm); + updateScrollbars(cm, barMeasure); + setDocumentHeight(cm, barMeasure); + update.finish(); + } +} + +// Sync the actual display DOM structure with display.view, removing +// nodes for lines that are no longer in view, and creating the ones +// that are not there yet, and updating the ones that are out of +// date. +function patchDisplay(cm, updateNumbersFrom, dims) { + var display = cm.display, lineNumbers = cm.options.lineNumbers; + var container = display.lineDiv, cur = container.firstChild; + + function rm(node) { + var next = node.nextSibling; + // Works around a throw-scroll bug in OS X Webkit + if (webkit && mac && cm.display.currentWheelTarget == node) + { node.style.display = "none"; } + else + { node.parentNode.removeChild(node); } + return next + } + + var view = display.view, lineN = display.viewFrom; + // Loop over the elements in the view, syncing cur (the DOM nodes + // in display.lineDiv) with the view as we go. + for (var i = 0; i < view.length; i++) { + var lineView = view[i]; + if (lineView.hidden) { + } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet + var node = buildLineElement(cm, lineView, lineN, dims); + container.insertBefore(node, cur); + } else { // Already drawn + while (cur != lineView.node) { cur = rm(cur); } + var updateNumber = lineNumbers && updateNumbersFrom != null && + updateNumbersFrom <= lineN && lineView.lineNumber; + if (lineView.changes) { + if (indexOf(lineView.changes, "gutter") > -1) { updateNumber = false; } + updateLineForChanges(cm, lineView, lineN, dims); + } + if (updateNumber) { + removeChildren(lineView.lineNumber); + lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN))); + } + cur = lineView.node.nextSibling; + } + lineN += lineView.size; + } + while (cur) { cur = rm(cur); } +} + +function updateGutterSpace(cm) { + var width = cm.display.gutters.offsetWidth; + cm.display.sizer.style.marginLeft = width + "px"; +} + +function setDocumentHeight(cm, measure) { + cm.display.sizer.style.minHeight = measure.docHeight + "px"; + cm.display.heightForcer.style.top = measure.docHeight + "px"; + cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px"; +} + +// Rebuild the gutter elements, ensure the margin to the left of the +// code matches their width. +function updateGutters(cm) { + var gutters = cm.display.gutters, specs = cm.options.gutters; + removeChildren(gutters); + var i = 0; + for (; i < specs.length; ++i) { + var gutterClass = specs[i]; + var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass)); + if (gutterClass == "CodeMirror-linenumbers") { + cm.display.lineGutter = gElt; + gElt.style.width = (cm.display.lineNumWidth || 1) + "px"; + } + } + gutters.style.display = i ? "" : "none"; + updateGutterSpace(cm); +} + +// Make sure the gutters options contains the element +// "CodeMirror-linenumbers" when the lineNumbers option is true. +function setGuttersForLineNumbers(options) { + var found = indexOf(options.gutters, "CodeMirror-linenumbers"); + if (found == -1 && options.lineNumbers) { + options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]); + } else if (found > -1 && !options.lineNumbers) { + options.gutters = options.gutters.slice(0); + options.gutters.splice(found, 1); + } +} + +// Since the delta values reported on mouse wheel events are +// unstandardized between browsers and even browser versions, and +// generally horribly unpredictable, this code starts by measuring +// the scroll effect that the first few mouse wheel events have, +// and, from that, detects the way it can convert deltas to pixel +// offsets afterwards. +// +// The reason we want to know the amount a wheel event will scroll +// is that it gives us a chance to update the display before the +// actual scrolling happens, reducing flickering. + +var wheelSamples = 0; +var wheelPixelsPerUnit = null; +// Fill in a browser-detected starting value on browsers where we +// know one. These don't have to be accurate -- the result of them +// being wrong would just be a slight flicker on the first wheel +// scroll (if it is large enough). +if (ie) { wheelPixelsPerUnit = -.53; } +else if (gecko) { wheelPixelsPerUnit = 15; } +else if (chrome) { wheelPixelsPerUnit = -.7; } +else if (safari) { wheelPixelsPerUnit = -1/3; } + +function wheelEventDelta(e) { + var dx = e.wheelDeltaX, dy = e.wheelDeltaY; + if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail; } + if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail; } + else if (dy == null) { dy = e.wheelDelta; } + return {x: dx, y: dy} +} +function wheelEventPixels(e) { + var delta = wheelEventDelta(e); + delta.x *= wheelPixelsPerUnit; + delta.y *= wheelPixelsPerUnit; + return delta +} + +function onScrollWheel(cm, e) { + var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y; + + var display = cm.display, scroll = display.scroller; + // Quit if there's nothing to scroll here + var canScrollX = scroll.scrollWidth > scroll.clientWidth; + var canScrollY = scroll.scrollHeight > scroll.clientHeight; + if (!(dx && canScrollX || dy && canScrollY)) { return } + + // Webkit browsers on OS X abort momentum scrolls when the target + // of the scroll event is removed from the scrollable element. + // This hack (see related code in patchDisplay) makes sure the + // element is kept around. + if (dy && mac && webkit) { + outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) { + for (var i = 0; i < view.length; i++) { + if (view[i].node == cur) { + cm.display.currentWheelTarget = cur; + break outer + } + } + } + } + + // On some browsers, horizontal scrolling will cause redraws to + // happen before the gutter has been realigned, causing it to + // wriggle around in a most unseemly way. When we have an + // estimated pixels/delta value, we just handle horizontal + // scrolling entirely here. It'll be slightly off from native, but + // better than glitching out. + if (dx && !gecko && !presto && wheelPixelsPerUnit != null) { + if (dy && canScrollY) + { updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit)); } + setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit)); + // Only prevent default scrolling if vertical scrolling is + // actually possible. Otherwise, it causes vertical scroll + // jitter on OSX trackpads when deltaX is small and deltaY + // is large (issue #3579) + if (!dy || (dy && canScrollY)) + { e_preventDefault(e); } + display.wheelStartX = null; // Abort measurement, if in progress + return + } + + // 'Project' the visible viewport to cover the area that is being + // scrolled into view (if we know enough to estimate it). + if (dy && wheelPixelsPerUnit != null) { + var pixels = dy * wheelPixelsPerUnit; + var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight; + if (pixels < 0) { top = Math.max(0, top + pixels - 50); } + else { bot = Math.min(cm.doc.height, bot + pixels + 50); } + updateDisplaySimple(cm, {top: top, bottom: bot}); + } + + if (wheelSamples < 20) { + if (display.wheelStartX == null) { + display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop; + display.wheelDX = dx; display.wheelDY = dy; + setTimeout(function () { + if (display.wheelStartX == null) { return } + var movedX = scroll.scrollLeft - display.wheelStartX; + var movedY = scroll.scrollTop - display.wheelStartY; + var sample = (movedY && display.wheelDY && movedY / display.wheelDY) || + (movedX && display.wheelDX && movedX / display.wheelDX); + display.wheelStartX = display.wheelStartY = null; + if (!sample) { return } + wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1); + ++wheelSamples; + }, 200); + } else { + display.wheelDX += dx; display.wheelDY += dy; + } + } +} + +// Selection objects are immutable. A new one is created every time +// the selection changes. A selection is one or more non-overlapping +// (and non-touching) ranges, sorted, and an integer that indicates +// which one is the primary selection (the one that's scrolled into +// view, that getCursor returns, etc). +var Selection = function(ranges, primIndex) { + this.ranges = ranges; + this.primIndex = primIndex; +}; + +Selection.prototype.primary = function () { return this.ranges[this.primIndex] }; + +Selection.prototype.equals = function (other) { + var this$1 = this; + + if (other == this) { return true } + if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false } + for (var i = 0; i < this.ranges.length; i++) { + var here = this$1.ranges[i], there = other.ranges[i]; + if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false } + } + return true +}; + +Selection.prototype.deepCopy = function () { + var this$1 = this; + + var out = []; + for (var i = 0; i < this.ranges.length; i++) + { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)); } + return new Selection(out, this.primIndex) +}; + +Selection.prototype.somethingSelected = function () { + var this$1 = this; + + for (var i = 0; i < this.ranges.length; i++) + { if (!this$1.ranges[i].empty()) { return true } } + return false +}; + +Selection.prototype.contains = function (pos, end) { + var this$1 = this; + + if (!end) { end = pos; } + for (var i = 0; i < this.ranges.length; i++) { + var range = this$1.ranges[i]; + if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0) + { return i } + } + return -1 +}; + +var Range = function(anchor, head) { + this.anchor = anchor; this.head = head; +}; + +Range.prototype.from = function () { return minPos(this.anchor, this.head) }; +Range.prototype.to = function () { return maxPos(this.anchor, this.head) }; +Range.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch }; + +// Take an unsorted, potentially overlapping set of ranges, and +// build a selection out of it. 'Consumes' ranges array (modifying +// it). +function normalizeSelection(ranges, primIndex) { + var prim = ranges[primIndex]; + ranges.sort(function (a, b) { return cmp(a.from(), b.from()); }); + primIndex = indexOf(ranges, prim); + for (var i = 1; i < ranges.length; i++) { + var cur = ranges[i], prev = ranges[i - 1]; + if (cmp(prev.to(), cur.from()) >= 0) { + var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to()); + var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head; + if (i <= primIndex) { --primIndex; } + ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to)); + } + } + return new Selection(ranges, primIndex) +} + +function simpleSelection(anchor, head) { + return new Selection([new Range(anchor, head || anchor)], 0) +} + +// Compute the position of the end of a change (its 'to' property +// refers to the pre-change end). +function changeEnd(change) { + if (!change.text) { return change.to } + return Pos(change.from.line + change.text.length - 1, + lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0)) +} + +// Adjust a position to refer to the post-change position of the +// same text, or the end of the change if the change covers it. +function adjustForChange(pos, change) { + if (cmp(pos, change.from) < 0) { return pos } + if (cmp(pos, change.to) <= 0) { return changeEnd(change) } + + var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch; + if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch; } + return Pos(line, ch) +} + +function computeSelAfterChange(doc, change) { + var out = []; + for (var i = 0; i < doc.sel.ranges.length; i++) { + var range = doc.sel.ranges[i]; + out.push(new Range(adjustForChange(range.anchor, change), + adjustForChange(range.head, change))); + } + return normalizeSelection(out, doc.sel.primIndex) +} + +function offsetPos(pos, old, nw) { + if (pos.line == old.line) + { return Pos(nw.line, pos.ch - old.ch + nw.ch) } + else + { return Pos(nw.line + (pos.line - old.line), pos.ch) } +} + +// Used by replaceSelections to allow moving the selection to the +// start or around the replaced test. Hint may be "start" or "around". +function computeReplacedSel(doc, changes, hint) { + var out = []; + var oldPrev = Pos(doc.first, 0), newPrev = oldPrev; + for (var i = 0; i < changes.length; i++) { + var change = changes[i]; + var from = offsetPos(change.from, oldPrev, newPrev); + var to = offsetPos(changeEnd(change), oldPrev, newPrev); + oldPrev = change.to; + newPrev = to; + if (hint == "around") { + var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0; + out[i] = new Range(inv ? to : from, inv ? from : to); + } else { + out[i] = new Range(from, from); + } + } + return new Selection(out, doc.sel.primIndex) +} + +// Used to get the editor into a consistent state again when options change. + +function loadMode(cm) { + cm.doc.mode = getMode(cm.options, cm.doc.modeOption); + resetModeState(cm); +} + +function resetModeState(cm) { + cm.doc.iter(function (line) { + if (line.stateAfter) { line.stateAfter = null; } + if (line.styles) { line.styles = null; } + }); + cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first; + startWorker(cm, 100); + cm.state.modeGen++; + if (cm.curOp) { regChange(cm); } +} + +// DOCUMENT DATA STRUCTURE + +// By default, updates that start and end at the beginning of a line +// are treated specially, in order to make the association of line +// widgets and marker elements with the text behave more intuitive. +function isWholeLineUpdate(doc, change) { + return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" && + (!doc.cm || doc.cm.options.wholeLineUpdateBefore) +} + +// Perform a change on the document data structure. +function updateDoc(doc, change, markedSpans, estimateHeight$$1) { + function spansFor(n) {return markedSpans ? markedSpans[n] : null} + function update(line, text, spans) { + updateLine(line, text, spans, estimateHeight$$1); + signalLater(line, "change", line, change); + } + function linesFor(start, end) { + var result = []; + for (var i = start; i < end; ++i) + { result.push(new Line(text[i], spansFor(i), estimateHeight$$1)); } + return result + } + + var from = change.from, to = change.to, text = change.text; + var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line); + var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line; + + // Adjust the line structure + if (change.full) { + doc.insert(0, linesFor(0, text.length)); + doc.remove(text.length, doc.size - text.length); + } else if (isWholeLineUpdate(doc, change)) { + // This is a whole-line replace. Treated specially to make + // sure line objects move the way they are supposed to. + var added = linesFor(0, text.length - 1); + update(lastLine, lastLine.text, lastSpans); + if (nlines) { doc.remove(from.line, nlines); } + if (added.length) { doc.insert(from.line, added); } + } else if (firstLine == lastLine) { + if (text.length == 1) { + update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans); + } else { + var added$1 = linesFor(1, text.length - 1); + added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight$$1)); + update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)); + doc.insert(from.line + 1, added$1); + } + } else if (text.length == 1) { + update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0)); + doc.remove(from.line + 1, nlines); + } else { + update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)); + update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans); + var added$2 = linesFor(1, text.length - 1); + if (nlines > 1) { doc.remove(from.line + 1, nlines - 1); } + doc.insert(from.line + 1, added$2); + } + + signalLater(doc, "change", doc, change); +} + +// Call f for all linked documents. +function linkedDocs(doc, f, sharedHistOnly) { + function propagate(doc, skip, sharedHist) { + if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) { + var rel = doc.linked[i]; + if (rel.doc == skip) { continue } + var shared = sharedHist && rel.sharedHist; + if (sharedHistOnly && !shared) { continue } + f(rel.doc, shared); + propagate(rel.doc, doc, shared); + } } + } + propagate(doc, null, true); +} + +// Attach a document to an editor. +function attachDoc(cm, doc) { + if (doc.cm) { throw new Error("This document is already in use.") } + cm.doc = doc; + doc.cm = cm; + estimateLineHeights(cm); + loadMode(cm); + setDirectionClass(cm); + if (!cm.options.lineWrapping) { findMaxLine(cm); } + cm.options.mode = doc.modeOption; + regChange(cm); +} + +function setDirectionClass(cm) { + (cm.doc.direction == "rtl" ? addClass : rmClass)(cm.display.lineDiv, "CodeMirror-rtl"); +} + +function directionChanged(cm) { + runInOp(cm, function () { + setDirectionClass(cm); + regChange(cm); + }); +} + +function History(startGen) { + // Arrays of change events and selections. Doing something adds an + // event to done and clears undo. Undoing moves events from done + // to undone, redoing moves them in the other direction. + this.done = []; this.undone = []; + this.undoDepth = Infinity; + // Used to track when changes can be merged into a single undo + // event + this.lastModTime = this.lastSelTime = 0; + this.lastOp = this.lastSelOp = null; + this.lastOrigin = this.lastSelOrigin = null; + // Used by the isClean() method + this.generation = this.maxGeneration = startGen || 1; +} + +// Create a history change event from an updateDoc-style change +// object. +function historyChangeFromChange(doc, change) { + var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}; + attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); + linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true); + return histChange +} + +// Pop all selection events off the end of a history array. Stop at +// a change event. +function clearSelectionEvents(array) { + while (array.length) { + var last = lst(array); + if (last.ranges) { array.pop(); } + else { break } + } +} + +// Find the top change event in the history. Pop off selection +// events that are in the way. +function lastChangeEvent(hist, force) { + if (force) { + clearSelectionEvents(hist.done); + return lst(hist.done) + } else if (hist.done.length && !lst(hist.done).ranges) { + return lst(hist.done) + } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) { + hist.done.pop(); + return lst(hist.done) + } +} + +// Register a change in the history. Merges changes that are within +// a single operation, or are close together with an origin that +// allows merging (starting with "+") into a single event. +function addChangeToHistory(doc, change, selAfter, opId) { + var hist = doc.history; + hist.undone.length = 0; + var time = +new Date, cur; + var last; + + if ((hist.lastOp == opId || + hist.lastOrigin == change.origin && change.origin && + ((change.origin.charAt(0) == "+" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) || + change.origin.charAt(0) == "*")) && + (cur = lastChangeEvent(hist, hist.lastOp == opId))) { + // Merge this change into the last event + last = lst(cur.changes); + if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) { + // Optimized case for simple insertion -- don't want to add + // new changesets for every character typed + last.to = changeEnd(change); + } else { + // Add new sub-event + cur.changes.push(historyChangeFromChange(doc, change)); + } + } else { + // Can not be merged, start a new event. + var before = lst(hist.done); + if (!before || !before.ranges) + { pushSelectionToHistory(doc.sel, hist.done); } + cur = {changes: [historyChangeFromChange(doc, change)], + generation: hist.generation}; + hist.done.push(cur); + while (hist.done.length > hist.undoDepth) { + hist.done.shift(); + if (!hist.done[0].ranges) { hist.done.shift(); } + } + } + hist.done.push(selAfter); + hist.generation = ++hist.maxGeneration; + hist.lastModTime = hist.lastSelTime = time; + hist.lastOp = hist.lastSelOp = opId; + hist.lastOrigin = hist.lastSelOrigin = change.origin; + + if (!last) { signal(doc, "historyAdded"); } +} + +function selectionEventCanBeMerged(doc, origin, prev, sel) { + var ch = origin.charAt(0); + return ch == "*" || + ch == "+" && + prev.ranges.length == sel.ranges.length && + prev.somethingSelected() == sel.somethingSelected() && + new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500) +} + +// Called whenever the selection changes, sets the new selection as +// the pending selection in the history, and pushes the old pending +// selection into the 'done' array when it was significantly +// different (in number of selected ranges, emptiness, or time). +function addSelectionToHistory(doc, sel, opId, options) { + var hist = doc.history, origin = options && options.origin; + + // A new event is started when the previous origin does not match + // the current, or the origins don't allow matching. Origins + // starting with * are always merged, those starting with + are + // merged when similar and close together in time. + if (opId == hist.lastSelOp || + (origin && hist.lastSelOrigin == origin && + (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin || + selectionEventCanBeMerged(doc, origin, lst(hist.done), sel)))) + { hist.done[hist.done.length - 1] = sel; } + else + { pushSelectionToHistory(sel, hist.done); } + + hist.lastSelTime = +new Date; + hist.lastSelOrigin = origin; + hist.lastSelOp = opId; + if (options && options.clearRedo !== false) + { clearSelectionEvents(hist.undone); } +} + +function pushSelectionToHistory(sel, dest) { + var top = lst(dest); + if (!(top && top.ranges && top.equals(sel))) + { dest.push(sel); } +} + +// Used to store marked span information in the history. +function attachLocalSpans(doc, change, from, to) { + var existing = change["spans_" + doc.id], n = 0; + doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) { + if (line.markedSpans) + { (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans; } + ++n; + }); +} + +// When un/re-doing restores text containing marked spans, those +// that have been explicitly cleared should not be restored. +function removeClearedSpans(spans) { + if (!spans) { return null } + var out; + for (var i = 0; i < spans.length; ++i) { + if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i); } } + else if (out) { out.push(spans[i]); } + } + return !out ? spans : out.length ? out : null +} + +// Retrieve and filter the old marked spans stored in a change event. +function getOldSpans(doc, change) { + var found = change["spans_" + doc.id]; + if (!found) { return null } + var nw = []; + for (var i = 0; i < change.text.length; ++i) + { nw.push(removeClearedSpans(found[i])); } + return nw +} + +// Used for un/re-doing changes from the history. Combines the +// result of computing the existing spans with the set of spans that +// existed in the history (so that deleting around a span and then +// undoing brings back the span). +function mergeOldSpans(doc, change) { + var old = getOldSpans(doc, change); + var stretched = stretchSpansOverChange(doc, change); + if (!old) { return stretched } + if (!stretched) { return old } + + for (var i = 0; i < old.length; ++i) { + var oldCur = old[i], stretchCur = stretched[i]; + if (oldCur && stretchCur) { + spans: for (var j = 0; j < stretchCur.length; ++j) { + var span = stretchCur[j]; + for (var k = 0; k < oldCur.length; ++k) + { if (oldCur[k].marker == span.marker) { continue spans } } + oldCur.push(span); + } + } else if (stretchCur) { + old[i] = stretchCur; + } + } + return old +} + +// Used both to provide a JSON-safe object in .getHistory, and, when +// detaching a document, to split the history in two +function copyHistoryArray(events, newGroup, instantiateSel) { + var copy = []; + for (var i = 0; i < events.length; ++i) { + var event = events[i]; + if (event.ranges) { + copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event); + continue + } + var changes = event.changes, newChanges = []; + copy.push({changes: newChanges}); + for (var j = 0; j < changes.length; ++j) { + var change = changes[j], m = (void 0); + newChanges.push({from: change.from, to: change.to, text: change.text}); + if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\d+)$/)) { + if (indexOf(newGroup, Number(m[1])) > -1) { + lst(newChanges)[prop] = change[prop]; + delete change[prop]; + } + } } } + } + } + return copy +} + +// The 'scroll' parameter given to many of these indicated whether +// the new cursor position should be scrolled into view after +// modifying the selection. + +// If shift is held or the extend flag is set, extends a range to +// include a given position (and optionally a second position). +// Otherwise, simply returns the range between the given positions. +// Used for cursor motion and such. +function extendRange(range, head, other, extend) { + if (extend) { + var anchor = range.anchor; + if (other) { + var posBefore = cmp(head, anchor) < 0; + if (posBefore != (cmp(other, anchor) < 0)) { + anchor = head; + head = other; + } else if (posBefore != (cmp(head, other) < 0)) { + head = other; + } + } + return new Range(anchor, head) + } else { + return new Range(other || head, head) + } +} + +// Extend the primary selection range, discard the rest. +function extendSelection(doc, head, other, options, extend) { + if (extend == null) { extend = doc.cm && (doc.cm.display.shift || doc.extend); } + setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options); +} + +// Extend all selections (pos is an array of selections with length +// equal the number of selections) +function extendSelections(doc, heads, options) { + var out = []; + var extend = doc.cm && (doc.cm.display.shift || doc.extend); + for (var i = 0; i < doc.sel.ranges.length; i++) + { out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend); } + var newSel = normalizeSelection(out, doc.sel.primIndex); + setSelection(doc, newSel, options); +} + +// Updates a single range in the selection. +function replaceOneSelection(doc, i, range, options) { + var ranges = doc.sel.ranges.slice(0); + ranges[i] = range; + setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options); +} + +// Reset the selection to a single range. +function setSimpleSelection(doc, anchor, head, options) { + setSelection(doc, simpleSelection(anchor, head), options); +} + +// Give beforeSelectionChange handlers a change to influence a +// selection update. +function filterSelectionChange(doc, sel, options) { + var obj = { + ranges: sel.ranges, + update: function(ranges) { + var this$1 = this; + + this.ranges = []; + for (var i = 0; i < ranges.length; i++) + { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor), + clipPos(doc, ranges[i].head)); } + }, + origin: options && options.origin + }; + signal(doc, "beforeSelectionChange", doc, obj); + if (doc.cm) { signal(doc.cm, "beforeSelectionChange", doc.cm, obj); } + if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) } + else { return sel } +} + +function setSelectionReplaceHistory(doc, sel, options) { + var done = doc.history.done, last = lst(done); + if (last && last.ranges) { + done[done.length - 1] = sel; + setSelectionNoUndo(doc, sel, options); + } else { + setSelection(doc, sel, options); + } +} + +// Set a new selection. +function setSelection(doc, sel, options) { + setSelectionNoUndo(doc, sel, options); + addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options); +} + +function setSelectionNoUndo(doc, sel, options) { + if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange")) + { sel = filterSelectionChange(doc, sel, options); } + + var bias = options && options.bias || + (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1); + setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true)); + + if (!(options && options.scroll === false) && doc.cm) + { ensureCursorVisible(doc.cm); } +} + +function setSelectionInner(doc, sel) { + if (sel.equals(doc.sel)) { return } + + doc.sel = sel; + + if (doc.cm) { + doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true; + signalCursorActivity(doc.cm); + } + signalLater(doc, "cursorActivity", doc); +} + +// Verify that the selection does not partially select any atomic +// marked ranges. +function reCheckSelection(doc) { + setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false)); +} + +// Return a selection that does not partially select any atomic +// ranges. +function skipAtomicInSelection(doc, sel, bias, mayClear) { + var out; + for (var i = 0; i < sel.ranges.length; i++) { + var range = sel.ranges[i]; + var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]; + var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear); + var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear); + if (out || newAnchor != range.anchor || newHead != range.head) { + if (!out) { out = sel.ranges.slice(0, i); } + out[i] = new Range(newAnchor, newHead); + } + } + return out ? normalizeSelection(out, sel.primIndex) : sel +} + +function skipAtomicInner(doc, pos, oldPos, dir, mayClear) { + var line = getLine(doc, pos.line); + if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) { + var sp = line.markedSpans[i], m = sp.marker; + if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) && + (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) { + if (mayClear) { + signal(m, "beforeCursorEnter"); + if (m.explicitlyCleared) { + if (!line.markedSpans) { break } + else {--i; continue} + } + } + if (!m.atomic) { continue } + + if (oldPos) { + var near = m.find(dir < 0 ? 1 : -1), diff = (void 0); + if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft) + { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null); } + if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0)) + { return skipAtomicInner(doc, near, pos, dir, mayClear) } + } + + var far = m.find(dir < 0 ? -1 : 1); + if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight) + { far = movePos(doc, far, dir, far.line == pos.line ? line : null); } + return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null + } + } } + return pos +} + +// Ensure a given position is not inside an atomic range. +function skipAtomic(doc, pos, oldPos, bias, mayClear) { + var dir = bias || 1; + var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) || + (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) || + skipAtomicInner(doc, pos, oldPos, -dir, mayClear) || + (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true)); + if (!found) { + doc.cantEdit = true; + return Pos(doc.first, 0) + } + return found +} + +function movePos(doc, pos, dir, line) { + if (dir < 0 && pos.ch == 0) { + if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) } + else { return null } + } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) { + if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) } + else { return null } + } else { + return new Pos(pos.line, pos.ch + dir) + } +} + +function selectAll(cm) { + cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll); +} + +// UPDATING + +// Allow "beforeChange" event handlers to influence a change +function filterChange(doc, change, update) { + var obj = { + canceled: false, + from: change.from, + to: change.to, + text: change.text, + origin: change.origin, + cancel: function () { return obj.canceled = true; } + }; + if (update) { obj.update = function (from, to, text, origin) { + if (from) { obj.from = clipPos(doc, from); } + if (to) { obj.to = clipPos(doc, to); } + if (text) { obj.text = text; } + if (origin !== undefined) { obj.origin = origin; } + }; } + signal(doc, "beforeChange", doc, obj); + if (doc.cm) { signal(doc.cm, "beforeChange", doc.cm, obj); } + + if (obj.canceled) { return null } + return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin} +} + +// Apply a change to a document, and add it to the document's +// history, and propagating it to all linked documents. +function makeChange(doc, change, ignoreReadOnly) { + if (doc.cm) { + if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) } + if (doc.cm.state.suppressEdits) { return } + } + + if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) { + change = filterChange(doc, change, true); + if (!change) { return } + } + + // Possibly split or suppress the update based on the presence + // of read-only spans in its range. + var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to); + if (split) { + for (var i = split.length - 1; i >= 0; --i) + { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin}); } + } else { + makeChangeInner(doc, change); + } +} + +function makeChangeInner(doc, change) { + if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) { return } + var selAfter = computeSelAfterChange(doc, change); + addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN); + + makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change)); + var rebased = []; + + linkedDocs(doc, function (doc, sharedHist) { + if (!sharedHist && indexOf(rebased, doc.history) == -1) { + rebaseHist(doc.history, change); + rebased.push(doc.history); + } + makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change)); + }); +} + +// Revert a change stored in a document's history. +function makeChangeFromHistory(doc, type, allowSelectionOnly) { + var suppress = doc.cm && doc.cm.state.suppressEdits; + if (suppress && !allowSelectionOnly) { return } + + var hist = doc.history, event, selAfter = doc.sel; + var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done; + + // Verify that there is a useable event (so that ctrl-z won't + // needlessly clear selection events) + var i = 0; + for (; i < source.length; i++) { + event = source[i]; + if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges) + { break } + } + if (i == source.length) { return } + hist.lastOrigin = hist.lastSelOrigin = null; + + for (;;) { + event = source.pop(); + if (event.ranges) { + pushSelectionToHistory(event, dest); + if (allowSelectionOnly && !event.equals(doc.sel)) { + setSelection(doc, event, {clearRedo: false}); + return + } + selAfter = event; + } else if (suppress) { + source.push(event); + return + } else { break } + } + + // Build up a reverse change object to add to the opposite history + // stack (redo when undoing, and vice versa). + var antiChanges = []; + pushSelectionToHistory(selAfter, dest); + dest.push({changes: antiChanges, generation: hist.generation}); + hist.generation = event.generation || ++hist.maxGeneration; + + var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange"); + + var loop = function ( i ) { + var change = event.changes[i]; + change.origin = type; + if (filter && !filterChange(doc, change, false)) { + source.length = 0; + return {} + } + + antiChanges.push(historyChangeFromChange(doc, change)); + + var after = i ? computeSelAfterChange(doc, change) : lst(source); + makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change)); + if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}); } + var rebased = []; + + // Propagate to the linked documents + linkedDocs(doc, function (doc, sharedHist) { + if (!sharedHist && indexOf(rebased, doc.history) == -1) { + rebaseHist(doc.history, change); + rebased.push(doc.history); + } + makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change)); + }); + }; + + for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) { + var returned = loop( i$1 ); + + if ( returned ) return returned.v; + } +} + +// Sub-views need their line numbers shifted when text is added +// above or below them in the parent document. +function shiftDoc(doc, distance) { + if (distance == 0) { return } + doc.first += distance; + doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range( + Pos(range.anchor.line + distance, range.anchor.ch), + Pos(range.head.line + distance, range.head.ch) + ); }), doc.sel.primIndex); + if (doc.cm) { + regChange(doc.cm, doc.first, doc.first - distance, distance); + for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++) + { regLineChange(doc.cm, l, "gutter"); } + } +} + +// More lower-level change function, handling only a single document +// (not linked ones). +function makeChangeSingleDoc(doc, change, selAfter, spans) { + if (doc.cm && !doc.cm.curOp) + { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) } + + if (change.to.line < doc.first) { + shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line)); + return + } + if (change.from.line > doc.lastLine()) { return } + + // Clip the change to the size of this doc + if (change.from.line < doc.first) { + var shift = change.text.length - 1 - (doc.first - change.from.line); + shiftDoc(doc, shift); + change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch), + text: [lst(change.text)], origin: change.origin}; + } + var last = doc.lastLine(); + if (change.to.line > last) { + change = {from: change.from, to: Pos(last, getLine(doc, last).text.length), + text: [change.text[0]], origin: change.origin}; + } + + change.removed = getBetween(doc, change.from, change.to); + + if (!selAfter) { selAfter = computeSelAfterChange(doc, change); } + if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans); } + else { updateDoc(doc, change, spans); } + setSelectionNoUndo(doc, selAfter, sel_dontScroll); +} + +// Handle the interaction of a change to a document with the editor +// that this document is part of. +function makeChangeSingleDocInEditor(cm, change, spans) { + var doc = cm.doc, display = cm.display, from = change.from, to = change.to; + + var recomputeMaxLength = false, checkWidthStart = from.line; + if (!cm.options.lineWrapping) { + checkWidthStart = lineNo(visualLine(getLine(doc, from.line))); + doc.iter(checkWidthStart, to.line + 1, function (line) { + if (line == display.maxLine) { + recomputeMaxLength = true; + return true + } + }); + } + + if (doc.sel.contains(change.from, change.to) > -1) + { signalCursorActivity(cm); } + + updateDoc(doc, change, spans, estimateHeight(cm)); + + if (!cm.options.lineWrapping) { + doc.iter(checkWidthStart, from.line + change.text.length, function (line) { + var len = lineLength(line); + if (len > display.maxLineLength) { + display.maxLine = line; + display.maxLineLength = len; + display.maxLineChanged = true; + recomputeMaxLength = false; + } + }); + if (recomputeMaxLength) { cm.curOp.updateMaxLine = true; } + } + + retreatFrontier(doc, from.line); + startWorker(cm, 400); + + var lendiff = change.text.length - (to.line - from.line) - 1; + // Remember that these lines changed, for updating the display + if (change.full) + { regChange(cm); } + else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change)) + { regLineChange(cm, from.line, "text"); } + else + { regChange(cm, from.line, to.line + 1, lendiff); } + + var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change"); + if (changeHandler || changesHandler) { + var obj = { + from: from, to: to, + text: change.text, + removed: change.removed, + origin: change.origin + }; + if (changeHandler) { signalLater(cm, "change", cm, obj); } + if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj); } + } + cm.display.selForContextMenu = null; +} + +function replaceRange(doc, code, from, to, origin) { + if (!to) { to = from; } + if (cmp(to, from) < 0) { var assign; + (assign = [to, from], from = assign[0], to = assign[1]); } + if (typeof code == "string") { code = doc.splitLines(code); } + makeChange(doc, {from: from, to: to, text: code, origin: origin}); +} + +// Rebasing/resetting history to deal with externally-sourced changes + +function rebaseHistSelSingle(pos, from, to, diff) { + if (to < pos.line) { + pos.line += diff; + } else if (from < pos.line) { + pos.line = from; + pos.ch = 0; + } +} + +// Tries to rebase an array of history events given a change in the +// document. If the change touches the same lines as the event, the +// event, and everything 'behind' it, is discarded. If the change is +// before the event, the event's positions are updated. Uses a +// copy-on-write scheme for the positions, to avoid having to +// reallocate them all on every rebase, but also avoid problems with +// shared position objects being unsafely updated. +function rebaseHistArray(array, from, to, diff) { + for (var i = 0; i < array.length; ++i) { + var sub = array[i], ok = true; + if (sub.ranges) { + if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; } + for (var j = 0; j < sub.ranges.length; j++) { + rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff); + rebaseHistSelSingle(sub.ranges[j].head, from, to, diff); + } + continue + } + for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) { + var cur = sub.changes[j$1]; + if (to < cur.from.line) { + cur.from = Pos(cur.from.line + diff, cur.from.ch); + cur.to = Pos(cur.to.line + diff, cur.to.ch); + } else if (from <= cur.to.line) { + ok = false; + break + } + } + if (!ok) { + array.splice(0, i + 1); + i = 0; + } + } +} + +function rebaseHist(hist, change) { + var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1; + rebaseHistArray(hist.done, from, to, diff); + rebaseHistArray(hist.undone, from, to, diff); +} + +// Utility for applying a change to a line by handle or number, +// returning the number and optionally registering the line as +// changed. +function changeLine(doc, handle, changeType, op) { + var no = handle, line = handle; + if (typeof handle == "number") { line = getLine(doc, clipLine(doc, handle)); } + else { no = lineNo(handle); } + if (no == null) { return null } + if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType); } + return line +} + +// The document is represented as a BTree consisting of leaves, with +// chunk of lines in them, and branches, with up to ten leaves or +// other branch nodes below them. The top node is always a branch +// node, and is the document object itself (meaning it has +// additional methods and properties). +// +// All nodes have parent links. The tree is used both to go from +// line numbers to line objects, and to go from objects to numbers. +// It also indexes by height, and is used to convert between height +// and line object, and to find the total height of the document. +// +// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html + +function LeafChunk(lines) { + var this$1 = this; + + this.lines = lines; + this.parent = null; + var height = 0; + for (var i = 0; i < lines.length; ++i) { + lines[i].parent = this$1; + height += lines[i].height; + } + this.height = height; +} + +LeafChunk.prototype = { + chunkSize: function() { return this.lines.length }, + + // Remove the n lines at offset 'at'. + removeInner: function(at, n) { + var this$1 = this; + + for (var i = at, e = at + n; i < e; ++i) { + var line = this$1.lines[i]; + this$1.height -= line.height; + cleanUpLine(line); + signalLater(line, "delete"); + } + this.lines.splice(at, n); + }, + + // Helper used to collapse a small branch into a single leaf. + collapse: function(lines) { + lines.push.apply(lines, this.lines); + }, + + // Insert the given array of lines at offset 'at', count them as + // having the given height. + insertInner: function(at, lines, height) { + var this$1 = this; + + this.height += height; + this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at)); + for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1; } + }, + + // Used to iterate over a part of the tree. + iterN: function(at, n, op) { + var this$1 = this; + + for (var e = at + n; at < e; ++at) + { if (op(this$1.lines[at])) { return true } } + } +}; + +function BranchChunk(children) { + var this$1 = this; + + this.children = children; + var size = 0, height = 0; + for (var i = 0; i < children.length; ++i) { + var ch = children[i]; + size += ch.chunkSize(); height += ch.height; + ch.parent = this$1; + } + this.size = size; + this.height = height; + this.parent = null; +} + +BranchChunk.prototype = { + chunkSize: function() { return this.size }, + + removeInner: function(at, n) { + var this$1 = this; + + this.size -= n; + for (var i = 0; i < this.children.length; ++i) { + var child = this$1.children[i], sz = child.chunkSize(); + if (at < sz) { + var rm = Math.min(n, sz - at), oldHeight = child.height; + child.removeInner(at, rm); + this$1.height -= oldHeight - child.height; + if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null; } + if ((n -= rm) == 0) { break } + at = 0; + } else { at -= sz; } + } + // If the result is smaller than 25 lines, ensure that it is a + // single leaf node. + if (this.size - n < 25 && + (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) { + var lines = []; + this.collapse(lines); + this.children = [new LeafChunk(lines)]; + this.children[0].parent = this; + } + }, + + collapse: function(lines) { + var this$1 = this; + + for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines); } + }, + + insertInner: function(at, lines, height) { + var this$1 = this; + + this.size += lines.length; + this.height += height; + for (var i = 0; i < this.children.length; ++i) { + var child = this$1.children[i], sz = child.chunkSize(); + if (at <= sz) { + child.insertInner(at, lines, height); + if (child.lines && child.lines.length > 50) { + // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced. + // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest. + var remaining = child.lines.length % 25 + 25; + for (var pos = remaining; pos < child.lines.length;) { + var leaf = new LeafChunk(child.lines.slice(pos, pos += 25)); + child.height -= leaf.height; + this$1.children.splice(++i, 0, leaf); + leaf.parent = this$1; + } + child.lines = child.lines.slice(0, remaining); + this$1.maybeSpill(); + } + break + } + at -= sz; + } + }, + + // When a node has grown, check whether it should be split. + maybeSpill: function() { + if (this.children.length <= 10) { return } + var me = this; + do { + var spilled = me.children.splice(me.children.length - 5, 5); + var sibling = new BranchChunk(spilled); + if (!me.parent) { // Become the parent node + var copy = new BranchChunk(me.children); + copy.parent = me; + me.children = [copy, sibling]; + me = copy; + } else { + me.size -= sibling.size; + me.height -= sibling.height; + var myIndex = indexOf(me.parent.children, me); + me.parent.children.splice(myIndex + 1, 0, sibling); + } + sibling.parent = me.parent; + } while (me.children.length > 10) + me.parent.maybeSpill(); + }, + + iterN: function(at, n, op) { + var this$1 = this; + + for (var i = 0; i < this.children.length; ++i) { + var child = this$1.children[i], sz = child.chunkSize(); + if (at < sz) { + var used = Math.min(n, sz - at); + if (child.iterN(at, used, op)) { return true } + if ((n -= used) == 0) { break } + at = 0; + } else { at -= sz; } + } + } +}; + +// Line widgets are block elements displayed above or below a line. + +var LineWidget = function(doc, node, options) { + var this$1 = this; + + if (options) { for (var opt in options) { if (options.hasOwnProperty(opt)) + { this$1[opt] = options[opt]; } } } + this.doc = doc; + this.node = node; +}; + +LineWidget.prototype.clear = function () { + var this$1 = this; + + var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line); + if (no == null || !ws) { return } + for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1); } } + if (!ws.length) { line.widgets = null; } + var height = widgetHeight(this); + updateLineHeight(line, Math.max(0, line.height - height)); + if (cm) { + runInOp(cm, function () { + adjustScrollWhenAboveVisible(cm, line, -height); + regLineChange(cm, no, "widget"); + }); + signalLater(cm, "lineWidgetCleared", cm, this, no); + } +}; + +LineWidget.prototype.changed = function () { + var this$1 = this; + + var oldH = this.height, cm = this.doc.cm, line = this.line; + this.height = null; + var diff = widgetHeight(this) - oldH; + if (!diff) { return } + updateLineHeight(line, line.height + diff); + if (cm) { + runInOp(cm, function () { + cm.curOp.forceUpdate = true; + adjustScrollWhenAboveVisible(cm, line, diff); + signalLater(cm, "lineWidgetChanged", cm, this$1, lineNo(line)); + }); + } +}; +eventMixin(LineWidget); + +function adjustScrollWhenAboveVisible(cm, line, diff) { + if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop)) + { addToScrollTop(cm, diff); } +} + +function addLineWidget(doc, handle, node, options) { + var widget = new LineWidget(doc, node, options); + var cm = doc.cm; + if (cm && widget.noHScroll) { cm.display.alignWidgets = true; } + changeLine(doc, handle, "widget", function (line) { + var widgets = line.widgets || (line.widgets = []); + if (widget.insertAt == null) { widgets.push(widget); } + else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget); } + widget.line = line; + if (cm && !lineIsHidden(doc, line)) { + var aboveVisible = heightAtLine(line) < doc.scrollTop; + updateLineHeight(line, line.height + widgetHeight(widget)); + if (aboveVisible) { addToScrollTop(cm, widget.height); } + cm.curOp.forceUpdate = true; + } + return true + }); + if (cm) { signalLater(cm, "lineWidgetAdded", cm, widget, typeof handle == "number" ? handle : lineNo(handle)); } + return widget +} + +// TEXTMARKERS + +// Created with markText and setBookmark methods. A TextMarker is a +// handle that can be used to clear or find a marked position in the +// document. Line objects hold arrays (markedSpans) containing +// {from, to, marker} object pointing to such marker objects, and +// indicating that such a marker is present on that line. Multiple +// lines may point to the same marker when it spans across lines. +// The spans will have null for their from/to properties when the +// marker continues beyond the start/end of the line. Markers have +// links back to the lines they currently touch. + +// Collapsed markers have unique ids, in order to be able to order +// them, which is needed for uniquely determining an outer marker +// when they overlap (they may nest, but not partially overlap). +var nextMarkerId = 0; + +var TextMarker = function(doc, type) { + this.lines = []; + this.type = type; + this.doc = doc; + this.id = ++nextMarkerId; +}; + +// Clear the marker. +TextMarker.prototype.clear = function () { + var this$1 = this; + + if (this.explicitlyCleared) { return } + var cm = this.doc.cm, withOp = cm && !cm.curOp; + if (withOp) { startOperation(cm); } + if (hasHandler(this, "clear")) { + var found = this.find(); + if (found) { signalLater(this, "clear", found.from, found.to); } + } + var min = null, max = null; + for (var i = 0; i < this.lines.length; ++i) { + var line = this$1.lines[i]; + var span = getMarkedSpanFor(line.markedSpans, this$1); + if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), "text"); } + else if (cm) { + if (span.to != null) { max = lineNo(line); } + if (span.from != null) { min = lineNo(line); } + } + line.markedSpans = removeMarkedSpan(line.markedSpans, span); + if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm) + { updateLineHeight(line, textHeight(cm.display)); } + } + if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) { + var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual); + if (len > cm.display.maxLineLength) { + cm.display.maxLine = visual; + cm.display.maxLineLength = len; + cm.display.maxLineChanged = true; + } + } } + + if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1); } + this.lines.length = 0; + this.explicitlyCleared = true; + if (this.atomic && this.doc.cantEdit) { + this.doc.cantEdit = false; + if (cm) { reCheckSelection(cm.doc); } + } + if (cm) { signalLater(cm, "markerCleared", cm, this, min, max); } + if (withOp) { endOperation(cm); } + if (this.parent) { this.parent.clear(); } +}; + +// Find the position of the marker in the document. Returns a {from, +// to} object by default. Side can be passed to get a specific side +// -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the +// Pos objects returned contain a line object, rather than a line +// number (used to prevent looking up the same line twice). +TextMarker.prototype.find = function (side, lineObj) { + var this$1 = this; + + if (side == null && this.type == "bookmark") { side = 1; } + var from, to; + for (var i = 0; i < this.lines.length; ++i) { + var line = this$1.lines[i]; + var span = getMarkedSpanFor(line.markedSpans, this$1); + if (span.from != null) { + from = Pos(lineObj ? line : lineNo(line), span.from); + if (side == -1) { return from } + } + if (span.to != null) { + to = Pos(lineObj ? line : lineNo(line), span.to); + if (side == 1) { return to } + } + } + return from && {from: from, to: to} +}; + +// Signals that the marker's widget changed, and surrounding layout +// should be recomputed. +TextMarker.prototype.changed = function () { + var this$1 = this; + + var pos = this.find(-1, true), widget = this, cm = this.doc.cm; + if (!pos || !cm) { return } + runInOp(cm, function () { + var line = pos.line, lineN = lineNo(pos.line); + var view = findViewForLine(cm, lineN); + if (view) { + clearLineMeasurementCacheFor(view); + cm.curOp.selectionChanged = cm.curOp.forceUpdate = true; + } + cm.curOp.updateMaxLine = true; + if (!lineIsHidden(widget.doc, line) && widget.height != null) { + var oldHeight = widget.height; + widget.height = null; + var dHeight = widgetHeight(widget) - oldHeight; + if (dHeight) + { updateLineHeight(line, line.height + dHeight); } + } + signalLater(cm, "markerChanged", cm, this$1); + }); +}; + +TextMarker.prototype.attachLine = function (line) { + if (!this.lines.length && this.doc.cm) { + var op = this.doc.cm.curOp; + if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1) + { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this); } + } + this.lines.push(line); +}; + +TextMarker.prototype.detachLine = function (line) { + this.lines.splice(indexOf(this.lines, line), 1); + if (!this.lines.length && this.doc.cm) { + var op = this.doc.cm.curOp;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this); + } +}; +eventMixin(TextMarker); + +// Create a marker, wire it up to the right lines, and +function markText(doc, from, to, options, type) { + // Shared markers (across linked documents) are handled separately + // (markTextShared will call out to this again, once per + // document). + if (options && options.shared) { return markTextShared(doc, from, to, options, type) } + // Ensure we are in an operation. + if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) } + + var marker = new TextMarker(doc, type), diff = cmp(from, to); + if (options) { copyObj(options, marker, false); } + // Don't connect empty markers unless clearWhenEmpty is false + if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false) + { return marker } + if (marker.replacedWith) { + // Showing up as a widget implies collapsed (widget replaces text) + marker.collapsed = true; + marker.widgetNode = eltP("span", [marker.replacedWith], "CodeMirror-widget"); + if (!options.handleMouseEvents) { marker.widgetNode.setAttribute("cm-ignore-events", "true"); } + if (options.insertLeft) { marker.widgetNode.insertLeft = true; } + } + if (marker.collapsed) { + if (conflictingCollapsedRange(doc, from.line, from, to, marker) || + from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker)) + { throw new Error("Inserting collapsed marker partially overlapping an existing one") } + seeCollapsedSpans(); + } + + if (marker.addToHistory) + { addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN); } + + var curLine = from.line, cm = doc.cm, updateMaxLine; + doc.iter(curLine, to.line + 1, function (line) { + if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine) + { updateMaxLine = true; } + if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0); } + addMarkedSpan(line, new MarkedSpan(marker, + curLine == from.line ? from.ch : null, + curLine == to.line ? to.ch : null)); + ++curLine; + }); + // lineIsHidden depends on the presence of the spans, so needs a second pass + if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) { + if (lineIsHidden(doc, line)) { updateLineHeight(line, 0); } + }); } + + if (marker.clearOnEnter) { on(marker, "beforeCursorEnter", function () { return marker.clear(); }); } + + if (marker.readOnly) { + seeReadOnlySpans(); + if (doc.history.done.length || doc.history.undone.length) + { doc.clearHistory(); } + } + if (marker.collapsed) { + marker.id = ++nextMarkerId; + marker.atomic = true; + } + if (cm) { + // Sync editor state + if (updateMaxLine) { cm.curOp.updateMaxLine = true; } + if (marker.collapsed) + { regChange(cm, from.line, to.line + 1); } + else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css) + { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, "text"); } } + if (marker.atomic) { reCheckSelection(cm.doc); } + signalLater(cm, "markerAdded", cm, marker); + } + return marker +} + +// SHARED TEXTMARKERS + +// A shared marker spans multiple linked documents. It is +// implemented as a meta-marker-object controlling multiple normal +// markers. +var SharedTextMarker = function(markers, primary) { + var this$1 = this; + + this.markers = markers; + this.primary = primary; + for (var i = 0; i < markers.length; ++i) + { markers[i].parent = this$1; } +}; + +SharedTextMarker.prototype.clear = function () { + var this$1 = this; + + if (this.explicitlyCleared) { return } + this.explicitlyCleared = true; + for (var i = 0; i < this.markers.length; ++i) + { this$1.markers[i].clear(); } + signalLater(this, "clear"); +}; + +SharedTextMarker.prototype.find = function (side, lineObj) { + return this.primary.find(side, lineObj) +}; +eventMixin(SharedTextMarker); + +function markTextShared(doc, from, to, options, type) { + options = copyObj(options); + options.shared = false; + var markers = [markText(doc, from, to, options, type)], primary = markers[0]; + var widget = options.widgetNode; + linkedDocs(doc, function (doc) { + if (widget) { options.widgetNode = widget.cloneNode(true); } + markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type)); + for (var i = 0; i < doc.linked.length; ++i) + { if (doc.linked[i].isParent) { return } } + primary = lst(markers); + }); + return new SharedTextMarker(markers, primary) +} + +function findSharedMarkers(doc) { + return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; }) +} + +function copySharedMarkers(doc, markers) { + for (var i = 0; i < markers.length; i++) { + var marker = markers[i], pos = marker.find(); + var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to); + if (cmp(mFrom, mTo)) { + var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type); + marker.markers.push(subMark); + subMark.parent = marker; + } + } +} + +function detachSharedMarkers(markers) { + var loop = function ( i ) { + var marker = markers[i], linked = [marker.primary.doc]; + linkedDocs(marker.primary.doc, function (d) { return linked.push(d); }); + for (var j = 0; j < marker.markers.length; j++) { + var subMarker = marker.markers[j]; + if (indexOf(linked, subMarker.doc) == -1) { + subMarker.parent = null; + marker.markers.splice(j--, 1); + } + } + }; + + for (var i = 0; i < markers.length; i++) loop( i ); +} + +var nextDocId = 0; +var Doc = function(text, mode, firstLine, lineSep, direction) { + if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep, direction) } + if (firstLine == null) { firstLine = 0; } + + BranchChunk.call(this, [new LeafChunk([new Line("", null)])]); + this.first = firstLine; + this.scrollTop = this.scrollLeft = 0; + this.cantEdit = false; + this.cleanGeneration = 1; + this.modeFrontier = this.highlightFrontier = firstLine; + var start = Pos(firstLine, 0); + this.sel = simpleSelection(start); + this.history = new History(null); + this.id = ++nextDocId; + this.modeOption = mode; + this.lineSep = lineSep; + this.direction = (direction == "rtl") ? "rtl" : "ltr"; + this.extend = false; + + if (typeof text == "string") { text = this.splitLines(text); } + updateDoc(this, {from: start, to: start, text: text}); + setSelection(this, simpleSelection(start), sel_dontScroll); +}; + +Doc.prototype = createObj(BranchChunk.prototype, { + constructor: Doc, + // Iterate over the document. Supports two forms -- with only one + // argument, it calls that for each line in the document. With + // three, it iterates over the range given by the first two (with + // the second being non-inclusive). + iter: function(from, to, op) { + if (op) { this.iterN(from - this.first, to - from, op); } + else { this.iterN(this.first, this.first + this.size, from); } + }, + + // Non-public interface for adding and removing lines. + insert: function(at, lines) { + var height = 0; + for (var i = 0; i < lines.length; ++i) { height += lines[i].height; } + this.insertInner(at - this.first, lines, height); + }, + remove: function(at, n) { this.removeInner(at - this.first, n); }, + + // From here, the methods are part of the public interface. Most + // are also available from CodeMirror (editor) instances. + + getValue: function(lineSep) { + var lines = getLines(this, this.first, this.first + this.size); + if (lineSep === false) { return lines } + return lines.join(lineSep || this.lineSeparator()) + }, + setValue: docMethodOp(function(code) { + var top = Pos(this.first, 0), last = this.first + this.size - 1; + makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length), + text: this.splitLines(code), origin: "setValue", full: true}, true); + if (this.cm) { scrollToCoords(this.cm, 0, 0); } + setSelection(this, simpleSelection(top), sel_dontScroll); + }), + replaceRange: function(code, from, to, origin) { + from = clipPos(this, from); + to = to ? clipPos(this, to) : from; + replaceRange(this, code, from, to, origin); + }, + getRange: function(from, to, lineSep) { + var lines = getBetween(this, clipPos(this, from), clipPos(this, to)); + if (lineSep === false) { return lines } + return lines.join(lineSep || this.lineSeparator()) + }, + + getLine: function(line) {var l = this.getLineHandle(line); return l && l.text}, + + getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }}, + getLineNumber: function(line) {return lineNo(line)}, + + getLineHandleVisualStart: function(line) { + if (typeof line == "number") { line = getLine(this, line); } + return visualLine(line) + }, + + lineCount: function() {return this.size}, + firstLine: function() {return this.first}, + lastLine: function() {return this.first + this.size - 1}, + + clipPos: function(pos) {return clipPos(this, pos)}, + + getCursor: function(start) { + var range$$1 = this.sel.primary(), pos; + if (start == null || start == "head") { pos = range$$1.head; } + else if (start == "anchor") { pos = range$$1.anchor; } + else if (start == "end" || start == "to" || start === false) { pos = range$$1.to(); } + else { pos = range$$1.from(); } + return pos + }, + listSelections: function() { return this.sel.ranges }, + somethingSelected: function() {return this.sel.somethingSelected()}, + + setCursor: docMethodOp(function(line, ch, options) { + setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options); + }), + setSelection: docMethodOp(function(anchor, head, options) { + setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options); + }), + extendSelection: docMethodOp(function(head, other, options) { + extendSelection(this, clipPos(this, head), other && clipPos(this, other), options); + }), + extendSelections: docMethodOp(function(heads, options) { + extendSelections(this, clipPosArray(this, heads), options); + }), + extendSelectionsBy: docMethodOp(function(f, options) { + var heads = map(this.sel.ranges, f); + extendSelections(this, clipPosArray(this, heads), options); + }), + setSelections: docMethodOp(function(ranges, primary, options) { + var this$1 = this; + + if (!ranges.length) { return } + var out = []; + for (var i = 0; i < ranges.length; i++) + { out[i] = new Range(clipPos(this$1, ranges[i].anchor), + clipPos(this$1, ranges[i].head)); } + if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex); } + setSelection(this, normalizeSelection(out, primary), options); + }), + addSelection: docMethodOp(function(anchor, head, options) { + var ranges = this.sel.ranges.slice(0); + ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor))); + setSelection(this, normalizeSelection(ranges, ranges.length - 1), options); + }), + + getSelection: function(lineSep) { + var this$1 = this; + + var ranges = this.sel.ranges, lines; + for (var i = 0; i < ranges.length; i++) { + var sel = getBetween(this$1, ranges[i].from(), ranges[i].to()); + lines = lines ? lines.concat(sel) : sel; + } + if (lineSep === false) { return lines } + else { return lines.join(lineSep || this.lineSeparator()) } + }, + getSelections: function(lineSep) { + var this$1 = this; + + var parts = [], ranges = this.sel.ranges; + for (var i = 0; i < ranges.length; i++) { + var sel = getBetween(this$1, ranges[i].from(), ranges[i].to()); + if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()); } + parts[i] = sel; + } + return parts + }, + replaceSelection: function(code, collapse, origin) { + var dup = []; + for (var i = 0; i < this.sel.ranges.length; i++) + { dup[i] = code; } + this.replaceSelections(dup, collapse, origin || "+input"); + }, + replaceSelections: docMethodOp(function(code, collapse, origin) { + var this$1 = this; + + var changes = [], sel = this.sel; + for (var i = 0; i < sel.ranges.length; i++) { + var range$$1 = sel.ranges[i]; + changes[i] = {from: range$$1.from(), to: range$$1.to(), text: this$1.splitLines(code[i]), origin: origin}; + } + var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse); + for (var i$1 = changes.length - 1; i$1 >= 0; i$1--) + { makeChange(this$1, changes[i$1]); } + if (newSel) { setSelectionReplaceHistory(this, newSel); } + else if (this.cm) { ensureCursorVisible(this.cm); } + }), + undo: docMethodOp(function() {makeChangeFromHistory(this, "undo");}), + redo: docMethodOp(function() {makeChangeFromHistory(this, "redo");}), + undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true);}), + redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true);}), + + setExtending: function(val) {this.extend = val;}, + getExtending: function() {return this.extend}, + + historySize: function() { + var hist = this.history, done = 0, undone = 0; + for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done; } } + for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone; } } + return {undo: done, redo: undone} + }, + clearHistory: function() {this.history = new History(this.history.maxGeneration);}, + + markClean: function() { + this.cleanGeneration = this.changeGeneration(true); + }, + changeGeneration: function(forceSplit) { + if (forceSplit) + { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null; } + return this.history.generation + }, + isClean: function (gen) { + return this.history.generation == (gen || this.cleanGeneration) + }, + + getHistory: function() { + return {done: copyHistoryArray(this.history.done), + undone: copyHistoryArray(this.history.undone)} + }, + setHistory: function(histData) { + var hist = this.history = new History(this.history.maxGeneration); + hist.done = copyHistoryArray(histData.done.slice(0), null, true); + hist.undone = copyHistoryArray(histData.undone.slice(0), null, true); + }, + + setGutterMarker: docMethodOp(function(line, gutterID, value) { + return changeLine(this, line, "gutter", function (line) { + var markers = line.gutterMarkers || (line.gutterMarkers = {}); + markers[gutterID] = value; + if (!value && isEmpty(markers)) { line.gutterMarkers = null; } + return true + }) + }), + + clearGutter: docMethodOp(function(gutterID) { + var this$1 = this; + + this.iter(function (line) { + if (line.gutterMarkers && line.gutterMarkers[gutterID]) { + changeLine(this$1, line, "gutter", function () { + line.gutterMarkers[gutterID] = null; + if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null; } + return true + }); + } + }); + }), + + lineInfo: function(line) { + var n; + if (typeof line == "number") { + if (!isLine(this, line)) { return null } + n = line; + line = getLine(this, line); + if (!line) { return null } + } else { + n = lineNo(line); + if (n == null) { return null } + } + return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers, + textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass, + widgets: line.widgets} + }, + + addLineClass: docMethodOp(function(handle, where, cls) { + return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) { + var prop = where == "text" ? "textClass" + : where == "background" ? "bgClass" + : where == "gutter" ? "gutterClass" : "wrapClass"; + if (!line[prop]) { line[prop] = cls; } + else if (classTest(cls).test(line[prop])) { return false } + else { line[prop] += " " + cls; } + return true + }) + }), + removeLineClass: docMethodOp(function(handle, where, cls) { + return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) { + var prop = where == "text" ? "textClass" + : where == "background" ? "bgClass" + : where == "gutter" ? "gutterClass" : "wrapClass"; + var cur = line[prop]; + if (!cur) { return false } + else if (cls == null) { line[prop] = null; } + else { + var found = cur.match(classTest(cls)); + if (!found) { return false } + var end = found.index + found[0].length; + line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null; + } + return true + }) + }), + + addLineWidget: docMethodOp(function(handle, node, options) { + return addLineWidget(this, handle, node, options) + }), + removeLineWidget: function(widget) { widget.clear(); }, + + markText: function(from, to, options) { + return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range") + }, + setBookmark: function(pos, options) { + var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options), + insertLeft: options && options.insertLeft, + clearWhenEmpty: false, shared: options && options.shared, + handleMouseEvents: options && options.handleMouseEvents}; + pos = clipPos(this, pos); + return markText(this, pos, pos, realOpts, "bookmark") + }, + findMarksAt: function(pos) { + pos = clipPos(this, pos); + var markers = [], spans = getLine(this, pos.line).markedSpans; + if (spans) { for (var i = 0; i < spans.length; ++i) { + var span = spans[i]; + if ((span.from == null || span.from <= pos.ch) && + (span.to == null || span.to >= pos.ch)) + { markers.push(span.marker.parent || span.marker); } + } } + return markers + }, + findMarks: function(from, to, filter) { + from = clipPos(this, from); to = clipPos(this, to); + var found = [], lineNo$$1 = from.line; + this.iter(from.line, to.line + 1, function (line) { + var spans = line.markedSpans; + if (spans) { for (var i = 0; i < spans.length; i++) { + var span = spans[i]; + if (!(span.to != null && lineNo$$1 == from.line && from.ch >= span.to || + span.from == null && lineNo$$1 != from.line || + span.from != null && lineNo$$1 == to.line && span.from >= to.ch) && + (!filter || filter(span.marker))) + { found.push(span.marker.parent || span.marker); } + } } + ++lineNo$$1; + }); + return found + }, + getAllMarks: function() { + var markers = []; + this.iter(function (line) { + var sps = line.markedSpans; + if (sps) { for (var i = 0; i < sps.length; ++i) + { if (sps[i].from != null) { markers.push(sps[i].marker); } } } + }); + return markers + }, + + posFromIndex: function(off) { + var ch, lineNo$$1 = this.first, sepSize = this.lineSeparator().length; + this.iter(function (line) { + var sz = line.text.length + sepSize; + if (sz > off) { ch = off; return true } + off -= sz; + ++lineNo$$1; + }); + return clipPos(this, Pos(lineNo$$1, ch)) + }, + indexFromPos: function (coords) { + coords = clipPos(this, coords); + var index = coords.ch; + if (coords.line < this.first || coords.ch < 0) { return 0 } + var sepSize = this.lineSeparator().length; + this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value + index += line.text.length + sepSize; + }); + return index + }, + + copy: function(copyHistory) { + var doc = new Doc(getLines(this, this.first, this.first + this.size), + this.modeOption, this.first, this.lineSep, this.direction); + doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft; + doc.sel = this.sel; + doc.extend = false; + if (copyHistory) { + doc.history.undoDepth = this.history.undoDepth; + doc.setHistory(this.getHistory()); + } + return doc + }, + + linkedDoc: function(options) { + if (!options) { options = {}; } + var from = this.first, to = this.first + this.size; + if (options.from != null && options.from > from) { from = options.from; } + if (options.to != null && options.to < to) { to = options.to; } + var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction); + if (options.sharedHist) { copy.history = this.history + ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist}); + copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]; + copySharedMarkers(copy, findSharedMarkers(this)); + return copy + }, + unlinkDoc: function(other) { + var this$1 = this; + + if (other instanceof CodeMirror$1) { other = other.doc; } + if (this.linked) { for (var i = 0; i < this.linked.length; ++i) { + var link = this$1.linked[i]; + if (link.doc != other) { continue } + this$1.linked.splice(i, 1); + other.unlinkDoc(this$1); + detachSharedMarkers(findSharedMarkers(this$1)); + break + } } + // If the histories were shared, split them again + if (other.history == this.history) { + var splitIds = [other.id]; + linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true); + other.history = new History(null); + other.history.done = copyHistoryArray(this.history.done, splitIds); + other.history.undone = copyHistoryArray(this.history.undone, splitIds); + } + }, + iterLinkedDocs: function(f) {linkedDocs(this, f);}, + + getMode: function() {return this.mode}, + getEditor: function() {return this.cm}, + + splitLines: function(str) { + if (this.lineSep) { return str.split(this.lineSep) } + return splitLinesAuto(str) + }, + lineSeparator: function() { return this.lineSep || "\n" }, + + setDirection: docMethodOp(function (dir) { + if (dir != "rtl") { dir = "ltr"; } + if (dir == this.direction) { return } + this.direction = dir; + this.iter(function (line) { return line.order = null; }); + if (this.cm) { directionChanged(this.cm); } + }) +}); + +// Public alias. +Doc.prototype.eachLine = Doc.prototype.iter; + +// Kludge to work around strange IE behavior where it'll sometimes +// re-fire a series of drag-related events right after the drop (#1551) +var lastDrop = 0; + +function onDrop(e) { + var cm = this; + clearDragCursor(cm); + if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) + { return } + e_preventDefault(e); + if (ie) { lastDrop = +new Date; } + var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files; + if (!pos || cm.isReadOnly()) { return } + // Might be a file drop, in which case we simply extract the text + // and insert it. + if (files && files.length && window.FileReader && window.File) { + var n = files.length, text = Array(n), read = 0; + var loadFile = function (file, i) { + if (cm.options.allowDropFileTypes && + indexOf(cm.options.allowDropFileTypes, file.type) == -1) + { return } + + var reader = new FileReader; + reader.onload = operation(cm, function () { + var content = reader.result; + if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) { content = ""; } + text[i] = content; + if (++read == n) { + pos = clipPos(cm.doc, pos); + var change = {from: pos, to: pos, + text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())), + origin: "paste"}; + makeChange(cm.doc, change); + setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change))); + } + }); + reader.readAsText(file); + }; + for (var i = 0; i < n; ++i) { loadFile(files[i], i); } + } else { // Normal drop + // Don't do a replace if the drop happened inside of the selected text. + if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) { + cm.state.draggingText(e); + // Ensure the editor is re-focused + setTimeout(function () { return cm.display.input.focus(); }, 20); + return + } + try { + var text$1 = e.dataTransfer.getData("Text"); + if (text$1) { + var selected; + if (cm.state.draggingText && !cm.state.draggingText.copy) + { selected = cm.listSelections(); } + setSelectionNoUndo(cm.doc, simpleSelection(pos, pos)); + if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1) + { replaceRange(cm.doc, "", selected[i$1].anchor, selected[i$1].head, "drag"); } } + cm.replaceSelection(text$1, "around", "paste"); + cm.display.input.focus(); + } + } + catch(e){} + } +} + +function onDragStart(cm, e) { + if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return } + if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return } + + e.dataTransfer.setData("Text", cm.getSelection()); + e.dataTransfer.effectAllowed = "copyMove"; + + // Use dummy image instead of default browsers image. + // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there. + if (e.dataTransfer.setDragImage && !safari) { + var img = elt("img", null, null, "position: fixed; left: 0; top: 0;"); + img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="; + if (presto) { + img.width = img.height = 1; + cm.display.wrapper.appendChild(img); + // Force a relayout, or Opera won't use our image for some obscure reason + img._top = img.offsetTop; + } + e.dataTransfer.setDragImage(img, 0, 0); + if (presto) { img.parentNode.removeChild(img); } + } +} + +function onDragOver(cm, e) { + var pos = posFromMouse(cm, e); + if (!pos) { return } + var frag = document.createDocumentFragment(); + drawSelectionCursor(cm, pos, frag); + if (!cm.display.dragCursor) { + cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors"); + cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv); + } + removeChildrenAndAdd(cm.display.dragCursor, frag); +} + +function clearDragCursor(cm) { + if (cm.display.dragCursor) { + cm.display.lineSpace.removeChild(cm.display.dragCursor); + cm.display.dragCursor = null; + } +} + +// These must be handled carefully, because naively registering a +// handler for each editor will cause the editors to never be +// garbage collected. + +function forEachCodeMirror(f) { + if (!document.getElementsByClassName) { return } + var byClass = document.getElementsByClassName("CodeMirror"); + for (var i = 0; i < byClass.length; i++) { + var cm = byClass[i].CodeMirror; + if (cm) { f(cm); } + } +} + +var globalsRegistered = false; +function ensureGlobalHandlers() { + if (globalsRegistered) { return } + registerGlobalHandlers(); + globalsRegistered = true; +} +function registerGlobalHandlers() { + // When the window resizes, we need to refresh active editors. + var resizeTimer; + on(window, "resize", function () { + if (resizeTimer == null) { resizeTimer = setTimeout(function () { + resizeTimer = null; + forEachCodeMirror(onResize); + }, 100); } + }); + // When the window loses focus, we want to show the editor as blurred + on(window, "blur", function () { return forEachCodeMirror(onBlur); }); +} +// Called when the window resizes +function onResize(cm) { + var d = cm.display; + if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth) + { return } + // Might be a text scaling operation, clear size caches. + d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null; + d.scrollbarsClipped = false; + cm.setSize(); +} + +var keyNames = { + 3: "Pause", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt", + 19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End", + 36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert", + 46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod", + 106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete", 145: "ScrollLock", + 173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\", + 221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete", + 63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert" +}; + +// Number keys +for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i); } +// Alphabetic keys +for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1); } +// Function keys +for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2; } + +var keyMap = {}; + +keyMap.basic = { + "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown", + "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown", + "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore", + "Tab": "defaultTab", "Shift-Tab": "indentAuto", + "Enter": "newlineAndIndent", "Insert": "toggleOverwrite", + "Esc": "singleSelection" +}; +// Note that the save and find-related commands aren't defined by +// default. User code or addons can define them. Unknown commands +// are simply ignored. +keyMap.pcDefault = { + "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo", + "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown", + "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd", + "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find", + "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll", + "Ctrl-[": "indentLess", "Ctrl-]": "indentMore", + "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection", + fallthrough: "basic" +}; +// Very basic readline/emacs-style bindings, which are standard on Mac. +keyMap.emacsy = { + "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown", + "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd", + "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore", + "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars", + "Ctrl-O": "openLine" +}; +keyMap.macDefault = { + "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo", + "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft", + "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore", + "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find", + "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll", + "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight", + "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd", + fallthrough: ["basic", "emacsy"] +}; +keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault; + +// KEYMAP DISPATCH + +function normalizeKeyName(name) { + var parts = name.split(/-(?!$)/); + name = parts[parts.length - 1]; + var alt, ctrl, shift, cmd; + for (var i = 0; i < parts.length - 1; i++) { + var mod = parts[i]; + if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true; } + else if (/^a(lt)?$/i.test(mod)) { alt = true; } + else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true; } + else if (/^s(hift)?$/i.test(mod)) { shift = true; } + else { throw new Error("Unrecognized modifier name: " + mod) } + } + if (alt) { name = "Alt-" + name; } + if (ctrl) { name = "Ctrl-" + name; } + if (cmd) { name = "Cmd-" + name; } + if (shift) { name = "Shift-" + name; } + return name +} + +// This is a kludge to keep keymaps mostly working as raw objects +// (backwards compatibility) while at the same time support features +// like normalization and multi-stroke key bindings. It compiles a +// new normalized keymap, and then updates the old object to reflect +// this. +function normalizeKeyMap(keymap) { + var copy = {}; + for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) { + var value = keymap[keyname]; + if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue } + if (value == "...") { delete keymap[keyname]; continue } + + var keys = map(keyname.split(" "), normalizeKeyName); + for (var i = 0; i < keys.length; i++) { + var val = (void 0), name = (void 0); + if (i == keys.length - 1) { + name = keys.join(" "); + val = value; + } else { + name = keys.slice(0, i + 1).join(" "); + val = "..."; + } + var prev = copy[name]; + if (!prev) { copy[name] = val; } + else if (prev != val) { throw new Error("Inconsistent bindings for " + name) } + } + delete keymap[keyname]; + } } + for (var prop in copy) { keymap[prop] = copy[prop]; } + return keymap +} + +function lookupKey(key, map$$1, handle, context) { + map$$1 = getKeyMap(map$$1); + var found = map$$1.call ? map$$1.call(key, context) : map$$1[key]; + if (found === false) { return "nothing" } + if (found === "...") { return "multi" } + if (found != null && handle(found)) { return "handled" } + + if (map$$1.fallthrough) { + if (Object.prototype.toString.call(map$$1.fallthrough) != "[object Array]") + { return lookupKey(key, map$$1.fallthrough, handle, context) } + for (var i = 0; i < map$$1.fallthrough.length; i++) { + var result = lookupKey(key, map$$1.fallthrough[i], handle, context); + if (result) { return result } + } + } +} + +// Modifier key presses don't count as 'real' key presses for the +// purpose of keymap fallthrough. +function isModifierKey(value) { + var name = typeof value == "string" ? value : keyNames[value.keyCode]; + return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod" +} + +function addModifierNames(name, event, noShift) { + var base = name; + if (event.altKey && base != "Alt") { name = "Alt-" + name; } + if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") { name = "Ctrl-" + name; } + if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") { name = "Cmd-" + name; } + if (!noShift && event.shiftKey && base != "Shift") { name = "Shift-" + name; } + return name +} + +// Look up the name of a key as indicated by an event object. +function keyName(event, noShift) { + if (presto && event.keyCode == 34 && event["char"]) { return false } + var name = keyNames[event.keyCode]; + if (name == null || event.altGraphKey) { return false } + // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause, + // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+) + if (event.keyCode == 3 && event.code) { name = event.code; } + return addModifierNames(name, event, noShift) +} + +function getKeyMap(val) { + return typeof val == "string" ? keyMap[val] : val +} + +// Helper for deleting text near the selection(s), used to implement +// backspace, delete, and similar functionality. +function deleteNearSelection(cm, compute) { + var ranges = cm.doc.sel.ranges, kill = []; + // Build up a set of ranges to kill first, merging overlapping + // ranges. + for (var i = 0; i < ranges.length; i++) { + var toKill = compute(ranges[i]); + while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) { + var replaced = kill.pop(); + if (cmp(replaced.from, toKill.from) < 0) { + toKill.from = replaced.from; + break + } + } + kill.push(toKill); + } + // Next, remove those actual ranges. + runInOp(cm, function () { + for (var i = kill.length - 1; i >= 0; i--) + { replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete"); } + ensureCursorVisible(cm); + }); +} + +function moveCharLogically(line, ch, dir) { + var target = skipExtendingChars(line.text, ch + dir, dir); + return target < 0 || target > line.text.length ? null : target +} + +function moveLogically(line, start, dir) { + var ch = moveCharLogically(line, start.ch, dir); + return ch == null ? null : new Pos(start.line, ch, dir < 0 ? "after" : "before") +} + +function endOfLine(visually, cm, lineObj, lineNo, dir) { + if (visually) { + var order = getOrder(lineObj, cm.doc.direction); + if (order) { + var part = dir < 0 ? lst(order) : order[0]; + var moveInStorageOrder = (dir < 0) == (part.level == 1); + var sticky = moveInStorageOrder ? "after" : "before"; + var ch; + // With a wrapped rtl chunk (possibly spanning multiple bidi parts), + // it could be that the last bidi part is not on the last visual line, + // since visual lines contain content order-consecutive chunks. + // Thus, in rtl, we are looking for the first (content-order) character + // in the rtl chunk that is on the last line (that is, the same line + // as the last (content-order) character). + if (part.level > 0 || cm.doc.direction == "rtl") { + var prep = prepareMeasureForLine(cm, lineObj); + ch = dir < 0 ? lineObj.text.length - 1 : 0; + var targetTop = measureCharPrepared(cm, prep, ch).top; + ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch); + if (sticky == "before") { ch = moveCharLogically(lineObj, ch, 1); } + } else { ch = dir < 0 ? part.to : part.from; } + return new Pos(lineNo, ch, sticky) + } + } + return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? "before" : "after") +} + +function moveVisually(cm, line, start, dir) { + var bidi = getOrder(line, cm.doc.direction); + if (!bidi) { return moveLogically(line, start, dir) } + if (start.ch >= line.text.length) { + start.ch = line.text.length; + start.sticky = "before"; + } else if (start.ch <= 0) { + start.ch = 0; + start.sticky = "after"; + } + var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos]; + if (cm.doc.direction == "ltr" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) { + // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines, + // nothing interesting happens. + return moveLogically(line, start, dir) + } + + var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); }; + var prep; + var getWrappedLineExtent = function (ch) { + if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} } + prep = prep || prepareMeasureForLine(cm, line); + return wrappedLineExtentChar(cm, line, prep, ch) + }; + var wrappedLineExtent = getWrappedLineExtent(start.sticky == "before" ? mv(start, -1) : start.ch); + + if (cm.doc.direction == "rtl" || part.level == 1) { + var moveInStorageOrder = (part.level == 1) == (dir < 0); + var ch = mv(start, moveInStorageOrder ? 1 : -1); + if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) { + // Case 2: We move within an rtl part or in an rtl editor on the same visual line + var sticky = moveInStorageOrder ? "before" : "after"; + return new Pos(start.line, ch, sticky) + } + } + + // Case 3: Could not move within this bidi part in this visual line, so leave + // the current bidi part + + var searchInVisualLine = function (partPos, dir, wrappedLineExtent) { + var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder + ? new Pos(start.line, mv(ch, 1), "before") + : new Pos(start.line, ch, "after"); }; + + for (; partPos >= 0 && partPos < bidi.length; partPos += dir) { + var part = bidi[partPos]; + var moveInStorageOrder = (dir > 0) == (part.level != 1); + var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1); + if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) } + ch = moveInStorageOrder ? part.from : mv(part.to, -1); + if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) } + } + }; + + // Case 3a: Look for other bidi parts on the same visual line + var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent); + if (res) { return res } + + // Case 3b: Look for other bidi parts on the next visual line + var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1); + if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) { + res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh)); + if (res) { return res } + } + + // Case 4: Nowhere to move + return null +} + +// Commands are parameter-less actions that can be performed on an +// editor, mostly used for keybindings. +var commands = { + selectAll: selectAll, + singleSelection: function (cm) { return cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll); }, + killLine: function (cm) { return deleteNearSelection(cm, function (range) { + if (range.empty()) { + var len = getLine(cm.doc, range.head.line).text.length; + if (range.head.ch == len && range.head.line < cm.lastLine()) + { return {from: range.head, to: Pos(range.head.line + 1, 0)} } + else + { return {from: range.head, to: Pos(range.head.line, len)} } + } else { + return {from: range.from(), to: range.to()} + } + }); }, + deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({ + from: Pos(range.from().line, 0), + to: clipPos(cm.doc, Pos(range.to().line + 1, 0)) + }); }); }, + delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({ + from: Pos(range.from().line, 0), to: range.from() + }); }); }, + delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { + var top = cm.charCoords(range.head, "div").top + 5; + var leftPos = cm.coordsChar({left: 0, top: top}, "div"); + return {from: leftPos, to: range.from()} + }); }, + delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) { + var top = cm.charCoords(range.head, "div").top + 5; + var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div"); + return {from: range.from(), to: rightPos } + }); }, + undo: function (cm) { return cm.undo(); }, + redo: function (cm) { return cm.redo(); }, + undoSelection: function (cm) { return cm.undoSelection(); }, + redoSelection: function (cm) { return cm.redoSelection(); }, + goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); }, + goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); }, + goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); }, + {origin: "+move", bias: 1} + ); }, + goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); }, + {origin: "+move", bias: 1} + ); }, + goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); }, + {origin: "+move", bias: -1} + ); }, + goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) { + var top = cm.cursorCoords(range.head, "div").top + 5; + return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div") + }, sel_move); }, + goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) { + var top = cm.cursorCoords(range.head, "div").top + 5; + return cm.coordsChar({left: 0, top: top}, "div") + }, sel_move); }, + goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) { + var top = cm.cursorCoords(range.head, "div").top + 5; + var pos = cm.coordsChar({left: 0, top: top}, "div"); + if (pos.ch < cm.getLine(pos.line).search(/\S/)) { return lineStartSmart(cm, range.head) } + return pos + }, sel_move); }, + goLineUp: function (cm) { return cm.moveV(-1, "line"); }, + goLineDown: function (cm) { return cm.moveV(1, "line"); }, + goPageUp: function (cm) { return cm.moveV(-1, "page"); }, + goPageDown: function (cm) { return cm.moveV(1, "page"); }, + goCharLeft: function (cm) { return cm.moveH(-1, "char"); }, + goCharRight: function (cm) { return cm.moveH(1, "char"); }, + goColumnLeft: function (cm) { return cm.moveH(-1, "column"); }, + goColumnRight: function (cm) { return cm.moveH(1, "column"); }, + goWordLeft: function (cm) { return cm.moveH(-1, "word"); }, + goGroupRight: function (cm) { return cm.moveH(1, "group"); }, + goGroupLeft: function (cm) { return cm.moveH(-1, "group"); }, + goWordRight: function (cm) { return cm.moveH(1, "word"); }, + delCharBefore: function (cm) { return cm.deleteH(-1, "char"); }, + delCharAfter: function (cm) { return cm.deleteH(1, "char"); }, + delWordBefore: function (cm) { return cm.deleteH(-1, "word"); }, + delWordAfter: function (cm) { return cm.deleteH(1, "word"); }, + delGroupBefore: function (cm) { return cm.deleteH(-1, "group"); }, + delGroupAfter: function (cm) { return cm.deleteH(1, "group"); }, + indentAuto: function (cm) { return cm.indentSelection("smart"); }, + indentMore: function (cm) { return cm.indentSelection("add"); }, + indentLess: function (cm) { return cm.indentSelection("subtract"); }, + insertTab: function (cm) { return cm.replaceSelection("\t"); }, + insertSoftTab: function (cm) { + var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize; + for (var i = 0; i < ranges.length; i++) { + var pos = ranges[i].from(); + var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize); + spaces.push(spaceStr(tabSize - col % tabSize)); + } + cm.replaceSelections(spaces); + }, + defaultTab: function (cm) { + if (cm.somethingSelected()) { cm.indentSelection("add"); } + else { cm.execCommand("insertTab"); } + }, + // Swap the two chars left and right of each selection's head. + // Move cursor behind the two swapped characters afterwards. + // + // Doesn't consider line feeds a character. + // Doesn't scan more than one line above to find a character. + // Doesn't do anything on an empty line. + // Doesn't do anything with non-empty selections. + transposeChars: function (cm) { return runInOp(cm, function () { + var ranges = cm.listSelections(), newSel = []; + for (var i = 0; i < ranges.length; i++) { + if (!ranges[i].empty()) { continue } + var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text; + if (line) { + if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1); } + if (cur.ch > 0) { + cur = new Pos(cur.line, cur.ch + 1); + cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2), + Pos(cur.line, cur.ch - 2), cur, "+transpose"); + } else if (cur.line > cm.doc.first) { + var prev = getLine(cm.doc, cur.line - 1).text; + if (prev) { + cur = new Pos(cur.line, 1); + cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() + + prev.charAt(prev.length - 1), + Pos(cur.line - 1, prev.length - 1), cur, "+transpose"); + } + } + } + newSel.push(new Range(cur, cur)); + } + cm.setSelections(newSel); + }); }, + newlineAndIndent: function (cm) { return runInOp(cm, function () { + var sels = cm.listSelections(); + for (var i = sels.length - 1; i >= 0; i--) + { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input"); } + sels = cm.listSelections(); + for (var i$1 = 0; i$1 < sels.length; i$1++) + { cm.indentLine(sels[i$1].from().line, null, true); } + ensureCursorVisible(cm); + }); }, + openLine: function (cm) { return cm.replaceSelection("\n", "start"); }, + toggleOverwrite: function (cm) { return cm.toggleOverwrite(); } +}; + + +function lineStart(cm, lineN) { + var line = getLine(cm.doc, lineN); + var visual = visualLine(line); + if (visual != line) { lineN = lineNo(visual); } + return endOfLine(true, cm, visual, lineN, 1) +} +function lineEnd(cm, lineN) { + var line = getLine(cm.doc, lineN); + var visual = visualLineEnd(line); + if (visual != line) { lineN = lineNo(visual); } + return endOfLine(true, cm, line, lineN, -1) +} +function lineStartSmart(cm, pos) { + var start = lineStart(cm, pos.line); + var line = getLine(cm.doc, start.line); + var order = getOrder(line, cm.doc.direction); + if (!order || order[0].level == 0) { + var firstNonWS = Math.max(0, line.text.search(/\S/)); + var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch; + return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky) + } + return start +} + +// Run a handler that was bound to a key. +function doHandleBinding(cm, bound, dropShift) { + if (typeof bound == "string") { + bound = commands[bound]; + if (!bound) { return false } + } + // Ensure previous input has been read, so that the handler sees a + // consistent view of the document + cm.display.input.ensurePolled(); + var prevShift = cm.display.shift, done = false; + try { + if (cm.isReadOnly()) { cm.state.suppressEdits = true; } + if (dropShift) { cm.display.shift = false; } + done = bound(cm) != Pass; + } finally { + cm.display.shift = prevShift; + cm.state.suppressEdits = false; + } + return done +} + +function lookupKeyForEditor(cm, name, handle) { + for (var i = 0; i < cm.state.keyMaps.length; i++) { + var result = lookupKey(name, cm.state.keyMaps[i], handle, cm); + if (result) { return result } + } + return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm)) + || lookupKey(name, cm.options.keyMap, handle, cm) +} + +// Note that, despite the name, this function is also used to check +// for bound mouse clicks. + +var stopSeq = new Delayed; + +function dispatchKey(cm, name, e, handle) { + var seq = cm.state.keySeq; + if (seq) { + if (isModifierKey(name)) { return "handled" } + if (/\'$/.test(name)) + { cm.state.keySeq = null; } + else + { stopSeq.set(50, function () { + if (cm.state.keySeq == seq) { + cm.state.keySeq = null; + cm.display.input.reset(); + } + }); } + if (dispatchKeyInner(cm, seq + " " + name, e, handle)) { return true } + } + return dispatchKeyInner(cm, name, e, handle) +} + +function dispatchKeyInner(cm, name, e, handle) { + var result = lookupKeyForEditor(cm, name, handle); + + if (result == "multi") + { cm.state.keySeq = name; } + if (result == "handled") + { signalLater(cm, "keyHandled", cm, name, e); } + + if (result == "handled" || result == "multi") { + e_preventDefault(e); + restartBlink(cm); + } + + return !!result +} + +// Handle a key from the keydown event. +function handleKeyBinding(cm, e) { + var name = keyName(e, true); + if (!name) { return false } + + if (e.shiftKey && !cm.state.keySeq) { + // First try to resolve full name (including 'Shift-'). Failing + // that, see if there is a cursor-motion command (starting with + // 'go') bound to the keyname without 'Shift-'. + return dispatchKey(cm, "Shift-" + name, e, function (b) { return doHandleBinding(cm, b, true); }) + || dispatchKey(cm, name, e, function (b) { + if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion) + { return doHandleBinding(cm, b) } + }) + } else { + return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); }) + } +} + +// Handle a key from the keypress event +function handleCharBinding(cm, e, ch) { + return dispatchKey(cm, "'" + ch + "'", e, function (b) { return doHandleBinding(cm, b, true); }) +} + +var lastStoppedKey = null; +function onKeyDown(e) { + var cm = this; + cm.curOp.focus = activeElt(); + if (signalDOMEvent(cm, e)) { return } + // IE does strange things with escape. + if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false; } + var code = e.keyCode; + cm.display.shift = code == 16 || e.shiftKey; + var handled = handleKeyBinding(cm, e); + if (presto) { + lastStoppedKey = handled ? code : null; + // Opera has no cut event... we try to at least catch the key combo + if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey)) + { cm.replaceSelection("", null, "cut"); } + } + + // Turn mouse into crosshair when Alt is held on Mac. + if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className)) + { showCrossHair(cm); } +} + +function showCrossHair(cm) { + var lineDiv = cm.display.lineDiv; + addClass(lineDiv, "CodeMirror-crosshair"); + + function up(e) { + if (e.keyCode == 18 || !e.altKey) { + rmClass(lineDiv, "CodeMirror-crosshair"); + off(document, "keyup", up); + off(document, "mouseover", up); + } + } + on(document, "keyup", up); + on(document, "mouseover", up); +} + +function onKeyUp(e) { + if (e.keyCode == 16) { this.doc.sel.shift = false; } + signalDOMEvent(this, e); +} + +function onKeyPress(e) { + var cm = this; + if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return } + var keyCode = e.keyCode, charCode = e.charCode; + if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return} + if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return } + var ch = String.fromCharCode(charCode == null ? keyCode : charCode); + // Some browsers fire keypress events for backspace + if (ch == "\x08") { return } + if (handleCharBinding(cm, e, ch)) { return } + cm.display.input.onKeyPress(e); +} + +var DOUBLECLICK_DELAY = 400; + +var PastClick = function(time, pos, button) { + this.time = time; + this.pos = pos; + this.button = button; +}; + +PastClick.prototype.compare = function (time, pos, button) { + return this.time + DOUBLECLICK_DELAY > time && + cmp(pos, this.pos) == 0 && button == this.button +}; + +var lastClick; +var lastDoubleClick; +function clickRepeat(pos, button) { + var now = +new Date; + if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) { + lastClick = lastDoubleClick = null; + return "triple" + } else if (lastClick && lastClick.compare(now, pos, button)) { + lastDoubleClick = new PastClick(now, pos, button); + lastClick = null; + return "double" + } else { + lastClick = new PastClick(now, pos, button); + lastDoubleClick = null; + return "single" + } +} + +// A mouse down can be a single click, double click, triple click, +// start of selection drag, start of text drag, new cursor +// (ctrl-click), rectangle drag (alt-drag), or xwin +// middle-click-paste. Or it might be a click on something we should +// not interfere with, such as a scrollbar or widget. +function onMouseDown(e) { + var cm = this, display = cm.display; + if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return } + display.input.ensurePolled(); + display.shift = e.shiftKey; + + if (eventInWidget(display, e)) { + if (!webkit) { + // Briefly turn off draggability, to allow widgets to do + // normal dragging things. + display.scroller.draggable = false; + setTimeout(function () { return display.scroller.draggable = true; }, 100); + } + return + } + if (clickInGutter(cm, e)) { return } + var pos = posFromMouse(cm, e), button = e_button(e), repeat = pos ? clickRepeat(pos, button) : "single"; + window.focus(); + + // #3261: make sure, that we're not starting a second selection + if (button == 1 && cm.state.selectingText) + { cm.state.selectingText(e); } + + if (pos && handleMappedButton(cm, button, pos, repeat, e)) { return } + + if (button == 1) { + if (pos) { leftButtonDown(cm, pos, repeat, e); } + else if (e_target(e) == display.scroller) { e_preventDefault(e); } + } else if (button == 2) { + if (pos) { extendSelection(cm.doc, pos); } + setTimeout(function () { return display.input.focus(); }, 20); + } else if (button == 3) { + if (captureRightClick) { onContextMenu(cm, e); } + else { delayBlurEvent(cm); } + } +} + +function handleMappedButton(cm, button, pos, repeat, event) { + var name = "Click"; + if (repeat == "double") { name = "Double" + name; } + else if (repeat == "triple") { name = "Triple" + name; } + name = (button == 1 ? "Left" : button == 2 ? "Middle" : "Right") + name; + + return dispatchKey(cm, addModifierNames(name, event), event, function (bound) { + if (typeof bound == "string") { bound = commands[bound]; } + if (!bound) { return false } + var done = false; + try { + if (cm.isReadOnly()) { cm.state.suppressEdits = true; } + done = bound(cm, pos) != Pass; + } finally { + cm.state.suppressEdits = false; + } + return done + }) +} + +function configureMouse(cm, repeat, event) { + var option = cm.getOption("configureMouse"); + var value = option ? option(cm, repeat, event) : {}; + if (value.unit == null) { + var rect = chromeOS ? event.shiftKey && event.metaKey : event.altKey; + value.unit = rect ? "rectangle" : repeat == "single" ? "char" : repeat == "double" ? "word" : "line"; + } + if (value.extend == null || cm.doc.extend) { value.extend = cm.doc.extend || event.shiftKey; } + if (value.addNew == null) { value.addNew = mac ? event.metaKey : event.ctrlKey; } + if (value.moveOnDrag == null) { value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey); } + return value +} + +function leftButtonDown(cm, pos, repeat, event) { + if (ie) { setTimeout(bind(ensureFocus, cm), 0); } + else { cm.curOp.focus = activeElt(); } + + var behavior = configureMouse(cm, repeat, event); + + var sel = cm.doc.sel, contained; + if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() && + repeat == "single" && (contained = sel.contains(pos)) > -1 && + (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) && + (cmp(contained.to(), pos) > 0 || pos.xRel < 0)) + { leftButtonStartDrag(cm, event, pos, behavior); } + else + { leftButtonSelect(cm, event, pos, behavior); } +} + +// Start a text drag. When it ends, see if any dragging actually +// happen, and treat as a click if it didn't. +function leftButtonStartDrag(cm, event, pos, behavior) { + var display = cm.display, moved = false; + var dragEnd = operation(cm, function (e) { + if (webkit) { display.scroller.draggable = false; } + cm.state.draggingText = false; + off(display.wrapper.ownerDocument, "mouseup", dragEnd); + off(display.wrapper.ownerDocument, "mousemove", mouseMove); + off(display.scroller, "dragstart", dragStart); + off(display.scroller, "drop", dragEnd); + if (!moved) { + e_preventDefault(e); + if (!behavior.addNew) + { extendSelection(cm.doc, pos, null, null, behavior.extend); } + // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081) + if (webkit || ie && ie_version == 9) + { setTimeout(function () {display.wrapper.ownerDocument.body.focus(); display.input.focus();}, 20); } + else + { display.input.focus(); } + } + }); + var mouseMove = function(e2) { + moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10; + }; + var dragStart = function () { return moved = true; }; + // Let the drag handler handle this. + if (webkit) { display.scroller.draggable = true; } + cm.state.draggingText = dragEnd; + dragEnd.copy = !behavior.moveOnDrag; + // IE's approach to draggable + if (display.scroller.dragDrop) { display.scroller.dragDrop(); } + on(display.wrapper.ownerDocument, "mouseup", dragEnd); + on(display.wrapper.ownerDocument, "mousemove", mouseMove); + on(display.scroller, "dragstart", dragStart); + on(display.scroller, "drop", dragEnd); + + delayBlurEvent(cm); + setTimeout(function () { return display.input.focus(); }, 20); +} + +function rangeForUnit(cm, pos, unit) { + if (unit == "char") { return new Range(pos, pos) } + if (unit == "word") { return cm.findWordAt(pos) } + if (unit == "line") { return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) } + var result = unit(cm, pos); + return new Range(result.from, result.to) +} + +// Normal selection, as opposed to text dragging. +function leftButtonSelect(cm, event, start, behavior) { + var display = cm.display, doc = cm.doc; + e_preventDefault(event); + + var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges; + if (behavior.addNew && !behavior.extend) { + ourIndex = doc.sel.contains(start); + if (ourIndex > -1) + { ourRange = ranges[ourIndex]; } + else + { ourRange = new Range(start, start); } + } else { + ourRange = doc.sel.primary(); + ourIndex = doc.sel.primIndex; + } + + if (behavior.unit == "rectangle") { + if (!behavior.addNew) { ourRange = new Range(start, start); } + start = posFromMouse(cm, event, true, true); + ourIndex = -1; + } else { + var range$$1 = rangeForUnit(cm, start, behavior.unit); + if (behavior.extend) + { ourRange = extendRange(ourRange, range$$1.anchor, range$$1.head, behavior.extend); } + else + { ourRange = range$$1; } + } + + if (!behavior.addNew) { + ourIndex = 0; + setSelection(doc, new Selection([ourRange], 0), sel_mouse); + startSel = doc.sel; + } else if (ourIndex == -1) { + ourIndex = ranges.length; + setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex), + {scroll: false, origin: "*mouse"}); + } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == "char" && !behavior.extend) { + setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0), + {scroll: false, origin: "*mouse"}); + startSel = doc.sel; + } else { + replaceOneSelection(doc, ourIndex, ourRange, sel_mouse); + } + + var lastPos = start; + function extendTo(pos) { + if (cmp(lastPos, pos) == 0) { return } + lastPos = pos; + + if (behavior.unit == "rectangle") { + var ranges = [], tabSize = cm.options.tabSize; + var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize); + var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize); + var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol); + for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line)); + line <= end; line++) { + var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize); + if (left == right) + { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))); } + else if (text.length > leftPos) + { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))); } + } + if (!ranges.length) { ranges.push(new Range(start, start)); } + setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex), + {origin: "*mouse", scroll: false}); + cm.scrollIntoView(pos); + } else { + var oldRange = ourRange; + var range$$1 = rangeForUnit(cm, pos, behavior.unit); + var anchor = oldRange.anchor, head; + if (cmp(range$$1.anchor, anchor) > 0) { + head = range$$1.head; + anchor = minPos(oldRange.from(), range$$1.anchor); + } else { + head = range$$1.anchor; + anchor = maxPos(oldRange.to(), range$$1.head); + } + var ranges$1 = startSel.ranges.slice(0); + ranges$1[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head)); + setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse); + } + } + + var editorSize = display.wrapper.getBoundingClientRect(); + // Used to ensure timeout re-tries don't fire when another extend + // happened in the meantime (clearTimeout isn't reliable -- at + // least on Chrome, the timeouts still happen even when cleared, + // if the clear happens after their scheduled firing time). + var counter = 0; + + function extend(e) { + var curCount = ++counter; + var cur = posFromMouse(cm, e, true, behavior.unit == "rectangle"); + if (!cur) { return } + if (cmp(cur, lastPos) != 0) { + cm.curOp.focus = activeElt(); + extendTo(cur); + var visible = visibleLines(display, doc); + if (cur.line >= visible.to || cur.line < visible.from) + { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e); }}), 150); } + } else { + var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0; + if (outside) { setTimeout(operation(cm, function () { + if (counter != curCount) { return } + display.scroller.scrollTop += outside; + extend(e); + }), 50); } + } + } + + function done(e) { + cm.state.selectingText = false; + counter = Infinity; + e_preventDefault(e); + display.input.focus(); + off(display.wrapper.ownerDocument, "mousemove", move); + off(display.wrapper.ownerDocument, "mouseup", up); + doc.history.lastSelOrigin = null; + } + + var move = operation(cm, function (e) { + if (e.buttons === 0 || !e_button(e)) { done(e); } + else { extend(e); } + }); + var up = operation(cm, done); + cm.state.selectingText = up; + on(display.wrapper.ownerDocument, "mousemove", move); + on(display.wrapper.ownerDocument, "mouseup", up); +} + +// Used when mouse-selecting to adjust the anchor to the proper side +// of a bidi jump depending on the visual position of the head. +function bidiSimplify(cm, range$$1) { + var anchor = range$$1.anchor; + var head = range$$1.head; + var anchorLine = getLine(cm.doc, anchor.line); + if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) { return range$$1 } + var order = getOrder(anchorLine); + if (!order) { return range$$1 } + var index = getBidiPartAt(order, anchor.ch, anchor.sticky), part = order[index]; + if (part.from != anchor.ch && part.to != anchor.ch) { return range$$1 } + var boundary = index + ((part.from == anchor.ch) == (part.level != 1) ? 0 : 1); + if (boundary == 0 || boundary == order.length) { return range$$1 } + + // Compute the relative visual position of the head compared to the + // anchor (<0 is to the left, >0 to the right) + var leftSide; + if (head.line != anchor.line) { + leftSide = (head.line - anchor.line) * (cm.doc.direction == "ltr" ? 1 : -1) > 0; + } else { + var headIndex = getBidiPartAt(order, head.ch, head.sticky); + var dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1); + if (headIndex == boundary - 1 || headIndex == boundary) + { leftSide = dir < 0; } + else + { leftSide = dir > 0; } + } + + var usePart = order[boundary + (leftSide ? -1 : 0)]; + var from = leftSide == (usePart.level == 1); + var ch = from ? usePart.from : usePart.to, sticky = from ? "after" : "before"; + return anchor.ch == ch && anchor.sticky == sticky ? range$$1 : new Range(new Pos(anchor.line, ch, sticky), head) +} + + +// Determines whether an event happened in the gutter, and fires the +// handlers for the corresponding event. +function gutterEvent(cm, e, type, prevent) { + var mX, mY; + if (e.touches) { + mX = e.touches[0].clientX; + mY = e.touches[0].clientY; + } else { + try { mX = e.clientX; mY = e.clientY; } + catch(e) { return false } + } + if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false } + if (prevent) { e_preventDefault(e); } + + var display = cm.display; + var lineBox = display.lineDiv.getBoundingClientRect(); + + if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) } + mY -= lineBox.top - display.viewOffset; + + for (var i = 0; i < cm.options.gutters.length; ++i) { + var g = display.gutters.childNodes[i]; + if (g && g.getBoundingClientRect().right >= mX) { + var line = lineAtHeight(cm.doc, mY); + var gutter = cm.options.gutters[i]; + signal(cm, type, cm, line, gutter, e); + return e_defaultPrevented(e) + } + } +} + +function clickInGutter(cm, e) { + return gutterEvent(cm, e, "gutterClick", true) +} + +// CONTEXT MENU HANDLING + +// To make the context menu work, we need to briefly unhide the +// textarea (making it as unobtrusive as possible) to let the +// right-click take effect on it. +function onContextMenu(cm, e) { + if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return } + if (signalDOMEvent(cm, e, "contextmenu")) { return } + cm.display.input.onContextMenu(e); +} + +function contextMenuInGutter(cm, e) { + if (!hasHandler(cm, "gutterContextMenu")) { return false } + return gutterEvent(cm, e, "gutterContextMenu", false) +} + +function themeChanged(cm) { + cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") + + cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-"); + clearCaches(cm); +} + +var Init = {toString: function(){return "CodeMirror.Init"}}; + +var defaults = {}; +var optionHandlers = {}; + +function defineOptions(CodeMirror) { + var optionHandlers = CodeMirror.optionHandlers; + + function option(name, deflt, handle, notOnInit) { + CodeMirror.defaults[name] = deflt; + if (handle) { optionHandlers[name] = + notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old); }} : handle; } + } + + CodeMirror.defineOption = option; + + // Passed to option handlers when there is no old value. + CodeMirror.Init = Init; + + // These two are, on init, called from the constructor because they + // have to be initialized before the editor can start at all. + option("value", "", function (cm, val) { return cm.setValue(val); }, true); + option("mode", null, function (cm, val) { + cm.doc.modeOption = val; + loadMode(cm); + }, true); + + option("indentUnit", 2, loadMode, true); + option("indentWithTabs", false); + option("smartIndent", true); + option("tabSize", 4, function (cm) { + resetModeState(cm); + clearCaches(cm); + regChange(cm); + }, true); + + option("lineSeparator", null, function (cm, val) { + cm.doc.lineSep = val; + if (!val) { return } + var newBreaks = [], lineNo = cm.doc.first; + cm.doc.iter(function (line) { + for (var pos = 0;;) { + var found = line.text.indexOf(val, pos); + if (found == -1) { break } + pos = found + val.length; + newBreaks.push(Pos(lineNo, found)); + } + lineNo++; + }); + for (var i = newBreaks.length - 1; i >= 0; i--) + { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)); } + }); + option("specialChars", /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028\u2029\ufeff]/g, function (cm, val, old) { + cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g"); + if (old != Init) { cm.refresh(); } + }); + option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true); + option("electricChars", true); + option("inputStyle", mobile ? "contenteditable" : "textarea", function () { + throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME + }, true); + option("spellcheck", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true); + option("rtlMoveVisually", !windows); + option("wholeLineUpdateBefore", true); + + option("theme", "default", function (cm) { + themeChanged(cm); + guttersChanged(cm); + }, true); + option("keyMap", "default", function (cm, val, old) { + var next = getKeyMap(val); + var prev = old != Init && getKeyMap(old); + if (prev && prev.detach) { prev.detach(cm, next); } + if (next.attach) { next.attach(cm, prev || null); } + }); + option("extraKeys", null); + option("configureMouse", null); + + option("lineWrapping", false, wrappingChanged, true); + option("gutters", [], function (cm) { + setGuttersForLineNumbers(cm.options); + guttersChanged(cm); + }, true); + option("fixedGutter", true, function (cm, val) { + cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0"; + cm.refresh(); + }, true); + option("coverGutterNextToScrollbar", false, function (cm) { return updateScrollbars(cm); }, true); + option("scrollbarStyle", "native", function (cm) { + initScrollbars(cm); + updateScrollbars(cm); + cm.display.scrollbars.setScrollTop(cm.doc.scrollTop); + cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft); + }, true); + option("lineNumbers", false, function (cm) { + setGuttersForLineNumbers(cm.options); + guttersChanged(cm); + }, true); + option("firstLineNumber", 1, guttersChanged, true); + option("lineNumberFormatter", function (integer) { return integer; }, guttersChanged, true); + option("showCursorWhenSelecting", false, updateSelection, true); + + option("resetSelectionOnContextMenu", true); + option("lineWiseCopyCut", true); + option("pasteLinesPerSelection", true); + + option("readOnly", false, function (cm, val) { + if (val == "nocursor") { + onBlur(cm); + cm.display.input.blur(); + } + cm.display.input.readOnlyChanged(val); + }); + option("disableInput", false, function (cm, val) {if (!val) { cm.display.input.reset(); }}, true); + option("dragDrop", true, dragDropChanged); + option("allowDropFileTypes", null); + + option("cursorBlinkRate", 530); + option("cursorScrollMargin", 0); + option("cursorHeight", 1, updateSelection, true); + option("singleCursorHeightPerLine", true, updateSelection, true); + option("workTime", 100); + option("workDelay", 100); + option("flattenSpans", true, resetModeState, true); + option("addModeClass", false, resetModeState, true); + option("pollInterval", 100); + option("undoDepth", 200, function (cm, val) { return cm.doc.history.undoDepth = val; }); + option("historyEventDelay", 1250); + option("viewportMargin", 10, function (cm) { return cm.refresh(); }, true); + option("maxHighlightLength", 10000, resetModeState, true); + option("moveInputWithCursor", true, function (cm, val) { + if (!val) { cm.display.input.resetPosition(); } + }); + + option("tabindex", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || ""; }); + option("autofocus", null); + option("direction", "ltr", function (cm, val) { return cm.doc.setDirection(val); }, true); +} + +function guttersChanged(cm) { + updateGutters(cm); + regChange(cm); + alignHorizontally(cm); +} + +function dragDropChanged(cm, value, old) { + var wasOn = old && old != Init; + if (!value != !wasOn) { + var funcs = cm.display.dragFunctions; + var toggle = value ? on : off; + toggle(cm.display.scroller, "dragstart", funcs.start); + toggle(cm.display.scroller, "dragenter", funcs.enter); + toggle(cm.display.scroller, "dragover", funcs.over); + toggle(cm.display.scroller, "dragleave", funcs.leave); + toggle(cm.display.scroller, "drop", funcs.drop); + } +} + +function wrappingChanged(cm) { + if (cm.options.lineWrapping) { + addClass(cm.display.wrapper, "CodeMirror-wrap"); + cm.display.sizer.style.minWidth = ""; + cm.display.sizerWidth = null; + } else { + rmClass(cm.display.wrapper, "CodeMirror-wrap"); + findMaxLine(cm); + } + estimateLineHeights(cm); + regChange(cm); + clearCaches(cm); + setTimeout(function () { return updateScrollbars(cm); }, 100); +} + +// A CodeMirror instance represents an editor. This is the object +// that user code is usually dealing with. + +function CodeMirror$1(place, options) { + var this$1 = this; + + if (!(this instanceof CodeMirror$1)) { return new CodeMirror$1(place, options) } + + this.options = options = options ? copyObj(options) : {}; + // Determine effective options based on given values and defaults. + copyObj(defaults, options, false); + setGuttersForLineNumbers(options); + + var doc = options.value; + if (typeof doc == "string") { doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction); } + this.doc = doc; + + var input = new CodeMirror$1.inputStyles[options.inputStyle](this); + var display = this.display = new Display(place, doc, input); + display.wrapper.CodeMirror = this; + updateGutters(this); + themeChanged(this); + if (options.lineWrapping) + { this.display.wrapper.className += " CodeMirror-wrap"; } + initScrollbars(this); + + this.state = { + keyMaps: [], // stores maps added by addKeyMap + overlays: [], // highlighting overlays, as added by addOverlay + modeGen: 0, // bumped when mode/overlay changes, used to invalidate highlighting info + overwrite: false, + delayingBlurEvent: false, + focused: false, + suppressEdits: false, // used to disable editing during key handlers when in readOnly mode + pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll + selectingText: false, + draggingText: false, + highlight: new Delayed(), // stores highlight worker timeout + keySeq: null, // Unfinished key sequence + specialChars: null + }; + + if (options.autofocus && !mobile) { display.input.focus(); } + + // Override magic textarea content restore that IE sometimes does + // on our hidden textarea on reload + if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20); } + + registerEventHandlers(this); + ensureGlobalHandlers(); + + startOperation(this); + this.curOp.forceUpdate = true; + attachDoc(this, doc); + + if ((options.autofocus && !mobile) || this.hasFocus()) + { setTimeout(bind(onFocus, this), 20); } + else + { onBlur(this); } + + for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt)) + { optionHandlers[opt](this$1, options[opt], Init); } } + maybeUpdateLineNumberWidth(this); + if (options.finishInit) { options.finishInit(this); } + for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1); } + endOperation(this); + // Suppress optimizelegibility in Webkit, since it breaks text + // measuring on line wrapping boundaries. + if (webkit && options.lineWrapping && + getComputedStyle(display.lineDiv).textRendering == "optimizelegibility") + { display.lineDiv.style.textRendering = "auto"; } +} + +// The default configuration options. +CodeMirror$1.defaults = defaults; +// Functions to run when options are changed. +CodeMirror$1.optionHandlers = optionHandlers; + +// Attach the necessary event handlers when initializing the editor +function registerEventHandlers(cm) { + var d = cm.display; + on(d.scroller, "mousedown", operation(cm, onMouseDown)); + // Older IE's will not fire a second mousedown for a double click + if (ie && ie_version < 11) + { on(d.scroller, "dblclick", operation(cm, function (e) { + if (signalDOMEvent(cm, e)) { return } + var pos = posFromMouse(cm, e); + if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return } + e_preventDefault(e); + var word = cm.findWordAt(pos); + extendSelection(cm.doc, word.anchor, word.head); + })); } + else + { on(d.scroller, "dblclick", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }); } + // Some browsers fire contextmenu *after* opening the menu, at + // which point we can't mess with it anymore. Context menu is + // handled in onMouseDown for these browsers. + if (!captureRightClick) { on(d.scroller, "contextmenu", function (e) { return onContextMenu(cm, e); }); } + + // Used to suppress mouse event handling when a touch happens + var touchFinished, prevTouch = {end: 0}; + function finishTouch() { + if (d.activeTouch) { + touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000); + prevTouch = d.activeTouch; + prevTouch.end = +new Date; + } + } + function isMouseLikeTouchEvent(e) { + if (e.touches.length != 1) { return false } + var touch = e.touches[0]; + return touch.radiusX <= 1 && touch.radiusY <= 1 + } + function farAway(touch, other) { + if (other.left == null) { return true } + var dx = other.left - touch.left, dy = other.top - touch.top; + return dx * dx + dy * dy > 20 * 20 + } + on(d.scroller, "touchstart", function (e) { + if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) { + d.input.ensurePolled(); + clearTimeout(touchFinished); + var now = +new Date; + d.activeTouch = {start: now, moved: false, + prev: now - prevTouch.end <= 300 ? prevTouch : null}; + if (e.touches.length == 1) { + d.activeTouch.left = e.touches[0].pageX; + d.activeTouch.top = e.touches[0].pageY; + } + } + }); + on(d.scroller, "touchmove", function () { + if (d.activeTouch) { d.activeTouch.moved = true; } + }); + on(d.scroller, "touchend", function (e) { + var touch = d.activeTouch; + if (touch && !eventInWidget(d, e) && touch.left != null && + !touch.moved && new Date - touch.start < 300) { + var pos = cm.coordsChar(d.activeTouch, "page"), range; + if (!touch.prev || farAway(touch, touch.prev)) // Single tap + { range = new Range(pos, pos); } + else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap + { range = cm.findWordAt(pos); } + else // Triple tap + { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))); } + cm.setSelection(range.anchor, range.head); + cm.focus(); + e_preventDefault(e); + } + finishTouch(); + }); + on(d.scroller, "touchcancel", finishTouch); + + // Sync scrolling between fake scrollbars and real scrollable + // area, ensure viewport is updated when scrolling. + on(d.scroller, "scroll", function () { + if (d.scroller.clientHeight) { + updateScrollTop(cm, d.scroller.scrollTop); + setScrollLeft(cm, d.scroller.scrollLeft, true); + signal(cm, "scroll", cm); + } + }); + + // Listen to wheel events in order to try and update the viewport on time. + on(d.scroller, "mousewheel", function (e) { return onScrollWheel(cm, e); }); + on(d.scroller, "DOMMouseScroll", function (e) { return onScrollWheel(cm, e); }); + + // Prevent wrapper from ever scrolling + on(d.wrapper, "scroll", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; }); + + d.dragFunctions = { + enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e); }}, + over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e); }}, + start: function (e) { return onDragStart(cm, e); }, + drop: operation(cm, onDrop), + leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm); }} + }; + + var inp = d.input.getField(); + on(inp, "keyup", function (e) { return onKeyUp.call(cm, e); }); + on(inp, "keydown", operation(cm, onKeyDown)); + on(inp, "keypress", operation(cm, onKeyPress)); + on(inp, "focus", function (e) { return onFocus(cm, e); }); + on(inp, "blur", function (e) { return onBlur(cm, e); }); +} + +var initHooks = []; +CodeMirror$1.defineInitHook = function (f) { return initHooks.push(f); }; + +// Indent the given line. The how parameter can be "smart", +// "add"/null, "subtract", or "prev". When aggressive is false +// (typically set to true for forced single-line indents), empty +// lines are not indented, and places where the mode returns Pass +// are left alone. +function indentLine(cm, n, how, aggressive) { + var doc = cm.doc, state; + if (how == null) { how = "add"; } + if (how == "smart") { + // Fall back to "prev" when the mode doesn't have an indentation + // method. + if (!doc.mode.indent) { how = "prev"; } + else { state = getContextBefore(cm, n).state; } + } + + var tabSize = cm.options.tabSize; + var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize); + if (line.stateAfter) { line.stateAfter = null; } + var curSpaceString = line.text.match(/^\s*/)[0], indentation; + if (!aggressive && !/\S/.test(line.text)) { + indentation = 0; + how = "not"; + } else if (how == "smart") { + indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text); + if (indentation == Pass || indentation > 150) { + if (!aggressive) { return } + how = "prev"; + } + } + if (how == "prev") { + if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize); } + else { indentation = 0; } + } else if (how == "add") { + indentation = curSpace + cm.options.indentUnit; + } else if (how == "subtract") { + indentation = curSpace - cm.options.indentUnit; + } else if (typeof how == "number") { + indentation = curSpace + how; + } + indentation = Math.max(0, indentation); + + var indentString = "", pos = 0; + if (cm.options.indentWithTabs) + { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";} } + if (pos < indentation) { indentString += spaceStr(indentation - pos); } + + if (indentString != curSpaceString) { + replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input"); + line.stateAfter = null; + return true + } else { + // Ensure that, if the cursor was in the whitespace at the start + // of the line, it is moved to the end of that space. + for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) { + var range = doc.sel.ranges[i$1]; + if (range.head.line == n && range.head.ch < curSpaceString.length) { + var pos$1 = Pos(n, curSpaceString.length); + replaceOneSelection(doc, i$1, new Range(pos$1, pos$1)); + break + } + } + } +} + +// This will be set to a {lineWise: bool, text: [string]} object, so +// that, when pasting, we know what kind of selections the copied +// text was made out of. +var lastCopied = null; + +function setLastCopied(newLastCopied) { + lastCopied = newLastCopied; +} + +function applyTextInput(cm, inserted, deleted, sel, origin) { + var doc = cm.doc; + cm.display.shift = false; + if (!sel) { sel = doc.sel; } + + var paste = cm.state.pasteIncoming || origin == "paste"; + var textLines = splitLinesAuto(inserted), multiPaste = null; + // When pasting N lines into N selections, insert one line per selection + if (paste && sel.ranges.length > 1) { + if (lastCopied && lastCopied.text.join("\n") == inserted) { + if (sel.ranges.length % lastCopied.text.length == 0) { + multiPaste = []; + for (var i = 0; i < lastCopied.text.length; i++) + { multiPaste.push(doc.splitLines(lastCopied.text[i])); } + } + } else if (textLines.length == sel.ranges.length && cm.options.pasteLinesPerSelection) { + multiPaste = map(textLines, function (l) { return [l]; }); + } + } + + var updateInput; + // Normal behavior is to insert the new text into every selection + for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) { + var range$$1 = sel.ranges[i$1]; + var from = range$$1.from(), to = range$$1.to(); + if (range$$1.empty()) { + if (deleted && deleted > 0) // Handle deletion + { from = Pos(from.line, from.ch - deleted); } + else if (cm.state.overwrite && !paste) // Handle overwrite + { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)); } + else if (lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == inserted) + { from = to = Pos(from.line, 0); } + } + updateInput = cm.curOp.updateInput; + var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines, + origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")}; + makeChange(cm.doc, changeEvent); + signalLater(cm, "inputRead", cm, changeEvent); + } + if (inserted && !paste) + { triggerElectric(cm, inserted); } + + ensureCursorVisible(cm); + cm.curOp.updateInput = updateInput; + cm.curOp.typing = true; + cm.state.pasteIncoming = cm.state.cutIncoming = false; +} + +function handlePaste(e, cm) { + var pasted = e.clipboardData && e.clipboardData.getData("Text"); + if (pasted) { + e.preventDefault(); + if (!cm.isReadOnly() && !cm.options.disableInput) + { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, "paste"); }); } + return true + } +} + +function triggerElectric(cm, inserted) { + // When an 'electric' character is inserted, immediately trigger a reindent + if (!cm.options.electricChars || !cm.options.smartIndent) { return } + var sel = cm.doc.sel; + + for (var i = sel.ranges.length - 1; i >= 0; i--) { + var range$$1 = sel.ranges[i]; + if (range$$1.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range$$1.head.line)) { continue } + var mode = cm.getModeAt(range$$1.head); + var indented = false; + if (mode.electricChars) { + for (var j = 0; j < mode.electricChars.length; j++) + { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) { + indented = indentLine(cm, range$$1.head.line, "smart"); + break + } } + } else if (mode.electricInput) { + if (mode.electricInput.test(getLine(cm.doc, range$$1.head.line).text.slice(0, range$$1.head.ch))) + { indented = indentLine(cm, range$$1.head.line, "smart"); } + } + if (indented) { signalLater(cm, "electricInput", cm, range$$1.head.line); } + } +} + +function copyableRanges(cm) { + var text = [], ranges = []; + for (var i = 0; i < cm.doc.sel.ranges.length; i++) { + var line = cm.doc.sel.ranges[i].head.line; + var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}; + ranges.push(lineRange); + text.push(cm.getRange(lineRange.anchor, lineRange.head)); + } + return {text: text, ranges: ranges} +} + +function disableBrowserMagic(field, spellcheck) { + field.setAttribute("autocorrect", "off"); + field.setAttribute("autocapitalize", "off"); + field.setAttribute("spellcheck", !!spellcheck); +} + +function hiddenTextarea() { + var te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none"); + var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;"); + // The textarea is kept positioned near the cursor to prevent the + // fact that it'll be scrolled into view on input from scrolling + // our fake cursor out of view. On webkit, when wrap=off, paste is + // very slow. So make the area wide instead. + if (webkit) { te.style.width = "1000px"; } + else { te.setAttribute("wrap", "off"); } + // If border: 0; -- iOS fails to open keyboard (issue #1287) + if (ios) { te.style.border = "1px solid black"; } + disableBrowserMagic(te); + return div +} + +// The publicly visible API. Note that methodOp(f) means +// 'wrap f in an operation, performed on its `this` parameter'. + +// This is not the complete set of editor methods. Most of the +// methods defined on the Doc type are also injected into +// CodeMirror.prototype, for backwards compatibility and +// convenience. + +var addEditorMethods = function(CodeMirror) { + var optionHandlers = CodeMirror.optionHandlers; + + var helpers = CodeMirror.helpers = {}; + + CodeMirror.prototype = { + constructor: CodeMirror, + focus: function(){window.focus(); this.display.input.focus();}, + + setOption: function(option, value) { + var options = this.options, old = options[option]; + if (options[option] == value && option != "mode") { return } + options[option] = value; + if (optionHandlers.hasOwnProperty(option)) + { operation(this, optionHandlers[option])(this, value, old); } + signal(this, "optionChange", this, option); + }, + + getOption: function(option) {return this.options[option]}, + getDoc: function() {return this.doc}, + + addKeyMap: function(map$$1, bottom) { + this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map$$1)); + }, + removeKeyMap: function(map$$1) { + var maps = this.state.keyMaps; + for (var i = 0; i < maps.length; ++i) + { if (maps[i] == map$$1 || maps[i].name == map$$1) { + maps.splice(i, 1); + return true + } } + }, + + addOverlay: methodOp(function(spec, options) { + var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec); + if (mode.startState) { throw new Error("Overlays may not be stateful.") } + insertSorted(this.state.overlays, + {mode: mode, modeSpec: spec, opaque: options && options.opaque, + priority: (options && options.priority) || 0}, + function (overlay) { return overlay.priority; }); + this.state.modeGen++; + regChange(this); + }), + removeOverlay: methodOp(function(spec) { + var this$1 = this; + + var overlays = this.state.overlays; + for (var i = 0; i < overlays.length; ++i) { + var cur = overlays[i].modeSpec; + if (cur == spec || typeof spec == "string" && cur.name == spec) { + overlays.splice(i, 1); + this$1.state.modeGen++; + regChange(this$1); + return + } + } + }), + + indentLine: methodOp(function(n, dir, aggressive) { + if (typeof dir != "string" && typeof dir != "number") { + if (dir == null) { dir = this.options.smartIndent ? "smart" : "prev"; } + else { dir = dir ? "add" : "subtract"; } + } + if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive); } + }), + indentSelection: methodOp(function(how) { + var this$1 = this; + + var ranges = this.doc.sel.ranges, end = -1; + for (var i = 0; i < ranges.length; i++) { + var range$$1 = ranges[i]; + if (!range$$1.empty()) { + var from = range$$1.from(), to = range$$1.to(); + var start = Math.max(end, from.line); + end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1; + for (var j = start; j < end; ++j) + { indentLine(this$1, j, how); } + var newRanges = this$1.doc.sel.ranges; + if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0) + { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll); } + } else if (range$$1.head.line > end) { + indentLine(this$1, range$$1.head.line, how, true); + end = range$$1.head.line; + if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1); } + } + } + }), + + // Fetch the parser token for a given character. Useful for hacks + // that want to inspect the mode state (say, for completion). + getTokenAt: function(pos, precise) { + return takeToken(this, pos, precise) + }, + + getLineTokens: function(line, precise) { + return takeToken(this, Pos(line), precise, true) + }, + + getTokenTypeAt: function(pos) { + pos = clipPos(this.doc, pos); + var styles = getLineStyles(this, getLine(this.doc, pos.line)); + var before = 0, after = (styles.length - 1) / 2, ch = pos.ch; + var type; + if (ch == 0) { type = styles[2]; } + else { for (;;) { + var mid = (before + after) >> 1; + if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid; } + else if (styles[mid * 2 + 1] < ch) { before = mid + 1; } + else { type = styles[mid * 2 + 2]; break } + } } + var cut = type ? type.indexOf("overlay ") : -1; + return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1) + }, + + getModeAt: function(pos) { + var mode = this.doc.mode; + if (!mode.innerMode) { return mode } + return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode + }, + + getHelper: function(pos, type) { + return this.getHelpers(pos, type)[0] + }, + + getHelpers: function(pos, type) { + var this$1 = this; + + var found = []; + if (!helpers.hasOwnProperty(type)) { return found } + var help = helpers[type], mode = this.getModeAt(pos); + if (typeof mode[type] == "string") { + if (help[mode[type]]) { found.push(help[mode[type]]); } + } else if (mode[type]) { + for (var i = 0; i < mode[type].length; i++) { + var val = help[mode[type][i]]; + if (val) { found.push(val); } + } + } else if (mode.helperType && help[mode.helperType]) { + found.push(help[mode.helperType]); + } else if (help[mode.name]) { + found.push(help[mode.name]); + } + for (var i$1 = 0; i$1 < help._global.length; i$1++) { + var cur = help._global[i$1]; + if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1) + { found.push(cur.val); } + } + return found + }, + + getStateAfter: function(line, precise) { + var doc = this.doc; + line = clipLine(doc, line == null ? doc.first + doc.size - 1: line); + return getContextBefore(this, line + 1, precise).state + }, + + cursorCoords: function(start, mode) { + var pos, range$$1 = this.doc.sel.primary(); + if (start == null) { pos = range$$1.head; } + else if (typeof start == "object") { pos = clipPos(this.doc, start); } + else { pos = start ? range$$1.from() : range$$1.to(); } + return cursorCoords(this, pos, mode || "page") + }, + + charCoords: function(pos, mode) { + return charCoords(this, clipPos(this.doc, pos), mode || "page") + }, + + coordsChar: function(coords, mode) { + coords = fromCoordSystem(this, coords, mode || "page"); + return coordsChar(this, coords.left, coords.top) + }, + + lineAtHeight: function(height, mode) { + height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top; + return lineAtHeight(this.doc, height + this.display.viewOffset) + }, + heightAtLine: function(line, mode, includeWidgets) { + var end = false, lineObj; + if (typeof line == "number") { + var last = this.doc.first + this.doc.size - 1; + if (line < this.doc.first) { line = this.doc.first; } + else if (line > last) { line = last; end = true; } + lineObj = getLine(this.doc, line); + } else { + lineObj = line; + } + return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page", includeWidgets || end).top + + (end ? this.doc.height - heightAtLine(lineObj) : 0) + }, + + defaultTextHeight: function() { return textHeight(this.display) }, + defaultCharWidth: function() { return charWidth(this.display) }, + + getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}}, + + addWidget: function(pos, node, scroll, vert, horiz) { + var display = this.display; + pos = cursorCoords(this, clipPos(this.doc, pos)); + var top = pos.bottom, left = pos.left; + node.style.position = "absolute"; + node.setAttribute("cm-ignore-events", "true"); + this.display.input.setUneditable(node); + display.sizer.appendChild(node); + if (vert == "over") { + top = pos.top; + } else if (vert == "above" || vert == "near") { + var vspace = Math.max(display.wrapper.clientHeight, this.doc.height), + hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth); + // Default to positioning above (if specified and possible); otherwise default to positioning below + if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight) + { top = pos.top - node.offsetHeight; } + else if (pos.bottom + node.offsetHeight <= vspace) + { top = pos.bottom; } + if (left + node.offsetWidth > hspace) + { left = hspace - node.offsetWidth; } + } + node.style.top = top + "px"; + node.style.left = node.style.right = ""; + if (horiz == "right") { + left = display.sizer.clientWidth - node.offsetWidth; + node.style.right = "0px"; + } else { + if (horiz == "left") { left = 0; } + else if (horiz == "middle") { left = (display.sizer.clientWidth - node.offsetWidth) / 2; } + node.style.left = left + "px"; + } + if (scroll) + { scrollIntoView(this, {left: left, top: top, right: left + node.offsetWidth, bottom: top + node.offsetHeight}); } + }, + + triggerOnKeyDown: methodOp(onKeyDown), + triggerOnKeyPress: methodOp(onKeyPress), + triggerOnKeyUp: onKeyUp, + triggerOnMouseDown: methodOp(onMouseDown), + + execCommand: function(cmd) { + if (commands.hasOwnProperty(cmd)) + { return commands[cmd].call(null, this) } + }, + + triggerElectric: methodOp(function(text) { triggerElectric(this, text); }), + + findPosH: function(from, amount, unit, visually) { + var this$1 = this; + + var dir = 1; + if (amount < 0) { dir = -1; amount = -amount; } + var cur = clipPos(this.doc, from); + for (var i = 0; i < amount; ++i) { + cur = findPosH(this$1.doc, cur, dir, unit, visually); + if (cur.hitSide) { break } + } + return cur + }, + + moveH: methodOp(function(dir, unit) { + var this$1 = this; + + this.extendSelectionsBy(function (range$$1) { + if (this$1.display.shift || this$1.doc.extend || range$$1.empty()) + { return findPosH(this$1.doc, range$$1.head, dir, unit, this$1.options.rtlMoveVisually) } + else + { return dir < 0 ? range$$1.from() : range$$1.to() } + }, sel_move); + }), + + deleteH: methodOp(function(dir, unit) { + var sel = this.doc.sel, doc = this.doc; + if (sel.somethingSelected()) + { doc.replaceSelection("", null, "+delete"); } + else + { deleteNearSelection(this, function (range$$1) { + var other = findPosH(doc, range$$1.head, dir, unit, false); + return dir < 0 ? {from: other, to: range$$1.head} : {from: range$$1.head, to: other} + }); } + }), + + findPosV: function(from, amount, unit, goalColumn) { + var this$1 = this; + + var dir = 1, x = goalColumn; + if (amount < 0) { dir = -1; amount = -amount; } + var cur = clipPos(this.doc, from); + for (var i = 0; i < amount; ++i) { + var coords = cursorCoords(this$1, cur, "div"); + if (x == null) { x = coords.left; } + else { coords.left = x; } + cur = findPosV(this$1, coords, dir, unit); + if (cur.hitSide) { break } + } + return cur + }, + + moveV: methodOp(function(dir, unit) { + var this$1 = this; + + var doc = this.doc, goals = []; + var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected(); + doc.extendSelectionsBy(function (range$$1) { + if (collapse) + { return dir < 0 ? range$$1.from() : range$$1.to() } + var headPos = cursorCoords(this$1, range$$1.head, "div"); + if (range$$1.goalColumn != null) { headPos.left = range$$1.goalColumn; } + goals.push(headPos.left); + var pos = findPosV(this$1, headPos, dir, unit); + if (unit == "page" && range$$1 == doc.sel.primary()) + { addToScrollTop(this$1, charCoords(this$1, pos, "div").top - headPos.top); } + return pos + }, sel_move); + if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++) + { doc.sel.ranges[i].goalColumn = goals[i]; } } + }), + + // Find the word at the given position (as returned by coordsChar). + findWordAt: function(pos) { + var doc = this.doc, line = getLine(doc, pos.line).text; + var start = pos.ch, end = pos.ch; + if (line) { + var helper = this.getHelper(pos, "wordChars"); + if ((pos.sticky == "before" || end == line.length) && start) { --start; } else { ++end; } + var startChar = line.charAt(start); + var check = isWordChar(startChar, helper) + ? function (ch) { return isWordChar(ch, helper); } + : /\s/.test(startChar) ? function (ch) { return /\s/.test(ch); } + : function (ch) { return (!/\s/.test(ch) && !isWordChar(ch)); }; + while (start > 0 && check(line.charAt(start - 1))) { --start; } + while (end < line.length && check(line.charAt(end))) { ++end; } + } + return new Range(Pos(pos.line, start), Pos(pos.line, end)) + }, + + toggleOverwrite: function(value) { + if (value != null && value == this.state.overwrite) { return } + if (this.state.overwrite = !this.state.overwrite) + { addClass(this.display.cursorDiv, "CodeMirror-overwrite"); } + else + { rmClass(this.display.cursorDiv, "CodeMirror-overwrite"); } + + signal(this, "overwriteToggle", this, this.state.overwrite); + }, + hasFocus: function() { return this.display.input.getField() == activeElt() }, + isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) }, + + scrollTo: methodOp(function (x, y) { scrollToCoords(this, x, y); }), + getScrollInfo: function() { + var scroller = this.display.scroller; + return {left: scroller.scrollLeft, top: scroller.scrollTop, + height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight, + width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth, + clientHeight: displayHeight(this), clientWidth: displayWidth(this)} + }, + + scrollIntoView: methodOp(function(range$$1, margin) { + if (range$$1 == null) { + range$$1 = {from: this.doc.sel.primary().head, to: null}; + if (margin == null) { margin = this.options.cursorScrollMargin; } + } else if (typeof range$$1 == "number") { + range$$1 = {from: Pos(range$$1, 0), to: null}; + } else if (range$$1.from == null) { + range$$1 = {from: range$$1, to: null}; + } + if (!range$$1.to) { range$$1.to = range$$1.from; } + range$$1.margin = margin || 0; + + if (range$$1.from.line != null) { + scrollToRange(this, range$$1); + } else { + scrollToCoordsRange(this, range$$1.from, range$$1.to, range$$1.margin); + } + }), + + setSize: methodOp(function(width, height) { + var this$1 = this; + + var interpret = function (val) { return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val; }; + if (width != null) { this.display.wrapper.style.width = interpret(width); } + if (height != null) { this.display.wrapper.style.height = interpret(height); } + if (this.options.lineWrapping) { clearLineMeasurementCache(this); } + var lineNo$$1 = this.display.viewFrom; + this.doc.iter(lineNo$$1, this.display.viewTo, function (line) { + if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) + { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo$$1, "widget"); break } } } + ++lineNo$$1; + }); + this.curOp.forceUpdate = true; + signal(this, "refresh", this); + }), + + operation: function(f){return runInOp(this, f)}, + startOperation: function(){return startOperation(this)}, + endOperation: function(){return endOperation(this)}, + + refresh: methodOp(function() { + var oldHeight = this.display.cachedTextHeight; + regChange(this); + this.curOp.forceUpdate = true; + clearCaches(this); + scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop); + updateGutterSpace(this); + if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5) + { estimateLineHeights(this); } + signal(this, "refresh", this); + }), + + swapDoc: methodOp(function(doc) { + var old = this.doc; + old.cm = null; + attachDoc(this, doc); + clearCaches(this); + this.display.input.reset(); + scrollToCoords(this, doc.scrollLeft, doc.scrollTop); + this.curOp.forceScroll = true; + signalLater(this, "swapDoc", this, old); + return old + }), + + getInputField: function(){return this.display.input.getField()}, + getWrapperElement: function(){return this.display.wrapper}, + getScrollerElement: function(){return this.display.scroller}, + getGutterElement: function(){return this.display.gutters} + }; + eventMixin(CodeMirror); + + CodeMirror.registerHelper = function(type, name, value) { + if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []}; } + helpers[type][name] = value; + }; + CodeMirror.registerGlobalHelper = function(type, name, predicate, value) { + CodeMirror.registerHelper(type, name, value); + helpers[type]._global.push({pred: predicate, val: value}); + }; +}; + +// Used for horizontal relative motion. Dir is -1 or 1 (left or +// right), unit can be "char", "column" (like char, but doesn't +// cross line boundaries), "word" (across next word), or "group" (to +// the start of next group of word or non-word-non-whitespace +// chars). The visually param controls whether, in right-to-left +// text, direction 1 means to move towards the next index in the +// string, or towards the character to the right of the current +// position. The resulting position will have a hitSide=true +// property if it reached the end of the document. +function findPosH(doc, pos, dir, unit, visually) { + var oldPos = pos; + var origDir = dir; + var lineObj = getLine(doc, pos.line); + function findNextLine() { + var l = pos.line + dir; + if (l < doc.first || l >= doc.first + doc.size) { return false } + pos = new Pos(l, pos.ch, pos.sticky); + return lineObj = getLine(doc, l) + } + function moveOnce(boundToLine) { + var next; + if (visually) { + next = moveVisually(doc.cm, lineObj, pos, dir); + } else { + next = moveLogically(lineObj, pos, dir); + } + if (next == null) { + if (!boundToLine && findNextLine()) + { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir); } + else + { return false } + } else { + pos = next; + } + return true + } + + if (unit == "char") { + moveOnce(); + } else if (unit == "column") { + moveOnce(true); + } else if (unit == "word" || unit == "group") { + var sawType = null, group = unit == "group"; + var helper = doc.cm && doc.cm.getHelper(pos, "wordChars"); + for (var first = true;; first = false) { + if (dir < 0 && !moveOnce(!first)) { break } + var cur = lineObj.text.charAt(pos.ch) || "\n"; + var type = isWordChar(cur, helper) ? "w" + : group && cur == "\n" ? "n" + : !group || /\s/.test(cur) ? null + : "p"; + if (group && !first && !type) { type = "s"; } + if (sawType && sawType != type) { + if (dir < 0) {dir = 1; moveOnce(); pos.sticky = "after";} + break + } + + if (type) { sawType = type; } + if (dir > 0 && !moveOnce(!first)) { break } + } + } + var result = skipAtomic(doc, pos, oldPos, origDir, true); + if (equalCursorPos(oldPos, result)) { result.hitSide = true; } + return result +} + +// For relative vertical movement. Dir may be -1 or 1. Unit can be +// "page" or "line". The resulting position will have a hitSide=true +// property if it reached the end of the document. +function findPosV(cm, pos, dir, unit) { + var doc = cm.doc, x = pos.left, y; + if (unit == "page") { + var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight); + var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3); + y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount; + + } else if (unit == "line") { + y = dir > 0 ? pos.bottom + 3 : pos.top - 3; + } + var target; + for (;;) { + target = coordsChar(cm, x, y); + if (!target.outside) { break } + if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break } + y += dir * 5; + } + return target +} + +// CONTENTEDITABLE INPUT STYLE + +var ContentEditableInput = function(cm) { + this.cm = cm; + this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null; + this.polling = new Delayed(); + this.composing = null; + this.gracePeriod = false; + this.readDOMTimeout = null; +}; + +ContentEditableInput.prototype.init = function (display) { + var this$1 = this; + + var input = this, cm = input.cm; + var div = input.div = display.lineDiv; + disableBrowserMagic(div, cm.options.spellcheck); + + on(div, "paste", function (e) { + if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return } + // IE doesn't fire input events, so we schedule a read for the pasted content in this way + if (ie_version <= 11) { setTimeout(operation(cm, function () { return this$1.updateFromDOM(); }), 20); } + }); + + on(div, "compositionstart", function (e) { + this$1.composing = {data: e.data, done: false}; + }); + on(div, "compositionupdate", function (e) { + if (!this$1.composing) { this$1.composing = {data: e.data, done: false}; } + }); + on(div, "compositionend", function (e) { + if (this$1.composing) { + if (e.data != this$1.composing.data) { this$1.readFromDOMSoon(); } + this$1.composing.done = true; + } + }); + + on(div, "touchstart", function () { return input.forceCompositionEnd(); }); + + on(div, "input", function () { + if (!this$1.composing) { this$1.readFromDOMSoon(); } + }); + + function onCopyCut(e) { + if (signalDOMEvent(cm, e)) { return } + if (cm.somethingSelected()) { + setLastCopied({lineWise: false, text: cm.getSelections()}); + if (e.type == "cut") { cm.replaceSelection("", null, "cut"); } + } else if (!cm.options.lineWiseCopyCut) { + return + } else { + var ranges = copyableRanges(cm); + setLastCopied({lineWise: true, text: ranges.text}); + if (e.type == "cut") { + cm.operation(function () { + cm.setSelections(ranges.ranges, 0, sel_dontScroll); + cm.replaceSelection("", null, "cut"); + }); + } + } + if (e.clipboardData) { + e.clipboardData.clearData(); + var content = lastCopied.text.join("\n"); + // iOS exposes the clipboard API, but seems to discard content inserted into it + e.clipboardData.setData("Text", content); + if (e.clipboardData.getData("Text") == content) { + e.preventDefault(); + return + } + } + // Old-fashioned briefly-focus-a-textarea hack + var kludge = hiddenTextarea(), te = kludge.firstChild; + cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild); + te.value = lastCopied.text.join("\n"); + var hadFocus = document.activeElement; + selectInput(te); + setTimeout(function () { + cm.display.lineSpace.removeChild(kludge); + hadFocus.focus(); + if (hadFocus == div) { input.showPrimarySelection(); } + }, 50); + } + on(div, "copy", onCopyCut); + on(div, "cut", onCopyCut); +}; + +ContentEditableInput.prototype.prepareSelection = function () { + var result = prepareSelection(this.cm, false); + result.focus = this.cm.state.focused; + return result +}; + +ContentEditableInput.prototype.showSelection = function (info, takeFocus) { + if (!info || !this.cm.display.view.length) { return } + if (info.focus || takeFocus) { this.showPrimarySelection(); } + this.showMultipleSelections(info); +}; + +ContentEditableInput.prototype.getSelection = function () { + return this.cm.display.wrapper.ownerDocument.getSelection() +}; + +ContentEditableInput.prototype.showPrimarySelection = function () { + var sel = this.getSelection(), cm = this.cm, prim = cm.doc.sel.primary(); + var from = prim.from(), to = prim.to(); + + if (cm.display.viewTo == cm.display.viewFrom || from.line >= cm.display.viewTo || to.line < cm.display.viewFrom) { + sel.removeAllRanges(); + return + } + + var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset); + var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset); + if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad && + cmp(minPos(curAnchor, curFocus), from) == 0 && + cmp(maxPos(curAnchor, curFocus), to) == 0) + { return } + + var view = cm.display.view; + var start = (from.line >= cm.display.viewFrom && posToDOM(cm, from)) || + {node: view[0].measure.map[2], offset: 0}; + var end = to.line < cm.display.viewTo && posToDOM(cm, to); + if (!end) { + var measure = view[view.length - 1].measure; + var map$$1 = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map; + end = {node: map$$1[map$$1.length - 1], offset: map$$1[map$$1.length - 2] - map$$1[map$$1.length - 3]}; + } + + if (!start || !end) { + sel.removeAllRanges(); + return + } + + var old = sel.rangeCount && sel.getRangeAt(0), rng; + try { rng = range(start.node, start.offset, end.offset, end.node); } + catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible + if (rng) { + if (!gecko && cm.state.focused) { + sel.collapse(start.node, start.offset); + if (!rng.collapsed) { + sel.removeAllRanges(); + sel.addRange(rng); + } + } else { + sel.removeAllRanges(); + sel.addRange(rng); + } + if (old && sel.anchorNode == null) { sel.addRange(old); } + else if (gecko) { this.startGracePeriod(); } + } + this.rememberSelection(); +}; + +ContentEditableInput.prototype.startGracePeriod = function () { + var this$1 = this; + + clearTimeout(this.gracePeriod); + this.gracePeriod = setTimeout(function () { + this$1.gracePeriod = false; + if (this$1.selectionChanged()) + { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }); } + }, 20); +}; + +ContentEditableInput.prototype.showMultipleSelections = function (info) { + removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors); + removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection); +}; + +ContentEditableInput.prototype.rememberSelection = function () { + var sel = this.getSelection(); + this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset; + this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset; +}; + +ContentEditableInput.prototype.selectionInEditor = function () { + var sel = this.getSelection(); + if (!sel.rangeCount) { return false } + var node = sel.getRangeAt(0).commonAncestorContainer; + return contains(this.div, node) +}; + +ContentEditableInput.prototype.focus = function () { + if (this.cm.options.readOnly != "nocursor") { + if (!this.selectionInEditor()) + { this.showSelection(this.prepareSelection(), true); } + this.div.focus(); + } +}; +ContentEditableInput.prototype.blur = function () { this.div.blur(); }; +ContentEditableInput.prototype.getField = function () { return this.div }; + +ContentEditableInput.prototype.supportsTouch = function () { return true }; + +ContentEditableInput.prototype.receivedFocus = function () { + var input = this; + if (this.selectionInEditor()) + { this.pollSelection(); } + else + { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }); } + + function poll() { + if (input.cm.state.focused) { + input.pollSelection(); + input.polling.set(input.cm.options.pollInterval, poll); + } + } + this.polling.set(this.cm.options.pollInterval, poll); +}; + +ContentEditableInput.prototype.selectionChanged = function () { + var sel = this.getSelection(); + return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset || + sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset +}; + +ContentEditableInput.prototype.pollSelection = function () { + if (this.readDOMTimeout != null || this.gracePeriod || !this.selectionChanged()) { return } + var sel = this.getSelection(), cm = this.cm; + // On Android Chrome (version 56, at least), backspacing into an + // uneditable block element will put the cursor in that element, + // and then, because it's not editable, hide the virtual keyboard. + // Because Android doesn't allow us to actually detect backspace + // presses in a sane way, this code checks for when that happens + // and simulates a backspace press in this case. + if (android && chrome && this.cm.options.gutters.length && isInGutter(sel.anchorNode)) { + this.cm.triggerOnKeyDown({type: "keydown", keyCode: 8, preventDefault: Math.abs}); + this.blur(); + this.focus(); + return + } + if (this.composing) { return } + this.rememberSelection(); + var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset); + var head = domToPos(cm, sel.focusNode, sel.focusOffset); + if (anchor && head) { runInOp(cm, function () { + setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll); + if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true; } + }); } +}; + +ContentEditableInput.prototype.pollContent = function () { + if (this.readDOMTimeout != null) { + clearTimeout(this.readDOMTimeout); + this.readDOMTimeout = null; + } + + var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary(); + var from = sel.from(), to = sel.to(); + if (from.ch == 0 && from.line > cm.firstLine()) + { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length); } + if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine()) + { to = Pos(to.line + 1, 0); } + if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false } + + var fromIndex, fromLine, fromNode; + if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) { + fromLine = lineNo(display.view[0].line); + fromNode = display.view[0].node; + } else { + fromLine = lineNo(display.view[fromIndex].line); + fromNode = display.view[fromIndex - 1].node.nextSibling; + } + var toIndex = findViewIndex(cm, to.line); + var toLine, toNode; + if (toIndex == display.view.length - 1) { + toLine = display.viewTo - 1; + toNode = display.lineDiv.lastChild; + } else { + toLine = lineNo(display.view[toIndex + 1].line) - 1; + toNode = display.view[toIndex + 1].node.previousSibling; + } + + if (!fromNode) { return false } + var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine)); + var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length)); + while (newText.length > 1 && oldText.length > 1) { + if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; } + else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; } + else { break } + } + + var cutFront = 0, cutEnd = 0; + var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length); + while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront)) + { ++cutFront; } + var newBot = lst(newText), oldBot = lst(oldText); + var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0), + oldBot.length - (oldText.length == 1 ? cutFront : 0)); + while (cutEnd < maxCutEnd && + newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) + { ++cutEnd; } + // Try to move start of change to start of selection if ambiguous + if (newText.length == 1 && oldText.length == 1 && fromLine == from.line) { + while (cutFront && cutFront > from.ch && + newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) { + cutFront--; + cutEnd++; + } + } + + newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\u200b+/, ""); + newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, ""); + + var chFrom = Pos(fromLine, cutFront); + var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0); + if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) { + replaceRange(cm.doc, newText, chFrom, chTo, "+input"); + return true + } +}; + +ContentEditableInput.prototype.ensurePolled = function () { + this.forceCompositionEnd(); +}; +ContentEditableInput.prototype.reset = function () { + this.forceCompositionEnd(); +}; +ContentEditableInput.prototype.forceCompositionEnd = function () { + if (!this.composing) { return } + clearTimeout(this.readDOMTimeout); + this.composing = null; + this.updateFromDOM(); + this.div.blur(); + this.div.focus(); +}; +ContentEditableInput.prototype.readFromDOMSoon = function () { + var this$1 = this; + + if (this.readDOMTimeout != null) { return } + this.readDOMTimeout = setTimeout(function () { + this$1.readDOMTimeout = null; + if (this$1.composing) { + if (this$1.composing.done) { this$1.composing = null; } + else { return } + } + this$1.updateFromDOM(); + }, 80); +}; + +ContentEditableInput.prototype.updateFromDOM = function () { + var this$1 = this; + + if (this.cm.isReadOnly() || !this.pollContent()) + { runInOp(this.cm, function () { return regChange(this$1.cm); }); } +}; + +ContentEditableInput.prototype.setUneditable = function (node) { + node.contentEditable = "false"; +}; + +ContentEditableInput.prototype.onKeyPress = function (e) { + if (e.charCode == 0 || this.composing) { return } + e.preventDefault(); + if (!this.cm.isReadOnly()) + { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0); } +}; + +ContentEditableInput.prototype.readOnlyChanged = function (val) { + this.div.contentEditable = String(val != "nocursor"); +}; + +ContentEditableInput.prototype.onContextMenu = function () {}; +ContentEditableInput.prototype.resetPosition = function () {}; + +ContentEditableInput.prototype.needsContentAttribute = true; + +function posToDOM(cm, pos) { + var view = findViewForLine(cm, pos.line); + if (!view || view.hidden) { return null } + var line = getLine(cm.doc, pos.line); + var info = mapFromLineView(view, line, pos.line); + + var order = getOrder(line, cm.doc.direction), side = "left"; + if (order) { + var partPos = getBidiPartAt(order, pos.ch); + side = partPos % 2 ? "right" : "left"; + } + var result = nodeAndOffsetInLineMap(info.map, pos.ch, side); + result.offset = result.collapse == "right" ? result.end : result.start; + return result +} + +function isInGutter(node) { + for (var scan = node; scan; scan = scan.parentNode) + { if (/CodeMirror-gutter-wrapper/.test(scan.className)) { return true } } + return false +} + +function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos } + +function domTextBetween(cm, from, to, fromLine, toLine) { + var text = "", closing = false, lineSep = cm.doc.lineSeparator(), extraLinebreak = false; + function recognizeMarker(id) { return function (marker) { return marker.id == id; } } + function close() { + if (closing) { + text += lineSep; + if (extraLinebreak) { text += lineSep; } + closing = extraLinebreak = false; + } + } + function addText(str) { + if (str) { + close(); + text += str; + } + } + function walk(node) { + if (node.nodeType == 1) { + var cmText = node.getAttribute("cm-text"); + if (cmText) { + addText(cmText); + return + } + var markerID = node.getAttribute("cm-marker"), range$$1; + if (markerID) { + var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID)); + if (found.length && (range$$1 = found[0].find(0))) + { addText(getBetween(cm.doc, range$$1.from, range$$1.to).join(lineSep)); } + return + } + if (node.getAttribute("contenteditable") == "false") { return } + var isBlock = /^(pre|div|p|li|table|br)$/i.test(node.nodeName); + if (!/^br$/i.test(node.nodeName) && node.textContent.length == 0) { return } + + if (isBlock) { close(); } + for (var i = 0; i < node.childNodes.length; i++) + { walk(node.childNodes[i]); } + + if (/^(pre|p)$/i.test(node.nodeName)) { extraLinebreak = true; } + if (isBlock) { closing = true; } + } else if (node.nodeType == 3) { + addText(node.nodeValue.replace(/\u200b/g, "").replace(/\u00a0/g, " ")); + } + } + for (;;) { + walk(from); + if (from == to) { break } + from = from.nextSibling; + extraLinebreak = false; + } + return text +} + +function domToPos(cm, node, offset) { + var lineNode; + if (node == cm.display.lineDiv) { + lineNode = cm.display.lineDiv.childNodes[offset]; + if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) } + node = null; offset = 0; + } else { + for (lineNode = node;; lineNode = lineNode.parentNode) { + if (!lineNode || lineNode == cm.display.lineDiv) { return null } + if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break } + } + } + for (var i = 0; i < cm.display.view.length; i++) { + var lineView = cm.display.view[i]; + if (lineView.node == lineNode) + { return locateNodeInLineView(lineView, node, offset) } + } +} + +function locateNodeInLineView(lineView, node, offset) { + var wrapper = lineView.text.firstChild, bad = false; + if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) } + if (node == wrapper) { + bad = true; + node = wrapper.childNodes[offset]; + offset = 0; + if (!node) { + var line = lineView.rest ? lst(lineView.rest) : lineView.line; + return badPos(Pos(lineNo(line), line.text.length), bad) + } + } + + var textNode = node.nodeType == 3 ? node : null, topNode = node; + if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) { + textNode = node.firstChild; + if (offset) { offset = textNode.nodeValue.length; } + } + while (topNode.parentNode != wrapper) { topNode = topNode.parentNode; } + var measure = lineView.measure, maps = measure.maps; + + function find(textNode, topNode, offset) { + for (var i = -1; i < (maps ? maps.length : 0); i++) { + var map$$1 = i < 0 ? measure.map : maps[i]; + for (var j = 0; j < map$$1.length; j += 3) { + var curNode = map$$1[j + 2]; + if (curNode == textNode || curNode == topNode) { + var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]); + var ch = map$$1[j] + offset; + if (offset < 0 || curNode != textNode) { ch = map$$1[j + (offset ? 1 : 0)]; } + return Pos(line, ch) + } + } + } + } + var found = find(textNode, topNode, offset); + if (found) { return badPos(found, bad) } + + // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems + for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) { + found = find(after, after.firstChild, 0); + if (found) + { return badPos(Pos(found.line, found.ch - dist), bad) } + else + { dist += after.textContent.length; } + } + for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) { + found = find(before, before.firstChild, -1); + if (found) + { return badPos(Pos(found.line, found.ch + dist$1), bad) } + else + { dist$1 += before.textContent.length; } + } +} + +// TEXTAREA INPUT STYLE + +var TextareaInput = function(cm) { + this.cm = cm; + // See input.poll and input.reset + this.prevInput = ""; + + // Flag that indicates whether we expect input to appear real soon + // now (after some event like 'keypress' or 'input') and are + // polling intensively. + this.pollingFast = false; + // Self-resetting timeout for the poller + this.polling = new Delayed(); + // Used to work around IE issue with selection being forgotten when focus moves away from textarea + this.hasSelection = false; + this.composing = null; +}; + +TextareaInput.prototype.init = function (display) { + var this$1 = this; + + var input = this, cm = this.cm; + this.createField(display); + var te = this.textarea; + + display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild); + + // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore) + if (ios) { te.style.width = "0px"; } + + on(te, "input", function () { + if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null; } + input.poll(); + }); + + on(te, "paste", function (e) { + if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return } + + cm.state.pasteIncoming = true; + input.fastPoll(); + }); + + function prepareCopyCut(e) { + if (signalDOMEvent(cm, e)) { return } + if (cm.somethingSelected()) { + setLastCopied({lineWise: false, text: cm.getSelections()}); + } else if (!cm.options.lineWiseCopyCut) { + return + } else { + var ranges = copyableRanges(cm); + setLastCopied({lineWise: true, text: ranges.text}); + if (e.type == "cut") { + cm.setSelections(ranges.ranges, null, sel_dontScroll); + } else { + input.prevInput = ""; + te.value = ranges.text.join("\n"); + selectInput(te); + } + } + if (e.type == "cut") { cm.state.cutIncoming = true; } + } + on(te, "cut", prepareCopyCut); + on(te, "copy", prepareCopyCut); + + on(display.scroller, "paste", function (e) { + if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return } + cm.state.pasteIncoming = true; + input.focus(); + }); + + // Prevent normal selection in the editor (we handle our own) + on(display.lineSpace, "selectstart", function (e) { + if (!eventInWidget(display, e)) { e_preventDefault(e); } + }); + + on(te, "compositionstart", function () { + var start = cm.getCursor("from"); + if (input.composing) { input.composing.range.clear(); } + input.composing = { + start: start, + range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"}) + }; + }); + on(te, "compositionend", function () { + if (input.composing) { + input.poll(); + input.composing.range.clear(); + input.composing = null; + } + }); +}; + +TextareaInput.prototype.createField = function (_display) { + // Wraps and hides input textarea + this.wrapper = hiddenTextarea(); + // The semihidden textarea that is focused when the editor is + // focused, and receives input. + this.textarea = this.wrapper.firstChild; +}; + +TextareaInput.prototype.prepareSelection = function () { + // Redraw the selection and/or cursor + var cm = this.cm, display = cm.display, doc = cm.doc; + var result = prepareSelection(cm); + + // Move the hidden textarea near the cursor to prevent scrolling artifacts + if (cm.options.moveInputWithCursor) { + var headPos = cursorCoords(cm, doc.sel.primary().head, "div"); + var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect(); + result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10, + headPos.top + lineOff.top - wrapOff.top)); + result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10, + headPos.left + lineOff.left - wrapOff.left)); + } + + return result +}; + +TextareaInput.prototype.showSelection = function (drawn) { + var cm = this.cm, display = cm.display; + removeChildrenAndAdd(display.cursorDiv, drawn.cursors); + removeChildrenAndAdd(display.selectionDiv, drawn.selection); + if (drawn.teTop != null) { + this.wrapper.style.top = drawn.teTop + "px"; + this.wrapper.style.left = drawn.teLeft + "px"; + } +}; + +// Reset the input to correspond to the selection (or to be empty, +// when not typing and nothing is selected) +TextareaInput.prototype.reset = function (typing) { + if (this.contextMenuPending || this.composing) { return } + var cm = this.cm; + if (cm.somethingSelected()) { + this.prevInput = ""; + var content = cm.getSelection(); + this.textarea.value = content; + if (cm.state.focused) { selectInput(this.textarea); } + if (ie && ie_version >= 9) { this.hasSelection = content; } + } else if (!typing) { + this.prevInput = this.textarea.value = ""; + if (ie && ie_version >= 9) { this.hasSelection = null; } + } +}; + +TextareaInput.prototype.getField = function () { return this.textarea }; + +TextareaInput.prototype.supportsTouch = function () { return false }; + +TextareaInput.prototype.focus = function () { + if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) { + try { this.textarea.focus(); } + catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM + } +}; + +TextareaInput.prototype.blur = function () { this.textarea.blur(); }; + +TextareaInput.prototype.resetPosition = function () { + this.wrapper.style.top = this.wrapper.style.left = 0; +}; + +TextareaInput.prototype.receivedFocus = function () { this.slowPoll(); }; + +// Poll for input changes, using the normal rate of polling. This +// runs as long as the editor is focused. +TextareaInput.prototype.slowPoll = function () { + var this$1 = this; + + if (this.pollingFast) { return } + this.polling.set(this.cm.options.pollInterval, function () { + this$1.poll(); + if (this$1.cm.state.focused) { this$1.slowPoll(); } + }); +}; + +// When an event has just come in that is likely to add or change +// something in the input textarea, we poll faster, to ensure that +// the change appears on the screen quickly. +TextareaInput.prototype.fastPoll = function () { + var missed = false, input = this; + input.pollingFast = true; + function p() { + var changed = input.poll(); + if (!changed && !missed) {missed = true; input.polling.set(60, p);} + else {input.pollingFast = false; input.slowPoll();} + } + input.polling.set(20, p); +}; + +// Read input from the textarea, and update the document to match. +// When something is selected, it is present in the textarea, and +// selected (unless it is huge, in which case a placeholder is +// used). When nothing is selected, the cursor sits after previously +// seen text (can be empty), which is stored in prevInput (we must +// not reset the textarea when typing, because that breaks IME). +TextareaInput.prototype.poll = function () { + var this$1 = this; + + var cm = this.cm, input = this.textarea, prevInput = this.prevInput; + // Since this is called a *lot*, try to bail out as cheaply as + // possible when it is clear that nothing happened. hasSelection + // will be the case when there is a lot of text in the textarea, + // in which case reading its value would be expensive. + if (this.contextMenuPending || !cm.state.focused || + (hasSelection(input) && !prevInput && !this.composing) || + cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq) + { return false } + + var text = input.value; + // If nothing changed, bail. + if (text == prevInput && !cm.somethingSelected()) { return false } + // Work around nonsensical selection resetting in IE9/10, and + // inexplicable appearance of private area unicode characters on + // some key combos in Mac (#2689). + if (ie && ie_version >= 9 && this.hasSelection === text || + mac && /[\uf700-\uf7ff]/.test(text)) { + cm.display.input.reset(); + return false + } + + if (cm.doc.sel == cm.display.selForContextMenu) { + var first = text.charCodeAt(0); + if (first == 0x200b && !prevInput) { prevInput = "\u200b"; } + if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") } + } + // Find the part of the input that is actually new + var same = 0, l = Math.min(prevInput.length, text.length); + while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same; } + + runInOp(cm, function () { + applyTextInput(cm, text.slice(same), prevInput.length - same, + null, this$1.composing ? "*compose" : null); + + // Don't leave long text in the textarea, since it makes further polling slow + if (text.length > 1000 || text.indexOf("\n") > -1) { input.value = this$1.prevInput = ""; } + else { this$1.prevInput = text; } + + if (this$1.composing) { + this$1.composing.range.clear(); + this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor("to"), + {className: "CodeMirror-composing"}); + } + }); + return true +}; + +TextareaInput.prototype.ensurePolled = function () { + if (this.pollingFast && this.poll()) { this.pollingFast = false; } +}; + +TextareaInput.prototype.onKeyPress = function () { + if (ie && ie_version >= 9) { this.hasSelection = null; } + this.fastPoll(); +}; + +TextareaInput.prototype.onContextMenu = function (e) { + var input = this, cm = input.cm, display = cm.display, te = input.textarea; + var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop; + if (!pos || presto) { return } // Opera is difficult. + + // Reset the current text selection only if the click is done outside of the selection + // and 'resetSelectionOnContextMenu' option is true. + var reset = cm.options.resetSelectionOnContextMenu; + if (reset && cm.doc.sel.contains(pos) == -1) + { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll); } + + var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText; + input.wrapper.style.cssText = "position: absolute"; + var wrapperBox = input.wrapper.getBoundingClientRect(); + te.style.cssText = "position: absolute; width: 30px; height: 30px;\n top: " + (e.clientY - wrapperBox.top - 5) + "px; left: " + (e.clientX - wrapperBox.left - 5) + "px;\n z-index: 1000; background: " + (ie ? "rgba(255, 255, 255, .05)" : "transparent") + ";\n outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);"; + var oldScrollY; + if (webkit) { oldScrollY = window.scrollY; } // Work around Chrome issue (#2712) + display.input.focus(); + if (webkit) { window.scrollTo(null, oldScrollY); } + display.input.reset(); + // Adds "Select all" to context menu in FF + if (!cm.somethingSelected()) { te.value = input.prevInput = " "; } + input.contextMenuPending = true; + display.selForContextMenu = cm.doc.sel; + clearTimeout(display.detectingSelectAll); + + // Select-all will be greyed out if there's nothing to select, so + // this adds a zero-width space so that we can later check whether + // it got selected. + function prepareSelectAllHack() { + if (te.selectionStart != null) { + var selected = cm.somethingSelected(); + var extval = "\u200b" + (selected ? te.value : ""); + te.value = "\u21da"; // Used to catch context-menu undo + te.value = extval; + input.prevInput = selected ? "" : "\u200b"; + te.selectionStart = 1; te.selectionEnd = extval.length; + // Re-set this, in case some other handler touched the + // selection in the meantime. + display.selForContextMenu = cm.doc.sel; + } + } + function rehide() { + input.contextMenuPending = false; + input.wrapper.style.cssText = oldWrapperCSS; + te.style.cssText = oldCSS; + if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos); } + + // Try to detect the user choosing select-all + if (te.selectionStart != null) { + if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack(); } + var i = 0, poll = function () { + if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 && + te.selectionEnd > 0 && input.prevInput == "\u200b") { + operation(cm, selectAll)(cm); + } else if (i++ < 10) { + display.detectingSelectAll = setTimeout(poll, 500); + } else { + display.selForContextMenu = null; + display.input.reset(); + } + }; + display.detectingSelectAll = setTimeout(poll, 200); + } + } + + if (ie && ie_version >= 9) { prepareSelectAllHack(); } + if (captureRightClick) { + e_stop(e); + var mouseup = function () { + off(window, "mouseup", mouseup); + setTimeout(rehide, 20); + }; + on(window, "mouseup", mouseup); + } else { + setTimeout(rehide, 50); + } +}; + +TextareaInput.prototype.readOnlyChanged = function (val) { + if (!val) { this.reset(); } + this.textarea.disabled = val == "nocursor"; +}; + +TextareaInput.prototype.setUneditable = function () {}; + +TextareaInput.prototype.needsContentAttribute = false; + +function fromTextArea(textarea, options) { + options = options ? copyObj(options) : {}; + options.value = textarea.value; + if (!options.tabindex && textarea.tabIndex) + { options.tabindex = textarea.tabIndex; } + if (!options.placeholder && textarea.placeholder) + { options.placeholder = textarea.placeholder; } + // Set autofocus to true if this textarea is focused, or if it has + // autofocus and no other element is focused. + if (options.autofocus == null) { + var hasFocus = activeElt(); + options.autofocus = hasFocus == textarea || + textarea.getAttribute("autofocus") != null && hasFocus == document.body; + } + + function save() {textarea.value = cm.getValue();} + + var realSubmit; + if (textarea.form) { + on(textarea.form, "submit", save); + // Deplorable hack to make the submit method do the right thing. + if (!options.leaveSubmitMethodAlone) { + var form = textarea.form; + realSubmit = form.submit; + try { + var wrappedSubmit = form.submit = function () { + save(); + form.submit = realSubmit; + form.submit(); + form.submit = wrappedSubmit; + }; + } catch(e) {} + } + } + + options.finishInit = function (cm) { + cm.save = save; + cm.getTextArea = function () { return textarea; }; + cm.toTextArea = function () { + cm.toTextArea = isNaN; // Prevent this from being ran twice + save(); + textarea.parentNode.removeChild(cm.getWrapperElement()); + textarea.style.display = ""; + if (textarea.form) { + off(textarea.form, "submit", save); + if (typeof textarea.form.submit == "function") + { textarea.form.submit = realSubmit; } + } + }; + }; + + textarea.style.display = "none"; + var cm = CodeMirror$1(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); }, + options); + return cm +} + +function addLegacyProps(CodeMirror) { + CodeMirror.off = off; + CodeMirror.on = on; + CodeMirror.wheelEventPixels = wheelEventPixels; + CodeMirror.Doc = Doc; + CodeMirror.splitLines = splitLinesAuto; + CodeMirror.countColumn = countColumn; + CodeMirror.findColumn = findColumn; + CodeMirror.isWordChar = isWordCharBasic; + CodeMirror.Pass = Pass; + CodeMirror.signal = signal; + CodeMirror.Line = Line; + CodeMirror.changeEnd = changeEnd; + CodeMirror.scrollbarModel = scrollbarModel; + CodeMirror.Pos = Pos; + CodeMirror.cmpPos = cmp; + CodeMirror.modes = modes; + CodeMirror.mimeModes = mimeModes; + CodeMirror.resolveMode = resolveMode; + CodeMirror.getMode = getMode; + CodeMirror.modeExtensions = modeExtensions; + CodeMirror.extendMode = extendMode; + CodeMirror.copyState = copyState; + CodeMirror.startState = startState; + CodeMirror.innerMode = innerMode; + CodeMirror.commands = commands; + CodeMirror.keyMap = keyMap; + CodeMirror.keyName = keyName; + CodeMirror.isModifierKey = isModifierKey; + CodeMirror.lookupKey = lookupKey; + CodeMirror.normalizeKeyMap = normalizeKeyMap; + CodeMirror.StringStream = StringStream; + CodeMirror.SharedTextMarker = SharedTextMarker; + CodeMirror.TextMarker = TextMarker; + CodeMirror.LineWidget = LineWidget; + CodeMirror.e_preventDefault = e_preventDefault; + CodeMirror.e_stopPropagation = e_stopPropagation; + CodeMirror.e_stop = e_stop; + CodeMirror.addClass = addClass; + CodeMirror.contains = contains; + CodeMirror.rmClass = rmClass; + CodeMirror.keyNames = keyNames; +} + +// EDITOR CONSTRUCTOR + +defineOptions(CodeMirror$1); + +addEditorMethods(CodeMirror$1); + +// Set up methods on CodeMirror's prototype to redirect to the editor's document. +var dontDelegate = "iter insert remove copy getEditor constructor".split(" "); +for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0) + { CodeMirror$1.prototype[prop] = (function(method) { + return function() {return method.apply(this.doc, arguments)} + })(Doc.prototype[prop]); } } + +eventMixin(Doc); + +// INPUT HANDLING + +CodeMirror$1.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput}; + +// MODE DEFINITION AND QUERYING + +// Extra arguments are stored as the mode's dependencies, which is +// used by (legacy) mechanisms like loadmode.js to automatically +// load a mode. (Preferred mechanism is the require/define calls.) +CodeMirror$1.defineMode = function(name/*, mode, …*/) { + if (!CodeMirror$1.defaults.mode && name != "null") { CodeMirror$1.defaults.mode = name; } + defineMode.apply(this, arguments); +}; + +CodeMirror$1.defineMIME = defineMIME; + +// Minimal default mode. +CodeMirror$1.defineMode("null", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); }); +CodeMirror$1.defineMIME("text/plain", "null"); + +// EXTENSIONS + +CodeMirror$1.defineExtension = function (name, func) { + CodeMirror$1.prototype[name] = func; +}; +CodeMirror$1.defineDocExtension = function (name, func) { + Doc.prototype[name] = func; +}; + +CodeMirror$1.fromTextArea = fromTextArea; + +addLegacyProps(CodeMirror$1); + +CodeMirror$1.version = "5.38.0"; + +return CodeMirror$1; + +}))); + + +/***/ }), + +/***/ "./node_modules/codemirror/mode/clojure/clojure.js": +/***/ (function(module, exports, __webpack_require__) { + +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: http://codemirror.net/LICENSE + +/** + * Author: Hans Engel + * Branched from CodeMirror's Scheme mode (by Koh Zi Han, based on implementation by Koh Zi Chun) + */ + +(function(mod) { + if (true) // CommonJS + mod(__webpack_require__("./node_modules/codemirror/lib/codemirror.js")); + else {} +})(function(CodeMirror) { +"use strict"; + +CodeMirror.defineMode("clojure", function (options) { + var BUILTIN = "builtin", COMMENT = "comment", STRING = "string", CHARACTER = "string-2", + ATOM = "atom", NUMBER = "number", BRACKET = "bracket", KEYWORD = "keyword", VAR = "variable"; + var INDENT_WORD_SKIP = options.indentUnit || 2; + var NORMAL_INDENT_UNIT = options.indentUnit || 2; + + function makeKeywords(str) { + var obj = {}, words = str.split(" "); + for (var i = 0; i < words.length; ++i) obj[words[i]] = true; + return obj; + } + + var atoms = makeKeywords("true false nil"); + + var keywords = makeKeywords( + "defn defn- def def- defonce defmulti defmethod defmacro defstruct deftype defprotocol defrecord defproject deftest " + + "slice defalias defhinted defmacro- defn-memo defnk defnk defonce- defunbound defunbound- defvar defvar- let letfn " + + "do case cond condp for loop recur when when-not when-let when-first if if-let if-not . .. -> ->> doto and or dosync " + + "doseq dotimes dorun doall load import unimport ns in-ns refer try catch finally throw with-open with-local-vars " + + "binding gen-class gen-and-load-class gen-and-save-class handler-case handle"); + + var builtins = makeKeywords( + "* *' *1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* " + + "*compile-path* *compiler-options* *data-readers* *e *err* *file* *flush-on-newline* *fn-loader* *in* " + + "*math-context* *ns* *out* *print-dup* *print-length* *print-level* *print-meta* *print-readably* *read-eval* " + + "*source-path* *unchecked-math* *use-context-classloader* *verbose-defrecords* *warn-on-reflection* + +' - -' -> " + + "->> ->ArrayChunk ->Vec ->VecNode ->VecSeq -cache-protocol-fn -reset-methods .. / < <= = == > >= EMPTY-NODE accessor " + + "aclone add-classpath add-watch agent agent-error agent-errors aget alength alias all-ns alter alter-meta! " + + "alter-var-root amap ancestors and apply areduce array-map aset aset-boolean aset-byte aset-char aset-double " + + "aset-float aset-int aset-long aset-short assert assoc assoc! assoc-in associative? atom await await-for await1 " + + "bases bean bigdec bigint biginteger binding bit-and bit-and-not bit-clear bit-flip bit-not bit-or bit-set " + + "bit-shift-left bit-shift-right bit-test bit-xor boolean boolean-array booleans bound-fn bound-fn* bound? butlast " + + "byte byte-array bytes case cat cast char char-array char-escape-string char-name-string char? chars chunk chunk-append " + + "chunk-buffer chunk-cons chunk-first chunk-next chunk-rest chunked-seq? class class? clear-agent-errors " + + "clojure-version coll? comment commute comp comparator compare compare-and-set! compile complement completing concat cond condp " + + "conj conj! cons constantly construct-proxy contains? count counted? create-ns create-struct cycle dec dec' decimal? " + + "declare dedupe default-data-readers definline definterface defmacro defmethod defmulti defn defn- defonce defprotocol " + + "defrecord defstruct deftype delay delay? deliver denominator deref derive descendants destructure disj disj! dissoc " + + "dissoc! distinct distinct? doall dorun doseq dosync dotimes doto double double-array doubles drop drop-last " + + "drop-while eduction empty empty? ensure enumeration-seq error-handler error-mode eval even? every-pred every? ex-data ex-info " + + "extend extend-protocol extend-type extenders extends? false? ffirst file-seq filter filterv find find-keyword " + + "find-ns find-protocol-impl find-protocol-method find-var first flatten float float-array float? floats flush fn fn? " + + "fnext fnil for force format frequencies future future-call future-cancel future-cancelled? future-done? future? " + + "gen-class gen-interface gensym get get-in get-method get-proxy-class get-thread-bindings get-validator group-by hash " + + "hash-combine hash-map hash-set identical? identity if-let if-not ifn? import in-ns inc inc' init-proxy instance? " + + "int int-array integer? interleave intern interpose into into-array ints io! isa? iterate iterator-seq juxt keep " + + "keep-indexed key keys keyword keyword? last lazy-cat lazy-seq let letfn line-seq list list* list? load load-file " + + "load-reader load-string loaded-libs locking long long-array longs loop macroexpand macroexpand-1 make-array " + + "make-hierarchy map map-indexed map? mapcat mapv max max-key memfn memoize merge merge-with meta method-sig methods " + + "min min-key mod munge name namespace namespace-munge neg? newline next nfirst nil? nnext not not-any? not-empty " + + "not-every? not= ns ns-aliases ns-imports ns-interns ns-map ns-name ns-publics ns-refers ns-resolve ns-unalias " + + "ns-unmap nth nthnext nthrest num number? numerator object-array odd? or parents partial partition partition-all " + + "partition-by pcalls peek persistent! pmap pop pop! pop-thread-bindings pos? pr pr-str prefer-method prefers " + + "primitives-classnames print print-ctor print-dup print-method print-simple print-str printf println println-str " + + "prn prn-str promise proxy proxy-call-with-super proxy-mappings proxy-name proxy-super push-thread-bindings pvalues " + + "quot rand rand-int rand-nth random-sample range ratio? rational? rationalize re-find re-groups re-matcher re-matches re-pattern " + + "re-seq read read-line read-string realized? reduce reduce-kv reductions ref ref-history-count ref-max-history " + + "ref-min-history ref-set refer refer-clojure reify release-pending-sends rem remove remove-all-methods " + + "remove-method remove-ns remove-watch repeat repeatedly replace replicate require reset! reset-meta! resolve rest " + + "restart-agent resultset-seq reverse reversible? rseq rsubseq satisfies? second select-keys send send-off seq seq? " + + "seque sequence sequential? set set-error-handler! set-error-mode! set-validator! set? short short-array shorts " + + "shuffle shutdown-agents slurp some some-fn sort sort-by sorted-map sorted-map-by sorted-set sorted-set-by sorted? " + + "special-symbol? spit split-at split-with str string? struct struct-map subs subseq subvec supers swap! symbol " + + "symbol? sync take take-last take-nth take-while test the-ns thread-bound? time to-array to-array-2d trampoline transduce " + + "transient tree-seq true? type unchecked-add unchecked-add-int unchecked-byte unchecked-char unchecked-dec " + + "unchecked-dec-int unchecked-divide-int unchecked-double unchecked-float unchecked-inc unchecked-inc-int " + + "unchecked-int unchecked-long unchecked-multiply unchecked-multiply-int unchecked-negate unchecked-negate-int "+ + "unchecked-remainder-int unchecked-short unchecked-subtract unchecked-subtract-int underive unquote " + + "unquote-splicing update update-in update-proxy use val vals var-get var-set var? vary-meta vec vector vector-of " + + "vector? volatile! volatile? vreset! vswap! when when-first when-let when-not while with-bindings with-bindings* with-in-str with-loading-context " + + "with-local-vars with-meta with-open with-out-str with-precision with-redefs with-redefs-fn xml-seq zero? zipmap " + + "*default-data-reader-fn* as-> cond-> cond->> reduced reduced? send-via set-agent-send-executor! " + + "set-agent-send-off-executor! some-> some->>"); + + var indentKeys = makeKeywords( + // Built-ins + "ns fn def defn defmethod bound-fn if if-not case condp when while when-not when-first do future comment doto " + + "locking proxy with-open with-precision reify deftype defrecord defprotocol extend extend-protocol extend-type " + + "try catch " + + + // Binding forms + "let letfn binding loop for doseq dotimes when-let if-let " + + + // Data structures + "defstruct struct-map assoc " + + + // clojure.test + "testing deftest " + + + // contrib + "handler-case handle dotrace deftrace"); + + var tests = { + digit: /\d/, + digit_or_colon: /[\d:]/, + hex: /[0-9a-f]/i, + sign: /[+-]/, + exponent: /e/i, + keyword_char: /[^\s\(\[\;\)\]]/, + symbol: /[\w*+!\-\._?:<>\/\xa1-\uffff]/, + block_indent: /^(?:def|with)[^\/]+$|\/(?:def|with)/ + }; + + function stateStack(indent, type, prev) { // represents a state stack object + this.indent = indent; + this.type = type; + this.prev = prev; + } + + function pushStack(state, indent, type) { + state.indentStack = new stateStack(indent, type, state.indentStack); + } + + function popStack(state) { + state.indentStack = state.indentStack.prev; + } + + function isNumber(ch, stream){ + // hex + if ( ch === '0' && stream.eat(/x/i) ) { + stream.eatWhile(tests.hex); + return true; + } + + // leading sign + if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) { + stream.eat(tests.sign); + ch = stream.next(); + } + + if ( tests.digit.test(ch) ) { + stream.eat(ch); + stream.eatWhile(tests.digit); + + if ( '.' == stream.peek() ) { + stream.eat('.'); + stream.eatWhile(tests.digit); + } else if ('/' == stream.peek() ) { + stream.eat('/'); + stream.eatWhile(tests.digit); + } + + if ( stream.eat(tests.exponent) ) { + stream.eat(tests.sign); + stream.eatWhile(tests.digit); + } + + return true; + } + + return false; + } + + // Eat character that starts after backslash \ + function eatCharacter(stream) { + var first = stream.next(); + // Read special literals: backspace, newline, space, return. + // Just read all lowercase letters. + if (first && first.match(/[a-z]/) && stream.match(/[a-z]+/, true)) { + return; + } + // Read unicode character: \u1000 \uA0a1 + if (first === "u") { + stream.match(/[0-9a-z]{4}/i, true); + } + } + + return { + startState: function () { + return { + indentStack: null, + indentation: 0, + mode: false + }; + }, + + token: function (stream, state) { + if (state.indentStack == null && stream.sol()) { + // update indentation, but only if indentStack is empty + state.indentation = stream.indentation(); + } + + // skip spaces + if (state.mode != "string" && stream.eatSpace()) { + return null; + } + var returnType = null; + + switch(state.mode){ + case "string": // multi-line string parsing mode + var next, escaped = false; + while ((next = stream.next()) != null) { + if (next == "\"" && !escaped) { + + state.mode = false; + break; + } + escaped = !escaped && next == "\\"; + } + returnType = STRING; // continue on in string mode + break; + default: // default parsing mode + var ch = stream.next(); + + if (ch == "\"") { + state.mode = "string"; + returnType = STRING; + } else if (ch == "\\") { + eatCharacter(stream); + returnType = CHARACTER; + } else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) { + returnType = ATOM; + } else if (ch == ";") { // comment + stream.skipToEnd(); // rest of the line is a comment + returnType = COMMENT; + } else if (isNumber(ch,stream)){ + returnType = NUMBER; + } else if (ch == "(" || ch == "[" || ch == "{" ) { + var keyWord = '', indentTemp = stream.column(), letter; + /** + Either + (indent-word .. + (non-indent-word .. + (;something else, bracket, etc. + */ + + if (ch == "(") while ((letter = stream.eat(tests.keyword_char)) != null) { + keyWord += letter; + } + + if (keyWord.length > 0 && (indentKeys.propertyIsEnumerable(keyWord) || + tests.block_indent.test(keyWord))) { // indent-word + pushStack(state, indentTemp + INDENT_WORD_SKIP, ch); + } else { // non-indent word + // we continue eating the spaces + stream.eatSpace(); + if (stream.eol() || stream.peek() == ";") { + // nothing significant after + // we restart indentation the user defined spaces after + pushStack(state, indentTemp + NORMAL_INDENT_UNIT, ch); + } else { + pushStack(state, indentTemp + stream.current().length, ch); // else we match + } + } + stream.backUp(stream.current().length - 1); // undo all the eating + + returnType = BRACKET; + } else if (ch == ")" || ch == "]" || ch == "}") { + returnType = BRACKET; + if (state.indentStack != null && state.indentStack.type == (ch == ")" ? "(" : (ch == "]" ? "[" :"{"))) { + popStack(state); + } + } else if ( ch == ":" ) { + stream.eatWhile(tests.symbol); + return ATOM; + } else { + stream.eatWhile(tests.symbol); + + if (keywords && keywords.propertyIsEnumerable(stream.current())) { + returnType = KEYWORD; + } else if (builtins && builtins.propertyIsEnumerable(stream.current())) { + returnType = BUILTIN; + } else if (atoms && atoms.propertyIsEnumerable(stream.current())) { + returnType = ATOM; + } else { + returnType = VAR; + } + } + } + + return returnType; + }, + + indent: function (state) { + if (state.indentStack == null) return state.indentation; + return state.indentStack.indent; + }, + + closeBrackets: {pairs: "()[]{}\"\""}, + lineComment: ";;" + }; +}); + +CodeMirror.defineMIME("text/x-clojure", "clojure"); +CodeMirror.defineMIME("text/x-clojurescript", "clojure"); +CodeMirror.defineMIME("application/edn", "clojure"); + +}); + + +/***/ }), + +/***/ "./node_modules/codemirror/theme/duotone-light.css": +/***/ (function(module, exports, __webpack_require__) { + +// extracted by mini-css-extract-plugin + +/***/ }), + +/***/ "./node_modules/d/index.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var assign = __webpack_require__("./node_modules/es5-ext/object/assign/index.js") + , normalizeOpts = __webpack_require__("./node_modules/es5-ext/object/normalize-options.js") + , isCallable = __webpack_require__("./node_modules/es5-ext/object/is-callable.js") + , contains = __webpack_require__("./node_modules/es5-ext/string/#/contains/index.js") + + , d; + +d = module.exports = function (dscr, value/*, options*/) { + var c, e, w, options, desc; + if ((arguments.length < 2) || (typeof dscr !== 'string')) { + options = value; + value = dscr; + dscr = null; + } else { + options = arguments[2]; + } + if (dscr == null) { + c = w = true; + e = false; + } else { + c = contains.call(dscr, 'c'); + e = contains.call(dscr, 'e'); + w = contains.call(dscr, 'w'); + } + + desc = { value: value, configurable: c, enumerable: e, writable: w }; + return !options ? desc : assign(normalizeOpts(options), desc); +}; + +d.gs = function (dscr, get, set/*, options*/) { + var c, e, options, desc; + if (typeof dscr !== 'string') { + options = set; + set = get; + get = dscr; + dscr = null; + } else { + options = arguments[3]; + } + if (get == null) { + get = undefined; + } else if (!isCallable(get)) { + options = get; + get = set = undefined; + } else if (set == null) { + set = undefined; + } else if (!isCallable(set)) { + options = set; + set = undefined; + } + if (dscr == null) { + c = true; + e = false; + } else { + c = contains.call(dscr, 'c'); + e = contains.call(dscr, 'e'); + } + + desc = { get: get, set: set, configurable: c, enumerable: e }; + return !options ? desc : assign(normalizeOpts(options), desc); +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/function/noop.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +// eslint-disable-next-line no-empty-function +module.exports = function () {}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/assign/index.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = __webpack_require__("./node_modules/es5-ext/object/assign/is-implemented.js")() + ? Object.assign + : __webpack_require__("./node_modules/es5-ext/object/assign/shim.js"); + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/assign/is-implemented.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = function () { + var assign = Object.assign, obj; + if (typeof assign !== "function") return false; + obj = { foo: "raz" }; + assign(obj, { bar: "dwa" }, { trzy: "trzy" }); + return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy"; +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/assign/shim.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var keys = __webpack_require__("./node_modules/es5-ext/object/keys/index.js") + , value = __webpack_require__("./node_modules/es5-ext/object/valid-value.js") + , max = Math.max; + +module.exports = function (dest, src /*, …srcn*/) { + var error, i, length = max(arguments.length, 2), assign; + dest = Object(value(dest)); + assign = function (key) { + try { + dest[key] = src[key]; + } catch (e) { + if (!error) error = e; + } + }; + for (i = 1; i < length; ++i) { + src = arguments[i]; + keys(src).forEach(assign); + } + if (error !== undefined) throw error; + return dest; +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/is-callable.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// Deprecated + + + +module.exports = function (obj) { + return typeof obj === "function"; +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/is-value.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var _undefined = __webpack_require__("./node_modules/es5-ext/function/noop.js")(); // Support ES3 engines + +module.exports = function (val) { + return (val !== _undefined) && (val !== null); +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/keys/index.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = __webpack_require__("./node_modules/es5-ext/object/keys/is-implemented.js")() + ? Object.keys + : __webpack_require__("./node_modules/es5-ext/object/keys/shim.js"); + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/keys/is-implemented.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = function () { + try { + Object.keys("primitive"); + return true; + } catch (e) { + return false; +} +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/keys/shim.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var isValue = __webpack_require__("./node_modules/es5-ext/object/is-value.js"); + +var keys = Object.keys; + +module.exports = function (object) { + return keys(isValue(object) ? Object(object) : object); +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/normalize-options.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var isValue = __webpack_require__("./node_modules/es5-ext/object/is-value.js"); + +var forEach = Array.prototype.forEach, create = Object.create; + +var process = function (src, obj) { + var key; + for (key in src) obj[key] = src[key]; +}; + +// eslint-disable-next-line no-unused-vars +module.exports = function (opts1 /*, …options*/) { + var result = create(null); + forEach.call(arguments, function (options) { + if (!isValue(options)) return; + process(Object(options), result); + }); + return result; +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/object/valid-value.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var isValue = __webpack_require__("./node_modules/es5-ext/object/is-value.js"); + +module.exports = function (value) { + if (!isValue(value)) throw new TypeError("Cannot use null or undefined"); + return value; +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/string/#/contains/index.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = __webpack_require__("./node_modules/es5-ext/string/#/contains/is-implemented.js")() + ? String.prototype.contains + : __webpack_require__("./node_modules/es5-ext/string/#/contains/shim.js"); + + +/***/ }), + +/***/ "./node_modules/es5-ext/string/#/contains/is-implemented.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var str = "razdwatrzy"; + +module.exports = function () { + if (typeof str.contains !== "function") return false; + return (str.contains("dwa") === true) && (str.contains("foo") === false); +}; + + +/***/ }), + +/***/ "./node_modules/es5-ext/string/#/contains/shim.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var indexOf = String.prototype.indexOf; + +module.exports = function (searchString/*, position*/) { + return indexOf.call(this, searchString, arguments[1]) > -1; +}; + + +/***/ }), + +/***/ "./node_modules/es6-symbol/index.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = __webpack_require__("./node_modules/es6-symbol/is-implemented.js")() ? Symbol : __webpack_require__("./node_modules/es6-symbol/polyfill.js"); + + +/***/ }), + +/***/ "./node_modules/es6-symbol/is-implemented.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var validTypes = { object: true, symbol: true }; + +module.exports = function () { + var symbol; + if (typeof Symbol !== 'function') return false; + symbol = Symbol('test symbol'); + try { String(symbol); } catch (e) { return false; } + + // Return 'true' also for polyfills + if (!validTypes[typeof Symbol.iterator]) return false; + if (!validTypes[typeof Symbol.toPrimitive]) return false; + if (!validTypes[typeof Symbol.toStringTag]) return false; + + return true; +}; + + +/***/ }), + +/***/ "./node_modules/es6-symbol/is-symbol.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = function (x) { + if (!x) return false; + if (typeof x === 'symbol') return true; + if (!x.constructor) return false; + if (x.constructor.name !== 'Symbol') return false; + return (x[x.constructor.toStringTag] === 'Symbol'); +}; + + +/***/ }), + +/***/ "./node_modules/es6-symbol/polyfill.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// ES2015 Symbol polyfill for environments that do not (or partially) support it + + + +var d = __webpack_require__("./node_modules/d/index.js") + , validateSymbol = __webpack_require__("./node_modules/es6-symbol/validate-symbol.js") + + , create = Object.create, defineProperties = Object.defineProperties + , defineProperty = Object.defineProperty, objPrototype = Object.prototype + , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null) + , isNativeSafe; + +if (typeof Symbol === 'function') { + NativeSymbol = Symbol; + try { + String(NativeSymbol()); + isNativeSafe = true; + } catch (ignore) {} +} + +var generateName = (function () { + var created = create(null); + return function (desc) { + var postfix = 0, name, ie11BugWorkaround; + while (created[desc + (postfix || '')]) ++postfix; + desc += (postfix || ''); + created[desc] = true; + name = '@@' + desc; + defineProperty(objPrototype, name, d.gs(null, function (value) { + // For IE11 issue see: + // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/ + // ie11-broken-getters-on-dom-objects + // https://github.com/medikoo/es6-symbol/issues/12 + if (ie11BugWorkaround) return; + ie11BugWorkaround = true; + defineProperty(this, name, d(value)); + ie11BugWorkaround = false; + })); + return name; + }; +}()); + +// Internal constructor (not one exposed) for creating Symbol instances. +// This one is used to ensure that `someSymbol instanceof Symbol` always return false +HiddenSymbol = function Symbol(description) { + if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor'); + return SymbolPolyfill(description); +}; + +// Exposed `Symbol` constructor +// (returns instances of HiddenSymbol) +module.exports = SymbolPolyfill = function Symbol(description) { + var symbol; + if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor'); + if (isNativeSafe) return NativeSymbol(description); + symbol = create(HiddenSymbol.prototype); + description = (description === undefined ? '' : String(description)); + return defineProperties(symbol, { + __description__: d('', description), + __name__: d('', generateName(description)) + }); +}; +defineProperties(SymbolPolyfill, { + for: d(function (key) { + if (globalSymbols[key]) return globalSymbols[key]; + return (globalSymbols[key] = SymbolPolyfill(String(key))); + }), + keyFor: d(function (s) { + var key; + validateSymbol(s); + for (key in globalSymbols) if (globalSymbols[key] === s) return key; + }), + + // To ensure proper interoperability with other native functions (e.g. Array.from) + // fallback to eventual native implementation of given symbol + hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')), + isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) || + SymbolPolyfill('isConcatSpreadable')), + iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')), + match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')), + replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')), + search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')), + species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')), + split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')), + toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')), + toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')), + unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables')) +}); + +// Internal tweaks for real symbol producer +defineProperties(HiddenSymbol.prototype, { + constructor: d(SymbolPolyfill), + toString: d('', function () { return this.__name__; }) +}); + +// Proper implementation of methods exposed on Symbol.prototype +// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype +defineProperties(SymbolPolyfill.prototype, { + toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }), + valueOf: d(function () { return validateSymbol(this); }) +}); +defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function () { + var symbol = validateSymbol(this); + if (typeof symbol === 'symbol') return symbol; + return symbol.toString(); +})); +defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol')); + +// Proper implementaton of toPrimitive and toStringTag for returned symbol instances +defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag, + d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag])); + +// Note: It's important to define `toPrimitive` as last one, as some implementations +// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols) +// And that may invoke error in definition flow: +// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149 +defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive, + d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive])); + + +/***/ }), + +/***/ "./node_modules/es6-symbol/validate-symbol.js": +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var isSymbol = __webpack_require__("./node_modules/es6-symbol/is-symbol.js"); + +module.exports = function (value) { + if (!isSymbol(value)) throw new TypeError(value + " is not a symbol"); + return value; +}; + + +/***/ }), + +/***/ "./node_modules/inherits/inherits_browser.js": +/***/ (function(module, exports) { + +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } +} + + +/***/ }), + +/***/ "./node_modules/is-buffer/index.js": +/***/ (function(module, exports) { + +/*! + * Determine if an object is a Buffer + * + * @author Feross Aboukhadijeh + * @license MIT + */ + +// The _isBuffer check is for Safari 5-7 support, because it's missing +// Object.prototype.constructor. Remove this eventually +module.exports = function (obj) { + return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) +} + +function isBuffer (obj) { + return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) +} + +// For Node v0.10 support. Remove this eventually. +function isSlowBuffer (obj) { + return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) +} + + +/***/ }), + +/***/ "./node_modules/lodash/_DataView.js": +/***/ (function(module, exports, __webpack_require__) { + +var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), + root = __webpack_require__("./node_modules/lodash/_root.js"); + +/* Built-in method references that are verified to be native. */ +var DataView = getNative(root, 'DataView'); + +module.exports = DataView; + + +/***/ }), + +/***/ "./node_modules/lodash/_Hash.js": +/***/ (function(module, exports, __webpack_require__) { + +var hashClear = __webpack_require__("./node_modules/lodash/_hashClear.js"), + hashDelete = __webpack_require__("./node_modules/lodash/_hashDelete.js"), + hashGet = __webpack_require__("./node_modules/lodash/_hashGet.js"), + hashHas = __webpack_require__("./node_modules/lodash/_hashHas.js"), + hashSet = __webpack_require__("./node_modules/lodash/_hashSet.js"); + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +module.exports = Hash; + + +/***/ }), + +/***/ "./node_modules/lodash/_ListCache.js": +/***/ (function(module, exports, __webpack_require__) { + +var listCacheClear = __webpack_require__("./node_modules/lodash/_listCacheClear.js"), + listCacheDelete = __webpack_require__("./node_modules/lodash/_listCacheDelete.js"), + listCacheGet = __webpack_require__("./node_modules/lodash/_listCacheGet.js"), + listCacheHas = __webpack_require__("./node_modules/lodash/_listCacheHas.js"), + listCacheSet = __webpack_require__("./node_modules/lodash/_listCacheSet.js"); + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +module.exports = ListCache; + + +/***/ }), + +/***/ "./node_modules/lodash/_Map.js": +/***/ (function(module, exports, __webpack_require__) { + +var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), + root = __webpack_require__("./node_modules/lodash/_root.js"); + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'); + +module.exports = Map; + + +/***/ }), + +/***/ "./node_modules/lodash/_MapCache.js": +/***/ (function(module, exports, __webpack_require__) { + +var mapCacheClear = __webpack_require__("./node_modules/lodash/_mapCacheClear.js"), + mapCacheDelete = __webpack_require__("./node_modules/lodash/_mapCacheDelete.js"), + mapCacheGet = __webpack_require__("./node_modules/lodash/_mapCacheGet.js"), + mapCacheHas = __webpack_require__("./node_modules/lodash/_mapCacheHas.js"), + mapCacheSet = __webpack_require__("./node_modules/lodash/_mapCacheSet.js"); + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +module.exports = MapCache; + + +/***/ }), + +/***/ "./node_modules/lodash/_Promise.js": +/***/ (function(module, exports, __webpack_require__) { + +var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), + root = __webpack_require__("./node_modules/lodash/_root.js"); + +/* Built-in method references that are verified to be native. */ +var Promise = getNative(root, 'Promise'); + +module.exports = Promise; + + +/***/ }), + +/***/ "./node_modules/lodash/_Set.js": +/***/ (function(module, exports, __webpack_require__) { + +var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), + root = __webpack_require__("./node_modules/lodash/_root.js"); + +/* Built-in method references that are verified to be native. */ +var Set = getNative(root, 'Set'); + +module.exports = Set; + + +/***/ }), + +/***/ "./node_modules/lodash/_SetCache.js": +/***/ (function(module, exports, __webpack_require__) { + +var MapCache = __webpack_require__("./node_modules/lodash/_MapCache.js"), + setCacheAdd = __webpack_require__("./node_modules/lodash/_setCacheAdd.js"), + setCacheHas = __webpack_require__("./node_modules/lodash/_setCacheHas.js"); + +/** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ +function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } +} + +// Add methods to `SetCache`. +SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; +SetCache.prototype.has = setCacheHas; + +module.exports = SetCache; + + +/***/ }), + +/***/ "./node_modules/lodash/_Stack.js": +/***/ (function(module, exports, __webpack_require__) { + +var ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"), + stackClear = __webpack_require__("./node_modules/lodash/_stackClear.js"), + stackDelete = __webpack_require__("./node_modules/lodash/_stackDelete.js"), + stackGet = __webpack_require__("./node_modules/lodash/_stackGet.js"), + stackHas = __webpack_require__("./node_modules/lodash/_stackHas.js"), + stackSet = __webpack_require__("./node_modules/lodash/_stackSet.js"); + +/** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; +} + +// Add methods to `Stack`. +Stack.prototype.clear = stackClear; +Stack.prototype['delete'] = stackDelete; +Stack.prototype.get = stackGet; +Stack.prototype.has = stackHas; +Stack.prototype.set = stackSet; + +module.exports = Stack; + + +/***/ }), + +/***/ "./node_modules/lodash/_Symbol.js": +/***/ (function(module, exports, __webpack_require__) { + +var root = __webpack_require__("./node_modules/lodash/_root.js"); + +/** Built-in value references. */ +var Symbol = root.Symbol; + +module.exports = Symbol; + + +/***/ }), + +/***/ "./node_modules/lodash/_Uint8Array.js": +/***/ (function(module, exports, __webpack_require__) { + +var root = __webpack_require__("./node_modules/lodash/_root.js"); + +/** Built-in value references. */ +var Uint8Array = root.Uint8Array; + +module.exports = Uint8Array; + + +/***/ }), + +/***/ "./node_modules/lodash/_WeakMap.js": +/***/ (function(module, exports, __webpack_require__) { + +var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), + root = __webpack_require__("./node_modules/lodash/_root.js"); + +/* Built-in method references that are verified to be native. */ +var WeakMap = getNative(root, 'WeakMap'); + +module.exports = WeakMap; + + +/***/ }), + +/***/ "./node_modules/lodash/_arrayFilter.js": +/***/ (function(module, exports) { + +/** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ +function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; +} + +module.exports = arrayFilter; + + +/***/ }), + +/***/ "./node_modules/lodash/_arrayLikeKeys.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseTimes = __webpack_require__("./node_modules/lodash/_baseTimes.js"), + isArguments = __webpack_require__("./node_modules/lodash/isArguments.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + isBuffer = __webpack_require__("./node_modules/lodash/isBuffer.js"), + isIndex = __webpack_require__("./node_modules/lodash/_isIndex.js"), + isTypedArray = __webpack_require__("./node_modules/lodash/isTypedArray.js"); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ +function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), + isArg = !isArr && isArguments(value), + isBuff = !isArr && !isArg && isBuffer(value), + isType = !isArr && !isArg && !isBuff && isTypedArray(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; +} + +module.exports = arrayLikeKeys; + + +/***/ }), + +/***/ "./node_modules/lodash/_arrayMap.js": +/***/ (function(module, exports) { + +/** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ +function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; +} + +module.exports = arrayMap; + + +/***/ }), + +/***/ "./node_modules/lodash/_arrayPush.js": +/***/ (function(module, exports) { + +/** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ +function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; +} + +module.exports = arrayPush; + + +/***/ }), + +/***/ "./node_modules/lodash/_arrayShuffle.js": +/***/ (function(module, exports, __webpack_require__) { + +var copyArray = __webpack_require__("./node_modules/lodash/_copyArray.js"), + shuffleSelf = __webpack_require__("./node_modules/lodash/_shuffleSelf.js"); + +/** + * A specialized version of `_.shuffle` for arrays. + * + * @private + * @param {Array} array The array to shuffle. + * @returns {Array} Returns the new shuffled array. + */ +function arrayShuffle(array) { + return shuffleSelf(copyArray(array)); +} + +module.exports = arrayShuffle; + + +/***/ }), + +/***/ "./node_modules/lodash/_arraySome.js": +/***/ (function(module, exports) { + +/** + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ +function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; +} + +module.exports = arraySome; + + +/***/ }), + +/***/ "./node_modules/lodash/_assocIndexOf.js": +/***/ (function(module, exports, __webpack_require__) { + +var eq = __webpack_require__("./node_modules/lodash/eq.js"); + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +module.exports = assocIndexOf; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseEach.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseForOwn = __webpack_require__("./node_modules/lodash/_baseForOwn.js"), + createBaseEach = __webpack_require__("./node_modules/lodash/_createBaseEach.js"); + +/** + * The base implementation of `_.forEach` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ +var baseEach = createBaseEach(baseForOwn); + +module.exports = baseEach; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseFlatten.js": +/***/ (function(module, exports, __webpack_require__) { + +var arrayPush = __webpack_require__("./node_modules/lodash/_arrayPush.js"), + isFlattenable = __webpack_require__("./node_modules/lodash/_isFlattenable.js"); + +/** + * The base implementation of `_.flatten` with support for restricting flattening. + * + * @private + * @param {Array} array The array to flatten. + * @param {number} depth The maximum recursion depth. + * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. + * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ +function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, + length = array.length; + + predicate || (predicate = isFlattenable); + result || (result = []); + + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; +} + +module.exports = baseFlatten; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseFor.js": +/***/ (function(module, exports, __webpack_require__) { + +var createBaseFor = __webpack_require__("./node_modules/lodash/_createBaseFor.js"); + +/** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ +var baseFor = createBaseFor(); + +module.exports = baseFor; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseForOwn.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseFor = __webpack_require__("./node_modules/lodash/_baseFor.js"), + keys = __webpack_require__("./node_modules/lodash/keys.js"); + +/** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ +function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); +} + +module.exports = baseForOwn; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseGet.js": +/***/ (function(module, exports, __webpack_require__) { + +var castPath = __webpack_require__("./node_modules/lodash/_castPath.js"), + toKey = __webpack_require__("./node_modules/lodash/_toKey.js"); + +/** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ +function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; +} + +module.exports = baseGet; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseGetAllKeys.js": +/***/ (function(module, exports, __webpack_require__) { + +var arrayPush = __webpack_require__("./node_modules/lodash/_arrayPush.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"); + +/** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ +function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); +} + +module.exports = baseGetAllKeys; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseGetTag.js": +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), + getRawTag = __webpack_require__("./node_modules/lodash/_getRawTag.js"), + objectToString = __webpack_require__("./node_modules/lodash/_objectToString.js"); + +/** `Object#toString` result references. */ +var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + +/** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); +} + +module.exports = baseGetTag; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseHasIn.js": +/***/ (function(module, exports) { + +/** + * The base implementation of `_.hasIn` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ +function baseHasIn(object, key) { + return object != null && key in Object(object); +} + +module.exports = baseHasIn; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIsArguments.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), + isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]'; + +/** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ +function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; +} + +module.exports = baseIsArguments; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIsEqual.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseIsEqualDeep = __webpack_require__("./node_modules/lodash/_baseIsEqualDeep.js"), + isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); + +/** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ +function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); +} + +module.exports = baseIsEqual; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIsEqualDeep.js": +/***/ (function(module, exports, __webpack_require__) { + +var Stack = __webpack_require__("./node_modules/lodash/_Stack.js"), + equalArrays = __webpack_require__("./node_modules/lodash/_equalArrays.js"), + equalByTag = __webpack_require__("./node_modules/lodash/_equalByTag.js"), + equalObjects = __webpack_require__("./node_modules/lodash/_equalObjects.js"), + getTag = __webpack_require__("./node_modules/lodash/_getTag.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + isBuffer = __webpack_require__("./node_modules/lodash/isBuffer.js"), + isTypedArray = __webpack_require__("./node_modules/lodash/isTypedArray.js"); + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1; + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + objectTag = '[object Object]'; + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = objIsArr ? arrayTag : getTag(object), + othTag = othIsArr ? arrayTag : getTag(other); + + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack); + return (objIsArr || isTypedArray(object)) + ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) + : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + + stack || (stack = new Stack); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); +} + +module.exports = baseIsEqualDeep; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIsMatch.js": +/***/ (function(module, exports, __webpack_require__) { + +var Stack = __webpack_require__("./node_modules/lodash/_Stack.js"), + baseIsEqual = __webpack_require__("./node_modules/lodash/_baseIsEqual.js"); + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + +/** + * The base implementation of `_.isMatch` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Array} matchData The property names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + */ +function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + + if (object == null) { + return !length; + } + object = Object(object); + while (index--) { + var data = matchData[index]; + if ((noCustomizer && data[2]) + ? data[1] !== object[data[0]] + : !(data[0] in object) + ) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + + if (noCustomizer && data[2]) { + if (objValue === undefined && !(key in object)) { + return false; + } + } else { + var stack = new Stack; + if (customizer) { + var result = customizer(objValue, srcValue, key, object, source, stack); + } + if (!(result === undefined + ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) + : result + )) { + return false; + } + } + } + return true; +} + +module.exports = baseIsMatch; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIsNative.js": +/***/ (function(module, exports, __webpack_require__) { + +var isFunction = __webpack_require__("./node_modules/lodash/isFunction.js"), + isMasked = __webpack_require__("./node_modules/lodash/_isMasked.js"), + isObject = __webpack_require__("./node_modules/lodash/isObject.js"), + toSource = __webpack_require__("./node_modules/lodash/_toSource.js"); + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Used for built-in method references. */ +var funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +module.exports = baseIsNative; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIsTypedArray.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), + isLength = __webpack_require__("./node_modules/lodash/isLength.js"), + isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + +var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + +/** Used to identify `toStringTag` values of typed arrays. */ +var typedArrayTags = {}; +typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = +typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = +typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = +typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = +typedArrayTags[uint32Tag] = true; +typedArrayTags[argsTag] = typedArrayTags[arrayTag] = +typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = +typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = +typedArrayTags[errorTag] = typedArrayTags[funcTag] = +typedArrayTags[mapTag] = typedArrayTags[numberTag] = +typedArrayTags[objectTag] = typedArrayTags[regexpTag] = +typedArrayTags[setTag] = typedArrayTags[stringTag] = +typedArrayTags[weakMapTag] = false; + +/** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ +function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; +} + +module.exports = baseIsTypedArray; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseIteratee.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseMatches = __webpack_require__("./node_modules/lodash/_baseMatches.js"), + baseMatchesProperty = __webpack_require__("./node_modules/lodash/_baseMatchesProperty.js"), + identity = __webpack_require__("./node_modules/lodash/identity.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + property = __webpack_require__("./node_modules/lodash/property.js"); + +/** + * The base implementation of `_.iteratee`. + * + * @private + * @param {*} [value=_.identity] The value to convert to an iteratee. + * @returns {Function} Returns the iteratee. + */ +function baseIteratee(value) { + // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. + // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. + if (typeof value == 'function') { + return value; + } + if (value == null) { + return identity; + } + if (typeof value == 'object') { + return isArray(value) + ? baseMatchesProperty(value[0], value[1]) + : baseMatches(value); + } + return property(value); +} + +module.exports = baseIteratee; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseKeys.js": +/***/ (function(module, exports, __webpack_require__) { + +var isPrototype = __webpack_require__("./node_modules/lodash/_isPrototype.js"), + nativeKeys = __webpack_require__("./node_modules/lodash/_nativeKeys.js"); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; +} + +module.exports = baseKeys; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseMap.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseEach = __webpack_require__("./node_modules/lodash/_baseEach.js"), + isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"); + +/** + * The base implementation of `_.map` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ +function baseMap(collection, iteratee) { + var index = -1, + result = isArrayLike(collection) ? Array(collection.length) : []; + + baseEach(collection, function(value, key, collection) { + result[++index] = iteratee(value, key, collection); + }); + return result; +} + +module.exports = baseMap; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseMatches.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseIsMatch = __webpack_require__("./node_modules/lodash/_baseIsMatch.js"), + getMatchData = __webpack_require__("./node_modules/lodash/_getMatchData.js"), + matchesStrictComparable = __webpack_require__("./node_modules/lodash/_matchesStrictComparable.js"); + +/** + * The base implementation of `_.matches` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new spec function. + */ +function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + return function(object) { + return object === source || baseIsMatch(object, source, matchData); + }; +} + +module.exports = baseMatches; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseMatchesProperty.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseIsEqual = __webpack_require__("./node_modules/lodash/_baseIsEqual.js"), + get = __webpack_require__("./node_modules/lodash/get.js"), + hasIn = __webpack_require__("./node_modules/lodash/hasIn.js"), + isKey = __webpack_require__("./node_modules/lodash/_isKey.js"), + isStrictComparable = __webpack_require__("./node_modules/lodash/_isStrictComparable.js"), + matchesStrictComparable = __webpack_require__("./node_modules/lodash/_matchesStrictComparable.js"), + toKey = __webpack_require__("./node_modules/lodash/_toKey.js"); + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + +/** + * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. + * + * @private + * @param {string} path The path of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ +function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + return function(object) { + var objValue = get(object, path); + return (objValue === undefined && objValue === srcValue) + ? hasIn(object, path) + : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); + }; +} + +module.exports = baseMatchesProperty; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseProperty.js": +/***/ (function(module, exports) { + +/** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new accessor function. + */ +function baseProperty(key) { + return function(object) { + return object == null ? undefined : object[key]; + }; +} + +module.exports = baseProperty; + + +/***/ }), + +/***/ "./node_modules/lodash/_basePropertyDeep.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGet = __webpack_require__("./node_modules/lodash/_baseGet.js"); + +/** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new accessor function. + */ +function basePropertyDeep(path) { + return function(object) { + return baseGet(object, path); + }; +} + +module.exports = basePropertyDeep; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseRandom.js": +/***/ (function(module, exports) { + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeFloor = Math.floor, + nativeRandom = Math.random; + +/** + * The base implementation of `_.random` without support for returning + * floating-point numbers. + * + * @private + * @param {number} lower The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the random number. + */ +function baseRandom(lower, upper) { + return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); +} + +module.exports = baseRandom; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseRange.js": +/***/ (function(module, exports) { + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeCeil = Math.ceil, + nativeMax = Math.max; + +/** + * The base implementation of `_.range` and `_.rangeRight` which doesn't + * coerce arguments. + * + * @private + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @param {number} step The value to increment or decrement by. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the range of numbers. + */ +function baseRange(start, end, step, fromRight) { + var index = -1, + length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), + result = Array(length); + + while (length--) { + result[fromRight ? length : ++index] = start; + start += step; + } + return result; +} + +module.exports = baseRange; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseShuffle.js": +/***/ (function(module, exports, __webpack_require__) { + +var shuffleSelf = __webpack_require__("./node_modules/lodash/_shuffleSelf.js"), + values = __webpack_require__("./node_modules/lodash/values.js"); + +/** + * The base implementation of `_.shuffle`. + * + * @private + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + */ +function baseShuffle(collection) { + return shuffleSelf(values(collection)); +} + +module.exports = baseShuffle; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseSlice.js": +/***/ (function(module, exports) { + +/** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ +function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; +} + +module.exports = baseSlice; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseTimes.js": +/***/ (function(module, exports) { + +/** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ +function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; +} + +module.exports = baseTimes; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseToString.js": +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), + arrayMap = __webpack_require__("./node_modules/lodash/_arrayMap.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + isSymbol = __webpack_require__("./node_modules/lodash/isSymbol.js"); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +module.exports = baseToString; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseUnary.js": +/***/ (function(module, exports) { + +/** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ +function baseUnary(func) { + return function(value) { + return func(value); + }; +} + +module.exports = baseUnary; + + +/***/ }), + +/***/ "./node_modules/lodash/_baseValues.js": +/***/ (function(module, exports, __webpack_require__) { + +var arrayMap = __webpack_require__("./node_modules/lodash/_arrayMap.js"); + +/** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ +function baseValues(object, props) { + return arrayMap(props, function(key) { + return object[key]; + }); +} + +module.exports = baseValues; + + +/***/ }), + +/***/ "./node_modules/lodash/_cacheHas.js": +/***/ (function(module, exports) { + +/** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function cacheHas(cache, key) { + return cache.has(key); +} + +module.exports = cacheHas; + + +/***/ }), + +/***/ "./node_modules/lodash/_castPath.js": +/***/ (function(module, exports, __webpack_require__) { + +var isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + isKey = __webpack_require__("./node_modules/lodash/_isKey.js"), + stringToPath = __webpack_require__("./node_modules/lodash/_stringToPath.js"), + toString = __webpack_require__("./node_modules/lodash/toString.js"); + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value, object) { + if (isArray(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); +} + +module.exports = castPath; + + +/***/ }), + +/***/ "./node_modules/lodash/_copyArray.js": +/***/ (function(module, exports) { + +/** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ +function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; +} + +module.exports = copyArray; + + +/***/ }), + +/***/ "./node_modules/lodash/_coreJsData.js": +/***/ (function(module, exports, __webpack_require__) { + +var root = __webpack_require__("./node_modules/lodash/_root.js"); + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +module.exports = coreJsData; + + +/***/ }), + +/***/ "./node_modules/lodash/_createBaseEach.js": +/***/ (function(module, exports, __webpack_require__) { + +var isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"); + +/** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ +function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + var length = collection.length, + index = fromRight ? length : -1, + iterable = Object(collection); + + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; +} + +module.exports = createBaseEach; + + +/***/ }), + +/***/ "./node_modules/lodash/_createBaseFor.js": +/***/ (function(module, exports) { + +/** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ +function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; +} + +module.exports = createBaseFor; + + +/***/ }), + +/***/ "./node_modules/lodash/_createRange.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseRange = __webpack_require__("./node_modules/lodash/_baseRange.js"), + isIterateeCall = __webpack_require__("./node_modules/lodash/_isIterateeCall.js"), + toFinite = __webpack_require__("./node_modules/lodash/toFinite.js"); + +/** + * Creates a `_.range` or `_.rangeRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new range function. + */ +function createRange(fromRight) { + return function(start, end, step) { + if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { + end = step = undefined; + } + // Ensure the sign of `-0` is preserved. + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); + return baseRange(start, end, step, fromRight); + }; +} + +module.exports = createRange; + + +/***/ }), + +/***/ "./node_modules/lodash/_equalArrays.js": +/***/ (function(module, exports, __webpack_require__) { + +var SetCache = __webpack_require__("./node_modules/lodash/_SetCache.js"), + arraySome = __webpack_require__("./node_modules/lodash/_arraySome.js"), + cacheHas = __webpack_require__("./node_modules/lodash/_cacheHas.js"); + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + +/** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ +function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(array); + if (stacked && stack.get(other)) { + return stacked == other; + } + var index = -1, + result = true, + seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; + + stack.set(array, other); + stack.set(other, array); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!cacheHas(seen, othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, bitmask, customizer, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + stack['delete'](other); + return result; +} + +module.exports = equalArrays; + + +/***/ }), + +/***/ "./node_modules/lodash/_equalByTag.js": +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), + Uint8Array = __webpack_require__("./node_modules/lodash/_Uint8Array.js"), + eq = __webpack_require__("./node_modules/lodash/eq.js"), + equalArrays = __webpack_require__("./node_modules/lodash/_equalArrays.js"), + mapToArray = __webpack_require__("./node_modules/lodash/_mapToArray.js"), + setToArray = __webpack_require__("./node_modules/lodash/_setToArray.js"); + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + +/** `Object#toString` result references. */ +var boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + mapTag = '[object Map]', + numberTag = '[object Number]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + symbolTag = '[object Symbol]'; + +var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]'; + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; + +/** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if ((object.byteLength != other.byteLength) || + (object.byteOffset != other.byteOffset)) { + return false; + } + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if ((object.byteLength != other.byteLength) || + !equalFunc(new Uint8Array(object), new Uint8Array(other))) { + return false; + } + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == (other + ''); + + case mapTag: + var convert = mapToArray; + + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + + // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; +} + +module.exports = equalByTag; + + +/***/ }), + +/***/ "./node_modules/lodash/_equalObjects.js": +/***/ (function(module, exports, __webpack_require__) { + +var getAllKeys = __webpack_require__("./node_modules/lodash/_getAllKeys.js"); + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1; + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked && stack.get(other)) { + return stacked == other; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, objValue, key, other, object, stack) + : customizer(objValue, othValue, key, object, other, stack); + } + // Recursively compare objects (susceptible to call stack limits). + if (!(compared === undefined + ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) + : compared + )) { + result = false; + break; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + stack['delete'](object); + stack['delete'](other); + return result; +} + +module.exports = equalObjects; + + +/***/ }), + +/***/ "./node_modules/lodash/_freeGlobal.js": +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +module.exports = freeGlobal; + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/global.js"))) + +/***/ }), + +/***/ "./node_modules/lodash/_getAllKeys.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGetAllKeys = __webpack_require__("./node_modules/lodash/_baseGetAllKeys.js"), + getSymbols = __webpack_require__("./node_modules/lodash/_getSymbols.js"), + keys = __webpack_require__("./node_modules/lodash/keys.js"); + +/** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ +function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); +} + +module.exports = getAllKeys; + + +/***/ }), + +/***/ "./node_modules/lodash/_getMapData.js": +/***/ (function(module, exports, __webpack_require__) { + +var isKeyable = __webpack_require__("./node_modules/lodash/_isKeyable.js"); + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +module.exports = getMapData; + + +/***/ }), + +/***/ "./node_modules/lodash/_getMatchData.js": +/***/ (function(module, exports, __webpack_require__) { + +var isStrictComparable = __webpack_require__("./node_modules/lodash/_isStrictComparable.js"), + keys = __webpack_require__("./node_modules/lodash/keys.js"); + +/** + * Gets the property names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ +function getMatchData(object) { + var result = keys(object), + length = result.length; + + while (length--) { + var key = result[length], + value = object[key]; + + result[length] = [key, value, isStrictComparable(value)]; + } + return result; +} + +module.exports = getMatchData; + + +/***/ }), + +/***/ "./node_modules/lodash/_getNative.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseIsNative = __webpack_require__("./node_modules/lodash/_baseIsNative.js"), + getValue = __webpack_require__("./node_modules/lodash/_getValue.js"); + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +module.exports = getNative; + + +/***/ }), + +/***/ "./node_modules/lodash/_getRawTag.js": +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + +/** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ +function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; +} + +module.exports = getRawTag; + + +/***/ }), + +/***/ "./node_modules/lodash/_getSymbols.js": +/***/ (function(module, exports, __webpack_require__) { + +var arrayFilter = __webpack_require__("./node_modules/lodash/_arrayFilter.js"), + stubArray = __webpack_require__("./node_modules/lodash/stubArray.js"); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Built-in value references. */ +var propertyIsEnumerable = objectProto.propertyIsEnumerable; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeGetSymbols = Object.getOwnPropertySymbols; + +/** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ +var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); +}; + +module.exports = getSymbols; + + +/***/ }), + +/***/ "./node_modules/lodash/_getTag.js": +/***/ (function(module, exports, __webpack_require__) { + +var DataView = __webpack_require__("./node_modules/lodash/_DataView.js"), + Map = __webpack_require__("./node_modules/lodash/_Map.js"), + Promise = __webpack_require__("./node_modules/lodash/_Promise.js"), + Set = __webpack_require__("./node_modules/lodash/_Set.js"), + WeakMap = __webpack_require__("./node_modules/lodash/_WeakMap.js"), + baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), + toSource = __webpack_require__("./node_modules/lodash/_toSource.js"); + +/** `Object#toString` result references. */ +var mapTag = '[object Map]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + setTag = '[object Set]', + weakMapTag = '[object WeakMap]'; + +var dataViewTag = '[object DataView]'; + +/** Used to detect maps, sets, and weakmaps. */ +var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + +/** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +var getTag = baseGetTag; + +// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. +if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map && getTag(new Map) != mapTag) || + (Promise && getTag(Promise.resolve()) != promiseTag) || + (Set && getTag(new Set) != setTag) || + (WeakMap && getTag(new WeakMap) != weakMapTag)) { + getTag = function(value) { + var result = baseGetTag(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; +} + +module.exports = getTag; + + +/***/ }), + +/***/ "./node_modules/lodash/_getValue.js": +/***/ (function(module, exports) { + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +module.exports = getValue; + + +/***/ }), + +/***/ "./node_modules/lodash/_hasPath.js": +/***/ (function(module, exports, __webpack_require__) { + +var castPath = __webpack_require__("./node_modules/lodash/_castPath.js"), + isArguments = __webpack_require__("./node_modules/lodash/isArguments.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + isIndex = __webpack_require__("./node_modules/lodash/_isIndex.js"), + isLength = __webpack_require__("./node_modules/lodash/isLength.js"), + toKey = __webpack_require__("./node_modules/lodash/_toKey.js"); + +/** + * Checks if `path` exists on `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + */ +function hasPath(object, path, hasFunc) { + path = castPath(path, object); + + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result || ++index != length) { + return result; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && + (isArray(object) || isArguments(object)); +} + +module.exports = hasPath; + + +/***/ }), + +/***/ "./node_modules/lodash/_hashClear.js": +/***/ (function(module, exports, __webpack_require__) { + +var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; +} + +module.exports = hashClear; + + +/***/ }), + +/***/ "./node_modules/lodash/_hashDelete.js": +/***/ (function(module, exports) { + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} + +module.exports = hashDelete; + + +/***/ }), + +/***/ "./node_modules/lodash/_hashGet.js": +/***/ (function(module, exports, __webpack_require__) { + +var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +module.exports = hashGet; + + +/***/ }), + +/***/ "./node_modules/lodash/_hashHas.js": +/***/ (function(module, exports, __webpack_require__) { + +var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); +} + +module.exports = hashHas; + + +/***/ }), + +/***/ "./node_modules/lodash/_hashSet.js": +/***/ (function(module, exports, __webpack_require__) { + +var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +module.exports = hashSet; + + +/***/ }), + +/***/ "./node_modules/lodash/_isFlattenable.js": +/***/ (function(module, exports, __webpack_require__) { + +var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), + isArguments = __webpack_require__("./node_modules/lodash/isArguments.js"), + isArray = __webpack_require__("./node_modules/lodash/isArray.js"); + +/** Built-in value references. */ +var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined; + +/** + * Checks if `value` is a flattenable `arguments` object or array. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. + */ +function isFlattenable(value) { + return isArray(value) || isArguments(value) || + !!(spreadableSymbol && value && value[spreadableSymbol]); +} + +module.exports = isFlattenable; + + +/***/ }), + +/***/ "./node_modules/lodash/_isIndex.js": +/***/ (function(module, exports) { + +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + +/** Used to detect unsigned integer values. */ +var reIsUint = /^(?:0|[1-9]\d*)$/; + +/** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ +function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); +} + +module.exports = isIndex; + + +/***/ }), + +/***/ "./node_modules/lodash/_isIterateeCall.js": +/***/ (function(module, exports, __webpack_require__) { + +var eq = __webpack_require__("./node_modules/lodash/eq.js"), + isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"), + isIndex = __webpack_require__("./node_modules/lodash/_isIndex.js"), + isObject = __webpack_require__("./node_modules/lodash/isObject.js"); + +/** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ +function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object) + ) { + return eq(object[index], value); + } + return false; +} + +module.exports = isIterateeCall; + + +/***/ }), + +/***/ "./node_modules/lodash/_isKey.js": +/***/ (function(module, exports, __webpack_require__) { + +var isArray = __webpack_require__("./node_modules/lodash/isArray.js"), + isSymbol = __webpack_require__("./node_modules/lodash/isSymbol.js"); + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + +/** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ +function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); +} + +module.exports = isKey; + + +/***/ }), + +/***/ "./node_modules/lodash/_isKeyable.js": +/***/ (function(module, exports) { + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +module.exports = isKeyable; + + +/***/ }), + +/***/ "./node_modules/lodash/_isMasked.js": +/***/ (function(module, exports, __webpack_require__) { + +var coreJsData = __webpack_require__("./node_modules/lodash/_coreJsData.js"); + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +module.exports = isMasked; + + +/***/ }), + +/***/ "./node_modules/lodash/_isPrototype.js": +/***/ (function(module, exports) { + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ +function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; +} + +module.exports = isPrototype; + + +/***/ }), + +/***/ "./node_modules/lodash/_isStrictComparable.js": +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__("./node_modules/lodash/isObject.js"); + +/** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ +function isStrictComparable(value) { + return value === value && !isObject(value); +} + +module.exports = isStrictComparable; + + +/***/ }), + +/***/ "./node_modules/lodash/_listCacheClear.js": +/***/ (function(module, exports) { + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; + this.size = 0; +} + +module.exports = listCacheClear; + + +/***/ }), + +/***/ "./node_modules/lodash/_listCacheDelete.js": +/***/ (function(module, exports, __webpack_require__) { + +var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); + +/** Used for built-in method references. */ +var arrayProto = Array.prototype; + +/** Built-in value references. */ +var splice = arrayProto.splice; + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; +} + +module.exports = listCacheDelete; + + +/***/ }), + +/***/ "./node_modules/lodash/_listCacheGet.js": +/***/ (function(module, exports, __webpack_require__) { + +var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +module.exports = listCacheGet; + + +/***/ }), + +/***/ "./node_modules/lodash/_listCacheHas.js": +/***/ (function(module, exports, __webpack_require__) { + +var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +module.exports = listCacheHas; + + +/***/ }), + +/***/ "./node_modules/lodash/_listCacheSet.js": +/***/ (function(module, exports, __webpack_require__) { + +var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +module.exports = listCacheSet; + + +/***/ }), + +/***/ "./node_modules/lodash/_mapCacheClear.js": +/***/ (function(module, exports, __webpack_require__) { + +var Hash = __webpack_require__("./node_modules/lodash/_Hash.js"), + ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"), + Map = __webpack_require__("./node_modules/lodash/_Map.js"); + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +module.exports = mapCacheClear; + + +/***/ }), + +/***/ "./node_modules/lodash/_mapCacheDelete.js": +/***/ (function(module, exports, __webpack_require__) { + +var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; +} + +module.exports = mapCacheDelete; + + +/***/ }), + +/***/ "./node_modules/lodash/_mapCacheGet.js": +/***/ (function(module, exports, __webpack_require__) { + +var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +module.exports = mapCacheGet; + + +/***/ }), + +/***/ "./node_modules/lodash/_mapCacheHas.js": +/***/ (function(module, exports, __webpack_require__) { + +var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +module.exports = mapCacheHas; + + +/***/ }), + +/***/ "./node_modules/lodash/_mapCacheSet.js": +/***/ (function(module, exports, __webpack_require__) { + +var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; +} + +module.exports = mapCacheSet; + + +/***/ }), + +/***/ "./node_modules/lodash/_mapToArray.js": +/***/ (function(module, exports) { + +/** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ +function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; +} + +module.exports = mapToArray; + + +/***/ }), + +/***/ "./node_modules/lodash/_matchesStrictComparable.js": +/***/ (function(module, exports) { + +/** + * A specialized version of `matchesProperty` for source values suitable + * for strict equality comparisons, i.e. `===`. + * + * @private + * @param {string} key The key of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ +function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && + (srcValue !== undefined || (key in Object(object))); + }; +} + +module.exports = matchesStrictComparable; + + +/***/ }), + +/***/ "./node_modules/lodash/_memoizeCapped.js": +/***/ (function(module, exports, __webpack_require__) { + +var memoize = __webpack_require__("./node_modules/lodash/memoize.js"); + +/** Used as the maximum memoize cache size. */ +var MAX_MEMOIZE_SIZE = 500; + +/** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ +function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; +} + +module.exports = memoizeCapped; + + +/***/ }), + +/***/ "./node_modules/lodash/_nativeCreate.js": +/***/ (function(module, exports, __webpack_require__) { + +var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"); + +/* Built-in method references that are verified to be native. */ +var nativeCreate = getNative(Object, 'create'); + +module.exports = nativeCreate; + + +/***/ }), + +/***/ "./node_modules/lodash/_nativeKeys.js": +/***/ (function(module, exports, __webpack_require__) { + +var overArg = __webpack_require__("./node_modules/lodash/_overArg.js"); + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeKeys = overArg(Object.keys, Object); + +module.exports = nativeKeys; + + +/***/ }), + +/***/ "./node_modules/lodash/_nodeUtil.js": +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__("./node_modules/lodash/_freeGlobal.js"); + +/** Detect free variable `exports`. */ +var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; + +/** Detect free variable `module`. */ +var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; + +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports = freeModule && freeModule.exports === freeExports; + +/** Detect free variable `process` from Node.js. */ +var freeProcess = moduleExports && freeGlobal.process; + +/** Used to access faster Node.js helpers. */ +var nodeUtil = (function() { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } + + // Legacy `process.binding('util')` for Node.js < 10. + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} +}()); + +module.exports = nodeUtil; + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/module.js")(module))) + +/***/ }), + +/***/ "./node_modules/lodash/_objectToString.js": +/***/ (function(module, exports) { + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ +function objectToString(value) { + return nativeObjectToString.call(value); +} + +module.exports = objectToString; + + +/***/ }), + +/***/ "./node_modules/lodash/_overArg.js": +/***/ (function(module, exports) { + +/** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ +function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; +} + +module.exports = overArg; + + +/***/ }), + +/***/ "./node_modules/lodash/_root.js": +/***/ (function(module, exports, __webpack_require__) { + +var freeGlobal = __webpack_require__("./node_modules/lodash/_freeGlobal.js"); + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +module.exports = root; + + +/***/ }), + +/***/ "./node_modules/lodash/_setCacheAdd.js": +/***/ (function(module, exports) { + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ +function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; +} + +module.exports = setCacheAdd; + + +/***/ }), + +/***/ "./node_modules/lodash/_setCacheHas.js": +/***/ (function(module, exports) { + +/** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ +function setCacheHas(value) { + return this.__data__.has(value); +} + +module.exports = setCacheHas; + + +/***/ }), + +/***/ "./node_modules/lodash/_setToArray.js": +/***/ (function(module, exports) { + +/** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ +function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; +} + +module.exports = setToArray; + + +/***/ }), + +/***/ "./node_modules/lodash/_shuffleSelf.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseRandom = __webpack_require__("./node_modules/lodash/_baseRandom.js"); + +/** + * A specialized version of `_.shuffle` which mutates and sets the size of `array`. + * + * @private + * @param {Array} array The array to shuffle. + * @param {number} [size=array.length] The size of `array`. + * @returns {Array} Returns `array`. + */ +function shuffleSelf(array, size) { + var index = -1, + length = array.length, + lastIndex = length - 1; + + size = size === undefined ? length : size; + while (++index < size) { + var rand = baseRandom(index, lastIndex), + value = array[rand]; + + array[rand] = array[index]; + array[index] = value; + } + array.length = size; + return array; +} + +module.exports = shuffleSelf; + + +/***/ }), + +/***/ "./node_modules/lodash/_stackClear.js": +/***/ (function(module, exports, __webpack_require__) { + +var ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"); + +/** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ +function stackClear() { + this.__data__ = new ListCache; + this.size = 0; +} + +module.exports = stackClear; + + +/***/ }), + +/***/ "./node_modules/lodash/_stackDelete.js": +/***/ (function(module, exports) { + +/** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; +} + +module.exports = stackDelete; + + +/***/ }), + +/***/ "./node_modules/lodash/_stackGet.js": +/***/ (function(module, exports) { + +/** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function stackGet(key) { + return this.__data__.get(key); +} + +module.exports = stackGet; + + +/***/ }), + +/***/ "./node_modules/lodash/_stackHas.js": +/***/ (function(module, exports) { + +/** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function stackHas(key) { + return this.__data__.has(key); +} + +module.exports = stackHas; + + +/***/ }), + +/***/ "./node_modules/lodash/_stackSet.js": +/***/ (function(module, exports, __webpack_require__) { + +var ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"), + Map = __webpack_require__("./node_modules/lodash/_Map.js"), + MapCache = __webpack_require__("./node_modules/lodash/_MapCache.js"); + +/** Used as the size to enable large array optimizations. */ +var LARGE_ARRAY_SIZE = 200; + +/** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ +function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; +} + +module.exports = stackSet; + + +/***/ }), + +/***/ "./node_modules/lodash/_stringToPath.js": +/***/ (function(module, exports, __webpack_require__) { + +var memoizeCapped = __webpack_require__("./node_modules/lodash/_memoizeCapped.js"); + +/** Used to match property names within property paths. */ +var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ +var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); + +module.exports = stringToPath; + + +/***/ }), + +/***/ "./node_modules/lodash/_toKey.js": +/***/ (function(module, exports, __webpack_require__) { + +var isSymbol = __webpack_require__("./node_modules/lodash/isSymbol.js"); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +module.exports = toKey; + + +/***/ }), + +/***/ "./node_modules/lodash/_toSource.js": +/***/ (function(module, exports) { + +/** Used for built-in method references. */ +var funcProto = Function.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +module.exports = toSource; + + +/***/ }), + +/***/ "./node_modules/lodash/eq.js": +/***/ (function(module, exports) { + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +module.exports = eq; + + +/***/ }), + +/***/ "./node_modules/lodash/flatMap.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseFlatten = __webpack_require__("./node_modules/lodash/_baseFlatten.js"), + map = __webpack_require__("./node_modules/lodash/map.js"); + +/** + * Creates a flattened array of values by running each element in `collection` + * thru `iteratee` and flattening the mapped results. The iteratee is invoked + * with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [n, n]; + * } + * + * _.flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ +function flatMap(collection, iteratee) { + return baseFlatten(map(collection, iteratee), 1); +} + +module.exports = flatMap; + + +/***/ }), + +/***/ "./node_modules/lodash/get.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGet = __webpack_require__("./node_modules/lodash/_baseGet.js"); + +/** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ +function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; +} + +module.exports = get; + + +/***/ }), + +/***/ "./node_modules/lodash/hasIn.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseHasIn = __webpack_require__("./node_modules/lodash/_baseHasIn.js"), + hasPath = __webpack_require__("./node_modules/lodash/_hasPath.js"); + +/** + * Checks if `path` is a direct or inherited property of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b'); + * // => true + * + * _.hasIn(object, ['a', 'b']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */ +function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); +} + +module.exports = hasIn; + + +/***/ }), + +/***/ "./node_modules/lodash/identity.js": +/***/ (function(module, exports) { + +/** + * This method returns the first argument it receives. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'a': 1 }; + * + * console.log(_.identity(object) === object); + * // => true + */ +function identity(value) { + return value; +} + +module.exports = identity; + + +/***/ }), + +/***/ "./node_modules/lodash/isArguments.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseIsArguments = __webpack_require__("./node_modules/lodash/_baseIsArguments.js"), + isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** Built-in value references. */ +var propertyIsEnumerable = objectProto.propertyIsEnumerable; + +/** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ +var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && + !propertyIsEnumerable.call(value, 'callee'); +}; + +module.exports = isArguments; + + +/***/ }), + +/***/ "./node_modules/lodash/isArray.js": +/***/ (function(module, exports) { + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +module.exports = isArray; + + +/***/ }), + +/***/ "./node_modules/lodash/isArrayLike.js": +/***/ (function(module, exports, __webpack_require__) { + +var isFunction = __webpack_require__("./node_modules/lodash/isFunction.js"), + isLength = __webpack_require__("./node_modules/lodash/isLength.js"); + +/** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); +} + +module.exports = isArrayLike; + + +/***/ }), + +/***/ "./node_modules/lodash/isBuffer.js": +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__("./node_modules/lodash/_root.js"), + stubFalse = __webpack_require__("./node_modules/lodash/stubFalse.js"); + +/** Detect free variable `exports`. */ +var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; + +/** Detect free variable `module`. */ +var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; + +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports = freeModule && freeModule.exports === freeExports; + +/** Built-in value references. */ +var Buffer = moduleExports ? root.Buffer : undefined; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; + +/** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ +var isBuffer = nativeIsBuffer || stubFalse; + +module.exports = isBuffer; + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/module.js")(module))) + +/***/ }), + +/***/ "./node_modules/lodash/isFunction.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), + isObject = __webpack_require__("./node_modules/lodash/isObject.js"); + +/** `Object#toString` result references. */ +var asyncTag = '[object AsyncFunction]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + if (!isObject(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; +} + +module.exports = isFunction; + + +/***/ }), + +/***/ "./node_modules/lodash/isLength.js": +/***/ (function(module, exports) { + +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + +/** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ +function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +} + +module.exports = isLength; + + +/***/ }), + +/***/ "./node_modules/lodash/isObject.js": +/***/ (function(module, exports) { + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); +} + +module.exports = isObject; + + +/***/ }), + +/***/ "./node_modules/lodash/isObjectLike.js": +/***/ (function(module, exports) { + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return value != null && typeof value == 'object'; +} + +module.exports = isObjectLike; + + +/***/ }), + +/***/ "./node_modules/lodash/isSymbol.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), + isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); +} + +module.exports = isSymbol; + + +/***/ }), + +/***/ "./node_modules/lodash/isTypedArray.js": +/***/ (function(module, exports, __webpack_require__) { + +var baseIsTypedArray = __webpack_require__("./node_modules/lodash/_baseIsTypedArray.js"), + baseUnary = __webpack_require__("./node_modules/lodash/_baseUnary.js"), + nodeUtil = __webpack_require__("./node_modules/lodash/_nodeUtil.js"); + +/* Node.js helper references. */ +var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + +/** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ +var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + +module.exports = isTypedArray; + + +/***/ }), + +/***/ "./node_modules/lodash/keys.js": +/***/ (function(module, exports, __webpack_require__) { + +var arrayLikeKeys = __webpack_require__("./node_modules/lodash/_arrayLikeKeys.js"), + baseKeys = __webpack_require__("./node_modules/lodash/_baseKeys.js"), + isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"); + +/** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ +function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +} + +module.exports = keys; + + +/***/ }), + +/***/ "./node_modules/lodash/lodash.js": +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(global, module) {var __WEBPACK_AMD_DEFINE_RESULT__;/** + * @license + * Lodash + * Copyright JS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ +;(function() { + + /** Used as a safe reference for `undefined` in pre-ES5 environments. */ + var undefined; + + /** Used as the semantic version number. */ + var VERSION = '4.17.10'; + + /** Used as the size to enable large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** Error message constants. */ + var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.', + FUNC_ERROR_TEXT = 'Expected a function'; + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + + /** Used as the maximum memoize cache size. */ + var MAX_MEMOIZE_SIZE = 500; + + /** Used as the internal argument placeholder. */ + var PLACEHOLDER = '__lodash_placeholder__'; + + /** Used to compose bitmasks for cloning. */ + var CLONE_DEEP_FLAG = 1, + CLONE_FLAT_FLAG = 2, + CLONE_SYMBOLS_FLAG = 4; + + /** Used to compose bitmasks for value comparisons. */ + var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + + /** Used to compose bitmasks for function metadata. */ + var WRAP_BIND_FLAG = 1, + WRAP_BIND_KEY_FLAG = 2, + WRAP_CURRY_BOUND_FLAG = 4, + WRAP_CURRY_FLAG = 8, + WRAP_CURRY_RIGHT_FLAG = 16, + WRAP_PARTIAL_FLAG = 32, + WRAP_PARTIAL_RIGHT_FLAG = 64, + WRAP_ARY_FLAG = 128, + WRAP_REARG_FLAG = 256, + WRAP_FLIP_FLAG = 512; + + /** Used as default options for `_.truncate`. */ + var DEFAULT_TRUNC_LENGTH = 30, + DEFAULT_TRUNC_OMISSION = '...'; + + /** Used to detect hot functions by number of calls within a span of milliseconds. */ + var HOT_COUNT = 800, + HOT_SPAN = 16; + + /** Used to indicate the type of lazy iteratees. */ + var LAZY_FILTER_FLAG = 1, + LAZY_MAP_FLAG = 2, + LAZY_WHILE_FLAG = 3; + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0, + MAX_SAFE_INTEGER = 9007199254740991, + MAX_INTEGER = 1.7976931348623157e+308, + NAN = 0 / 0; + + /** Used as references for the maximum length and index of an array. */ + var MAX_ARRAY_LENGTH = 4294967295, + MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, + HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; + + /** Used to associate wrap methods with their bit flags. */ + var wrapFlags = [ + ['ary', WRAP_ARY_FLAG], + ['bind', WRAP_BIND_FLAG], + ['bindKey', WRAP_BIND_KEY_FLAG], + ['curry', WRAP_CURRY_FLAG], + ['curryRight', WRAP_CURRY_RIGHT_FLAG], + ['flip', WRAP_FLIP_FLAG], + ['partial', WRAP_PARTIAL_FLAG], + ['partialRight', WRAP_PARTIAL_RIGHT_FLAG], + ['rearg', WRAP_REARG_FLAG] + ]; + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + asyncTag = '[object AsyncFunction]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + domExcTag = '[object DOMException]', + errorTag = '[object Error]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + mapTag = '[object Map]', + numberTag = '[object Number]', + nullTag = '[object Null]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + proxyTag = '[object Proxy]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + symbolTag = '[object Symbol]', + undefinedTag = '[object Undefined]', + weakMapTag = '[object WeakMap]', + weakSetTag = '[object WeakSet]'; + + var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to match empty string literals in compiled template source. */ + var reEmptyStringLeading = /\b__p \+= '';/g, + reEmptyStringMiddle = /\b(__p \+=) '' \+/g, + reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; + + /** Used to match HTML entities and HTML characters. */ + var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, + reUnescapedHtml = /[&<>"']/g, + reHasEscapedHtml = RegExp(reEscapedHtml.source), + reHasUnescapedHtml = RegExp(reUnescapedHtml.source); + + /** Used to match template delimiters. */ + var reEscape = /<%-([\s\S]+?)%>/g, + reEvaluate = /<%([\s\S]+?)%>/g, + reInterpolate = /<%=([\s\S]+?)%>/g; + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, + reHasRegExpChar = RegExp(reRegExpChar.source); + + /** Used to match leading and trailing whitespace. */ + var reTrim = /^\s+|\s+$/g, + reTrimStart = /^\s+/, + reTrimEnd = /\s+$/; + + /** Used to match wrap detail comments. */ + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, + reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, + reSplitDetails = /,? & /; + + /** Used to match words composed of alphanumeric characters. */ + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * Used to match + * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). + */ + var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; + + /** Used to match `RegExp` flags from their coerced string values. */ + var reFlags = /\w*$/; + + /** Used to detect bad signed hexadecimal string values. */ + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + + /** Used to detect binary string values. */ + var reIsBinary = /^0b[01]+$/i; + + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used to detect octal string values. */ + var reIsOctal = /^0o[0-7]+$/i; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** Used to match Latin Unicode letters (excluding mathematical operators). */ + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + + /** Used to ensure capturing order of template delimiters. */ + var reNoMatch = /($^)/; + + /** Used to match unescaped characters in compiled string literals. */ + var reUnescapedString = /['\n\r\u2028\u2029\\]/g; + + /** Used to compose unicode character classes. */ + var rsAstralRange = '\\ud800-\\udfff', + rsComboMarksRange = '\\u0300-\\u036f', + reComboHalfMarksRange = '\\ufe20-\\ufe2f', + rsComboSymbolsRange = '\\u20d0-\\u20ff', + rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, + rsDingbatRange = '\\u2700-\\u27bf', + rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', + rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', + rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', + rsPunctuationRange = '\\u2000-\\u206f', + rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000', + rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', + rsVarRange = '\\ufe0e\\ufe0f', + rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; + + /** Used to compose unicode capture groups. */ + var rsApos = "['\u2019]", + rsAstral = '[' + rsAstralRange + ']', + rsBreak = '[' + rsBreakRange + ']', + rsCombo = '[' + rsComboRange + ']', + rsDigits = '\\d+', + rsDingbat = '[' + rsDingbatRange + ']', + rsLower = '[' + rsLowerRange + ']', + rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', + rsFitz = '\\ud83c[\\udffb-\\udfff]', + rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', + rsNonAstral = '[^' + rsAstralRange + ']', + rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', + rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', + rsUpper = '[' + rsUpperRange + ']', + rsZWJ = '\\u200d'; + + /** Used to compose unicode regexes. */ + var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')', + rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')', + rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', + rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', + reOptMod = rsModifier + '?', + rsOptVar = '[' + rsVarRange + ']?', + rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', + rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', + rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', + rsSeq = rsOptVar + reOptMod + rsOptJoin, + rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq, + rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; + + /** Used to match apostrophes. */ + var reApos = RegExp(rsApos, 'g'); + + /** + * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and + * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). + */ + var reComboMark = RegExp(rsCombo, 'g'); + + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ + var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); + + /** Used to match complex or compound words. */ + var reUnicodeWord = RegExp([ + rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')', + rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')', + rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower, + rsUpper + '+' + rsOptContrUpper, + rsOrdUpper, + rsOrdLower, + rsDigits, + rsEmoji + ].join('|'), 'g'); + + /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ + var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); + + /** Used to detect strings that need a more robust regexp to match words. */ + var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + + /** Used to assign default `context` object properties. */ + var contextProps = [ + 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array', + 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object', + 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array', + 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', + '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout' + ]; + + /** Used to make template sourceURLs easier to identify. */ + var templateCounter = -1; + + /** Used to identify `toStringTag` values of typed arrays. */ + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = + typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = + typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = + typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = + typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = + typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = + typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = + typedArrayTags[errorTag] = typedArrayTags[funcTag] = + typedArrayTags[mapTag] = typedArrayTags[numberTag] = + typedArrayTags[objectTag] = typedArrayTags[regexpTag] = + typedArrayTags[setTag] = typedArrayTags[stringTag] = + typedArrayTags[weakMapTag] = false; + + /** Used to identify `toStringTag` values supported by `_.clone`. */ + var cloneableTags = {}; + cloneableTags[argsTag] = cloneableTags[arrayTag] = + cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = + cloneableTags[boolTag] = cloneableTags[dateTag] = + cloneableTags[float32Tag] = cloneableTags[float64Tag] = + cloneableTags[int8Tag] = cloneableTags[int16Tag] = + cloneableTags[int32Tag] = cloneableTags[mapTag] = + cloneableTags[numberTag] = cloneableTags[objectTag] = + cloneableTags[regexpTag] = cloneableTags[setTag] = + cloneableTags[stringTag] = cloneableTags[symbolTag] = + cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = + cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; + cloneableTags[errorTag] = cloneableTags[funcTag] = + cloneableTags[weakMapTag] = false; + + /** Used to map Latin Unicode letters to basic Latin letters. */ + var deburredLetters = { + // Latin-1 Supplement block. + '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A', + '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a', + '\xc7': 'C', '\xe7': 'c', + '\xd0': 'D', '\xf0': 'd', + '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E', + '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e', + '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I', + '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i', + '\xd1': 'N', '\xf1': 'n', + '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O', + '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o', + '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U', + '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u', + '\xdd': 'Y', '\xfd': 'y', '\xff': 'y', + '\xc6': 'Ae', '\xe6': 'ae', + '\xde': 'Th', '\xfe': 'th', + '\xdf': 'ss', + // Latin Extended-A block. + '\u0100': 'A', '\u0102': 'A', '\u0104': 'A', + '\u0101': 'a', '\u0103': 'a', '\u0105': 'a', + '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C', + '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c', + '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd', + '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E', + '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e', + '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G', + '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g', + '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h', + '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I', + '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i', + '\u0134': 'J', '\u0135': 'j', + '\u0136': 'K', '\u0137': 'k', '\u0138': 'k', + '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L', + '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l', + '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N', + '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n', + '\u014c': 'O', '\u014e': 'O', '\u0150': 'O', + '\u014d': 'o', '\u014f': 'o', '\u0151': 'o', + '\u0154': 'R', '\u0156': 'R', '\u0158': 'R', + '\u0155': 'r', '\u0157': 'r', '\u0159': 'r', + '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S', + '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's', + '\u0162': 'T', '\u0164': 'T', '\u0166': 'T', + '\u0163': 't', '\u0165': 't', '\u0167': 't', + '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U', + '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u', + '\u0174': 'W', '\u0175': 'w', + '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y', + '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z', + '\u017a': 'z', '\u017c': 'z', '\u017e': 'z', + '\u0132': 'IJ', '\u0133': 'ij', + '\u0152': 'Oe', '\u0153': 'oe', + '\u0149': "'n", '\u017f': 's' + }; + + /** Used to map characters to HTML entities. */ + var htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' + }; + + /** Used to map HTML entities to characters. */ + var htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'" + }; + + /** Used to escape characters for inclusion in compiled string literals. */ + var stringEscapes = { + '\\': '\\', + "'": "'", + '\n': 'n', + '\r': 'r', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + /** Built-in method references without a dependency on `root`. */ + var freeParseFloat = parseFloat, + freeParseInt = parseInt; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + + /** Detect free variable `self`. */ + var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root = freeGlobal || freeSelf || Function('return this')(); + + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; + + /** Detect free variable `module`. */ + var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports = freeModule && freeModule.exports === freeExports; + + /** Detect free variable `process` from Node.js. */ + var freeProcess = moduleExports && freeGlobal.process; + + /** Used to access faster Node.js helpers. */ + var nodeUtil = (function() { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } + + // Legacy `process.binding('util')` for Node.js < 10. + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} + }()); + + /* Node.js helper references. */ + var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, + nodeIsDate = nodeUtil && nodeUtil.isDate, + nodeIsMap = nodeUtil && nodeUtil.isMap, + nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, + nodeIsSet = nodeUtil && nodeUtil.isSet, + nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + + /*--------------------------------------------------------------------------*/ + + /** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. + */ + function apply(func, thisArg, args) { + switch (args.length) { + case 0: return func.call(thisArg); + case 1: return func.call(thisArg, args[0]); + case 2: return func.call(thisArg, args[0], args[1]); + case 3: return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); + } + + /** + * A specialized version of `baseAggregator` for arrays. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ + function arrayAggregator(array, setter, iteratee, accumulator) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + var value = array[index]; + setter(accumulator, value, iteratee(value), array); + } + return accumulator; + } + + /** + * A specialized version of `_.forEach` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEach(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + + /** + * A specialized version of `_.forEachRight` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEachRight(array, iteratee) { + var length = array == null ? 0 : array.length; + + while (length--) { + if (iteratee(array[length], length, array) === false) { + break; + } + } + return array; + } + + /** + * A specialized version of `_.every` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + */ + function arrayEvery(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (!predicate(array[index], index, array)) { + return false; + } + } + return true; + } + + /** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; + } + + /** + * A specialized version of `_.includes` for arrays without support for + * specifying an index to search from. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */ + function arrayIncludes(array, value) { + var length = array == null ? 0 : array.length; + return !!length && baseIndexOf(array, value, 0) > -1; + } + + /** + * This function is like `arrayIncludes` except that it accepts a comparator. + * + * @private + * @param {Array} [array] The array to inspect. + * @param {*} target The value to search for. + * @param {Function} comparator The comparator invoked per element. + * @returns {boolean} Returns `true` if `target` is found, else `false`. + */ + function arrayIncludesWith(array, value, comparator) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (comparator(value, array[index])) { + return true; + } + } + return false; + } + + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + + /** + * A specialized version of `_.reduce` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the first element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, + length = array == null ? 0 : array.length; + + if (initAccum && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + + /** + * A specialized version of `_.reduceRight` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initAccum] Specify using the last element of `array` as + * the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduceRight(array, iteratee, accumulator, initAccum) { + var length = array == null ? 0 : array.length; + if (initAccum && length) { + accumulator = array[--length]; + } + while (length--) { + accumulator = iteratee(accumulator, array[length], length, array); + } + return accumulator; + } + + /** + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + + /** + * Gets the size of an ASCII `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ + var asciiSize = baseProperty('length'); + + /** + * Converts an ASCII `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function asciiToArray(string) { + return string.split(''); + } + + /** + * Splits an ASCII `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + function asciiWords(string) { + return string.match(reAsciiWord) || []; + } + + /** + * The base implementation of methods like `_.findKey` and `_.findLastKey`, + * without support for iteratee shorthands, which iterates over `collection` + * using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the found element or its key, else `undefined`. + */ + function baseFindKey(collection, predicate, eachFunc) { + var result; + eachFunc(collection, function(value, key, collection) { + if (predicate(value, key, collection)) { + result = key; + return false; + } + }); + return result; + } + + /** + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} predicate The function invoked per iteration. + * @param {number} fromIndex The index to search from. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, + index = fromIndex + (fromRight ? 1 : -1); + + while ((fromRight ? index-- : ++index < length)) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; + } + + /** + * The base implementation of `_.indexOf` without `fromIndex` bounds checks. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function baseIndexOf(array, value, fromIndex) { + return value === value + ? strictIndexOf(array, value, fromIndex) + : baseFindIndex(array, baseIsNaN, fromIndex); + } + + /** + * This function is like `baseIndexOf` except that it accepts a comparator. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @param {Function} comparator The comparator invoked per element. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function baseIndexOfWith(array, value, fromIndex, comparator) { + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (comparator(array[index], value)) { + return index; + } + } + return -1; + } + + /** + * The base implementation of `_.isNaN` without support for number objects. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + */ + function baseIsNaN(value) { + return value !== value; + } + + /** + * The base implementation of `_.mean` and `_.meanBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {number} Returns the mean. + */ + function baseMean(array, iteratee) { + var length = array == null ? 0 : array.length; + return length ? (baseSum(array, iteratee) / length) : NAN; + } + + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new accessor function. + */ + function baseProperty(key) { + return function(object) { + return object == null ? undefined : object[key]; + }; + } + + /** + * The base implementation of `_.propertyOf` without support for deep paths. + * + * @private + * @param {Object} object The object to query. + * @returns {Function} Returns the new accessor function. + */ + function basePropertyOf(object) { + return function(key) { + return object == null ? undefined : object[key]; + }; + } + + /** + * The base implementation of `_.reduce` and `_.reduceRight`, without support + * for iteratee shorthands, which iterates over `collection` using `eachFunc`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} accumulator The initial value. + * @param {boolean} initAccum Specify using the first or last element of + * `collection` as the initial value. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the accumulated value. + */ + function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { + eachFunc(collection, function(value, index, collection) { + accumulator = initAccum + ? (initAccum = false, value) + : iteratee(accumulator, value, index, collection); + }); + return accumulator; + } + + /** + * The base implementation of `_.sortBy` which uses `comparer` to define the + * sort order of `array` and replaces criteria objects with their corresponding + * values. + * + * @private + * @param {Array} array The array to sort. + * @param {Function} comparer The function to define sort order. + * @returns {Array} Returns `array`. + */ + function baseSortBy(array, comparer) { + var length = array.length; + + array.sort(comparer); + while (length--) { + array[length] = array[length].value; + } + return array; + } + + /** + * The base implementation of `_.sum` and `_.sumBy` without support for + * iteratee shorthands. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {number} Returns the sum. + */ + function baseSum(array, iteratee) { + var result, + index = -1, + length = array.length; + + while (++index < length) { + var current = iteratee(array[index]); + if (current !== undefined) { + result = result === undefined ? current : (result + current); + } + } + return result; + } + + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + + /** + * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array + * of key-value pairs for `object` corresponding to the property names of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the key-value pairs. + */ + function baseToPairs(object, props) { + return arrayMap(props, function(key) { + return [key, object[key]]; + }); + } + + /** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ + function baseUnary(func) { + return function(value) { + return func(value); + }; + } + + /** + * The base implementation of `_.values` and `_.valuesIn` which creates an + * array of `object` property values corresponding to the property names + * of `props`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} props The property names to get values for. + * @returns {Object} Returns the array of property values. + */ + function baseValues(object, props) { + return arrayMap(props, function(key) { + return object[key]; + }); + } + + /** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function cacheHas(cache, key) { + return cache.has(key); + } + + /** + * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the first unmatched string symbol. + */ + function charsStartIndex(strSymbols, chrSymbols) { + var index = -1, + length = strSymbols.length; + + while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} + return index; + } + + /** + * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol + * that is not found in the character symbols. + * + * @private + * @param {Array} strSymbols The string symbols to inspect. + * @param {Array} chrSymbols The character symbols to find. + * @returns {number} Returns the index of the last unmatched string symbol. + */ + function charsEndIndex(strSymbols, chrSymbols) { + var index = strSymbols.length; + + while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} + return index; + } + + /** + * Gets the number of `placeholder` occurrences in `array`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} placeholder The placeholder to search for. + * @returns {number} Returns the placeholder count. + */ + function countHolders(array, placeholder) { + var length = array.length, + result = 0; + + while (length--) { + if (array[length] === placeholder) { + ++result; + } + } + return result; + } + + /** + * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A + * letters to basic Latin letters. + * + * @private + * @param {string} letter The matched letter to deburr. + * @returns {string} Returns the deburred letter. + */ + var deburrLetter = basePropertyOf(deburredLetters); + + /** + * Used by `_.escape` to convert characters to HTML entities. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ + var escapeHtmlChar = basePropertyOf(htmlEscapes); + + /** + * Used by `_.template` to escape characters for inclusion in compiled string literals. + * + * @private + * @param {string} chr The matched character to escape. + * @returns {string} Returns the escaped character. + */ + function escapeStringChar(chr) { + return '\\' + stringEscapes[chr]; + } + + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function getValue(object, key) { + return object == null ? undefined : object[key]; + } + + /** + * Checks if `string` contains Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. + */ + function hasUnicode(string) { + return reHasUnicode.test(string); + } + + /** + * Checks if `string` contains a word composed of Unicode symbols. + * + * @private + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a word is found, else `false`. + */ + function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + + /** + * Converts `iterator` to an array. + * + * @private + * @param {Object} iterator The iterator to convert. + * @returns {Array} Returns the converted array. + */ + function iteratorToArray(iterator) { + var data, + result = []; + + while (!(data = iterator.next()).done) { + result.push(data.value); + } + return result; + } + + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + + /** + * Replaces all `placeholder` elements in `array` with an internal placeholder + * and returns an array of their indexes. + * + * @private + * @param {Array} array The array to modify. + * @param {*} placeholder The placeholder to replace. + * @returns {Array} Returns the new array of placeholder indexes. + */ + function replaceHolders(array, placeholder) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (value === placeholder || value === PLACEHOLDER) { + array[index] = PLACEHOLDER; + result[resIndex++] = index; + } + } + return result; + } + + /** + * Gets the value at `key`, unless `key` is "__proto__". + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function safeGet(object, key) { + return key == '__proto__' + ? undefined + : object[key]; + } + + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + + /** + * Converts `set` to its value-value pairs. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the value-value pairs. + */ + function setToPairs(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = [value, value]; + }); + return result; + } + + /** + * A specialized version of `_.indexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; + } + + /** + * A specialized version of `_.lastIndexOf` which performs strict equality + * comparisons of values, i.e. `===`. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function strictLastIndexOf(array, value, fromIndex) { + var index = fromIndex + 1; + while (index--) { + if (array[index] === value) { + return index; + } + } + return index; + } + + /** + * Gets the number of symbols in `string`. + * + * @private + * @param {string} string The string to inspect. + * @returns {number} Returns the string size. + */ + function stringSize(string) { + return hasUnicode(string) + ? unicodeSize(string) + : asciiSize(string); + } + + /** + * Converts `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function stringToArray(string) { + return hasUnicode(string) + ? unicodeToArray(string) + : asciiToArray(string); + } + + /** + * Used by `_.unescape` to convert HTML entities to characters. + * + * @private + * @param {string} chr The matched character to unescape. + * @returns {string} Returns the unescaped character. + */ + var unescapeHtmlChar = basePropertyOf(htmlUnescapes); + + /** + * Gets the size of a Unicode `string`. + * + * @private + * @param {string} string The string inspect. + * @returns {number} Returns the string size. + */ + function unicodeSize(string) { + var result = reUnicode.lastIndex = 0; + while (reUnicode.test(string)) { + ++result; + } + return result; + } + + /** + * Converts a Unicode `string` to an array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. + */ + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + + /** + * Splits a Unicode `string` into an array of its words. + * + * @private + * @param {string} The string to inspect. + * @returns {Array} Returns the words of `string`. + */ + function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + + /*--------------------------------------------------------------------------*/ + + /** + * Create a new pristine `lodash` function using the `context` object. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Util + * @param {Object} [context=root] The context object. + * @returns {Function} Returns a new `lodash` function. + * @example + * + * _.mixin({ 'foo': _.constant('foo') }); + * + * var lodash = _.runInContext(); + * lodash.mixin({ 'bar': lodash.constant('bar') }); + * + * _.isFunction(_.foo); + * // => true + * _.isFunction(_.bar); + * // => false + * + * lodash.isFunction(lodash.foo); + * // => false + * lodash.isFunction(lodash.bar); + * // => true + * + * // Create a suped-up `defer` in Node.js. + * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; + */ + var runInContext = (function runInContext(context) { + context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps)); + + /** Built-in constructor references. */ + var Array = context.Array, + Date = context.Date, + Error = context.Error, + Function = context.Function, + Math = context.Math, + Object = context.Object, + RegExp = context.RegExp, + String = context.String, + TypeError = context.TypeError; + + /** Used for built-in method references. */ + var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + + /** Used to detect overreaching core-js shims. */ + var coreJsData = context['__core-js_shared__']; + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Used to generate unique IDs. */ + var idCounter = 0; + + /** Used to detect methods masquerading as native. */ + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; + }()); + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto.toString; + + /** Used to infer the `Object` constructor. */ + var objectCtorString = funcToString.call(Object); + + /** Used to restore the original `_` reference in `_.noConflict`. */ + var oldDash = root._; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** Built-in value references. */ + var Buffer = moduleExports ? context.Buffer : undefined, + Symbol = context.Symbol, + Uint8Array = context.Uint8Array, + allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined, + getPrototype = overArg(Object.getPrototypeOf, Object), + objectCreate = Object.create, + propertyIsEnumerable = objectProto.propertyIsEnumerable, + splice = arrayProto.splice, + spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined, + symIterator = Symbol ? Symbol.iterator : undefined, + symToStringTag = Symbol ? Symbol.toStringTag : undefined; + + var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} + }()); + + /** Mocked built-ins. */ + var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, + ctxNow = Date && Date.now !== root.Date.now && Date.now, + ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeCeil = Math.ceil, + nativeFloor = Math.floor, + nativeGetSymbols = Object.getOwnPropertySymbols, + nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, + nativeIsFinite = context.isFinite, + nativeJoin = arrayProto.join, + nativeKeys = overArg(Object.keys, Object), + nativeMax = Math.max, + nativeMin = Math.min, + nativeNow = Date.now, + nativeParseInt = context.parseInt, + nativeRandom = Math.random, + nativeReverse = arrayProto.reverse; + + /* Built-in method references that are verified to be native. */ + var DataView = getNative(context, 'DataView'), + Map = getNative(context, 'Map'), + Promise = getNative(context, 'Promise'), + Set = getNative(context, 'Set'), + WeakMap = getNative(context, 'WeakMap'), + nativeCreate = getNative(Object, 'create'); + + /** Used to store function metadata. */ + var metaMap = WeakMap && new WeakMap; + + /** Used to lookup unminified function names. */ + var realNames = {}; + + /** Used to detect maps, sets, and weakmaps. */ + var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolValueOf = symbolProto ? symbolProto.valueOf : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a `lodash` object which wraps `value` to enable implicit method + * chain sequences. Methods that operate on and return arrays, collections, + * and functions can be chained together. Methods that retrieve a single value + * or may return a primitive value will automatically end the chain sequence + * and return the unwrapped value. Otherwise, the value must be unwrapped + * with `_#value`. + * + * Explicit chain sequences, which must be unwrapped with `_#value`, may be + * enabled using `_.chain`. + * + * The execution of chained methods is lazy, that is, it's deferred until + * `_#value` is implicitly or explicitly called. + * + * Lazy evaluation allows several methods to support shortcut fusion. + * Shortcut fusion is an optimization to merge iteratee calls; this avoids + * the creation of intermediate arrays and can greatly reduce the number of + * iteratee executions. Sections of a chain sequence qualify for shortcut + * fusion if the section is applied to an array and iteratees accept only + * one argument. The heuristic for whether a section qualifies for shortcut + * fusion is subject to change. + * + * Chaining is supported in custom builds as long as the `_#value` method is + * directly or indirectly included in the build. + * + * In addition to lodash methods, wrappers have `Array` and `String` methods. + * + * The wrapper `Array` methods are: + * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` + * + * The wrapper `String` methods are: + * `replace` and `split` + * + * The wrapper methods that support shortcut fusion are: + * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, + * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, + * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` + * + * The chainable wrapper methods are: + * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, + * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, + * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, + * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, + * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, + * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, + * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, + * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, + * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, + * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, + * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, + * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, + * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, + * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, + * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, + * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, + * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, + * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, + * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, + * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, + * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, + * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, + * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, + * `zipObject`, `zipObjectDeep`, and `zipWith` + * + * The wrapper methods that are **not** chainable by default are: + * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, + * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, + * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, + * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, + * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, + * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, + * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, + * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, + * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, + * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, + * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, + * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, + * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, + * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, + * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, + * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, + * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, + * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, + * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, + * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, + * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, + * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, + * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, + * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, + * `upperFirst`, `value`, and `words` + * + * @name _ + * @constructor + * @category Seq + * @param {*} value The value to wrap in a `lodash` instance. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2, 3]); + * + * // Returns an unwrapped value. + * wrapped.reduce(_.add); + * // => 6 + * + * // Returns a wrapped value. + * var squares = wrapped.map(square); + * + * _.isArray(squares); + * // => false + * + * _.isArray(squares.value()); + * // => true + */ + function lodash(value) { + if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { + if (value instanceof LodashWrapper) { + return value; + } + if (hasOwnProperty.call(value, '__wrapped__')) { + return wrapperClone(value); + } + } + return new LodashWrapper(value); + } + + /** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. + */ + var baseCreate = (function() { + function object() {} + return function(proto) { + if (!isObject(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object.prototype = proto; + var result = new object; + object.prototype = undefined; + return result; + }; + }()); + + /** + * The function whose prototype chain sequence wrappers inherit from. + * + * @private + */ + function baseLodash() { + // No operation performed. + } + + /** + * The base constructor for creating `lodash` wrapper objects. + * + * @private + * @param {*} value The value to wrap. + * @param {boolean} [chainAll] Enable explicit method chain sequences. + */ + function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = !!chainAll; + this.__index__ = 0; + this.__values__ = undefined; + } + + /** + * By default, the template delimiters used by lodash are like those in + * embedded Ruby (ERB) as well as ES2015 template strings. Change the + * following template settings to use alternative delimiters. + * + * @static + * @memberOf _ + * @type {Object} + */ + lodash.templateSettings = { + + /** + * Used to detect `data` property values to be HTML-escaped. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'escape': reEscape, + + /** + * Used to detect code to be evaluated. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'evaluate': reEvaluate, + + /** + * Used to detect `data` property values to inject. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + 'interpolate': reInterpolate, + + /** + * Used to reference the data object in the template text. + * + * @memberOf _.templateSettings + * @type {string} + */ + 'variable': '', + + /** + * Used to import variables into the compiled template. + * + * @memberOf _.templateSettings + * @type {Object} + */ + 'imports': { + + /** + * A reference to the `lodash` function. + * + * @memberOf _.templateSettings.imports + * @type {Function} + */ + '_': lodash + } + }; + + // Ensure wrappers are instances of `baseLodash`. + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + + LodashWrapper.prototype = baseCreate(baseLodash.prototype); + LodashWrapper.prototype.constructor = LodashWrapper; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. + * + * @private + * @constructor + * @param {*} value The value to wrap. + */ + function LazyWrapper(value) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + + /** + * Creates a clone of the lazy wrapper object. + * + * @private + * @name clone + * @memberOf LazyWrapper + * @returns {Object} Returns the cloned `LazyWrapper` object. + */ + function lazyClone() { + var result = new LazyWrapper(this.__wrapped__); + result.__actions__ = copyArray(this.__actions__); + result.__dir__ = this.__dir__; + result.__filtered__ = this.__filtered__; + result.__iteratees__ = copyArray(this.__iteratees__); + result.__takeCount__ = this.__takeCount__; + result.__views__ = copyArray(this.__views__); + return result; + } + + /** + * Reverses the direction of lazy iteration. + * + * @private + * @name reverse + * @memberOf LazyWrapper + * @returns {Object} Returns the new reversed `LazyWrapper` object. + */ + function lazyReverse() { + if (this.__filtered__) { + var result = new LazyWrapper(this); + result.__dir__ = -1; + result.__filtered__ = true; + } else { + result = this.clone(); + result.__dir__ *= -1; + } + return result; + } + + /** + * Extracts the unwrapped value from its lazy wrapper. + * + * @private + * @name value + * @memberOf LazyWrapper + * @returns {*} Returns the unwrapped value. + */ + function lazyValue() { + var array = this.__wrapped__.value(), + dir = this.__dir__, + isArr = isArray(array), + isRight = dir < 0, + arrLength = isArr ? array.length : 0, + view = getView(0, arrLength, this.__views__), + start = view.start, + end = view.end, + length = end - start, + index = isRight ? end : (start - 1), + iteratees = this.__iteratees__, + iterLength = iteratees.length, + resIndex = 0, + takeCount = nativeMin(length, this.__takeCount__); + + if (!isArr || (!isRight && arrLength == length && takeCount == length)) { + return baseWrapperValue(array, this.__actions__); + } + var result = []; + + outer: + while (length-- && resIndex < takeCount) { + index += dir; + + var iterIndex = -1, + value = array[index]; + + while (++iterIndex < iterLength) { + var data = iteratees[iterIndex], + iteratee = data.iteratee, + type = data.type, + computed = iteratee(value); + + if (type == LAZY_MAP_FLAG) { + value = computed; + } else if (!computed) { + if (type == LAZY_FILTER_FLAG) { + continue outer; + } else { + break outer; + } + } + } + result[resIndex++] = value; + } + return result; + } + + // Ensure `LazyWrapper` is an instance of `baseLodash`. + LazyWrapper.prototype = baseCreate(baseLodash.prototype); + LazyWrapper.prototype.constructor = LazyWrapper; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; + } + + /** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; + } + + /** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; + } + + /** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); + } + + /** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ + function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; + } + + // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + + /*------------------------------------------------------------------------*/ + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + + /** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; + } + + /** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; + } + + /** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + + /** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ + function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + + // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + /** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ + function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; + } + + /** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; + } + + /** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + + /** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + + /** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ + function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + /*------------------------------------------------------------------------*/ + + /** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ + function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } + } + + /** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ + function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; + } + + /** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ + function setCacheHas(value) { + return this.__data__.has(value); + } + + // Add methods to `SetCache`. + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + + /*------------------------------------------------------------------------*/ + + /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; + } + + /** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ + function stackClear() { + this.__data__ = new ListCache; + this.size = 0; + } + + /** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; + } + + /** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function stackGet(key) { + return this.__data__.get(key); + } + + /** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function stackHas(key) { + return this.__data__.has(key); + } + + /** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ + function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; + } + + // Add methods to `Stack`. + Stack.prototype.clear = stackClear; + Stack.prototype['delete'] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + + /*------------------------------------------------------------------------*/ + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), + isArg = !isArr && isArguments(value), + isBuff = !isArr && !isArg && isBuffer(value), + isType = !isArr && !isArg && !isBuff && isTypedArray(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; + } + + /** + * A specialized version of `_.sample` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @returns {*} Returns the random element. + */ + function arraySample(array) { + var length = array.length; + return length ? array[baseRandom(0, length - 1)] : undefined; + } + + /** + * A specialized version of `_.sampleSize` for arrays. + * + * @private + * @param {Array} array The array to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ + function arraySampleSize(array, n) { + return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); + } + + /** + * A specialized version of `_.shuffle` for arrays. + * + * @private + * @param {Array} array The array to shuffle. + * @returns {Array} Returns the new shuffled array. + */ + function arrayShuffle(array) { + return shuffleSelf(copyArray(array)); + } + + /** + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignMergeValue(object, key, value) { + if ((value !== undefined && !eq(object[key], value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + + /** + * Aggregates elements of `collection` on `accumulator` with keys transformed + * by `iteratee` and values set by `setter`. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform keys. + * @param {Object} accumulator The initial aggregated object. + * @returns {Function} Returns `accumulator`. + */ + function baseAggregator(collection, setter, iteratee, accumulator) { + baseEach(collection, function(value, key, collection) { + setter(accumulator, value, iteratee(value), collection); + }); + return accumulator; + } + + /** + * The base implementation of `_.assign` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + function baseAssign(object, source) { + return object && copyObject(source, keys(source), object); + } + + /** + * The base implementation of `_.assignIn` without support for multiple sources + * or `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + function baseAssignIn(object, source) { + return object && copyObject(source, keysIn(source), object); + } + + /** + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty) { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; + } + } + + /** + * The base implementation of `_.at` without support for individual paths. + * + * @private + * @param {Object} object The object to iterate over. + * @param {string[]} paths The property paths to pick. + * @returns {Array} Returns the picked elements. + */ + function baseAt(object, paths) { + var index = -1, + length = paths.length, + result = Array(length), + skip = object == null; + + while (++index < length) { + result[index] = skip ? undefined : get(object, paths[index]); + } + return result; + } + + /** + * The base implementation of `_.clamp` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + */ + function baseClamp(number, lower, upper) { + if (number === number) { + if (upper !== undefined) { + number = number <= upper ? number : upper; + } + if (lower !== undefined) { + number = number >= lower ? number : lower; + } + } + return number; + } + + /** + * The base implementation of `_.clone` and `_.cloneDeep` which tracks + * traversed objects. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} bitmask The bitmask flags. + * 1 - Deep clone + * 2 - Flatten inherited properties + * 4 - Clone symbols + * @param {Function} [customizer] The function to customize cloning. + * @param {string} [key] The key of `value`. + * @param {Object} [object] The parent object of `value`. + * @param {Object} [stack] Tracks traversed objects and their clone counterparts. + * @returns {*} Returns the cloned value. + */ + function baseClone(value, bitmask, customizer, key, object, stack) { + var result, + isDeep = bitmask & CLONE_DEEP_FLAG, + isFlat = bitmask & CLONE_FLAT_FLAG, + isFull = bitmask & CLONE_SYMBOLS_FLAG; + + if (customizer) { + result = object ? customizer(value, key, object, stack) : customizer(value); + } + if (result !== undefined) { + return result; + } + if (!isObject(value)) { + return value; + } + var isArr = isArray(value); + if (isArr) { + result = initCloneArray(value); + if (!isDeep) { + return copyArray(value, result); + } + } else { + var tag = getTag(value), + isFunc = tag == funcTag || tag == genTag; + + if (isBuffer(value)) { + return cloneBuffer(value, isDeep); + } + if (tag == objectTag || tag == argsTag || (isFunc && !object)) { + result = (isFlat || isFunc) ? {} : initCloneObject(value); + if (!isDeep) { + return isFlat + ? copySymbolsIn(value, baseAssignIn(result, value)) + : copySymbols(value, baseAssign(result, value)); + } + } else { + if (!cloneableTags[tag]) { + return object ? value : {}; + } + result = initCloneByTag(value, tag, isDeep); + } + } + // Check for circular references and return its corresponding clone. + stack || (stack = new Stack); + var stacked = stack.get(value); + if (stacked) { + return stacked; + } + stack.set(value, result); + + if (isSet(value)) { + value.forEach(function(subValue) { + result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); + }); + + return result; + } + + if (isMap(value)) { + value.forEach(function(subValue, key) { + result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); + }); + + return result; + } + + var keysFunc = isFull + ? (isFlat ? getAllKeysIn : getAllKeys) + : (isFlat ? keysIn : keys); + + var props = isArr ? undefined : keysFunc(value); + arrayEach(props || value, function(subValue, key) { + if (props) { + key = subValue; + subValue = value[key]; + } + // Recursively populate clone (susceptible to call stack limits). + assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); + }); + return result; + } + + /** + * The base implementation of `_.conforms` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property predicates to conform to. + * @returns {Function} Returns the new spec function. + */ + function baseConforms(source) { + var props = keys(source); + return function(object) { + return baseConformsTo(object, source, props); + }; + } + + /** + * The base implementation of `_.conformsTo` which accepts `props` to check. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + */ + function baseConformsTo(object, source, props) { + var length = props.length; + if (object == null) { + return !length; + } + object = Object(object); + while (length--) { + var key = props[length], + predicate = source[key], + value = object[key]; + + if ((value === undefined && !(key in object)) || !predicate(value)) { + return false; + } + } + return true; + } + + /** + * The base implementation of `_.delay` and `_.defer` which accepts `args` + * to provide to `func`. + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {Array} args The arguments to provide to `func`. + * @returns {number|Object} Returns the timer id or timeout object. + */ + function baseDelay(func, wait, args) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + return setTimeout(function() { func.apply(undefined, args); }, wait); + } + + /** + * The base implementation of methods like `_.difference` without support + * for excluding multiple arrays or iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Array} values The values to exclude. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + */ + function baseDifference(array, values, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + isCommon = true, + length = array.length, + result = [], + valuesLength = values.length; + + if (!length) { + return result; + } + if (iteratee) { + values = arrayMap(values, baseUnary(iteratee)); + } + if (comparator) { + includes = arrayIncludesWith; + isCommon = false; + } + else if (values.length >= LARGE_ARRAY_SIZE) { + includes = cacheHas; + isCommon = false; + values = new SetCache(values); + } + outer: + while (++index < length) { + var value = array[index], + computed = iteratee == null ? value : iteratee(value); + + value = (comparator || value !== 0) ? value : 0; + if (isCommon && computed === computed) { + var valuesIndex = valuesLength; + while (valuesIndex--) { + if (values[valuesIndex] === computed) { + continue outer; + } + } + result.push(value); + } + else if (!includes(values, computed, comparator)) { + result.push(value); + } + } + return result; + } + + /** + * The base implementation of `_.forEach` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + var baseEach = createBaseEach(baseForOwn); + + /** + * The base implementation of `_.forEachRight` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + */ + var baseEachRight = createBaseEach(baseForOwnRight, true); + + /** + * The base implementation of `_.every` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false` + */ + function baseEvery(collection, predicate) { + var result = true; + baseEach(collection, function(value, index, collection) { + result = !!predicate(value, index, collection); + return result; + }); + return result; + } + + /** + * The base implementation of methods like `_.max` and `_.min` which accepts a + * `comparator` to determine the extremum value. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The iteratee invoked per iteration. + * @param {Function} comparator The comparator used to compare values. + * @returns {*} Returns the extremum value. + */ + function baseExtremum(array, iteratee, comparator) { + var index = -1, + length = array.length; + + while (++index < length) { + var value = array[index], + current = iteratee(value); + + if (current != null && (computed === undefined + ? (current === current && !isSymbol(current)) + : comparator(current, computed) + )) { + var computed = current, + result = value; + } + } + return result; + } + + /** + * The base implementation of `_.fill` without an iteratee call guard. + * + * @private + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + */ + function baseFill(array, value, start, end) { + var length = array.length; + + start = toInteger(start); + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = (end === undefined || end > length) ? length : toInteger(end); + if (end < 0) { + end += length; + } + end = start > end ? 0 : toLength(end); + while (start < end) { + array[start++] = value; + } + return array; + } + + /** + * The base implementation of `_.filter` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + function baseFilter(collection, predicate) { + var result = []; + baseEach(collection, function(value, index, collection) { + if (predicate(value, index, collection)) { + result.push(value); + } + }); + return result; + } + + /** + * The base implementation of `_.flatten` with support for restricting flattening. + * + * @private + * @param {Array} array The array to flatten. + * @param {number} depth The maximum recursion depth. + * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. + * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ + function baseFlatten(array, depth, predicate, isStrict, result) { + var index = -1, + length = array.length; + + predicate || (predicate = isFlattenable); + result || (result = []); + + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, depth - 1, predicate, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; + } + + /** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseFor = createBaseFor(); + + /** + * This function is like `baseFor` except that it iterates over properties + * in the opposite order. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseForRight = createBaseFor(true); + + /** + * The base implementation of `_.forOwn` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwn(object, iteratee) { + return object && baseFor(object, iteratee, keys); + } + + /** + * The base implementation of `_.forOwnRight` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwnRight(object, iteratee) { + return object && baseForRight(object, iteratee, keys); + } + + /** + * The base implementation of `_.functions` which creates an array of + * `object` function property names filtered from `props`. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} props The property names to filter. + * @returns {Array} Returns the function names. + */ + function baseFunctions(object, props) { + return arrayFilter(props, function(key) { + return isFunction(object[key]); + }); + } + + /** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; + } + + /** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); + } + + /** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); + } + + /** + * The base implementation of `_.gt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + */ + function baseGt(value, other) { + return value > other; + } + + /** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + function baseHas(object, key) { + return object != null && hasOwnProperty.call(object, key); + } + + /** + * The base implementation of `_.hasIn` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + function baseHasIn(object, key) { + return object != null && key in Object(object); + } + + /** + * The base implementation of `_.inRange` which doesn't coerce arguments. + * + * @private + * @param {number} number The number to check. + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + */ + function baseInRange(number, start, end) { + return number >= nativeMin(start, end) && number < nativeMax(start, end); + } + + /** + * The base implementation of methods like `_.intersection`, without support + * for iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of shared values. + */ + function baseIntersection(arrays, iteratee, comparator) { + var includes = comparator ? arrayIncludesWith : arrayIncludes, + length = arrays[0].length, + othLength = arrays.length, + othIndex = othLength, + caches = Array(othLength), + maxLength = Infinity, + result = []; + + while (othIndex--) { + var array = arrays[othIndex]; + if (othIndex && iteratee) { + array = arrayMap(array, baseUnary(iteratee)); + } + maxLength = nativeMin(array.length, maxLength); + caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120)) + ? new SetCache(othIndex && array) + : undefined; + } + array = arrays[0]; + + var index = -1, + seen = caches[0]; + + outer: + while (++index < length && result.length < maxLength) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + value = (comparator || value !== 0) ? value : 0; + if (!(seen + ? cacheHas(seen, computed) + : includes(result, computed, comparator) + )) { + othIndex = othLength; + while (--othIndex) { + var cache = caches[othIndex]; + if (!(cache + ? cacheHas(cache, computed) + : includes(arrays[othIndex], computed, comparator)) + ) { + continue outer; + } + } + if (seen) { + seen.push(computed); + } + result.push(value); + } + } + return result; + } + + /** + * The base implementation of `_.invert` and `_.invertBy` which inverts + * `object` with values transformed by `iteratee` and set by `setter`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} setter The function to set `accumulator` values. + * @param {Function} iteratee The iteratee to transform values. + * @param {Object} accumulator The initial inverted object. + * @returns {Function} Returns `accumulator`. + */ + function baseInverter(object, setter, iteratee, accumulator) { + baseForOwn(object, function(value, key, object) { + setter(accumulator, iteratee(value), key, object); + }); + return accumulator; + } + + /** + * The base implementation of `_.invoke` without support for individual + * method arguments. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {Array} args The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + */ + function baseInvoke(object, path, args) { + path = castPath(path, object); + object = parent(object, path); + var func = object == null ? object : object[toKey(last(path))]; + return func == null ? undefined : apply(func, object, args); + } + + /** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ + function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; + } + + /** + * The base implementation of `_.isArrayBuffer` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + */ + function baseIsArrayBuffer(value) { + return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; + } + + /** + * The base implementation of `_.isDate` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + */ + function baseIsDate(value) { + return isObjectLike(value) && baseGetTag(value) == dateTag; + } + + /** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); + } + + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = objIsArr ? arrayTag : getTag(object), + othTag = othIsArr ? arrayTag : getTag(other); + + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack); + return (objIsArr || isTypedArray(object)) + ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) + : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + + stack || (stack = new Stack); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); + } + + /** + * The base implementation of `_.isMap` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + */ + function baseIsMap(value) { + return isObjectLike(value) && getTag(value) == mapTag; + } + + /** + * The base implementation of `_.isMatch` without support for iteratee shorthands. + * + * @private + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Array} matchData The property names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + */ + function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + + if (object == null) { + return !length; + } + object = Object(object); + while (index--) { + var data = matchData[index]; + if ((noCustomizer && data[2]) + ? data[1] !== object[data[0]] + : !(data[0] in object) + ) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + + if (noCustomizer && data[2]) { + if (objValue === undefined && !(key in object)) { + return false; + } + } else { + var stack = new Stack; + if (customizer) { + var result = customizer(objValue, srcValue, key, object, source, stack); + } + if (!(result === undefined + ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) + : result + )) { + return false; + } + } + } + return true; + } + + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + + /** + * The base implementation of `_.isRegExp` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + */ + function baseIsRegExp(value) { + return isObjectLike(value) && baseGetTag(value) == regexpTag; + } + + /** + * The base implementation of `_.isSet` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + */ + function baseIsSet(value) { + return isObjectLike(value) && getTag(value) == setTag; + } + + /** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ + function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; + } + + /** + * The base implementation of `_.iteratee`. + * + * @private + * @param {*} [value=_.identity] The value to convert to an iteratee. + * @returns {Function} Returns the iteratee. + */ + function baseIteratee(value) { + // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. + // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. + if (typeof value == 'function') { + return value; + } + if (value == null) { + return identity; + } + if (typeof value == 'object') { + return isArray(value) + ? baseMatchesProperty(value[0], value[1]) + : baseMatches(value); + } + return property(value); + } + + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; + } + + /** + * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeysIn(object) { + if (!isObject(object)) { + return nativeKeysIn(object); + } + var isProto = isPrototype(object), + result = []; + + for (var key in object) { + if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + return result; + } + + /** + * The base implementation of `_.lt` which doesn't coerce arguments. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + */ + function baseLt(value, other) { + return value < other; + } + + /** + * The base implementation of `_.map` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function baseMap(collection, iteratee) { + var index = -1, + result = isArrayLike(collection) ? Array(collection.length) : []; + + baseEach(collection, function(value, key, collection) { + result[++index] = iteratee(value, key, collection); + }); + return result; + } + + /** + * The base implementation of `_.matches` which doesn't clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new spec function. + */ + function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + return function(object) { + return object === source || baseIsMatch(object, source, matchData); + }; + } + + /** + * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. + * + * @private + * @param {string} path The path of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + return function(object) { + var objValue = get(object, path); + return (objValue === undefined && objValue === srcValue) + ? hasIn(object, path) + : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); + }; + } + + /** + * The base implementation of `_.merge` without support for multiple sources. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {number} srcIndex The index of `source`. + * @param {Function} [customizer] The function to customize merged values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + baseFor(source, function(srcValue, key) { + if (isObject(srcValue)) { + stack || (stack = new Stack); + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } + else { + var newValue = customizer + ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) + : undefined; + + if (newValue === undefined) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, keysIn); + } + + /** + * A specialized version of `baseMerge` for arrays and objects which performs + * deep merges and tracks traversed objects enabling objects with circular + * references to be merged. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {string} key The key of the value to merge. + * @param {number} srcIndex The index of `source`. + * @param {Function} mergeFunc The function to merge values. + * @param {Function} [customizer] The function to customize assigned values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), + srcValue = safeGet(source, key), + stacked = stack.get(srcValue); + + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer + ? customizer(objValue, srcValue, (key + ''), object, source, stack) + : undefined; + + var isCommon = newValue === undefined; + + if (isCommon) { + var isArr = isArray(srcValue), + isBuff = !isArr && isBuffer(srcValue), + isTyped = !isArr && !isBuff && isTypedArray(srcValue); + + newValue = srcValue; + if (isArr || isBuff || isTyped) { + if (isArray(objValue)) { + newValue = objValue; + } + else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } + else if (isBuff) { + isCommon = false; + newValue = cloneBuffer(srcValue, true); + } + else if (isTyped) { + isCommon = false; + newValue = cloneTypedArray(srcValue, true); + } + else { + newValue = []; + } + } + else if (isPlainObject(srcValue) || isArguments(srcValue)) { + newValue = objValue; + if (isArguments(objValue)) { + newValue = toPlainObject(objValue); + } + else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) { + newValue = initCloneObject(srcValue); + } + } + else { + isCommon = false; + } + } + if (isCommon) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack['delete'](srcValue); + } + assignMergeValue(object, key, newValue); + } + + /** + * The base implementation of `_.nth` which doesn't coerce arguments. + * + * @private + * @param {Array} array The array to query. + * @param {number} n The index of the element to return. + * @returns {*} Returns the nth element of `array`. + */ + function baseNth(array, n) { + var length = array.length; + if (!length) { + return; + } + n += n < 0 ? length : 0; + return isIndex(n, length) ? array[n] : undefined; + } + + /** + * The base implementation of `_.orderBy` without param guards. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. + * @param {string[]} orders The sort orders of `iteratees`. + * @returns {Array} Returns the new sorted array. + */ + function baseOrderBy(collection, iteratees, orders) { + var index = -1; + iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee())); + + var result = baseMap(collection, function(value, key, collection) { + var criteria = arrayMap(iteratees, function(iteratee) { + return iteratee(value); + }); + return { 'criteria': criteria, 'index': ++index, 'value': value }; + }); + + return baseSortBy(result, function(object, other) { + return compareMultiple(object, other, orders); + }); + } + + /** + * The base implementation of `_.pick` without support for individual + * property identifiers. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @returns {Object} Returns the new object. + */ + function basePick(object, paths) { + return basePickBy(object, paths, function(value, path) { + return hasIn(object, path); + }); + } + + /** + * The base implementation of `_.pickBy` without support for iteratee shorthands. + * + * @private + * @param {Object} object The source object. + * @param {string[]} paths The property paths to pick. + * @param {Function} predicate The function invoked per property. + * @returns {Object} Returns the new object. + */ + function basePickBy(object, paths, predicate) { + var index = -1, + length = paths.length, + result = {}; + + while (++index < length) { + var path = paths[index], + value = baseGet(object, path); + + if (predicate(value, path)) { + baseSet(result, castPath(path, object), value); + } + } + return result; + } + + /** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new accessor function. + */ + function basePropertyDeep(path) { + return function(object) { + return baseGet(object, path); + }; + } + + /** + * The base implementation of `_.pullAllBy` without support for iteratee + * shorthands. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + */ + function basePullAll(array, values, iteratee, comparator) { + var indexOf = comparator ? baseIndexOfWith : baseIndexOf, + index = -1, + length = values.length, + seen = array; + + if (array === values) { + values = copyArray(values); + } + if (iteratee) { + seen = arrayMap(array, baseUnary(iteratee)); + } + while (++index < length) { + var fromIndex = 0, + value = values[index], + computed = iteratee ? iteratee(value) : value; + + while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) { + if (seen !== array) { + splice.call(seen, fromIndex, 1); + } + splice.call(array, fromIndex, 1); + } + } + return array; + } + + /** + * The base implementation of `_.pullAt` without support for individual + * indexes or capturing the removed elements. + * + * @private + * @param {Array} array The array to modify. + * @param {number[]} indexes The indexes of elements to remove. + * @returns {Array} Returns `array`. + */ + function basePullAt(array, indexes) { + var length = array ? indexes.length : 0, + lastIndex = length - 1; + + while (length--) { + var index = indexes[length]; + if (length == lastIndex || index !== previous) { + var previous = index; + if (isIndex(index)) { + splice.call(array, index, 1); + } else { + baseUnset(array, index); + } + } + } + return array; + } + + /** + * The base implementation of `_.random` without support for returning + * floating-point numbers. + * + * @private + * @param {number} lower The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the random number. + */ + function baseRandom(lower, upper) { + return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); + } + + /** + * The base implementation of `_.range` and `_.rangeRight` which doesn't + * coerce arguments. + * + * @private + * @param {number} start The start of the range. + * @param {number} end The end of the range. + * @param {number} step The value to increment or decrement by. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the range of numbers. + */ + function baseRange(start, end, step, fromRight) { + var index = -1, + length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), + result = Array(length); + + while (length--) { + result[fromRight ? length : ++index] = start; + start += step; + } + return result; + } + + /** + * The base implementation of `_.repeat` which doesn't coerce arguments. + * + * @private + * @param {string} string The string to repeat. + * @param {number} n The number of times to repeat the string. + * @returns {string} Returns the repeated string. + */ + function baseRepeat(string, n) { + var result = ''; + if (!string || n < 1 || n > MAX_SAFE_INTEGER) { + return result; + } + // Leverage the exponentiation by squaring algorithm for a faster repeat. + // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. + do { + if (n % 2) { + result += string; + } + n = nativeFloor(n / 2); + if (n) { + string += string; + } + } while (n); + + return result; + } + + /** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */ + function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ''); + } + + /** + * The base implementation of `_.sample`. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + */ + function baseSample(collection) { + return arraySample(values(collection)); + } + + /** + * The base implementation of `_.sampleSize` without param guards. + * + * @private + * @param {Array|Object} collection The collection to sample. + * @param {number} n The number of elements to sample. + * @returns {Array} Returns the random elements. + */ + function baseSampleSize(collection, n) { + var array = values(collection); + return shuffleSelf(array, baseClamp(n, 0, array.length)); + } + + /** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + function baseSet(object, path, value, customizer) { + if (!isObject(object)) { + return object; + } + path = castPath(path, object); + + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined; + if (newValue === undefined) { + newValue = isObject(objValue) + ? objValue + : (isIndex(path[index + 1]) ? [] : {}); + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; + } + + /** + * The base implementation of `setData` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ + var baseSetData = !metaMap ? identity : function(func, data) { + metaMap.set(func, data); + return func; + }; + + /** + * The base implementation of `setToString` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + var baseSetToString = !defineProperty ? identity : function(func, string) { + return defineProperty(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); + }; + + /** + * The base implementation of `_.shuffle`. + * + * @private + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + */ + function baseShuffle(collection) { + return shuffleSelf(values(collection)); + } + + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; + } + + /** + * The base implementation of `_.some` without support for iteratee shorthands. + * + * @private + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + function baseSome(collection, predicate) { + var result; + + baseEach(collection, function(value, index, collection) { + result = predicate(value, index, collection); + return !result; + }); + return !!result; + } + + /** + * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which + * performs a binary search of `array` to determine the index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {boolean} [retHighest] Specify returning the highest qualified index. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + */ + function baseSortedIndex(array, value, retHighest) { + var low = 0, + high = array == null ? low : array.length; + + if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { + while (low < high) { + var mid = (low + high) >>> 1, + computed = array[mid]; + + if (computed !== null && !isSymbol(computed) && + (retHighest ? (computed <= value) : (computed < value))) { + low = mid + 1; + } else { + high = mid; + } + } + return high; + } + return baseSortedIndexBy(array, value, identity, retHighest); + } + + /** + * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` + * which invokes `iteratee` for `value` and each element of `array` to compute + * their sort ranking. The iteratee is invoked with one argument; (value). + * + * @private + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} iteratee The iteratee invoked per element. + * @param {boolean} [retHighest] Specify returning the highest qualified index. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + */ + function baseSortedIndexBy(array, value, iteratee, retHighest) { + value = iteratee(value); + + var low = 0, + high = array == null ? 0 : array.length, + valIsNaN = value !== value, + valIsNull = value === null, + valIsSymbol = isSymbol(value), + valIsUndefined = value === undefined; + + while (low < high) { + var mid = nativeFloor((low + high) / 2), + computed = iteratee(array[mid]), + othIsDefined = computed !== undefined, + othIsNull = computed === null, + othIsReflexive = computed === computed, + othIsSymbol = isSymbol(computed); + + if (valIsNaN) { + var setLow = retHighest || othIsReflexive; + } else if (valIsUndefined) { + setLow = othIsReflexive && (retHighest || othIsDefined); + } else if (valIsNull) { + setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); + } else if (valIsSymbol) { + setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); + } else if (othIsNull || othIsSymbol) { + setLow = false; + } else { + setLow = retHighest ? (computed <= value) : (computed < value); + } + if (setLow) { + low = mid + 1; + } else { + high = mid; + } + } + return nativeMin(high, MAX_ARRAY_INDEX); + } + + /** + * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without + * support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ + function baseSortedUniq(array, iteratee) { + var index = -1, + length = array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + if (!index || !eq(computed, seen)) { + var seen = computed; + result[resIndex++] = value === 0 ? 0 : value; + } + } + return result; + } + + /** + * The base implementation of `_.toNumber` which doesn't ensure correct + * conversions of binary, hexadecimal, or octal string values. + * + * @private + * @param {*} value The value to process. + * @returns {number} Returns the number. + */ + function baseToNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + return +value; + } + + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * The base implementation of `_.uniqBy` without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + */ + function baseUniq(array, iteratee, comparator) { + var index = -1, + includes = arrayIncludes, + length = array.length, + isCommon = true, + result = [], + seen = result; + + if (comparator) { + isCommon = false; + includes = arrayIncludesWith; + } + else if (length >= LARGE_ARRAY_SIZE) { + var set = iteratee ? null : createSet(array); + if (set) { + return setToArray(set); + } + isCommon = false; + includes = cacheHas; + seen = new SetCache; + } + else { + seen = iteratee ? [] : result; + } + outer: + while (++index < length) { + var value = array[index], + computed = iteratee ? iteratee(value) : value; + + value = (comparator || value !== 0) ? value : 0; + if (isCommon && computed === computed) { + var seenIndex = seen.length; + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + if (iteratee) { + seen.push(computed); + } + result.push(value); + } + else if (!includes(seen, computed, comparator)) { + if (seen !== result) { + seen.push(computed); + } + result.push(value); + } + } + return result; + } + + /** + * The base implementation of `_.unset`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The property path to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + */ + function baseUnset(object, path) { + path = castPath(path, object); + object = parent(object, path); + return object == null || delete object[toKey(last(path))]; + } + + /** + * The base implementation of `_.update`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to update. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + function baseUpdate(object, path, updater, customizer) { + return baseSet(object, path, updater(baseGet(object, path)), customizer); + } + + /** + * The base implementation of methods like `_.dropWhile` and `_.takeWhile` + * without support for iteratee shorthands. + * + * @private + * @param {Array} array The array to query. + * @param {Function} predicate The function invoked per iteration. + * @param {boolean} [isDrop] Specify dropping elements instead of taking them. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Array} Returns the slice of `array`. + */ + function baseWhile(array, predicate, isDrop, fromRight) { + var length = array.length, + index = fromRight ? length : -1; + + while ((fromRight ? index-- : ++index < length) && + predicate(array[index], index, array)) {} + + return isDrop + ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length)) + : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index)); + } + + /** + * The base implementation of `wrapperValue` which returns the result of + * performing a sequence of actions on the unwrapped `value`, where each + * successive action is supplied the return value of the previous. + * + * @private + * @param {*} value The unwrapped value. + * @param {Array} actions Actions to perform to resolve the unwrapped value. + * @returns {*} Returns the resolved value. + */ + function baseWrapperValue(value, actions) { + var result = value; + if (result instanceof LazyWrapper) { + result = result.value(); + } + return arrayReduce(actions, function(result, action) { + return action.func.apply(action.thisArg, arrayPush([result], action.args)); + }, result); + } + + /** + * The base implementation of methods like `_.xor`, without support for + * iteratee shorthands, that accepts an array of arrays to inspect. + * + * @private + * @param {Array} arrays The arrays to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of values. + */ + function baseXor(arrays, iteratee, comparator) { + var length = arrays.length; + if (length < 2) { + return length ? baseUniq(arrays[0]) : []; + } + var index = -1, + result = Array(length); + + while (++index < length) { + var array = arrays[index], + othIndex = -1; + + while (++othIndex < length) { + if (othIndex != index) { + result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator); + } + } + } + return baseUniq(baseFlatten(result, 1), iteratee, comparator); + } + + /** + * This base implementation of `_.zipObject` which assigns values using `assignFunc`. + * + * @private + * @param {Array} props The property identifiers. + * @param {Array} values The property values. + * @param {Function} assignFunc The function to assign values. + * @returns {Object} Returns the new object. + */ + function baseZipObject(props, values, assignFunc) { + var index = -1, + length = props.length, + valsLength = values.length, + result = {}; + + while (++index < length) { + var value = index < valsLength ? values[index] : undefined; + assignFunc(result, props[index], value); + } + return result; + } + + /** + * Casts `value` to an empty array if it's not an array like object. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array|Object} Returns the cast array-like object. + */ + function castArrayLikeObject(value) { + return isArrayLikeObject(value) ? value : []; + } + + /** + * Casts `value` to `identity` if it's not a function. + * + * @private + * @param {*} value The value to inspect. + * @returns {Function} Returns cast function. + */ + function castFunction(value) { + return typeof value == 'function' ? value : identity; + } + + /** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ + function castPath(value, object) { + if (isArray(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); + } + + /** + * A `baseRest` alias which can be replaced with `identity` by module + * replacement plugins. + * + * @private + * @type {Function} + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ + var castRest = baseRest; + + /** + * Casts `array` to a slice if it's needed. + * + * @private + * @param {Array} array The array to inspect. + * @param {number} start The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the cast slice. + */ + function castSlice(array, start, end) { + var length = array.length; + end = end === undefined ? length : end; + return (!start && end >= length) ? array : baseSlice(array, start, end); + } + + /** + * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). + * + * @private + * @param {number|Object} id The timer id or timeout object of the timer to clear. + */ + var clearTimeout = ctxClearTimeout || function(id) { + return root.clearTimeout(id); + }; + + /** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */ + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var length = buffer.length, + result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + + buffer.copy(result); + return result; + } + + /** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; + } + + /** + * Creates a clone of `dataView`. + * + * @private + * @param {Object} dataView The data view to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned data view. + */ + function cloneDataView(dataView, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); + } + + /** + * Creates a clone of `regexp`. + * + * @private + * @param {Object} regexp The regexp to clone. + * @returns {Object} Returns the cloned regexp. + */ + function cloneRegExp(regexp) { + var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result.lastIndex = regexp.lastIndex; + return result; + } + + /** + * Creates a clone of the `symbol` object. + * + * @private + * @param {Object} symbol The symbol object to clone. + * @returns {Object} Returns the cloned symbol object. + */ + function cloneSymbol(symbol) { + return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; + } + + /** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */ + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); + } + + /** + * Compares values to sort them in ascending order. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {number} Returns the sort order indicator for `value`. + */ + function compareAscending(value, other) { + if (value !== other) { + var valIsDefined = value !== undefined, + valIsNull = value === null, + valIsReflexive = value === value, + valIsSymbol = isSymbol(value); + + var othIsDefined = other !== undefined, + othIsNull = other === null, + othIsReflexive = other === other, + othIsSymbol = isSymbol(other); + + if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || + (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) || + (valIsNull && othIsDefined && othIsReflexive) || + (!valIsDefined && othIsReflexive) || + !valIsReflexive) { + return 1; + } + if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || + (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || + (othIsNull && valIsDefined && valIsReflexive) || + (!othIsDefined && valIsReflexive) || + !othIsReflexive) { + return -1; + } + } + return 0; + } + + /** + * Used by `_.orderBy` to compare multiple properties of a value to another + * and stable sort them. + * + * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, + * specify an order of "desc" for descending or "asc" for ascending sort order + * of corresponding values. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {boolean[]|string[]} orders The order to sort by for each property. + * @returns {number} Returns the sort order indicator for `object`. + */ + function compareMultiple(object, other, orders) { + var index = -1, + objCriteria = object.criteria, + othCriteria = other.criteria, + length = objCriteria.length, + ordersLength = orders.length; + + while (++index < length) { + var result = compareAscending(objCriteria[index], othCriteria[index]); + if (result) { + if (index >= ordersLength) { + return result; + } + var order = orders[index]; + return result * (order == 'desc' ? -1 : 1); + } + } + // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications + // that causes it, under certain circumstances, to provide the same value for + // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 + // for more details. + // + // This also ensures a stable sort in V8 and other engines. + // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. + return object.index - other.index; + } + + /** + * Creates an array that is the composition of partially applied arguments, + * placeholders, and provided arguments into a single array of arguments. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to prepend to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ + function composeArgs(args, partials, holders, isCurried) { + var argsIndex = -1, + argsLength = args.length, + holdersLength = holders.length, + leftIndex = -1, + leftLength = partials.length, + rangeLength = nativeMax(argsLength - holdersLength, 0), + result = Array(leftLength + rangeLength), + isUncurried = !isCurried; + + while (++leftIndex < leftLength) { + result[leftIndex] = partials[leftIndex]; + } + while (++argsIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[holders[argsIndex]] = args[argsIndex]; + } + } + while (rangeLength--) { + result[leftIndex++] = args[argsIndex++]; + } + return result; + } + + /** + * This function is like `composeArgs` except that the arguments composition + * is tailored for `_.partialRight`. + * + * @private + * @param {Array} args The provided arguments. + * @param {Array} partials The arguments to append to those provided. + * @param {Array} holders The `partials` placeholder indexes. + * @params {boolean} [isCurried] Specify composing for a curried function. + * @returns {Array} Returns the new array of composed arguments. + */ + function composeArgsRight(args, partials, holders, isCurried) { + var argsIndex = -1, + argsLength = args.length, + holdersIndex = -1, + holdersLength = holders.length, + rightIndex = -1, + rightLength = partials.length, + rangeLength = nativeMax(argsLength - holdersLength, 0), + result = Array(rangeLength + rightLength), + isUncurried = !isCurried; + + while (++argsIndex < rangeLength) { + result[argsIndex] = args[argsIndex]; + } + var offset = argsIndex; + while (++rightIndex < rightLength) { + result[offset + rightIndex] = partials[rightIndex]; + } + while (++holdersIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result[offset + holders[holdersIndex]] = args[argsIndex++]; + } + } + return result; + } + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ + function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; + + if (newValue === undefined) { + newValue = source[key]; + } + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + return object; + } + + /** + * Copies own symbols of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + function copySymbols(source, object) { + return copyObject(source, getSymbols(source), object); + } + + /** + * Copies own and inherited symbols of `source` to `object`. + * + * @private + * @param {Object} source The object to copy symbols from. + * @param {Object} [object={}] The object to copy symbols to. + * @returns {Object} Returns `object`. + */ + function copySymbolsIn(source, object) { + return copyObject(source, getSymbolsIn(source), object); + } + + /** + * Creates a function like `_.groupBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} [initializer] The accumulator object initializer. + * @returns {Function} Returns the new aggregator function. + */ + function createAggregator(setter, initializer) { + return function(collection, iteratee) { + var func = isArray(collection) ? arrayAggregator : baseAggregator, + accumulator = initializer ? initializer() : {}; + + return func(collection, setter, getIteratee(iteratee, 2), accumulator); + }; + } + + /** + * Creates a function like `_.assign`. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ + function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, + length = sources.length, + customizer = length > 1 ? sources[length - 1] : undefined, + guard = length > 2 ? sources[2] : undefined; + + customizer = (assigner.length > 3 && typeof customizer == 'function') + ? (length--, customizer) + : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined : customizer; + length = 1; + } + object = Object(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); + } + + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee); + } + var length = collection.length, + index = fromRight ? length : -1, + iterable = Object(collection); + + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + + /** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + + /** + * Creates a function that wraps `func` to invoke it with the optional `this` + * binding of `thisArg`. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createBind(func, bitmask, thisArg) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + + function wrapper() { + var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; + return fn.apply(isBind ? thisArg : this, arguments); + } + return wrapper; + } + + /** + * Creates a function like `_.lowerFirst`. + * + * @private + * @param {string} methodName The name of the `String` case method to use. + * @returns {Function} Returns the new case function. + */ + function createCaseFirst(methodName) { + return function(string) { + string = toString(string); + + var strSymbols = hasUnicode(string) + ? stringToArray(string) + : undefined; + + var chr = strSymbols + ? strSymbols[0] + : string.charAt(0); + + var trailing = strSymbols + ? castSlice(strSymbols, 1).join('') + : string.slice(1); + + return chr[methodName]() + trailing; + }; + } + + /** + * Creates a function like `_.camelCase`. + * + * @private + * @param {Function} callback The function to combine each word. + * @returns {Function} Returns the new compounder function. + */ + function createCompounder(callback) { + return function(string) { + return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); + }; + } + + /** + * Creates a function that produces an instance of `Ctor` regardless of + * whether it was invoked as part of a `new` expression or by `call` or `apply`. + * + * @private + * @param {Function} Ctor The constructor to wrap. + * @returns {Function} Returns the new wrapped function. + */ + function createCtor(Ctor) { + return function() { + // Use a `switch` statement to work with class constructors. See + // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist + // for more details. + var args = arguments; + switch (args.length) { + case 0: return new Ctor; + case 1: return new Ctor(args[0]); + case 2: return new Ctor(args[0], args[1]); + case 3: return new Ctor(args[0], args[1], args[2]); + case 4: return new Ctor(args[0], args[1], args[2], args[3]); + case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]); + case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); + case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); + } + var thisBinding = baseCreate(Ctor.prototype), + result = Ctor.apply(thisBinding, args); + + // Mimic the constructor's `return` behavior. + // See https://es5.github.io/#x13.2.2 for more details. + return isObject(result) ? result : thisBinding; + }; + } + + /** + * Creates a function that wraps `func` to enable currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {number} arity The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createCurry(func, bitmask, arity) { + var Ctor = createCtor(func); + + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length, + placeholder = getHolder(wrapper); + + while (index--) { + args[index] = arguments[index]; + } + var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder) + ? [] + : replaceHolders(args, placeholder); + + length -= holders.length; + if (length < arity) { + return createRecurry( + func, bitmask, createHybrid, wrapper.placeholder, undefined, + args, holders, undefined, undefined, arity - length); + } + var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; + return apply(fn, this, args); + } + return wrapper; + } + + /** + * Creates a `_.find` or `_.findLast` function. + * + * @private + * @param {Function} findIndexFunc The function to find the collection index. + * @returns {Function} Returns the new find function. + */ + function createFind(findIndexFunc) { + return function(collection, predicate, fromIndex) { + var iterable = Object(collection); + if (!isArrayLike(collection)) { + var iteratee = getIteratee(predicate, 3); + collection = keys(collection); + predicate = function(key) { return iteratee(iterable[key], key, iterable); }; + } + var index = findIndexFunc(collection, predicate, fromIndex); + return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined; + }; + } + + /** + * Creates a `_.flow` or `_.flowRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new flow function. + */ + function createFlow(fromRight) { + return flatRest(function(funcs) { + var length = funcs.length, + index = length, + prereq = LodashWrapper.prototype.thru; + + if (fromRight) { + funcs.reverse(); + } + while (index--) { + var func = funcs[index]; + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + if (prereq && !wrapper && getFuncName(func) == 'wrapper') { + var wrapper = new LodashWrapper([], true); + } + } + index = wrapper ? index : length; + while (++index < length) { + func = funcs[index]; + + var funcName = getFuncName(func), + data = funcName == 'wrapper' ? getData(func) : undefined; + + if (data && isLaziable(data[0]) && + data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && + !data[4].length && data[9] == 1 + ) { + wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); + } else { + wrapper = (func.length == 1 && isLaziable(func)) + ? wrapper[funcName]() + : wrapper.thru(func); + } + } + return function() { + var args = arguments, + value = args[0]; + + if (wrapper && args.length == 1 && isArray(value)) { + return wrapper.plant(value).value(); + } + var index = 0, + result = length ? funcs[index].apply(this, args) : value; + + while (++index < length) { + result = funcs[index].call(this, result); + } + return result; + }; + }); + } + + /** + * Creates a function that wraps `func` to invoke it with optional `this` + * binding of `thisArg`, partial application, and currying. + * + * @private + * @param {Function|string} func The function or method name to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [partialsRight] The arguments to append to those provided + * to the new function. + * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { + var isAry = bitmask & WRAP_ARY_FLAG, + isBind = bitmask & WRAP_BIND_FLAG, + isBindKey = bitmask & WRAP_BIND_KEY_FLAG, + isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), + isFlip = bitmask & WRAP_FLIP_FLAG, + Ctor = isBindKey ? undefined : createCtor(func); + + function wrapper() { + var length = arguments.length, + args = Array(length), + index = length; + + while (index--) { + args[index] = arguments[index]; + } + if (isCurried) { + var placeholder = getHolder(wrapper), + holdersCount = countHolders(args, placeholder); + } + if (partials) { + args = composeArgs(args, partials, holders, isCurried); + } + if (partialsRight) { + args = composeArgsRight(args, partialsRight, holdersRight, isCurried); + } + length -= holdersCount; + if (isCurried && length < arity) { + var newHolders = replaceHolders(args, placeholder); + return createRecurry( + func, bitmask, createHybrid, wrapper.placeholder, thisArg, + args, newHolders, argPos, ary, arity - length + ); + } + var thisBinding = isBind ? thisArg : this, + fn = isBindKey ? thisBinding[func] : func; + + length = args.length; + if (argPos) { + args = reorder(args, argPos); + } else if (isFlip && length > 1) { + args.reverse(); + } + if (isAry && ary < length) { + args.length = ary; + } + if (this && this !== root && this instanceof wrapper) { + fn = Ctor || createCtor(fn); + } + return fn.apply(thisBinding, args); + } + return wrapper; + } + + /** + * Creates a function like `_.invertBy`. + * + * @private + * @param {Function} setter The function to set accumulator values. + * @param {Function} toIteratee The function to resolve iteratees. + * @returns {Function} Returns the new inverter function. + */ + function createInverter(setter, toIteratee) { + return function(object, iteratee) { + return baseInverter(object, setter, toIteratee(iteratee), {}); + }; + } + + /** + * Creates a function that performs a mathematical operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @param {number} [defaultValue] The value used for `undefined` arguments. + * @returns {Function} Returns the new mathematical operation function. + */ + function createMathOperation(operator, defaultValue) { + return function(value, other) { + var result; + if (value === undefined && other === undefined) { + return defaultValue; + } + if (value !== undefined) { + result = value; + } + if (other !== undefined) { + if (result === undefined) { + return other; + } + if (typeof value == 'string' || typeof other == 'string') { + value = baseToString(value); + other = baseToString(other); + } else { + value = baseToNumber(value); + other = baseToNumber(other); + } + result = operator(value, other); + } + return result; + }; + } + + /** + * Creates a function like `_.over`. + * + * @private + * @param {Function} arrayFunc The function to iterate over iteratees. + * @returns {Function} Returns the new over function. + */ + function createOver(arrayFunc) { + return flatRest(function(iteratees) { + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + return baseRest(function(args) { + var thisArg = this; + return arrayFunc(iteratees, function(iteratee) { + return apply(iteratee, thisArg, args); + }); + }); + }); + } + + /** + * Creates the padding for `string` based on `length`. The `chars` string + * is truncated if the number of characters exceeds `length`. + * + * @private + * @param {number} length The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padding for `string`. + */ + function createPadding(length, chars) { + chars = chars === undefined ? ' ' : baseToString(chars); + + var charsLength = chars.length; + if (charsLength < 2) { + return charsLength ? baseRepeat(chars, length) : chars; + } + var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); + return hasUnicode(chars) + ? castSlice(stringToArray(result), 0, length).join('') + : result.slice(0, length); + } + + /** + * Creates a function that wraps `func` to invoke it with the `this` binding + * of `thisArg` and `partials` prepended to the arguments it receives. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} partials The arguments to prepend to those provided to + * the new function. + * @returns {Function} Returns the new wrapped function. + */ + function createPartial(func, bitmask, thisArg, partials) { + var isBind = bitmask & WRAP_BIND_FLAG, + Ctor = createCtor(func); + + function wrapper() { + var argsIndex = -1, + argsLength = arguments.length, + leftIndex = -1, + leftLength = partials.length, + args = Array(leftLength + argsLength), + fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; + + while (++leftIndex < leftLength) { + args[leftIndex] = partials[leftIndex]; + } + while (argsLength--) { + args[leftIndex++] = arguments[++argsIndex]; + } + return apply(fn, isBind ? thisArg : this, args); + } + return wrapper; + } + + /** + * Creates a `_.range` or `_.rangeRight` function. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new range function. + */ + function createRange(fromRight) { + return function(start, end, step) { + if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { + end = step = undefined; + } + // Ensure the sign of `-0` is preserved. + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); + return baseRange(start, end, step, fromRight); + }; + } + + /** + * Creates a function that performs a relational operation on two values. + * + * @private + * @param {Function} operator The function to perform the operation. + * @returns {Function} Returns the new relational operation function. + */ + function createRelationalOperation(operator) { + return function(value, other) { + if (!(typeof value == 'string' && typeof other == 'string')) { + value = toNumber(value); + other = toNumber(other); + } + return operator(value, other); + }; + } + + /** + * Creates a function that wraps `func` to continue currying. + * + * @private + * @param {Function} func The function to wrap. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @param {Function} wrapFunc The function to create the `func` wrapper. + * @param {*} placeholder The placeholder value. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to prepend to those provided to + * the new function. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { + var isCurry = bitmask & WRAP_CURRY_FLAG, + newHolders = isCurry ? holders : undefined, + newHoldersRight = isCurry ? undefined : holders, + newPartials = isCurry ? partials : undefined, + newPartialsRight = isCurry ? undefined : partials; + + bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG); + bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); + + if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { + bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); + } + var newData = [ + func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, + newHoldersRight, argPos, ary, arity + ]; + + var result = wrapFunc.apply(undefined, newData); + if (isLaziable(func)) { + setData(result, newData); + } + result.placeholder = placeholder; + return setWrapToString(result, func, bitmask); + } + + /** + * Creates a function like `_.round`. + * + * @private + * @param {string} methodName The name of the `Math` method to use when rounding. + * @returns {Function} Returns the new round function. + */ + function createRound(methodName) { + var func = Math[methodName]; + return function(number, precision) { + number = toNumber(number); + precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); + if (precision) { + // Shift with exponential notation to avoid floating-point issues. + // See [MDN](https://mdn.io/round#Examples) for more details. + var pair = (toString(number) + 'e').split('e'), + value = func(pair[0] + 'e' + (+pair[1] + precision)); + + pair = (toString(value) + 'e').split('e'); + return +(pair[0] + 'e' + (+pair[1] - precision)); + } + return func(number); + }; + } + + /** + * Creates a set object of `values`. + * + * @private + * @param {Array} values The values to add to the set. + * @returns {Object} Returns the new set. + */ + var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { + return new Set(values); + }; + + /** + * Creates a `_.toPairs` or `_.toPairsIn` function. + * + * @private + * @param {Function} keysFunc The function to get the keys of a given object. + * @returns {Function} Returns the new pairs function. + */ + function createToPairs(keysFunc) { + return function(object) { + var tag = getTag(object); + if (tag == mapTag) { + return mapToArray(object); + } + if (tag == setTag) { + return setToPairs(object); + } + return baseToPairs(object, keysFunc(object)); + }; + } + + /** + * Creates a function that either curries or invokes `func` with optional + * `this` binding and partially applied arguments. + * + * @private + * @param {Function|string} func The function or method name to wrap. + * @param {number} bitmask The bitmask flags. + * 1 - `_.bind` + * 2 - `_.bindKey` + * 4 - `_.curry` or `_.curryRight` of a bound function + * 8 - `_.curry` + * 16 - `_.curryRight` + * 32 - `_.partial` + * 64 - `_.partialRight` + * 128 - `_.rearg` + * 256 - `_.ary` + * 512 - `_.flip` + * @param {*} [thisArg] The `this` binding of `func`. + * @param {Array} [partials] The arguments to be partially applied. + * @param {Array} [holders] The `partials` placeholder indexes. + * @param {Array} [argPos] The argument positions of the new function. + * @param {number} [ary] The arity cap of `func`. + * @param {number} [arity] The arity of `func`. + * @returns {Function} Returns the new wrapped function. + */ + function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { + var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; + if (!isBindKey && typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + var length = partials ? partials.length : 0; + if (!length) { + bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); + partials = holders = undefined; + } + ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0); + arity = arity === undefined ? arity : toInteger(arity); + length -= holders ? holders.length : 0; + + if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { + var partialsRight = partials, + holdersRight = holders; + + partials = holders = undefined; + } + var data = isBindKey ? undefined : getData(func); + + var newData = [ + func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, + argPos, ary, arity + ]; + + if (data) { + mergeData(newData, data); + } + func = newData[0]; + bitmask = newData[1]; + thisArg = newData[2]; + partials = newData[3]; + holders = newData[4]; + arity = newData[9] = newData[9] === undefined + ? (isBindKey ? 0 : func.length) + : nativeMax(newData[9] - length, 0); + + if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { + bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); + } + if (!bitmask || bitmask == WRAP_BIND_FLAG) { + var result = createBind(func, bitmask, thisArg); + } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { + result = createCurry(func, bitmask, arity); + } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { + result = createPartial(func, bitmask, thisArg, partials); + } else { + result = createHybrid.apply(undefined, newData); + } + var setter = data ? baseSetData : setData; + return setWrapToString(setter(result, newData), func, bitmask); + } + + /** + * Used by `_.defaults` to customize its `_.assignIn` use to assign properties + * of source objects to the destination object for all destination properties + * that resolve to `undefined`. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {string} key The key of the property to assign. + * @param {Object} object The parent object of `objValue`. + * @returns {*} Returns the value to assign. + */ + function customDefaultsAssignIn(objValue, srcValue, key, object) { + if (objValue === undefined || + (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) { + return srcValue; + } + return objValue; + } + + /** + * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source + * objects into destination objects that are passed thru. + * + * @private + * @param {*} objValue The destination value. + * @param {*} srcValue The source value. + * @param {string} key The key of the property to merge. + * @param {Object} object The parent object of `objValue`. + * @param {Object} source The parent object of `srcValue`. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + * @returns {*} Returns the value to assign. + */ + function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { + if (isObject(objValue) && isObject(srcValue)) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, objValue); + baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack); + stack['delete'](srcValue); + } + return objValue; + } + + /** + * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain + * objects. + * + * @private + * @param {*} value The value to inspect. + * @param {string} key The key of the property to inspect. + * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. + */ + function customOmitClone(value) { + return isPlainObject(value) ? undefined : value; + } + + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(array); + if (stacked && stack.get(other)) { + return stacked == other; + } + var index = -1, + result = true, + seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; + + stack.set(array, other); + stack.set(other, array); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!cacheHas(seen, othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, bitmask, customizer, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + stack['delete'](other); + return result; + } + + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if ((object.byteLength != other.byteLength) || + (object.byteOffset != other.byteOffset)) { + return false; + } + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if ((object.byteLength != other.byteLength) || + !equalFunc(new Uint8Array(object), new Uint8Array(other))) { + return false; + } + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == (other + ''); + + case mapTag: + var convert = mapToArray; + + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + + // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; + } + + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked && stack.get(other)) { + return stacked == other; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, objValue, key, other, object, stack) + : customizer(objValue, othValue, key, object, other, stack); + } + // Recursively compare objects (susceptible to call stack limits). + if (!(compared === undefined + ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) + : compared + )) { + result = false; + break; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + stack['delete'](object); + stack['delete'](other); + return result; + } + + /** + * A specialized version of `baseRest` which flattens the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @returns {Function} Returns the new function. + */ + function flatRest(func) { + return setToString(overRest(func, undefined, flatten), func + ''); + } + + /** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); + } + + /** + * Creates an array of own and inherited enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeysIn(object) { + return baseGetAllKeys(object, keysIn, getSymbolsIn); + } + + /** + * Gets metadata for `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {*} Returns the metadata for `func`. + */ + var getData = !metaMap ? noop : function(func) { + return metaMap.get(func); + }; + + /** + * Gets the name of `func`. + * + * @private + * @param {Function} func The function to query. + * @returns {string} Returns the function name. + */ + function getFuncName(func) { + var result = (func.name + ''), + array = realNames[result], + length = hasOwnProperty.call(realNames, result) ? array.length : 0; + + while (length--) { + var data = array[length], + otherFunc = data.func; + if (otherFunc == null || otherFunc == func) { + return data.name; + } + } + return result; + } + + /** + * Gets the argument placeholder value for `func`. + * + * @private + * @param {Function} func The function to inspect. + * @returns {*} Returns the placeholder value. + */ + function getHolder(func) { + var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func; + return object.placeholder; + } + + /** + * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, + * this function returns the custom method, otherwise it returns `baseIteratee`. + * If arguments are provided, the chosen function is invoked with them and + * its result is returned. + * + * @private + * @param {*} [value] The value to convert to an iteratee. + * @param {number} [arity] The arity of the created iteratee. + * @returns {Function} Returns the chosen function or its result. + */ + function getIteratee() { + var result = lodash.iteratee || iteratee; + result = result === iteratee ? baseIteratee : result; + return arguments.length ? result(arguments[0], arguments[1]) : result; + } + + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; + } + + /** + * Gets the property names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ + function getMatchData(object) { + var result = keys(object), + length = result.length; + + while (length--) { + var key = result[length], + value = object[key]; + + result[length] = [key, value, isStrictComparable(value)]; + } + return result; + } + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + /** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ + function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; + } + + /** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); + }; + + /** + * Creates an array of the own and inherited enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { + var result = []; + while (object) { + arrayPush(result, getSymbols(object)); + object = getPrototype(object); + } + return result; + }; + + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + var getTag = baseGetTag; + + // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. + if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map && getTag(new Map) != mapTag) || + (Promise && getTag(Promise.resolve()) != promiseTag) || + (Set && getTag(new Set) != setTag) || + (WeakMap && getTag(new WeakMap) != weakMapTag)) { + getTag = function(value) { + var result = baseGetTag(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; + } + + /** + * Gets the view, applying any `transforms` to the `start` and `end` positions. + * + * @private + * @param {number} start The start of the view. + * @param {number} end The end of the view. + * @param {Array} transforms The transformations to apply to the view. + * @returns {Object} Returns an object containing the `start` and `end` + * positions of the view. + */ + function getView(start, end, transforms) { + var index = -1, + length = transforms.length; + + while (++index < length) { + var data = transforms[index], + size = data.size; + + switch (data.type) { + case 'drop': start += size; break; + case 'dropRight': end -= size; break; + case 'take': end = nativeMin(end, start + size); break; + case 'takeRight': start = nativeMax(start, end - size); break; + } + } + return { 'start': start, 'end': end }; + } + + /** + * Extracts wrapper details from the `source` body comment. + * + * @private + * @param {string} source The source to inspect. + * @returns {Array} Returns the wrapper details. + */ + function getWrapDetails(source) { + var match = source.match(reWrapDetails); + return match ? match[1].split(reSplitDetails) : []; + } + + /** + * Checks if `path` exists on `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + */ + function hasPath(object, path, hasFunc) { + path = castPath(path, object); + + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result || ++index != length) { + return result; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && + (isArray(object) || isArguments(object)); + } + + /** + * Initializes an array clone. + * + * @private + * @param {Array} array The array to clone. + * @returns {Array} Returns the initialized clone. + */ + function initCloneArray(array) { + var length = array.length, + result = new array.constructor(length); + + // Add properties assigned by `RegExp#exec`. + if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { + result.index = array.index; + result.input = array.input; + } + return result; + } + + /** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneObject(object) { + return (typeof object.constructor == 'function' && !isPrototype(object)) + ? baseCreate(getPrototype(object)) + : {}; + } + + /** + * Initializes an object clone based on its `toStringTag`. + * + * **Note:** This function only supports cloning values with tags of + * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {string} tag The `toStringTag` of the object to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneByTag(object, tag, isDeep) { + var Ctor = object.constructor; + switch (tag) { + case arrayBufferTag: + return cloneArrayBuffer(object); + + case boolTag: + case dateTag: + return new Ctor(+object); + + case dataViewTag: + return cloneDataView(object, isDeep); + + case float32Tag: case float64Tag: + case int8Tag: case int16Tag: case int32Tag: + case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: + return cloneTypedArray(object, isDeep); + + case mapTag: + return new Ctor; + + case numberTag: + case stringTag: + return new Ctor(object); + + case regexpTag: + return cloneRegExp(object); + + case setTag: + return new Ctor; + + case symbolTag: + return cloneSymbol(object); + } + } + + /** + * Inserts wrapper `details` in a comment at the top of the `source` body. + * + * @private + * @param {string} source The source to modify. + * @returns {Array} details The details to insert. + * @returns {string} Returns the modified source. + */ + function insertWrapDetails(source, details) { + var length = details.length; + if (!length) { + return source; + } + var lastIndex = length - 1; + details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex]; + details = details.join(length > 2 ? ', ' : ' '); + return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n'); + } + + /** + * Checks if `value` is a flattenable `arguments` object or array. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. + */ + function isFlattenable(value) { + return isArray(value) || isArguments(value) || + !!(spreadableSymbol && value && value[spreadableSymbol]); + } + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); + } + + /** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ + function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object) + ) { + return eq(object[index], value); + } + return false; + } + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); + } + + /** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ + function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); + } + + /** + * Checks if `func` has a lazy counterpart. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` has a lazy counterpart, + * else `false`. + */ + function isLaziable(func) { + var funcName = getFuncName(func), + other = lodash[funcName]; + + if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { + return false; + } + if (func === other) { + return true; + } + var data = getData(other); + return !!data && func === data[0]; + } + + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); + } + + /** + * Checks if `func` is capable of being masked. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `func` is maskable, else `false`. + */ + var isMaskable = coreJsData ? isFunction : stubFalse; + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; + } + + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ + function isStrictComparable(value) { + return value === value && !isObject(value); + } + + /** + * A specialized version of `matchesProperty` for source values suitable + * for strict equality comparisons, i.e. `===`. + * + * @private + * @param {string} key The key of the property to get. + * @param {*} srcValue The value to match. + * @returns {Function} Returns the new spec function. + */ + function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && + (srcValue !== undefined || (key in Object(object))); + }; + } + + /** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ + function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; + } + + /** + * Merges the function metadata of `source` into `data`. + * + * Merging metadata reduces the number of wrappers used to invoke a function. + * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` + * may be applied regardless of execution order. Methods like `_.ary` and + * `_.rearg` modify function arguments, making the order in which they are + * executed important, preventing the merging of metadata. However, we make + * an exception for a safe combined case where curried functions have `_.ary` + * and or `_.rearg` applied. + * + * @private + * @param {Array} data The destination metadata. + * @param {Array} source The source metadata. + * @returns {Array} Returns `data`. + */ + function mergeData(data, source) { + var bitmask = data[1], + srcBitmask = source[1], + newBitmask = bitmask | srcBitmask, + isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); + + var isCombo = + ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) || + ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) || + ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG)); + + // Exit early if metadata can't be merged. + if (!(isCommon || isCombo)) { + return data; + } + // Use source `thisArg` if available. + if (srcBitmask & WRAP_BIND_FLAG) { + data[2] = source[2]; + // Set when currying a bound function. + newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; + } + // Compose partial arguments. + var value = source[3]; + if (value) { + var partials = data[3]; + data[3] = partials ? composeArgs(partials, value, source[4]) : value; + data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; + } + // Compose partial right arguments. + value = source[5]; + if (value) { + partials = data[5]; + data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; + data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; + } + // Use source `argPos` if available. + value = source[7]; + if (value) { + data[7] = value; + } + // Use source `ary` if it's smaller. + if (srcBitmask & WRAP_ARY_FLAG) { + data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); + } + // Use source `arity` if one is not provided. + if (data[9] == null) { + data[9] = source[9]; + } + // Use source `func` and merge bitmasks. + data[0] = source[0]; + data[1] = newBitmask; + + return data; + } + + /** + * This function is like + * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * except that it includes inherited enumerable properties. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function nativeKeysIn(object) { + var result = []; + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } + } + return result; + } + + /** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ + function objectToString(value) { + return nativeObjectToString.call(value); + } + + /** + * A specialized version of `baseRest` which transforms the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @param {Function} transform The rest array transform. + * @returns {Function} Returns the new function. + */ + function overRest(func, start, transform) { + start = nativeMax(start === undefined ? (func.length - 1) : start, 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply(func, this, otherArgs); + }; + } + + /** + * Gets the parent value at `path` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array} path The path to get the parent value of. + * @returns {*} Returns the parent value. + */ + function parent(object, path) { + return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); + } + + /** + * Reorder `array` according to the specified indexes where the element at + * the first index is assigned as the first element, the element at + * the second index is assigned as the second element, and so on. + * + * @private + * @param {Array} array The array to reorder. + * @param {Array} indexes The arranged array indexes. + * @returns {Array} Returns `array`. + */ + function reorder(array, indexes) { + var arrLength = array.length, + length = nativeMin(indexes.length, arrLength), + oldArray = copyArray(array); + + while (length--) { + var index = indexes[length]; + array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined; + } + return array; + } + + /** + * Sets metadata for `func`. + * + * **Note:** If this function becomes hot, i.e. is invoked a lot in a short + * period of time, it will trip its breaker and transition to an identity + * function to avoid garbage collection pauses in V8. See + * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) + * for more details. + * + * @private + * @param {Function} func The function to associate metadata with. + * @param {*} data The metadata. + * @returns {Function} Returns `func`. + */ + var setData = shortOut(baseSetData); + + /** + * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). + * + * @private + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @returns {number|Object} Returns the timer id or timeout object. + */ + var setTimeout = ctxSetTimeout || function(func, wait) { + return root.setTimeout(func, wait); + }; + + /** + * Sets the `toString` method of `func` to return `string`. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + var setToString = shortOut(baseSetToString); + + /** + * Sets the `toString` method of `wrapper` to mimic the source of `reference` + * with wrapper details in a comment at the top of the source body. + * + * @private + * @param {Function} wrapper The function to modify. + * @param {Function} reference The reference function. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Function} Returns `wrapper`. + */ + function setWrapToString(wrapper, reference, bitmask) { + var source = (reference + ''); + return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); + } + + /** + * Creates a function that'll short out and invoke `identity` instead + * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` + * milliseconds. + * + * @private + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. + */ + function shortOut(func) { + var count = 0, + lastCalled = 0; + + return function() { + var stamp = nativeNow(), + remaining = HOT_SPAN - (stamp - lastCalled); + + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(undefined, arguments); + }; + } + + /** + * A specialized version of `_.shuffle` which mutates and sets the size of `array`. + * + * @private + * @param {Array} array The array to shuffle. + * @param {number} [size=array.length] The size of `array`. + * @returns {Array} Returns `array`. + */ + function shuffleSelf(array, size) { + var index = -1, + length = array.length, + lastIndex = length - 1; + + size = size === undefined ? length : size; + while (++index < size) { + var rand = baseRandom(index, lastIndex), + value = array[rand]; + + array[rand] = array[index]; + array[index] = value; + } + array.length = size; + return array; + } + + /** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ + var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + }); + + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + /** + * Updates wrapper `details` based on `bitmask` flags. + * + * @private + * @returns {Array} details The details to modify. + * @param {number} bitmask The bitmask flags. See `createWrap` for more details. + * @returns {Array} Returns `details`. + */ + function updateWrapDetails(details, bitmask) { + arrayEach(wrapFlags, function(pair) { + var value = '_.' + pair[0]; + if ((bitmask & pair[1]) && !arrayIncludes(details, value)) { + details.push(value); + } + }); + return details.sort(); + } + + /** + * Creates a clone of `wrapper`. + * + * @private + * @param {Object} wrapper The wrapper to clone. + * @returns {Object} Returns the cloned wrapper. + */ + function wrapperClone(wrapper) { + if (wrapper instanceof LazyWrapper) { + return wrapper.clone(); + } + var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); + result.__actions__ = copyArray(wrapper.__actions__); + result.__index__ = wrapper.__index__; + result.__values__ = wrapper.__values__; + return result; + } + + /*------------------------------------------------------------------------*/ + + /** + * Creates an array of elements split into groups the length of `size`. + * If `array` can't be split evenly, the final chunk will be the remaining + * elements. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to process. + * @param {number} [size=1] The length of each chunk + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the new array of chunks. + * @example + * + * _.chunk(['a', 'b', 'c', 'd'], 2); + * // => [['a', 'b'], ['c', 'd']] + * + * _.chunk(['a', 'b', 'c', 'd'], 3); + * // => [['a', 'b', 'c'], ['d']] + */ + function chunk(array, size, guard) { + if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) { + size = 1; + } else { + size = nativeMax(toInteger(size), 0); + } + var length = array == null ? 0 : array.length; + if (!length || size < 1) { + return []; + } + var index = 0, + resIndex = 0, + result = Array(nativeCeil(length / size)); + + while (index < length) { + result[resIndex++] = baseSlice(array, index, (index += size)); + } + return result; + } + + /** + * Creates an array with all falsey values removed. The values `false`, `null`, + * `0`, `""`, `undefined`, and `NaN` are falsey. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to compact. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.compact([0, 1, false, 2, '', 3]); + * // => [1, 2, 3] + */ + function compact(array) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (value) { + result[resIndex++] = value; + } + } + return result; + } + + /** + * Creates a new array concatenating `array` with any additional arrays + * and/or values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to concatenate. + * @param {...*} [values] The values to concatenate. + * @returns {Array} Returns the new concatenated array. + * @example + * + * var array = [1]; + * var other = _.concat(array, 2, [3], [[4]]); + * + * console.log(other); + * // => [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */ + function concat() { + var length = arguments.length; + if (!length) { + return []; + } + var args = Array(length - 1), + array = arguments[0], + index = length; + + while (index--) { + args[index - 1] = arguments[index]; + } + return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1)); + } + + /** + * Creates an array of `array` values not included in the other given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * **Note:** Unlike `_.pullAll`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.without, _.xor + * @example + * + * _.difference([2, 1], [2, 3]); + * // => [1] + */ + var difference = baseRest(function(array, values) { + return isArrayLikeObject(array) + ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) + : []; + }); + + /** + * This method is like `_.difference` except that it accepts `iteratee` which + * is invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * **Note:** Unlike `_.pullAllBy`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2] + * + * // The `_.property` iteratee shorthand. + * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + var differenceBy = baseRest(function(array, values) { + var iteratee = last(values); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return isArrayLikeObject(array) + ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)) + : []; + }); + + /** + * This method is like `_.difference` except that it accepts `comparator` + * which is invoked to compare elements of `array` to `values`. The order and + * references of result values are determined by the first array. The comparator + * is invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.pullAllWith`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * + * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); + * // => [{ 'x': 2, 'y': 1 }] + */ + var differenceWith = baseRest(function(array, values) { + var comparator = last(values); + if (isArrayLikeObject(comparator)) { + comparator = undefined; + } + return isArrayLikeObject(array) + ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator) + : []; + }); + + /** + * Creates a slice of `array` with `n` elements dropped from the beginning. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.drop([1, 2, 3]); + * // => [2, 3] + * + * _.drop([1, 2, 3], 2); + * // => [3] + * + * _.drop([1, 2, 3], 5); + * // => [] + * + * _.drop([1, 2, 3], 0); + * // => [1, 2, 3] + */ + function drop(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + return baseSlice(array, n < 0 ? 0 : n, length); + } + + /** + * Creates a slice of `array` with `n` elements dropped from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to drop. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.dropRight([1, 2, 3]); + * // => [1, 2] + * + * _.dropRight([1, 2, 3], 2); + * // => [1] + * + * _.dropRight([1, 2, 3], 5); + * // => [] + * + * _.dropRight([1, 2, 3], 0); + * // => [1, 2, 3] + */ + function dropRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, 0, n < 0 ? 0 : n); + } + + /** + * Creates a slice of `array` excluding elements dropped from the end. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.dropRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney'] + * + * // The `_.matches` iteratee shorthand. + * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropRightWhile(users, ['active', false]); + * // => objects for ['barney'] + * + * // The `_.property` iteratee shorthand. + * _.dropRightWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ + function dropRightWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3), true, true) + : []; + } + + /** + * Creates a slice of `array` excluding elements dropped from the beginning. + * Elements are dropped until `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.dropWhile(users, function(o) { return !o.active; }); + * // => objects for ['pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.dropWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.dropWhile(users, ['active', false]); + * // => objects for ['pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.dropWhile(users, 'active'); + * // => objects for ['barney', 'fred', 'pebbles'] + */ + function dropWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3), true) + : []; + } + + /** + * Fills elements of `array` with `value` from `start` up to, but not + * including, `end`. + * + * **Note:** This method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Array + * @param {Array} array The array to fill. + * @param {*} value The value to fill `array` with. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.fill(array, 'a'); + * console.log(array); + * // => ['a', 'a', 'a'] + * + * _.fill(Array(3), 2); + * // => [2, 2, 2] + * + * _.fill([4, 6, 8, 10], '*', 1, 3); + * // => [4, '*', '*', 10] + */ + function fill(array, value, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if (start && typeof start != 'number' && isIterateeCall(array, value, start)) { + start = 0; + end = length; + } + return baseFill(array, value, start, end); + } + + /** + * This method is like `_.find` except that it returns the index of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.findIndex(users, function(o) { return o.user == 'barney'; }); + * // => 0 + * + * // The `_.matches` iteratee shorthand. + * _.findIndex(users, { 'user': 'fred', 'active': false }); + * // => 1 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findIndex(users, ['active', false]); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.findIndex(users, 'active'); + * // => 2 + */ + function findIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseFindIndex(array, getIteratee(predicate, 3), index); + } + + /** + * This method is like `_.findIndex` except that it iterates over elements + * of `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the found element, else `-1`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); + * // => 2 + * + * // The `_.matches` iteratee shorthand. + * _.findLastIndex(users, { 'user': 'barney', 'active': true }); + * // => 0 + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastIndex(users, ['active', false]); + * // => 2 + * + * // The `_.property` iteratee shorthand. + * _.findLastIndex(users, 'active'); + * // => 0 + */ + function findLastIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length - 1; + if (fromIndex !== undefined) { + index = toInteger(fromIndex); + index = fromIndex < 0 + ? nativeMax(length + index, 0) + : nativeMin(index, length - 1); + } + return baseFindIndex(array, getIteratee(predicate, 3), index, true); + } + + /** + * Flattens `array` a single level deep. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flatten([1, [2, [3, [4]], 5]]); + * // => [1, 2, [3, [4]], 5] + */ + function flatten(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, 1) : []; + } + + /** + * Recursively flattens `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to flatten. + * @returns {Array} Returns the new flattened array. + * @example + * + * _.flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */ + function flattenDeep(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, INFINITY) : []; + } + + /** + * Recursively flatten `array` up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Array + * @param {Array} array The array to flatten. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * var array = [1, [2, [3, [4]], 5]]; + * + * _.flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * _.flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */ + function flattenDepth(array, depth) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + depth = depth === undefined ? 1 : toInteger(depth); + return baseFlatten(array, depth); + } + + /** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} pairs The key-value pairs. + * @returns {Object} Returns the new object. + * @example + * + * _.fromPairs([['a', 1], ['b', 2]]); + * // => { 'a': 1, 'b': 2 } + */ + function fromPairs(pairs) { + var index = -1, + length = pairs == null ? 0 : pairs.length, + result = {}; + + while (++index < length) { + var pair = pairs[index]; + result[pair[0]] = pair[1]; + } + return result; + } + + /** + * Gets the first element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias first + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the first element of `array`. + * @example + * + * _.head([1, 2, 3]); + * // => 1 + * + * _.head([]); + * // => undefined + */ + function head(array) { + return (array && array.length) ? array[0] : undefined; + } + + /** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the + * offset from the end of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // Search from the `fromIndex`. + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */ + function indexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseIndexOf(array, value, index); + } + + /** + * Gets all but the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.initial([1, 2, 3]); + * // => [1, 2] + */ + function initial(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 0, -1) : []; + } + + /** + * Creates an array of unique values that are included in all given arrays + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. The order and references of result values are + * determined by the first array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersection([2, 1], [2, 3]); + * // => [2] + */ + var intersection = baseRest(function(arrays) { + var mapped = arrayMap(arrays, castArrayLikeObject); + return (mapped.length && mapped[0] === arrays[0]) + ? baseIntersection(mapped) + : []; + }); + + /** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which they're compared. The order and references of result values are + * determined by the first array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + * + * // The `_.property` iteratee shorthand. + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */ + var intersectionBy = baseRest(function(arrays) { + var iteratee = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + + if (iteratee === last(mapped)) { + iteratee = undefined; + } else { + mapped.pop(); + } + return (mapped.length && mapped[0] === arrays[0]) + ? baseIntersection(mapped, getIteratee(iteratee, 2)) + : []; + }); + + /** + * This method is like `_.intersection` except that it accepts `comparator` + * which is invoked to compare elements of `arrays`. The order and references + * of result values are determined by the first array. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of intersecting values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */ + var intersectionWith = baseRest(function(arrays) { + var comparator = last(arrays), + mapped = arrayMap(arrays, castArrayLikeObject); + + comparator = typeof comparator == 'function' ? comparator : undefined; + if (comparator) { + mapped.pop(); + } + return (mapped.length && mapped[0] === arrays[0]) + ? baseIntersection(mapped, undefined, comparator) + : []; + }); + + /** + * Converts all elements in `array` into a string separated by `separator`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to convert. + * @param {string} [separator=','] The element separator. + * @returns {string} Returns the joined string. + * @example + * + * _.join(['a', 'b', 'c'], '~'); + * // => 'a~b~c' + */ + function join(array, separator) { + return array == null ? '' : nativeJoin.call(array, separator); + } + + /** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ + function last(array) { + var length = array == null ? 0 : array.length; + return length ? array[length - 1] : undefined; + } + + /** + * This method is like `_.indexOf` except that it iterates over elements of + * `array` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=array.length-1] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * // Search from the `fromIndex`. + * _.lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + */ + function lastIndexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length; + if (fromIndex !== undefined) { + index = toInteger(fromIndex); + index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); + } + return value === value + ? strictLastIndexOf(array, value, index) + : baseFindIndex(array, baseIsNaN, index, true); + } + + /** + * Gets the element at index `n` of `array`. If `n` is negative, the nth + * element from the end is returned. + * + * @static + * @memberOf _ + * @since 4.11.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=0] The index of the element to return. + * @returns {*} Returns the nth element of `array`. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * + * _.nth(array, 1); + * // => 'b' + * + * _.nth(array, -2); + * // => 'c'; + */ + function nth(array, n) { + return (array && array.length) ? baseNth(array, toInteger(n)) : undefined; + } + + /** + * Removes all given values from `array` using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` + * to remove elements from an array by predicate. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...*} [values] The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pull(array, 'a', 'c'); + * console.log(array); + * // => ['b', 'b'] + */ + var pull = baseRest(pullAll); + + /** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = ['a', 'b', 'c', 'a', 'b', 'c']; + * + * _.pullAll(array, ['a', 'c']); + * console.log(array); + * // => ['b', 'b'] + */ + function pullAll(array, values) { + return (array && array.length && values && values.length) + ? basePullAll(array, values) + : array; + } + + /** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to generate the criterion + * by which they're compared. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ + function pullAllBy(array, values, iteratee) { + return (array && array.length && values && values.length) + ? basePullAll(array, values, getIteratee(iteratee, 2)) + : array; + } + + /** + * This method is like `_.pullAll` except that it accepts `comparator` which + * is invoked to compare elements of `array` to `values`. The comparator is + * invoked with two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ + function pullAllWith(array, values, comparator) { + return (array && array.length && values && values.length) + ? basePullAll(array, values, undefined, comparator) + : array; + } + + /** + * Removes elements from `array` corresponding to `indexes` and returns an + * array of removed elements. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {...(number|number[])} [indexes] The indexes of elements to remove. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = ['a', 'b', 'c', 'd']; + * var pulled = _.pullAt(array, [1, 3]); + * + * console.log(array); + * // => ['a', 'c'] + * + * console.log(pulled); + * // => ['b', 'd'] + */ + var pullAt = flatRest(function(array, indexes) { + var length = array == null ? 0 : array.length, + result = baseAt(array, indexes); + + basePullAt(array, arrayMap(indexes, function(index) { + return isIndex(index, length) ? +index : index; + }).sort(compareAscending)); + + return result; + }); + + /** + * Removes all elements from `array` that `predicate` returns truthy for + * and returns an array of the removed elements. The predicate is invoked + * with three arguments: (value, index, array). + * + * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` + * to pull elements from an array by value. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Array + * @param {Array} array The array to modify. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * @example + * + * var array = [1, 2, 3, 4]; + * var evens = _.remove(array, function(n) { + * return n % 2 == 0; + * }); + * + * console.log(array); + * // => [1, 3] + * + * console.log(evens); + * // => [2, 4] + */ + function remove(array, predicate) { + var result = []; + if (!(array && array.length)) { + return result; + } + var index = -1, + indexes = [], + length = array.length; + + predicate = getIteratee(predicate, 3); + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result.push(value); + indexes.push(index); + } + } + basePullAt(array, indexes); + return result; + } + + /** + * Reverses `array` so that the first element becomes the last, the second + * element becomes the second to last, and so on. + * + * **Note:** This method mutates `array` and is based on + * [`Array#reverse`](https://mdn.io/Array/reverse). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to modify. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.reverse(array); + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + function reverse(array) { + return array == null ? array : nativeReverse.call(array); + } + + /** + * Creates a slice of `array` from `start` up to, but not including, `end`. + * + * **Note:** This method is used instead of + * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are + * returned. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function slice(array, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if (end && typeof end != 'number' && isIterateeCall(array, start, end)) { + start = 0; + end = length; + } + else { + start = start == null ? 0 : toInteger(start); + end = end === undefined ? length : toInteger(end); + } + return baseSlice(array, start, end); + } + + /** + * Uses a binary search to determine the lowest index at which `value` + * should be inserted into `array` in order to maintain its sort order. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + */ + function sortedIndex(array, value) { + return baseSortedIndex(array, value); + } + + /** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 0 + * + * // The `_.property` iteratee shorthand. + * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); + * // => 0 + */ + function sortedIndexBy(array, value, iteratee) { + return baseSortedIndexBy(array, value, getIteratee(iteratee, 2)); + } + + /** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([4, 5, 5, 5, 6], 5); + * // => 1 + */ + function sortedIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value); + if (index < length && eq(array[index], value)) { + return index; + } + } + return -1; + } + + /** + * This method is like `_.sortedIndex` except that it returns the highest + * index at which `value` should be inserted into `array` in order to + * maintain its sort order. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * _.sortedLastIndex([4, 5, 5, 5, 6], 5); + * // => 4 + */ + function sortedLastIndex(array, value) { + return baseSortedIndex(array, value, true); + } + + /** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted + * into `array`. + * @example + * + * var objects = [{ 'x': 4 }, { 'x': 5 }]; + * + * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); + * // => 1 + * + * // The `_.property` iteratee shorthand. + * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); + * // => 1 + */ + function sortedLastIndexBy(array, value, iteratee) { + return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true); + } + + /** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); + * // => 3 + */ + function sortedLastIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value, true) - 1; + if (eq(array[index], value)) { + return index; + } + } + return -1; + } + + /** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */ + function sortedUniq(array) { + return (array && array.length) + ? baseSortedUniq(array) + : []; + } + + /** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.3] + */ + function sortedUniqBy(array, iteratee) { + return (array && array.length) + ? baseSortedUniq(array, getIteratee(iteratee, 2)) + : []; + } + + /** + * Gets all but the first element of `array`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to query. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.tail([1, 2, 3]); + * // => [2, 3] + */ + function tail(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 1, length) : []; + } + + /** + * Creates a slice of `array` with `n` elements taken from the beginning. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.take([1, 2, 3]); + * // => [1] + * + * _.take([1, 2, 3], 2); + * // => [1, 2] + * + * _.take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.take([1, 2, 3], 0); + * // => [] + */ + function take(array, n, guard) { + if (!(array && array.length)) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + return baseSlice(array, 0, n < 0 ? 0 : n); + } + + /** + * Creates a slice of `array` with `n` elements taken from the end. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {number} [n=1] The number of elements to take. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the slice of `array`. + * @example + * + * _.takeRight([1, 2, 3]); + * // => [3] + * + * _.takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * _.takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * _.takeRight([1, 2, 3], 0); + * // => [] + */ + function takeRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = (guard || n === undefined) ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, n < 0 ? 0 : n, length); + } + + /** + * Creates a slice of `array` with elements taken from the end. Elements are + * taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * _.takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.matches` iteratee shorthand. + * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * // The `_.property` iteratee shorthand. + * _.takeRightWhile(users, 'active'); + * // => [] + */ + function takeRightWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3), false, true) + : []; + } + + /** + * Creates a slice of `array` with elements taken from the beginning. Elements + * are taken until `predicate` returns falsey. The predicate is invoked with + * three arguments: (value, index, array). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Array + * @param {Array} array The array to query. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the slice of `array`. + * @example + * + * var users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * _.takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * // The `_.matches` iteratee shorthand. + * _.takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * // The `_.property` iteratee shorthand. + * _.takeWhile(users, 'active'); + * // => [] + */ + function takeWhile(array, predicate) { + return (array && array.length) + ? baseWhile(array, getIteratee(predicate, 3)) + : []; + } + + /** + * Creates an array of unique values, in order, from all given arrays using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.union([2], [1, 2]); + * // => [2, 1] + */ + var union = baseRest(function(arrays) { + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); + }); + + /** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which uniqueness is computed. Result values are chosen from the first + * array in which the value occurs. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * _.unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + var unionBy = baseRest(function(arrays) { + var iteratee = last(arrays); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)); + }); + + /** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. Result values are chosen from + * the first array in which the value occurs. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + var unionWith = baseRest(function(arrays) { + var comparator = last(arrays); + comparator = typeof comparator == 'function' ? comparator : undefined; + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator); + }); + + /** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. The order of result values is determined by the order they occur + * in the array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ + function uniq(array) { + return (array && array.length) ? baseUniq(array) : []; + } + + /** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The order of result values is determined by the + * order they occur in the array. The iteratee is invoked with one argument: + * (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // The `_.property` iteratee shorthand. + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + function uniqBy(array, iteratee) { + return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : []; + } + + /** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The order of result values is + * determined by the order they occur in the array.The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */ + function uniqWith(array, comparator) { + comparator = typeof comparator == 'function' ? comparator : undefined; + return (array && array.length) ? baseUniq(array, undefined, comparator) : []; + } + + /** + * This method is like `_.zip` except that it accepts an array of grouped + * elements and creates an array regrouping the elements to their pre-zip + * configuration. + * + * @static + * @memberOf _ + * @since 1.2.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + * + * _.unzip(zipped); + * // => [['a', 'b'], [1, 2], [true, false]] + */ + function unzip(array) { + if (!(array && array.length)) { + return []; + } + var length = 0; + array = arrayFilter(array, function(group) { + if (isArrayLikeObject(group)) { + length = nativeMax(group.length, length); + return true; + } + }); + return baseTimes(length, function(index) { + return arrayMap(array, baseProperty(index)); + }); + } + + /** + * This method is like `_.unzip` except that it accepts `iteratee` to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {Array} array The array of grouped elements to process. + * @param {Function} [iteratee=_.identity] The function to combine + * regrouped values. + * @returns {Array} Returns the new array of regrouped elements. + * @example + * + * var zipped = _.zip([1, 2], [10, 20], [100, 200]); + * // => [[1, 10, 100], [2, 20, 200]] + * + * _.unzipWith(zipped, _.add); + * // => [3, 30, 300] + */ + function unzipWith(array, iteratee) { + if (!(array && array.length)) { + return []; + } + var result = unzip(array); + if (iteratee == null) { + return result; + } + return arrayMap(result, function(group) { + return apply(iteratee, undefined, group); + }); + } + + /** + * Creates an array excluding all given values using + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * **Note:** Unlike `_.pull`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {Array} array The array to inspect. + * @param {...*} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.xor + * @example + * + * _.without([2, 1, 2, 3], 1, 2); + * // => [3] + */ + var without = baseRest(function(array, values) { + return isArrayLikeObject(array) + ? baseDifference(array, values) + : []; + }); + + /** + * Creates an array of unique values that is the + * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) + * of the given arrays. The order of result values is determined by the order + * they occur in the arrays. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @returns {Array} Returns the new array of filtered values. + * @see _.difference, _.without + * @example + * + * _.xor([2, 1], [2, 3]); + * // => [1, 3] + */ + var xor = baseRest(function(arrays) { + return baseXor(arrayFilter(arrays, isArrayLikeObject)); + }); + + /** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by + * which by which they're compared. The order of result values is determined + * by the order they occur in the arrays. The iteratee is invoked with one + * argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [1.2, 3.4] + * + * // The `_.property` iteratee shorthand. + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + var xorBy = baseRest(function(arrays) { + var iteratee = last(arrays); + if (isArrayLikeObject(iteratee)) { + iteratee = undefined; + } + return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2)); + }); + + /** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The order of result values is + * determined by the order they occur in the arrays. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + var xorWith = baseRest(function(arrays) { + var comparator = last(arrays); + comparator = typeof comparator == 'function' ? comparator : undefined; + return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator); + }); + + /** + * Creates an array of grouped elements, the first of which contains the + * first elements of the given arrays, the second of which contains the + * second elements of the given arrays, and so on. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zip(['a', 'b'], [1, 2], [true, false]); + * // => [['a', 1, true], ['b', 2, false]] + */ + var zip = baseRest(unzip); + + /** + * This method is like `_.fromPairs` except that it accepts two arrays, + * one of property identifiers and one of corresponding values. + * + * @static + * @memberOf _ + * @since 0.4.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObject(['a', 'b'], [1, 2]); + * // => { 'a': 1, 'b': 2 } + */ + function zipObject(props, values) { + return baseZipObject(props || [], values || [], assignValue); + } + + /** + * This method is like `_.zipObject` except that it supports property paths. + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Array + * @param {Array} [props=[]] The property identifiers. + * @param {Array} [values=[]] The property values. + * @returns {Object} Returns the new object. + * @example + * + * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); + * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */ + function zipObjectDeep(props, values) { + return baseZipObject(props || [], values || [], baseSet); + } + + /** + * This method is like `_.zip` except that it accepts `iteratee` to specify + * how grouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Array + * @param {...Array} [arrays] The arrays to process. + * @param {Function} [iteratee=_.identity] The function to combine + * grouped values. + * @returns {Array} Returns the new array of grouped elements. + * @example + * + * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { + * return a + b + c; + * }); + * // => [111, 222] + */ + var zipWith = baseRest(function(arrays) { + var length = arrays.length, + iteratee = length > 1 ? arrays[length - 1] : undefined; + + iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined; + return unzipWith(arrays, iteratee); + }); + + /*------------------------------------------------------------------------*/ + + /** + * Creates a `lodash` wrapper instance that wraps `value` with explicit method + * chain sequences enabled. The result of such sequences must be unwrapped + * with `_#value`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Seq + * @param {*} value The value to wrap. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'pebbles', 'age': 1 } + * ]; + * + * var youngest = _ + * .chain(users) + * .sortBy('age') + * .map(function(o) { + * return o.user + ' is ' + o.age; + * }) + * .head() + * .value(); + * // => 'pebbles is 1' + */ + function chain(value) { + var result = lodash(value); + result.__chain__ = true; + return result; + } + + /** + * This method invokes `interceptor` and returns `value`. The interceptor + * is invoked with one argument; (value). The purpose of this method is to + * "tap into" a method chain sequence in order to modify intermediate results. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns `value`. + * @example + * + * _([1, 2, 3]) + * .tap(function(array) { + * // Mutate input array. + * array.pop(); + * }) + * .reverse() + * .value(); + * // => [2, 1] + */ + function tap(value, interceptor) { + interceptor(value); + return value; + } + + /** + * This method is like `_.tap` except that it returns the result of `interceptor`. + * The purpose of this method is to "pass thru" values replacing intermediate + * results in a method chain sequence. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Seq + * @param {*} value The value to provide to `interceptor`. + * @param {Function} interceptor The function to invoke. + * @returns {*} Returns the result of `interceptor`. + * @example + * + * _(' abc ') + * .chain() + * .trim() + * .thru(function(value) { + * return [value]; + * }) + * .value(); + * // => ['abc'] + */ + function thru(value, interceptor) { + return interceptor(value); + } + + /** + * This method is the wrapper version of `_.at`. + * + * @name at + * @memberOf _ + * @since 1.0.0 + * @category Seq + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _(object).at(['a[0].b.c', 'a[1]']).value(); + * // => [3, 4] + */ + var wrapperAt = flatRest(function(paths) { + var length = paths.length, + start = length ? paths[0] : 0, + value = this.__wrapped__, + interceptor = function(object) { return baseAt(object, paths); }; + + if (length > 1 || this.__actions__.length || + !(value instanceof LazyWrapper) || !isIndex(start)) { + return this.thru(interceptor); + } + value = value.slice(start, +start + (length ? 1 : 0)); + value.__actions__.push({ + 'func': thru, + 'args': [interceptor], + 'thisArg': undefined + }); + return new LodashWrapper(value, this.__chain__).thru(function(array) { + if (length && !array.length) { + array.push(undefined); + } + return array; + }); + }); + + /** + * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. + * + * @name chain + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // A sequence without explicit chaining. + * _(users).head(); + * // => { 'user': 'barney', 'age': 36 } + * + * // A sequence with explicit chaining. + * _(users) + * .chain() + * .head() + * .pick('user') + * .value(); + * // => { 'user': 'barney' } + */ + function wrapperChain() { + return chain(this); + } + + /** + * Executes the chain sequence and returns the wrapped result. + * + * @name commit + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2]; + * var wrapped = _(array).push(3); + * + * console.log(array); + * // => [1, 2] + * + * wrapped = wrapped.commit(); + * console.log(array); + * // => [1, 2, 3] + * + * wrapped.last(); + * // => 3 + * + * console.log(array); + * // => [1, 2, 3] + */ + function wrapperCommit() { + return new LodashWrapper(this.value(), this.__chain__); + } + + /** + * Gets the next value on a wrapped object following the + * [iterator protocol](https://mdn.io/iteration_protocols#iterator). + * + * @name next + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the next iterator value. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped.next(); + * // => { 'done': false, 'value': 1 } + * + * wrapped.next(); + * // => { 'done': false, 'value': 2 } + * + * wrapped.next(); + * // => { 'done': true, 'value': undefined } + */ + function wrapperNext() { + if (this.__values__ === undefined) { + this.__values__ = toArray(this.value()); + } + var done = this.__index__ >= this.__values__.length, + value = done ? undefined : this.__values__[this.__index__++]; + + return { 'done': done, 'value': value }; + } + + /** + * Enables the wrapper to be iterable. + * + * @name Symbol.iterator + * @memberOf _ + * @since 4.0.0 + * @category Seq + * @returns {Object} Returns the wrapper object. + * @example + * + * var wrapped = _([1, 2]); + * + * wrapped[Symbol.iterator]() === wrapped; + * // => true + * + * Array.from(wrapped); + * // => [1, 2] + */ + function wrapperToIterator() { + return this; + } + + /** + * Creates a clone of the chain sequence planting `value` as the wrapped value. + * + * @name plant + * @memberOf _ + * @since 3.2.0 + * @category Seq + * @param {*} value The value to plant. + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * function square(n) { + * return n * n; + * } + * + * var wrapped = _([1, 2]).map(square); + * var other = wrapped.plant([3, 4]); + * + * other.value(); + * // => [9, 16] + * + * wrapped.value(); + * // => [1, 4] + */ + function wrapperPlant(value) { + var result, + parent = this; + + while (parent instanceof baseLodash) { + var clone = wrapperClone(parent); + clone.__index__ = 0; + clone.__values__ = undefined; + if (result) { + previous.__wrapped__ = clone; + } else { + result = clone; + } + var previous = clone; + parent = parent.__wrapped__; + } + previous.__wrapped__ = value; + return result; + } + + /** + * This method is the wrapper version of `_.reverse`. + * + * **Note:** This method mutates the wrapped array. + * + * @name reverse + * @memberOf _ + * @since 0.1.0 + * @category Seq + * @returns {Object} Returns the new `lodash` wrapper instance. + * @example + * + * var array = [1, 2, 3]; + * + * _(array).reverse().value() + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + function wrapperReverse() { + var value = this.__wrapped__; + if (value instanceof LazyWrapper) { + var wrapped = value; + if (this.__actions__.length) { + wrapped = new LazyWrapper(this); + } + wrapped = wrapped.reverse(); + wrapped.__actions__.push({ + 'func': thru, + 'args': [reverse], + 'thisArg': undefined + }); + return new LodashWrapper(wrapped, this.__chain__); + } + return this.thru(reverse); + } + + /** + * Executes the chain sequence to resolve the unwrapped value. + * + * @name value + * @memberOf _ + * @since 0.1.0 + * @alias toJSON, valueOf + * @category Seq + * @returns {*} Returns the resolved unwrapped value. + * @example + * + * _([1, 2, 3]).value(); + * // => [1, 2, 3] + */ + function wrapperValue() { + return baseWrapperValue(this.__wrapped__, this.__actions__); + } + + /*------------------------------------------------------------------------*/ + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the number of times the key was returned by `iteratee`. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.countBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': 1, '6': 2 } + * + * // The `_.property` iteratee shorthand. + * _.countBy(['one', 'two', 'three'], 'length'); + * // => { '3': 2, '5': 1 } + */ + var countBy = createAggregator(function(result, value, key) { + if (hasOwnProperty.call(result, key)) { + ++result[key]; + } else { + baseAssignValue(result, key, 1); + } + }); + + /** + * Checks if `predicate` returns truthy for **all** elements of `collection`. + * Iteration is stopped once `predicate` returns falsey. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * **Note:** This method returns `true` for + * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because + * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of + * elements of empty collections. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if all elements pass the predicate check, + * else `false`. + * @example + * + * _.every([true, 1, null, 'yes'], Boolean); + * // => false + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.every(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.every(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.every(users, 'active'); + * // => false + */ + function every(collection, predicate, guard) { + var func = isArray(collection) ? arrayEvery : baseEvery; + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined; + } + return func(collection, getIteratee(predicate, 3)); + } + + /** + * Iterates over elements of `collection`, returning an array of all elements + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * **Note:** Unlike `_.remove`, this method returns a new array. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.reject + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false } + * ]; + * + * _.filter(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.filter(users, { 'age': 36, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.filter(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.filter(users, 'active'); + * // => objects for ['barney'] + */ + function filter(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, getIteratee(predicate, 3)); + } + + /** + * Iterates over elements of `collection`, returning the first element + * `predicate` returns truthy for. The predicate is invoked with three + * arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=0] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false }, + * { 'user': 'pebbles', 'age': 1, 'active': true } + * ]; + * + * _.find(users, function(o) { return o.age < 40; }); + * // => object for 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.find(users, { 'age': 1, 'active': true }); + * // => object for 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.find(users, ['active', false]); + * // => object for 'fred' + * + * // The `_.property` iteratee shorthand. + * _.find(users, 'active'); + * // => object for 'barney' + */ + var find = createFind(findIndex); + + /** + * This method is like `_.find` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param {number} [fromIndex=collection.length-1] The index to search from. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * _.findLast([1, 2, 3, 4], function(n) { + * return n % 2 == 1; + * }); + * // => 3 + */ + var findLast = createFind(findLastIndex); + + /** + * Creates a flattened array of values by running each element in `collection` + * thru `iteratee` and flattening the mapped results. The iteratee is invoked + * with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [n, n]; + * } + * + * _.flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + function flatMap(collection, iteratee) { + return baseFlatten(map(collection, iteratee), 1); + } + + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ + function flatMapDeep(collection, iteratee) { + return baseFlatten(map(collection, iteratee), INFINITY); + } + + /** + * This method is like `_.flatMap` except that it recursively flattens the + * mapped results up to `depth` times. + * + * @static + * @memberOf _ + * @since 4.7.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {number} [depth=1] The maximum recursion depth. + * @returns {Array} Returns the new flattened array. + * @example + * + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * _.flatMapDepth([1, 2], duplicate, 2); + * // => [[1, 1], [2, 2]] + */ + function flatMapDepth(collection, iteratee, depth) { + depth = depth === undefined ? 1 : toInteger(depth); + return baseFlatten(map(collection, iteratee), depth); + } + + /** + * Iterates over elements of `collection` and invokes `iteratee` for each element. + * The iteratee is invoked with three arguments: (value, index|key, collection). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" + * property are iterated like arrays. To avoid this behavior use `_.forIn` + * or `_.forOwn` for object iteration. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @alias each + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEachRight + * @example + * + * _.forEach([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. + * + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ + function forEach(collection, iteratee) { + var func = isArray(collection) ? arrayEach : baseEach; + return func(collection, getIteratee(iteratee, 3)); + } + + /** + * This method is like `_.forEach` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @alias eachRight + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array|Object} Returns `collection`. + * @see _.forEach + * @example + * + * _.forEachRight([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `2` then `1`. + */ + function forEachRight(collection, iteratee) { + var func = isArray(collection) ? arrayEachRight : baseEachRight; + return func(collection, getIteratee(iteratee, 3)); + } + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The order of grouped values + * is determined by the order they occur in `collection`. The corresponding + * value of each key is an array of elements responsible for generating the + * key. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * _.groupBy([6.1, 4.2, 6.3], Math.floor); + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * // The `_.property` iteratee shorthand. + * _.groupBy(['one', 'two', 'three'], 'length'); + * // => { '3': ['one', 'two'], '5': ['three'] } + */ + var groupBy = createAggregator(function(result, value, key) { + if (hasOwnProperty.call(result, key)) { + result[key].push(value); + } else { + baseAssignValue(result, key, [value]); + } + }); + + /** + * Checks if `value` is in `collection`. If `collection` is a string, it's + * checked for a substring of `value`, otherwise + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * is used for equality comparisons. If `fromIndex` is negative, it's used as + * the offset from the end of `collection`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {boolean} Returns `true` if `value` is found, else `false`. + * @example + * + * _.includes([1, 2, 3], 1); + * // => true + * + * _.includes([1, 2, 3], 1, 2); + * // => false + * + * _.includes({ 'a': 1, 'b': 2 }, 1); + * // => true + * + * _.includes('abcd', 'bc'); + * // => true + */ + function includes(collection, value, fromIndex, guard) { + collection = isArrayLike(collection) ? collection : values(collection); + fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0; + + var length = collection.length; + if (fromIndex < 0) { + fromIndex = nativeMax(length + fromIndex, 0); + } + return isString(collection) + ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1) + : (!!length && baseIndexOf(collection, value, fromIndex) > -1); + } + + /** + * Invokes the method at `path` of each element in `collection`, returning + * an array of the results of each invoked method. Any additional arguments + * are provided to each invoked method. If `path` is a function, it's invoked + * for, and `this` bound to, each element in `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array|Function|string} path The path of the method to invoke or + * the function invoked per iteration. + * @param {...*} [args] The arguments to invoke each method with. + * @returns {Array} Returns the array of results. + * @example + * + * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * _.invokeMap([123, 456], String.prototype.split, ''); + * // => [['1', '2', '3'], ['4', '5', '6']] + */ + var invokeMap = baseRest(function(collection, path, args) { + var index = -1, + isFunc = typeof path == 'function', + result = isArrayLike(collection) ? Array(collection.length) : []; + + baseEach(collection, function(value) { + result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args); + }); + return result; + }); + + /** + * Creates an object composed of keys generated from the results of running + * each element of `collection` thru `iteratee`. The corresponding value of + * each key is the last element responsible for generating the key. The + * iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The iteratee to transform keys. + * @returns {Object} Returns the composed aggregate object. + * @example + * + * var array = [ + * { 'dir': 'left', 'code': 97 }, + * { 'dir': 'right', 'code': 100 } + * ]; + * + * _.keyBy(array, function(o) { + * return String.fromCharCode(o.code); + * }); + * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } + * + * _.keyBy(array, 'dir'); + * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } + */ + var keyBy = createAggregator(function(result, value, key) { + baseAssignValue(result, key, value); + }); + + /** + * Creates an array of values by running each element in `collection` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. + * + * The guarded methods are: + * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, + * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, + * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, + * `template`, `trim`, `trimEnd`, `trimStart`, and `words` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + * @example + * + * function square(n) { + * return n * n; + * } + * + * _.map([4, 8], square); + * // => [16, 64] + * + * _.map({ 'a': 4, 'b': 8 }, square); + * // => [16, 64] (iteration order is not guaranteed) + * + * var users = [ + * { 'user': 'barney' }, + * { 'user': 'fred' } + * ]; + * + * // The `_.property` iteratee shorthand. + * _.map(users, 'user'); + * // => ['barney', 'fred'] + */ + function map(collection, iteratee) { + var func = isArray(collection) ? arrayMap : baseMap; + return func(collection, getIteratee(iteratee, 3)); + } + + /** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] + * The iteratees to sort by. + * @param {string[]} [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // Sort by `user` in ascending order and by `age` in descending order. + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + */ + function orderBy(collection, iteratees, orders, guard) { + if (collection == null) { + return []; + } + if (!isArray(iteratees)) { + iteratees = iteratees == null ? [] : [iteratees]; + } + orders = guard ? undefined : orders; + if (!isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + return baseOrderBy(collection, iteratees, orders); + } + + /** + * Creates an array of elements split into two groups, the first of which + * contains elements `predicate` returns truthy for, the second of which + * contains elements `predicate` returns falsey for. The predicate is + * invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the array of grouped elements. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true }, + * { 'user': 'pebbles', 'age': 1, 'active': false } + * ]; + * + * _.partition(users, function(o) { return o.active; }); + * // => objects for [['fred'], ['barney', 'pebbles']] + * + * // The `_.matches` iteratee shorthand. + * _.partition(users, { 'age': 1, 'active': false }); + * // => objects for [['pebbles'], ['barney', 'fred']] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.partition(users, ['active', false]); + * // => objects for [['barney', 'pebbles'], ['fred']] + * + * // The `_.property` iteratee shorthand. + * _.partition(users, 'active'); + * // => objects for [['fred'], ['barney', 'pebbles']] + */ + var partition = createAggregator(function(result, value, key) { + result[key ? 0 : 1].push(value); + }, function() { return [[], []]; }); + + /** + * Reduces `collection` to a value which is the accumulated result of running + * each element in `collection` thru `iteratee`, where each successive + * invocation is supplied the return value of the previous. If `accumulator` + * is not given, the first element of `collection` is used as the initial + * value. The iteratee is invoked with four arguments: + * (accumulator, value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.reduce`, `_.reduceRight`, and `_.transform`. + * + * The guarded methods are: + * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, + * and `sortBy` + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduceRight + * @example + * + * _.reduce([1, 2], function(sum, n) { + * return sum + n; + * }, 0); + * // => 3 + * + * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * return result; + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) + */ + function reduce(collection, iteratee, accumulator) { + var func = isArray(collection) ? arrayReduce : baseReduce, + initAccum = arguments.length < 3; + + return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach); + } + + /** + * This method is like `_.reduce` except that it iterates over elements of + * `collection` from right to left. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @returns {*} Returns the accumulated value. + * @see _.reduce + * @example + * + * var array = [[0, 1], [2, 3], [4, 5]]; + * + * _.reduceRight(array, function(flattened, other) { + * return flattened.concat(other); + * }, []); + * // => [4, 5, 2, 3, 0, 1] + */ + function reduceRight(collection, iteratee, accumulator) { + var func = isArray(collection) ? arrayReduceRight : baseReduce, + initAccum = arguments.length < 3; + + return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight); + } + + /** + * The opposite of `_.filter`; this method returns the elements of `collection` + * that `predicate` does **not** return truthy for. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + * @see _.filter + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': false }, + * { 'user': 'fred', 'age': 40, 'active': true } + * ]; + * + * _.reject(users, function(o) { return !o.active; }); + * // => objects for ['fred'] + * + * // The `_.matches` iteratee shorthand. + * _.reject(users, { 'age': 40, 'active': true }); + * // => objects for ['barney'] + * + * // The `_.matchesProperty` iteratee shorthand. + * _.reject(users, ['active', false]); + * // => objects for ['fred'] + * + * // The `_.property` iteratee shorthand. + * _.reject(users, 'active'); + * // => objects for ['barney'] + */ + function reject(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, negate(getIteratee(predicate, 3))); + } + + /** + * Gets a random element from `collection`. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @returns {*} Returns the random element. + * @example + * + * _.sample([1, 2, 3, 4]); + * // => 2 + */ + function sample(collection) { + var func = isArray(collection) ? arraySample : baseSample; + return func(collection); + } + + /** + * Gets `n` random elements at unique keys from `collection` up to the + * size of `collection`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Collection + * @param {Array|Object} collection The collection to sample. + * @param {number} [n=1] The number of elements to sample. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Array} Returns the random elements. + * @example + * + * _.sampleSize([1, 2, 3], 2); + * // => [3, 1] + * + * _.sampleSize([1, 2, 3], 4); + * // => [2, 3, 1] + */ + function sampleSize(collection, n, guard) { + if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) { + n = 1; + } else { + n = toInteger(n); + } + var func = isArray(collection) ? arraySampleSize : baseSampleSize; + return func(collection, n); + } + + /** + * Creates an array of shuffled values, using a version of the + * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to shuffle. + * @returns {Array} Returns the new shuffled array. + * @example + * + * _.shuffle([1, 2, 3, 4]); + * // => [4, 1, 3, 2] + */ + function shuffle(collection) { + var func = isArray(collection) ? arrayShuffle : baseShuffle; + return func(collection); + } + + /** + * Gets the size of `collection` by returning its length for array-like + * values or the number of own enumerable string keyed properties for objects. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object|string} collection The collection to inspect. + * @returns {number} Returns the collection size. + * @example + * + * _.size([1, 2, 3]); + * // => 3 + * + * _.size({ 'a': 1, 'b': 2 }); + * // => 2 + * + * _.size('pebbles'); + * // => 7 + */ + function size(collection) { + if (collection == null) { + return 0; + } + if (isArrayLike(collection)) { + return isString(collection) ? stringSize(collection) : collection.length; + } + var tag = getTag(collection); + if (tag == mapTag || tag == setTag) { + return collection.size; + } + return baseKeys(collection).length; + } + + /** + * Checks if `predicate` returns truthy for **any** element of `collection`. + * Iteration is stopped once `predicate` returns truthy. The predicate is + * invoked with three arguments: (value, index|key, collection). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + * @example + * + * _.some([null, 0, 'yes', false], Boolean); + * // => true + * + * var users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false } + * ]; + * + * // The `_.matches` iteratee shorthand. + * _.some(users, { 'user': 'barney', 'active': false }); + * // => false + * + * // The `_.matchesProperty` iteratee shorthand. + * _.some(users, ['active', false]); + * // => true + * + * // The `_.property` iteratee shorthand. + * _.some(users, 'active'); + * // => true + */ + function some(collection, predicate, guard) { + var func = isArray(collection) ? arraySome : baseSome; + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined; + } + return func(collection, getIteratee(predicate, 3)); + } + + /** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection thru each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {...(Function|Function[])} [iteratees=[_.identity]] + * The iteratees to sort by. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, [function(o) { return o.user; }]); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]] + */ + var sortBy = baseRest(function(collection, iteratees) { + if (collection == null) { + return []; + } + var length = iteratees.length; + if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { + iteratees = []; + } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { + iteratees = [iteratees[0]]; + } + return baseOrderBy(collection, baseFlatten(iteratees, 1), []); + }); + + /*------------------------------------------------------------------------*/ + + /** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ + var now = ctxNow || function() { + return root.Date.now(); + }; + + /*------------------------------------------------------------------------*/ + + /** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {number} n The number of calls before `func` is invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var saves = ['profile', 'settings']; + * + * var done = _.after(saves.length, function() { + * console.log('done saving!'); + * }); + * + * _.forEach(saves, function(type) { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ + function after(n, func) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n < 1) { + return func.apply(this, arguments); + } + }; + } + + /** + * Creates a function that invokes `func`, with up to `n` arguments, + * ignoring any additional arguments. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @param {number} [n=func.length] The arity cap. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.ary(parseInt, 1)); + * // => [6, 8, 10] + */ + function ary(func, n, guard) { + n = guard ? undefined : n; + n = (func && n == null) ? func.length : n; + return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n); + } + + /** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {number} n The number of calls at which `func` is no longer invoked. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * jQuery(element).on('click', _.before(5, addContactToList)); + * // => Allows adding up to 4 contacts to the list. + */ + function before(n, func) { + var result; + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n > 0) { + result = func.apply(this, arguments); + } + if (n <= 1) { + func = undefined; + } + return result; + }; + } + + /** + * Creates a function that invokes `func` with the `this` binding of `thisArg` + * and `partials` prepended to the arguments it receives. + * + * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for partially applied arguments. + * + * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" + * property of bound functions. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * + * var object = { 'user': 'fred' }; + * + * var bound = _.bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * // Bound with placeholders. + * var bound = _.bind(greet, object, _, '!'); + * bound('hi'); + * // => 'hi fred!' + */ + var bind = baseRest(function(func, thisArg, partials) { + var bitmask = WRAP_BIND_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bind)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(func, bitmask, thisArg, partials, holders); + }); + + /** + * Creates a function that invokes the method at `object[key]` with `partials` + * prepended to the arguments it receives. + * + * This method differs from `_.bind` by allowing bound functions to reference + * methods that may be redefined or don't yet exist. See + * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) + * for more details. + * + * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Function + * @param {Object} object The object to invoke the method on. + * @param {string} key The key of the method. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var object = { + * 'user': 'fred', + * 'greet': function(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * }; + * + * var bound = _.bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function(greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * var bound = _.bindKey(object, 'greet', _, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ + var bindKey = baseRest(function(object, key, partials) { + var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bindKey)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(key, bitmask, object, partials, holders); + }); + + /** + * Creates a function that accepts arguments of `func` and either invokes + * `func` returning its result, if at least `arity` number of arguments have + * been provided, or returns a function that accepts the remaining `func` + * arguments, and so on. The arity of `func` may be specified if `func.length` + * is not sufficient. + * + * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, + * may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curry(abc); + * + * curried(1)(2)(3); + * // => [1, 2, 3] + * + * curried(1, 2)(3); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(1)(_, 3)(2); + * // => [1, 2, 3] + */ + function curry(func, arity, guard) { + arity = guard ? undefined : arity; + var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity); + result.placeholder = curry.placeholder; + return result; + } + + /** + * This method is like `_.curry` except that arguments are applied to `func` + * in the manner of `_.partialRight` instead of `_.partial`. + * + * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for provided arguments. + * + * **Note:** This method doesn't set the "length" property of curried functions. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the new curried function. + * @example + * + * var abc = function(a, b, c) { + * return [a, b, c]; + * }; + * + * var curried = _.curryRight(abc); + * + * curried(3)(2)(1); + * // => [1, 2, 3] + * + * curried(2, 3)(1); + * // => [1, 2, 3] + * + * curried(1, 2, 3); + * // => [1, 2, 3] + * + * // Curried with placeholders. + * curried(3)(1, _)(2); + * // => [1, 2, 3] + */ + function curryRight(func, arity, guard) { + arity = guard ? undefined : arity; + var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity); + result.placeholder = curryRight.placeholder; + return result; + } + + /** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ + function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + timeWaiting = wait - timeSinceLastCall; + + return maxing + ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) + : timeWaiting; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + + /** + * Defers invoking the `func` until the current call stack has cleared. Any + * additional arguments are provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to defer. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.defer(function(text) { + * console.log(text); + * }, 'deferred'); + * // => Logs 'deferred' after one millisecond. + */ + var defer = baseRest(function(func, args) { + return baseDelay(func, 1, args); + }); + + /** + * Invokes `func` after `wait` milliseconds. Any additional arguments are + * provided to `func` when it's invoked. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay invocation. + * @param {...*} [args] The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * @example + * + * _.delay(function(text) { + * console.log(text); + * }, 1000, 'later'); + * // => Logs 'later' after one second. + */ + var delay = baseRest(function(func, wait, args) { + return baseDelay(func, toNumber(wait) || 0, args); + }); + + /** + * Creates a function that invokes `func` with arguments reversed. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to flip arguments for. + * @returns {Function} Returns the new flipped function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ + function flip(func) { + return createWrap(func, WRAP_FLIP_FLAG); + } + + /** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ + function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; + } + + // Expose `MapCache`. + memoize.Cache = MapCache; + + /** + * Creates a function that negates the result of the predicate `func`. The + * `func` predicate is invoked with the `this` binding and arguments of the + * created function. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} predicate The predicate to negate. + * @returns {Function} Returns the new negated function. + * @example + * + * function isEven(n) { + * return n % 2 == 0; + * } + * + * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); + * // => [1, 3, 5] + */ + function negate(predicate) { + if (typeof predicate != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + return function() { + var args = arguments; + switch (args.length) { + case 0: return !predicate.call(this); + case 1: return !predicate.call(this, args[0]); + case 2: return !predicate.call(this, args[0], args[1]); + case 3: return !predicate.call(this, args[0], args[1], args[2]); + } + return !predicate.apply(this, args); + }; + } + + /** + * Creates a function that is restricted to invoking `func` once. Repeat calls + * to the function return the value of the first invocation. The `func` is + * invoked with the `this` binding and arguments of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ + function once(func) { + return before(2, func); + } + + /** + * Creates a function that invokes `func` with its arguments transformed. + * + * @static + * @since 4.0.0 + * @memberOf _ + * @category Function + * @param {Function} func The function to wrap. + * @param {...(Function|Function[])} [transforms=[_.identity]] + * The argument transforms. + * @returns {Function} Returns the new function. + * @example + * + * function doubled(n) { + * return n * 2; + * } + * + * function square(n) { + * return n * n; + * } + * + * var func = _.overArgs(function(x, y) { + * return [x, y]; + * }, [square, doubled]); + * + * func(9, 3); + * // => [81, 6] + * + * func(10, 5); + * // => [100, 10] + */ + var overArgs = castRest(function(func, transforms) { + transforms = (transforms.length == 1 && isArray(transforms[0])) + ? arrayMap(transforms[0], baseUnary(getIteratee())) + : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())); + + var funcsLength = transforms.length; + return baseRest(function(args) { + var index = -1, + length = nativeMin(args.length, funcsLength); + + while (++index < length) { + args[index] = transforms[index].call(this, args[index]); + } + return apply(func, this, args); + }); + }); + + /** + * Creates a function that invokes `func` with `partials` prepended to the + * arguments it receives. This method is like `_.bind` except it does **not** + * alter the `this` binding. + * + * The `_.partial.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 0.2.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var sayHelloTo = _.partial(greet, 'hello'); + * sayHelloTo('fred'); + * // => 'hello fred' + * + * // Partially applied with placeholders. + * var greetFred = _.partial(greet, _, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + */ + var partial = baseRest(function(func, partials) { + var holders = replaceHolders(partials, getHolder(partial)); + return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders); + }); + + /** + * This method is like `_.partial` except that partially applied arguments + * are appended to the arguments it receives. + * + * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic + * builds, may be used as a placeholder for partially applied arguments. + * + * **Note:** This method doesn't set the "length" property of partially + * applied functions. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Function + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [partials] The arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * function greet(greeting, name) { + * return greeting + ' ' + name; + * } + * + * var greetFred = _.partialRight(greet, 'fred'); + * greetFred('hi'); + * // => 'hi fred' + * + * // Partially applied with placeholders. + * var sayHelloTo = _.partialRight(greet, 'hello', _); + * sayHelloTo('fred'); + * // => 'hello fred' + */ + var partialRight = baseRest(function(func, partials) { + var holders = replaceHolders(partials, getHolder(partialRight)); + return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders); + }); + + /** + * Creates a function that invokes `func` with arguments arranged according + * to the specified `indexes` where the argument value at the first index is + * provided as the first argument, the argument value at the second index is + * provided as the second argument, and so on. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Function + * @param {Function} func The function to rearrange arguments for. + * @param {...(number|number[])} indexes The arranged argument indexes. + * @returns {Function} Returns the new function. + * @example + * + * var rearged = _.rearg(function(a, b, c) { + * return [a, b, c]; + * }, [2, 0, 1]); + * + * rearged('b', 'c', 'a') + * // => ['a', 'b', 'c'] + */ + var rearg = flatRest(function(func, indexes) { + return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes); + }); + + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as + * an array. + * + * **Note:** This method is based on the + * [rest parameter](https://mdn.io/rest_parameters). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.rest(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ + function rest(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = start === undefined ? start : toInteger(start); + return baseRest(func, start); + } + + /** + * Creates a function that invokes `func` with the `this` binding of the + * create function and an array of arguments much like + * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). + * + * **Note:** This method is based on the + * [spread operator](https://mdn.io/spread_operator). + * + * @static + * @memberOf _ + * @since 3.2.0 + * @category Function + * @param {Function} func The function to spread arguments over. + * @param {number} [start=0] The start position of the spread. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.spread(function(who, what) { + * return who + ' says ' + what; + * }); + * + * say(['fred', 'hello']); + * // => 'fred says hello' + * + * var numbers = Promise.all([ + * Promise.resolve(40), + * Promise.resolve(36) + * ]); + * + * numbers.then(_.spread(function(x, y) { + * return x + y; + * })); + * // => a Promise of 76 + */ + function spread(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = start == null ? 0 : nativeMax(toInteger(start), 0); + return baseRest(function(args) { + var array = args[start], + otherArgs = castSlice(args, 0, start); + + if (array) { + arrayPush(otherArgs, array); + } + return apply(func, this, otherArgs); + }); + } + + /** + * Creates a throttled function that only invokes `func` at most once per + * every `wait` milliseconds. The throttled function comes with a `cancel` + * method to cancel delayed `func` invocations and a `flush` method to + * immediately invoke them. Provide `options` to indicate whether `func` + * should be invoked on the leading and/or trailing edge of the `wait` + * timeout. The `func` is invoked with the last arguments provided to the + * throttled function. Subsequent calls to the throttled function return the + * result of the last `func` invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the throttled function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.throttle` and `_.debounce`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to throttle. + * @param {number} [wait=0] The number of milliseconds to throttle invocations to. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=true] + * Specify invoking on the leading edge of the timeout. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // Avoid excessively updating the position while scrolling. + * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); + * + * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. + * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); + * jQuery(element).on('click', throttled); + * + * // Cancel the trailing throttled invocation. + * jQuery(window).on('popstate', throttled.cancel); + */ + function throttle(func, wait, options) { + var leading = true, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + if (isObject(options)) { + leading = 'leading' in options ? !!options.leading : leading; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + return debounce(func, wait, { + 'leading': leading, + 'maxWait': wait, + 'trailing': trailing + }); + } + + /** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Function + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */ + function unary(func) { + return ary(func, 1); + } + + /** + * Creates a function that provides `value` to `wrapper` as its first + * argument. Any additional arguments provided to the function are appended + * to those provided to the `wrapper`. The wrapper is invoked with the `this` + * binding of the created function. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {*} value The value to wrap. + * @param {Function} [wrapper=identity] The wrapper function. + * @returns {Function} Returns the new function. + * @example + * + * var p = _.wrap(_.escape, function(func, text) { + * return '

' + func(text) + '

'; + * }); + * + * p('fred, barney, & pebbles'); + * // => '

fred, barney, & pebbles

' + */ + function wrap(value, wrapper) { + return partial(castFunction(wrapper), value); + } + + /*------------------------------------------------------------------------*/ + + /** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */ + function castArray() { + if (!arguments.length) { + return []; + } + var value = arguments[0]; + return isArray(value) ? value : [value]; + } + + /** + * Creates a shallow clone of `value`. + * + * **Note:** This method is loosely based on the + * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) + * and supports cloning arrays, array buffers, booleans, date objects, maps, + * numbers, `Object` objects, regexes, sets, strings, symbols, and typed + * arrays. The own enumerable properties of `arguments` objects are cloned + * as plain objects. An empty object is returned for uncloneable values such + * as error objects, functions, DOM nodes, and WeakMaps. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to clone. + * @returns {*} Returns the cloned value. + * @see _.cloneDeep + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var shallow = _.clone(objects); + * console.log(shallow[0] === objects[0]); + * // => true + */ + function clone(value) { + return baseClone(value, CLONE_SYMBOLS_FLAG); + } + + /** + * This method is like `_.clone` except that it accepts `customizer` which + * is invoked to produce the cloned value. If `customizer` returns `undefined`, + * cloning is handled by the method instead. The `customizer` is invoked with + * up to four arguments; (value [, index|key, object, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the cloned value. + * @see _.cloneDeepWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(false); + * } + * } + * + * var el = _.cloneWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 0 + */ + function cloneWith(value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseClone(value, CLONE_SYMBOLS_FLAG, customizer); + } + + /** + * This method is like `_.clone` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @returns {*} Returns the deep cloned value. + * @see _.clone + * @example + * + * var objects = [{ 'a': 1 }, { 'b': 2 }]; + * + * var deep = _.cloneDeep(objects); + * console.log(deep[0] === objects[0]); + * // => false + */ + function cloneDeep(value) { + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG); + } + + /** + * This method is like `_.cloneWith` except that it recursively clones `value`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to recursively clone. + * @param {Function} [customizer] The function to customize cloning. + * @returns {*} Returns the deep cloned value. + * @see _.cloneWith + * @example + * + * function customizer(value) { + * if (_.isElement(value)) { + * return value.cloneNode(true); + * } + * } + * + * var el = _.cloneDeepWith(document.body, customizer); + * + * console.log(el === document.body); + * // => false + * console.log(el.nodeName); + * // => 'BODY' + * console.log(el.childNodes.length); + * // => 20 + */ + function cloneDeepWith(value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); + } + + /** + * Checks if `object` conforms to `source` by invoking the predicate + * properties of `source` with the corresponding property values of `object`. + * + * **Note:** This method is equivalent to `_.conforms` when `source` is + * partially applied. + * + * @static + * @memberOf _ + * @since 4.14.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); + * // => true + * + * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); + * // => false + */ + function conformsTo(object, source) { + return source == null || baseConformsTo(object, source, keys(source)); + } + + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + function eq(value, other) { + return value === other || (value !== value && other !== other); + } + + /** + * Checks if `value` is greater than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than `other`, + * else `false`. + * @see _.lt + * @example + * + * _.gt(3, 1); + * // => true + * + * _.gt(3, 3); + * // => false + * + * _.gt(1, 3); + * // => false + */ + var gt = createRelationalOperation(baseGt); + + /** + * Checks if `value` is greater than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is greater than or equal to + * `other`, else `false`. + * @see _.lte + * @example + * + * _.gte(3, 1); + * // => true + * + * _.gte(3, 3); + * // => true + * + * _.gte(1, 3); + * // => false + */ + var gte = createRelationalOperation(function(value, other) { + return value >= other; + }); + + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && + !propertyIsEnumerable.call(value, 'callee'); + }; + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray = Array.isArray; + + /** + * Checks if `value` is classified as an `ArrayBuffer` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. + * @example + * + * _.isArrayBuffer(new ArrayBuffer(2)); + * // => true + * + * _.isArrayBuffer(new Array(2)); + * // => false + */ + var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer; + + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + + /** + * Checks if `value` is classified as a boolean primitive or object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. + * @example + * + * _.isBoolean(false); + * // => true + * + * _.isBoolean(null); + * // => false + */ + function isBoolean(value) { + return value === true || value === false || + (isObjectLike(value) && baseGetTag(value) == boolTag); + } + + /** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ + var isBuffer = nativeIsBuffer || stubFalse; + + /** + * Checks if `value` is classified as a `Date` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a date object, else `false`. + * @example + * + * _.isDate(new Date); + * // => true + * + * _.isDate('Mon April 23 2012'); + * // => false + */ + var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate; + + /** + * Checks if `value` is likely a DOM element. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. + * @example + * + * _.isElement(document.body); + * // => true + * + * _.isElement(''); + * // => false + */ + function isElement(value) { + return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); + } + + /** + * Checks if `value` is an empty object, collection, map, or set. + * + * Objects are considered empty if they have no own enumerable string keyed + * properties. + * + * Array-like values such as `arguments` objects, arrays, buffers, strings, or + * jQuery-like collections are considered empty if they have a `length` of `0`. + * Similarly, maps and sets are considered empty if they have a `size` of `0`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is empty, else `false`. + * @example + * + * _.isEmpty(null); + * // => true + * + * _.isEmpty(true); + * // => true + * + * _.isEmpty(1); + * // => true + * + * _.isEmpty([1, 2, 3]); + * // => false + * + * _.isEmpty({ 'a': 1 }); + * // => false + */ + function isEmpty(value) { + if (value == null) { + return true; + } + if (isArrayLike(value) && + (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || + isBuffer(value) || isTypedArray(value) || isArguments(value))) { + return !value.length; + } + var tag = getTag(value); + if (tag == mapTag || tag == setTag) { + return !value.size; + } + if (isPrototype(value)) { + return !baseKeys(value).length; + } + for (var key in value) { + if (hasOwnProperty.call(value, key)) { + return false; + } + } + return true; + } + + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ + function isEqual(value, other) { + return baseIsEqual(value, other); + } + + /** + * This method is like `_.isEqual` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with up to + * six arguments: (objValue, othValue [, index|key, object, other, stack]). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true + */ + function isEqualWith(value, other, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + var result = customizer ? customizer(value, other) : undefined; + return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result; + } + + /** + * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, + * `SyntaxError`, `TypeError`, or `URIError` object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an error object, else `false`. + * @example + * + * _.isError(new Error); + * // => true + * + * _.isError(Error); + * // => false + */ + function isError(value) { + if (!isObjectLike(value)) { + return false; + } + var tag = baseGetTag(value); + return tag == errorTag || tag == domExcTag || + (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value)); + } + + /** + * Checks if `value` is a finite primitive number. + * + * **Note:** This method is based on + * [`Number.isFinite`](https://mdn.io/Number/isFinite). + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. + * @example + * + * _.isFinite(3); + * // => true + * + * _.isFinite(Number.MIN_VALUE); + * // => true + * + * _.isFinite(Infinity); + * // => false + * + * _.isFinite('3'); + * // => false + */ + function isFinite(value) { + return typeof value == 'number' && nativeIsFinite(value); + } + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + if (!isObject(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + + /** + * Checks if `value` is an integer. + * + * **Note:** This method is based on + * [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */ + function isInteger(value) { + return typeof value == 'number' && value == toInteger(value); + } + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + + /** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ + function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); + } + + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + function isObjectLike(value) { + return value != null && typeof value == 'object'; + } + + /** + * Checks if `value` is classified as a `Map` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a map, else `false`. + * @example + * + * _.isMap(new Map); + * // => true + * + * _.isMap(new WeakMap); + * // => false + */ + var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; + + /** + * Performs a partial deep comparison between `object` and `source` to + * determine if `object` contains equivalent property values. + * + * **Note:** This method is equivalent to `_.matches` when `source` is + * partially applied. + * + * Partial comparisons will match empty array and empty object `source` + * values against any array or object value, respectively. See `_.isEqual` + * for a list of supported value comparisons. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * + * _.isMatch(object, { 'b': 2 }); + * // => true + * + * _.isMatch(object, { 'b': 1 }); + * // => false + */ + function isMatch(object, source) { + return object === source || baseIsMatch(object, source, getMatchData(source)); + } + + /** + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined`, comparisons + * are handled by the method instead. The `customizer` is invoked with five + * arguments: (objValue, srcValue, index|key, object, source). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true + */ + function isMatchWith(object, source, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return baseIsMatch(object, source, getMatchData(source), customizer); + } + + /** + * Checks if `value` is `NaN`. + * + * **Note:** This method is based on + * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as + * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for + * `undefined` and other non-number values. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. + * @example + * + * _.isNaN(NaN); + * // => true + * + * _.isNaN(new Number(NaN)); + * // => true + * + * isNaN(undefined); + * // => true + * + * _.isNaN(undefined); + * // => false + */ + function isNaN(value) { + // An `NaN` primitive is the only value that is not equal to itself. + // Perform the `toStringTag` check first to avoid errors with some + // ActiveX objects in IE. + return isNumber(value) && value != +value; + } + + /** + * Checks if `value` is a pristine native function. + * + * **Note:** This method can't reliably detect native functions in the presence + * of the core-js package because core-js circumvents this kind of detection. + * Despite multiple requests, the core-js maintainer has made it clear: any + * attempt to fix the detection will be obstructed. As a result, we're left + * with little choice but to throw an error. Unfortunately, this also affects + * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), + * which rely on core-js. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false + */ + function isNative(value) { + if (isMaskable(value)) { + throw new Error(CORE_ERROR_TEXT); + } + return baseIsNative(value); + } + + /** + * Checks if `value` is `null`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `null`, else `false`. + * @example + * + * _.isNull(null); + * // => true + * + * _.isNull(void 0); + * // => false + */ + function isNull(value) { + return value === null; + } + + /** + * Checks if `value` is `null` or `undefined`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */ + function isNil(value) { + return value == null; + } + + /** + * Checks if `value` is classified as a `Number` primitive or object. + * + * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are + * classified as numbers, use the `_.isFinite` method. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a number, else `false`. + * @example + * + * _.isNumber(3); + * // => true + * + * _.isNumber(Number.MIN_VALUE); + * // => true + * + * _.isNumber(Infinity); + * // => true + * + * _.isNumber('3'); + * // => false + */ + function isNumber(value) { + return typeof value == 'number' || + (isObjectLike(value) && baseGetTag(value) == numberTag); + } + + /** + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. + * + * @static + * @memberOf _ + * @since 0.8.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); + * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true + */ + function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag) { + return false; + } + var proto = getPrototype(value); + if (proto === null) { + return true; + } + var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; + return typeof Ctor == 'function' && Ctor instanceof Ctor && + funcToString.call(Ctor) == objectCtorString; + } + + /** + * Checks if `value` is classified as a `RegExp` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. + * @example + * + * _.isRegExp(/abc/); + * // => true + * + * _.isRegExp('/abc/'); + * // => false + */ + var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp; + + /** + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. + * + * **Note:** This method is based on + * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. + * @example + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */ + function isSafeInteger(value) { + return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; + } + + /** + * Checks if `value` is classified as a `Set` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a set, else `false`. + * @example + * + * _.isSet(new Set); + * // => true + * + * _.isSet(new WeakSet); + * // => false + */ + var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; + + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ + function isString(value) { + return typeof value == 'string' || + (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); + } + + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); + } + + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + + /** + * Checks if `value` is `undefined`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. + * @example + * + * _.isUndefined(void 0); + * // => true + * + * _.isUndefined(null); + * // => false + */ + function isUndefined(value) { + return value === undefined; + } + + /** + * Checks if `value` is classified as a `WeakMap` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. + * @example + * + * _.isWeakMap(new WeakMap); + * // => true + * + * _.isWeakMap(new Map); + * // => false + */ + function isWeakMap(value) { + return isObjectLike(value) && getTag(value) == weakMapTag; + } + + /** + * Checks if `value` is classified as a `WeakSet` object. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. + * @example + * + * _.isWeakSet(new WeakSet); + * // => true + * + * _.isWeakSet(new Set); + * // => false + */ + function isWeakSet(value) { + return isObjectLike(value) && baseGetTag(value) == weakSetTag; + } + + /** + * Checks if `value` is less than `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than `other`, + * else `false`. + * @see _.gt + * @example + * + * _.lt(1, 3); + * // => true + * + * _.lt(3, 3); + * // => false + * + * _.lt(3, 1); + * // => false + */ + var lt = createRelationalOperation(baseLt); + + /** + * Checks if `value` is less than or equal to `other`. + * + * @static + * @memberOf _ + * @since 3.9.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if `value` is less than or equal to + * `other`, else `false`. + * @see _.gte + * @example + * + * _.lte(1, 3); + * // => true + * + * _.lte(3, 3); + * // => true + * + * _.lte(3, 1); + * // => false + */ + var lte = createRelationalOperation(function(value, other) { + return value <= other; + }); + + /** + * Converts `value` to an array. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {Array} Returns the converted array. + * @example + * + * _.toArray({ 'a': 1, 'b': 2 }); + * // => [1, 2] + * + * _.toArray('abc'); + * // => ['a', 'b', 'c'] + * + * _.toArray(1); + * // => [] + * + * _.toArray(null); + * // => [] + */ + function toArray(value) { + if (!value) { + return []; + } + if (isArrayLike(value)) { + return isString(value) ? stringToArray(value) : copyArray(value); + } + if (symIterator && value[symIterator]) { + return iteratorToArray(value[symIterator]()); + } + var tag = getTag(value), + func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values); + + return func(value); + } + + /** + * Converts `value` to a finite number. + * + * @static + * @memberOf _ + * @since 4.12.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted number. + * @example + * + * _.toFinite(3.2); + * // => 3.2 + * + * _.toFinite(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toFinite(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toFinite('3.2'); + * // => 3.2 + */ + function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign = (value < 0 ? -1 : 1); + return sign * MAX_INTEGER; + } + return value === value ? value : 0; + } + + /** + * Converts `value` to an integer. + * + * **Note:** This method is loosely based on + * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toInteger(3.2); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3.2'); + * // => 3 + */ + function toInteger(value) { + var result = toFinite(value), + remainder = result % 1; + + return result === result ? (remainder ? result - remainder : result) : 0; + } + + /** + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toLength(3.2); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3.2'); + * // => 3 + */ + function toLength(value) { + return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0; + } + + /** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ + function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); + } + + /** + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } + * + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } + */ + function toPlainObject(value) { + return copyObject(value, keysIn(value)); + } + + /** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toSafeInteger(3.2); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3.2'); + * // => 3 + */ + function toSafeInteger(value) { + return value + ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) + : (value === 0 ? value : 0); + } + + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + function toString(value) { + return value == null ? '' : baseToString(value); + } + + /*------------------------------------------------------------------------*/ + + /** + * Assigns own enumerable string keyed properties of source objects to the + * destination object. Source objects are applied from left to right. + * Subsequent sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @static + * @memberOf _ + * @since 0.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assignIn + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assign({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3 } + */ + var assign = createAssigner(function(object, source) { + if (isPrototype(source) || isArrayLike(source)) { + copyObject(source, keys(source), object); + return; + } + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + assignValue(object, key, source[key]); + } + } + }); + + /** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.assign + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * function Bar() { + * this.c = 3; + * } + * + * Foo.prototype.b = 2; + * Bar.prototype.d = 4; + * + * _.assignIn({ 'a': 0 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } + */ + var assignIn = createAssigner(function(object, source) { + copyObject(source, keysIn(source), object); + }); + + /** + * This method is like `_.assignIn` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias extendWith + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + var assignInWith = createAssigner(function(object, source, srcIndex, customizer) { + copyObject(source, keysIn(source), object, customizer); + }); + + /** + * This method is like `_.assign` except that it accepts `customizer` + * which is invoked to produce the assigned values. If `customizer` returns + * `undefined`, assignment is handled by the method instead. The `customizer` + * is invoked with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @see _.assignInWith + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + var assignWith = createAssigner(function(object, source, srcIndex, customizer) { + copyObject(source, keys(source), object, customizer); + }); + + /** + * Creates an array of values corresponding to `paths` of `object`. + * + * @static + * @memberOf _ + * @since 1.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Array} Returns the picked values. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; + * + * _.at(object, ['a[0].b.c', 'a[1]']); + * // => [3, 4] + */ + var at = flatRest(baseAt); + + /** + * Creates an object that inherits from the `prototype` object. If a + * `properties` object is given, its own enumerable string keyed properties + * are assigned to the created object. + * + * @static + * @memberOf _ + * @since 2.3.0 + * @category Object + * @param {Object} prototype The object to inherit from. + * @param {Object} [properties] The properties to assign to the object. + * @returns {Object} Returns the new object. + * @example + * + * function Shape() { + * this.x = 0; + * this.y = 0; + * } + * + * function Circle() { + * Shape.call(this); + * } + * + * Circle.prototype = _.create(Shape.prototype, { + * 'constructor': Circle + * }); + * + * var circle = new Circle; + * circle instanceof Circle; + * // => true + * + * circle instanceof Shape; + * // => true + */ + function create(prototype, properties) { + var result = baseCreate(prototype); + return properties == null ? result : baseAssign(result, properties); + } + + /** + * Assigns own and inherited enumerable string keyed properties of source + * objects to the destination object for all destination properties that + * resolve to `undefined`. Source objects are applied from left to right. + * Once a property is set, additional values of the same property are ignored. + * + * **Note:** This method mutates `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaultsDeep + * @example + * + * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + var defaults = baseRest(function(object, sources) { + object = Object(object); + + var index = -1; + var length = sources.length; + var guard = length > 2 ? sources[2] : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + length = 1; + } + + while (++index < length) { + var source = sources[index]; + var props = keysIn(source); + var propsIndex = -1; + var propsLength = props.length; + + while (++propsIndex < propsLength) { + var key = props[propsIndex]; + var value = object[key]; + + if (value === undefined || + (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) { + object[key] = source[key]; + } + } + } + + return object; + }); + + /** + * This method is like `_.defaults` except that it recursively assigns + * default properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.10.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @see _.defaults + * @example + * + * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); + * // => { 'a': { 'b': 2, 'c': 3 } } + */ + var defaultsDeep = baseRest(function(args) { + args.push(undefined, customDefaultsMerge); + return apply(mergeWith, undefined, args); + }); + + /** + * This method is like `_.find` except that it returns the key of the first + * element `predicate` returns truthy for instead of the element itself. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findKey(users, function(o) { return o.age < 40; }); + * // => 'barney' (iteration order is not guaranteed) + * + * // The `_.matches` iteratee shorthand. + * _.findKey(users, { 'age': 1, 'active': true }); + * // => 'pebbles' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findKey(users, 'active'); + * // => 'barney' + */ + function findKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwn); + } + + /** + * This method is like `_.findKey` except that it iterates over elements of + * a collection in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @param {Function} [predicate=_.identity] The function invoked per iteration. + * @returns {string|undefined} Returns the key of the matched element, + * else `undefined`. + * @example + * + * var users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * + * _.findLastKey(users, function(o) { return o.age < 40; }); + * // => returns 'pebbles' assuming `_.findKey` returns 'barney' + * + * // The `_.matches` iteratee shorthand. + * _.findLastKey(users, { 'age': 36, 'active': true }); + * // => 'barney' + * + * // The `_.matchesProperty` iteratee shorthand. + * _.findLastKey(users, ['active', false]); + * // => 'fred' + * + * // The `_.property` iteratee shorthand. + * _.findLastKey(users, 'active'); + * // => 'pebbles' + */ + function findLastKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight); + } + + /** + * Iterates over own and inherited enumerable string keyed properties of an + * object and invokes `iteratee` for each property. The iteratee is invoked + * with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forInRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forIn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). + */ + function forIn(object, iteratee) { + return object == null + ? object + : baseFor(object, getIteratee(iteratee, 3), keysIn); + } + + /** + * This method is like `_.forIn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forIn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forInRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. + */ + function forInRight(object, iteratee) { + return object == null + ? object + : baseForRight(object, getIteratee(iteratee, 3), keysIn); + } + + /** + * Iterates over own enumerable string keyed properties of an object and + * invokes `iteratee` for each property. The iteratee is invoked with three + * arguments: (value, key, object). Iteratee functions may exit iteration + * early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 0.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwnRight + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwn(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ + function forOwn(object, iteratee) { + return object && baseForOwn(object, getIteratee(iteratee, 3)); + } + + /** + * This method is like `_.forOwn` except that it iterates over properties of + * `object` in the opposite order. + * + * @static + * @memberOf _ + * @since 2.0.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns `object`. + * @see _.forOwn + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.forOwnRight(new Foo, function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. + */ + function forOwnRight(object, iteratee) { + return object && baseForOwnRight(object, getIteratee(iteratee, 3)); + } + + /** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functionsIn + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */ + function functions(object) { + return object == null ? [] : baseFunctions(object, keys(object)); + } + + /** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the function names. + * @see _.functions + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ + function functionsIn(object) { + return object == null ? [] : baseFunctions(object, keysIn(object)); + } + + /** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ + function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; + } + + /** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ + function has(object, path) { + return object != null && hasPath(object, path, baseHas); + } + + /** + * Checks if `path` is a direct or inherited property of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b'); + * // => true + * + * _.hasIn(object, ['a', 'b']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */ + function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); + } + + /** + * Creates an object composed of the inverted keys and values of `object`. + * If `object` contains duplicate values, subsequent values overwrite + * property assignments of previous values. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Object + * @param {Object} object The object to invert. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invert(object); + * // => { '1': 'c', '2': 'b' } + */ + var invert = createInverter(function(result, value, key) { + if (value != null && + typeof value.toString != 'function') { + value = nativeObjectToString.call(value); + } + + result[value] = key; + }, constant(identity)); + + /** + * This method is like `_.invert` except that the inverted object is generated + * from the results of running each element of `object` thru `iteratee`. The + * corresponding inverted value of each inverted key is an array of keys + * responsible for generating the inverted value. The iteratee is invoked + * with one argument: (value). + * + * @static + * @memberOf _ + * @since 4.1.0 + * @category Object + * @param {Object} object The object to invert. + * @param {Function} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Object} Returns the new inverted object. + * @example + * + * var object = { 'a': 1, 'b': 2, 'c': 1 }; + * + * _.invertBy(object); + * // => { '1': ['a', 'c'], '2': ['b'] } + * + * _.invertBy(object, function(value) { + * return 'group' + value; + * }); + * // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */ + var invertBy = createInverter(function(result, value, key) { + if (value != null && + typeof value.toString != 'function') { + value = nativeObjectToString.call(value); + } + + if (hasOwnProperty.call(result, value)) { + result[value].push(key); + } else { + result[value] = [key]; + } + }, getIteratee); + + /** + * Invokes the method at `path` of `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the method to invoke. + * @param {...*} [args] The arguments to invoke the method with. + * @returns {*} Returns the result of the invoked method. + * @example + * + * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; + * + * _.invoke(object, 'a[0].b.c.slice', 1, 3); + * // => [2, 3] + */ + var invoke = baseRest(baseInvoke); + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); + } + + /** + * The opposite of `_.mapValues`; this method creates an object with the + * same values as `object` and keys generated by running each own enumerable + * string keyed property of `object` thru `iteratee`. The iteratee is invoked + * with three arguments: (value, key, object). + * + * @static + * @memberOf _ + * @since 3.8.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapValues + * @example + * + * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { + * return key + value; + * }); + * // => { 'a1': 1, 'b2': 2 } + */ + function mapKeys(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + + baseForOwn(object, function(value, key, object) { + baseAssignValue(result, iteratee(value, key, object), value); + }); + return result; + } + + /** + * Creates an object with the same keys as `object` and values generated + * by running each own enumerable string keyed property of `object` thru + * `iteratee`. The iteratee is invoked with three arguments: + * (value, key, object). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @returns {Object} Returns the new mapped object. + * @see _.mapKeys + * @example + * + * var users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * + * _.mapValues(users, function(o) { return o.age; }); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + * + * // The `_.property` iteratee shorthand. + * _.mapValues(users, 'age'); + * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) + */ + function mapValues(object, iteratee) { + var result = {}; + iteratee = getIteratee(iteratee, 3); + + baseForOwn(object, function(value, key, object) { + baseAssignValue(result, key, iteratee(value, key, object)); + }); + return result; + } + + /** + * This method is like `_.assign` except that it recursively merges own and + * inherited enumerable string keyed properties of source objects into the + * destination object. Source properties that resolve to `undefined` are + * skipped if a destination value exists. Array and plain object properties + * are merged recursively. Other objects and value types are overridden by + * assignment. Source objects are applied from left to right. Subsequent + * sources overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 0.5.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * var object = { + * 'a': [{ 'b': 2 }, { 'd': 4 }] + * }; + * + * var other = { + * 'a': [{ 'c': 3 }, { 'e': 5 }] + * }; + * + * _.merge(object, other); + * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } + */ + var merge = createAssigner(function(object, source, srcIndex) { + baseMerge(object, source, srcIndex); + }); + + /** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */ + var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { + baseMerge(object, source, srcIndex, customizer); + }); + + /** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable property paths of `object` that are not omitted. + * + * **Note:** This method is considerably slower than `_.pick`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to omit. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omit(object, ['a', 'c']); + * // => { 'b': '2' } + */ + var omit = flatRest(function(object, paths) { + var result = {}; + if (object == null) { + return result; + } + var isDeep = false; + paths = arrayMap(paths, function(path) { + path = castPath(path, object); + isDeep || (isDeep = path.length > 1); + return path; + }); + copyObject(object, getAllKeysIn(object), result); + if (isDeep) { + result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone); + } + var length = paths.length; + while (length--) { + baseUnset(result, paths[length]); + } + return result; + }); + + /** + * The opposite of `_.pickBy`; this method creates an object composed of + * the own and inherited enumerable string keyed properties of `object` that + * `predicate` doesn't return truthy for. The predicate is invoked with two + * arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ + function omitBy(object, predicate) { + return pickBy(object, negate(getIteratee(predicate))); + } + + /** + * Creates an object composed of the picked `object` properties. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [paths] The property paths to pick. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */ + var pick = flatRest(function(object, paths) { + return object == null ? {} : basePick(object, paths); + }); + + /** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with two arguments: (value, key). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The source object. + * @param {Function} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */ + function pickBy(object, predicate) { + if (object == null) { + return {}; + } + var props = arrayMap(getAllKeysIn(object), function(prop) { + return [prop]; + }); + predicate = getIteratee(predicate); + return basePickBy(object, props, function(value, path) { + return predicate(value, path[0]); + }); + } + + /** + * This method is like `_.get` except that if the resolved value is a + * function it's invoked with the `this` binding of its parent object and + * its result is returned. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to resolve. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; + * + * _.result(object, 'a[0].b.c1'); + * // => 3 + * + * _.result(object, 'a[0].b.c2'); + * // => 4 + * + * _.result(object, 'a[0].b.c3', 'default'); + * // => 'default' + * + * _.result(object, 'a[0].b.c3', _.constant('default')); + * // => 'default' + */ + function result(object, path, defaultValue) { + path = castPath(path, object); + + var index = -1, + length = path.length; + + // Ensure the loop is entered when path is empty. + if (!length) { + length = 1; + object = undefined; + } + while (++index < length) { + var value = object == null ? undefined : object[toKey(path[index])]; + if (value === undefined) { + index = length; + value = defaultValue; + } + object = isFunction(value) ? value.call(object) : value; + } + return object; + } + + /** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ + function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); + } + + /** + * This method is like `_.set` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.setWith(object, '[0][1]', 'a', Object); + * // => { '0': { '1': 'a' } } + */ + function setWith(object, path, value, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return object == null ? object : baseSet(object, path, value, customizer); + } + + /** + * Creates an array of own enumerable string keyed-value pairs for `object` + * which can be consumed by `_.fromPairs`. If `object` is a map or set, its + * entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entries + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairs(new Foo); + * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) + */ + var toPairs = createToPairs(keys); + + /** + * Creates an array of own and inherited enumerable string keyed-value pairs + * for `object` which can be consumed by `_.fromPairs`. If `object` is a map + * or set, its entries are returned. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @alias entriesIn + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the key-value pairs. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.toPairsIn(new Foo); + * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) + */ + var toPairsIn = createToPairs(keysIn); + + /** + * An alternative to `_.reduce`; this method transforms `object` to a new + * `accumulator` object which is the result of running each of its own + * enumerable string keyed properties thru `iteratee`, with each invocation + * potentially mutating the `accumulator` object. If `accumulator` is not + * provided, a new object with the same `[[Prototype]]` will be used. The + * iteratee is invoked with four arguments: (accumulator, value, key, object). + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @static + * @memberOf _ + * @since 1.3.0 + * @category Object + * @param {Object} object The object to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The custom accumulator value. + * @returns {*} Returns the accumulated value. + * @example + * + * _.transform([2, 3, 4], function(result, n) { + * result.push(n *= n); + * return n % 2 == 0; + * }, []); + * // => [4, 9] + * + * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { + * (result[value] || (result[value] = [])).push(key); + * }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */ + function transform(object, iteratee, accumulator) { + var isArr = isArray(object), + isArrLike = isArr || isBuffer(object) || isTypedArray(object); + + iteratee = getIteratee(iteratee, 4); + if (accumulator == null) { + var Ctor = object && object.constructor; + if (isArrLike) { + accumulator = isArr ? new Ctor : []; + } + else if (isObject(object)) { + accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; + } + else { + accumulator = {}; + } + } + (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) { + return iteratee(accumulator, value, index, object); + }); + return accumulator; + } + + /** + * Removes the property at `path` of `object`. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to unset. + * @returns {boolean} Returns `true` if the property is deleted, else `false`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 7 } }] }; + * _.unset(object, 'a[0].b.c'); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + * + * _.unset(object, ['a', '0', 'b', 'c']); + * // => true + * + * console.log(object); + * // => { 'a': [{ 'b': {} }] }; + */ + function unset(object, path) { + return object == null ? true : baseUnset(object, path); + } + + /** + * This method is like `_.set` except that accepts `updater` to produce the + * value to set. Use `_.updateWith` to customize `path` creation. The `updater` + * is invoked with one argument: (value). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.update(object, 'a[0].b.c', function(n) { return n * n; }); + * console.log(object.a[0].b.c); + * // => 9 + * + * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); + * console.log(object.x[0].y.z); + * // => 0 + */ + function update(object, path, updater) { + return object == null ? object : baseUpdate(object, path, castFunction(updater)); + } + + /** + * This method is like `_.update` except that it accepts `customizer` which is + * invoked to produce the objects of `path`. If `customizer` returns `undefined` + * path creation is handled by the method instead. The `customizer` is invoked + * with three arguments: (nsValue, key, nsObject). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.6.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {Function} updater The function to produce the updated value. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * var object = {}; + * + * _.updateWith(object, '[0][1]', _.constant('a'), Object); + * // => { '0': { '1': 'a' } } + */ + function updateWith(object, path, updater, customizer) { + customizer = typeof customizer == 'function' ? customizer : undefined; + return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer); + } + + /** + * Creates an array of the own enumerable string keyed property values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.values(new Foo); + * // => [1, 2] (iteration order is not guaranteed) + * + * _.values('hi'); + * // => ['h', 'i'] + */ + function values(object) { + return object == null ? [] : baseValues(object, keys(object)); + } + + /** + * Creates an array of the own and inherited enumerable string keyed property + * values of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property values. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.valuesIn(new Foo); + * // => [1, 2, 3] (iteration order is not guaranteed) + */ + function valuesIn(object) { + return object == null ? [] : baseValues(object, keysIn(object)); + } + + /*------------------------------------------------------------------------*/ + + /** + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Number + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + * // => 5 + */ + function clamp(number, lower, upper) { + if (upper === undefined) { + upper = lower; + lower = undefined; + } + if (upper !== undefined) { + upper = toNumber(upper); + upper = upper === upper ? upper : 0; + } + if (lower !== undefined) { + lower = toNumber(lower); + lower = lower === lower ? lower : 0; + } + return baseClamp(toNumber(number), lower, upper); + } + + /** + * Checks if `n` is between `start` and up to, but not including, `end`. If + * `end` is not specified, it's set to `start` with `start` then set to `0`. + * If `start` is greater than `end` the params are swapped to support + * negative ranges. + * + * @static + * @memberOf _ + * @since 3.3.0 + * @category Number + * @param {number} number The number to check. + * @param {number} [start=0] The start of the range. + * @param {number} end The end of the range. + * @returns {boolean} Returns `true` if `number` is in the range, else `false`. + * @see _.range, _.rangeRight + * @example + * + * _.inRange(3, 2, 4); + * // => true + * + * _.inRange(4, 8); + * // => true + * + * _.inRange(4, 2); + * // => false + * + * _.inRange(2, 2); + * // => false + * + * _.inRange(1.2, 2); + * // => true + * + * _.inRange(5.2, 4); + * // => false + * + * _.inRange(-3, -2, -6); + * // => true + */ + function inRange(number, start, end) { + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + number = toNumber(number); + return baseInRange(number, start, end); + } + + /** + * Produces a random number between the inclusive `lower` and `upper` bounds. + * If only one argument is provided a number between `0` and the given number + * is returned. If `floating` is `true`, or either `lower` or `upper` are + * floats, a floating-point number is returned instead of an integer. + * + * **Note:** JavaScript follows the IEEE-754 standard for resolving + * floating-point values which can produce unexpected results. + * + * @static + * @memberOf _ + * @since 0.7.0 + * @category Number + * @param {number} [lower=0] The lower bound. + * @param {number} [upper=1] The upper bound. + * @param {boolean} [floating] Specify returning a floating-point number. + * @returns {number} Returns the random number. + * @example + * + * _.random(0, 5); + * // => an integer between 0 and 5 + * + * _.random(5); + * // => also an integer between 0 and 5 + * + * _.random(5, true); + * // => a floating-point number between 0 and 5 + * + * _.random(1.2, 5.2); + * // => a floating-point number between 1.2 and 5.2 + */ + function random(lower, upper, floating) { + if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) { + upper = floating = undefined; + } + if (floating === undefined) { + if (typeof upper == 'boolean') { + floating = upper; + upper = undefined; + } + else if (typeof lower == 'boolean') { + floating = lower; + lower = undefined; + } + } + if (lower === undefined && upper === undefined) { + lower = 0; + upper = 1; + } + else { + lower = toFinite(lower); + if (upper === undefined) { + upper = lower; + lower = 0; + } else { + upper = toFinite(upper); + } + } + if (lower > upper) { + var temp = lower; + lower = upper; + upper = temp; + } + if (floating || lower % 1 || upper % 1) { + var rand = nativeRandom(); + return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper); + } + return baseRandom(lower, upper); + } + + /*------------------------------------------------------------------------*/ + + /** + * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the camel cased string. + * @example + * + * _.camelCase('Foo Bar'); + * // => 'fooBar' + * + * _.camelCase('--foo-bar--'); + * // => 'fooBar' + * + * _.camelCase('__FOO_BAR__'); + * // => 'fooBar' + */ + var camelCase = createCompounder(function(result, word, index) { + word = word.toLowerCase(); + return result + (index ? capitalize(word) : word); + }); + + /** + * Converts the first character of `string` to upper case and the remaining + * to lower case. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. + * @example + * + * _.capitalize('FRED'); + * // => 'Fred' + */ + function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); + } + + /** + * Deburrs `string` by converting + * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) + * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) + * letters to basic Latin letters and removing + * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to deburr. + * @returns {string} Returns the deburred string. + * @example + * + * _.deburr('déjà vu'); + * // => 'deja vu' + */ + function deburr(string) { + string = toString(string); + return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ''); + } + + /** + * Checks if `string` ends with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=string.length] The position to search up to. + * @returns {boolean} Returns `true` if `string` ends with `target`, + * else `false`. + * @example + * + * _.endsWith('abc', 'c'); + * // => true + * + * _.endsWith('abc', 'b'); + * // => false + * + * _.endsWith('abc', 'b', 2); + * // => true + */ + function endsWith(string, target, position) { + string = toString(string); + target = baseToString(target); + + var length = string.length; + position = position === undefined + ? length + : baseClamp(toInteger(position), 0, length); + + var end = position; + position -= target.length; + return position >= 0 && string.slice(position, end) == target; + } + + /** + * Converts the characters "&", "<", ">", '"', and "'" in `string` to their + * corresponding HTML entities. + * + * **Note:** No other characters are escaped. To escape additional + * characters use a third-party library like [_he_](https://mths.be/he). + * + * Though the ">" character is escaped for symmetry, characters like + * ">" and "/" don't need escaping in HTML and have no special meaning + * unless they're part of a tag or unquoted attribute value. See + * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) + * (under "semi-related fun fact") for more details. + * + * When working with HTML you should always + * [quote attribute values](http://wonko.com/post/html-escaping) to reduce + * XSS vectors. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escape('fred, barney, & pebbles'); + * // => 'fred, barney, & pebbles' + */ + function escape(string) { + string = toString(string); + return (string && reHasUnescapedHtml.test(string)) + ? string.replace(reUnescapedHtml, escapeHtmlChar) + : string; + } + + /** + * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", + * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to escape. + * @returns {string} Returns the escaped string. + * @example + * + * _.escapeRegExp('[lodash](https://lodash.com/)'); + * // => '\[lodash\]\(https://lodash\.com/\)' + */ + function escapeRegExp(string) { + string = toString(string); + return (string && reHasRegExpChar.test(string)) + ? string.replace(reRegExpChar, '\\$&') + : string; + } + + /** + * Converts `string` to + * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the kebab cased string. + * @example + * + * _.kebabCase('Foo Bar'); + * // => 'foo-bar' + * + * _.kebabCase('fooBar'); + * // => 'foo-bar' + * + * _.kebabCase('__FOO_BAR__'); + * // => 'foo-bar' + */ + var kebabCase = createCompounder(function(result, word, index) { + return result + (index ? '-' : '') + word.toLowerCase(); + }); + + /** + * Converts `string`, as space separated words, to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * _.lowerCase('--Foo-Bar--'); + * // => 'foo bar' + * + * _.lowerCase('fooBar'); + * // => 'foo bar' + * + * _.lowerCase('__FOO_BAR__'); + * // => 'foo bar' + */ + var lowerCase = createCompounder(function(result, word, index) { + return result + (index ? ' ' : '') + word.toLowerCase(); + }); + + /** + * Converts the first character of `string` to lower case. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.lowerFirst('Fred'); + * // => 'fred' + * + * _.lowerFirst('FRED'); + * // => 'fRED' + */ + var lowerFirst = createCaseFirst('toLowerCase'); + + /** + * Pads `string` on the left and right sides if it's shorter than `length`. + * Padding characters are truncated if they can't be evenly divided by `length`. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.pad('abc', 8); + * // => ' abc ' + * + * _.pad('abc', 8, '_-'); + * // => '_-abc_-_' + * + * _.pad('abc', 3); + * // => 'abc' + */ + function pad(string, length, chars) { + string = toString(string); + length = toInteger(length); + + var strLength = length ? stringSize(string) : 0; + if (!length || strLength >= length) { + return string; + } + var mid = (length - strLength) / 2; + return ( + createPadding(nativeFloor(mid), chars) + + string + + createPadding(nativeCeil(mid), chars) + ); + } + + /** + * Pads `string` on the right side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.padEnd('abc', 6); + * // => 'abc ' + * + * _.padEnd('abc', 6, '_-'); + * // => 'abc_-_' + * + * _.padEnd('abc', 3); + * // => 'abc' + */ + function padEnd(string, length, chars) { + string = toString(string); + length = toInteger(length); + + var strLength = length ? stringSize(string) : 0; + return (length && strLength < length) + ? (string + createPadding(length - strLength, chars)) + : string; + } + + /** + * Pads `string` on the left side if it's shorter than `length`. Padding + * characters are truncated if they exceed `length`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to pad. + * @param {number} [length=0] The padding length. + * @param {string} [chars=' '] The string used as padding. + * @returns {string} Returns the padded string. + * @example + * + * _.padStart('abc', 6); + * // => ' abc' + * + * _.padStart('abc', 6, '_-'); + * // => '_-_abc' + * + * _.padStart('abc', 3); + * // => 'abc' + */ + function padStart(string, length, chars) { + string = toString(string); + length = toInteger(length); + + var strLength = length ? stringSize(string) : 0; + return (length && strLength < length) + ? (createPadding(length - strLength, chars) + string) + : string; + } + + /** + * Converts `string` to an integer of the specified radix. If `radix` is + * `undefined` or `0`, a `radix` of `10` is used unless `value` is a + * hexadecimal, in which case a `radix` of `16` is used. + * + * **Note:** This method aligns with the + * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. + * + * @static + * @memberOf _ + * @since 1.1.0 + * @category String + * @param {string} string The string to convert. + * @param {number} [radix=10] The radix to interpret `value` by. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {number} Returns the converted integer. + * @example + * + * _.parseInt('08'); + * // => 8 + * + * _.map(['6', '08', '10'], _.parseInt); + * // => [6, 8, 10] + */ + function parseInt(string, radix, guard) { + if (guard || radix == null) { + radix = 0; + } else if (radix) { + radix = +radix; + } + return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0); + } + + /** + * Repeats the given string `n` times. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to repeat. + * @param {number} [n=1] The number of times to repeat the string. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {string} Returns the repeated string. + * @example + * + * _.repeat('*', 3); + * // => '***' + * + * _.repeat('abc', 2); + * // => 'abcabc' + * + * _.repeat('abc', 0); + * // => '' + */ + function repeat(string, n, guard) { + if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) { + n = 1; + } else { + n = toInteger(n); + } + return baseRepeat(toString(string), n); + } + + /** + * Replaces matches for `pattern` in `string` with `replacement`. + * + * **Note:** This method is based on + * [`String#replace`](https://mdn.io/String/replace). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to modify. + * @param {RegExp|string} pattern The pattern to replace. + * @param {Function|string} replacement The match replacement. + * @returns {string} Returns the modified string. + * @example + * + * _.replace('Hi Fred', 'Fred', 'Barney'); + * // => 'Hi Barney' + */ + function replace() { + var args = arguments, + string = toString(args[0]); + + return args.length < 3 ? string : string.replace(args[1], args[2]); + } + + /** + * Converts `string` to + * [snake case](https://en.wikipedia.org/wiki/Snake_case). + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the snake cased string. + * @example + * + * _.snakeCase('Foo Bar'); + * // => 'foo_bar' + * + * _.snakeCase('fooBar'); + * // => 'foo_bar' + * + * _.snakeCase('--FOO-BAR--'); + * // => 'foo_bar' + */ + var snakeCase = createCompounder(function(result, word, index) { + return result + (index ? '_' : '') + word.toLowerCase(); + }); + + /** + * Splits `string` by `separator`. + * + * **Note:** This method is based on + * [`String#split`](https://mdn.io/String/split). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to split. + * @param {RegExp|string} separator The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * @example + * + * _.split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ + function split(string, separator, limit) { + if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) { + separator = limit = undefined; + } + limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0; + if (!limit) { + return []; + } + string = toString(string); + if (string && ( + typeof separator == 'string' || + (separator != null && !isRegExp(separator)) + )) { + separator = baseToString(separator); + if (!separator && hasUnicode(string)) { + return castSlice(stringToArray(string), 0, limit); + } + } + return string.split(separator, limit); + } + + /** + * Converts `string` to + * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). + * + * @static + * @memberOf _ + * @since 3.1.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the start cased string. + * @example + * + * _.startCase('--foo-bar--'); + * // => 'Foo Bar' + * + * _.startCase('fooBar'); + * // => 'Foo Bar' + * + * _.startCase('__FOO_BAR__'); + * // => 'FOO BAR' + */ + var startCase = createCompounder(function(result, word, index) { + return result + (index ? ' ' : '') + upperFirst(word); + }); + + /** + * Checks if `string` starts with the given target string. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to inspect. + * @param {string} [target] The string to search for. + * @param {number} [position=0] The position to search from. + * @returns {boolean} Returns `true` if `string` starts with `target`, + * else `false`. + * @example + * + * _.startsWith('abc', 'a'); + * // => true + * + * _.startsWith('abc', 'b'); + * // => false + * + * _.startsWith('abc', 'b', 1); + * // => true + */ + function startsWith(string, target, position) { + string = toString(string); + position = position == null + ? 0 + : baseClamp(toInteger(position), 0, string.length); + + target = baseToString(target); + return string.slice(position, position + target.length) == target; + } + + /** + * Creates a compiled template function that can interpolate data properties + * in "interpolate" delimiters, HTML-escape interpolated data properties in + * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data + * properties may be accessed as free variables in the template. If a setting + * object is given, it takes precedence over `_.templateSettings` values. + * + * **Note:** In the development build `_.template` utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) + * for easier debugging. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category String + * @param {string} [string=''] The template string. + * @param {Object} [options={}] The options object. + * @param {RegExp} [options.escape=_.templateSettings.escape] + * The HTML "escape" delimiter. + * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] + * The "evaluate" delimiter. + * @param {Object} [options.imports=_.templateSettings.imports] + * An object to import into the template as free variables. + * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] + * The "interpolate" delimiter. + * @param {string} [options.sourceURL='lodash.templateSources[n]'] + * The sourceURL of the compiled template. + * @param {string} [options.variable='obj'] + * The data object variable name. + * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. + * @returns {Function} Returns the compiled template function. + * @example + * + * // Use the "interpolate" delimiter to create a compiled template. + * var compiled = _.template('hello <%= user %>!'); + * compiled({ 'user': 'fred' }); + * // => 'hello fred!' + * + * // Use the HTML "escape" delimiter to escape data property values. + * var compiled = _.template('<%- value %>'); + * compiled({ 'value': ' - - diff --git a/classes/ADSR.js b/src/classes/ADSR.js similarity index 100% rename from classes/ADSR.js rename to src/classes/ADSR.js diff --git a/classes/Block.js b/src/classes/Block.js similarity index 100% rename from classes/Block.js rename to src/classes/Block.js diff --git a/classes/Delay.js b/src/classes/Delay.js similarity index 100% rename from classes/Delay.js rename to src/classes/Delay.js diff --git a/classes/Drums.js b/src/classes/Drums.js similarity index 100% rename from classes/Drums.js rename to src/classes/Drums.js diff --git a/classes/Filter.js b/src/classes/Filter.js similarity index 100% rename from classes/Filter.js rename to src/classes/Filter.js diff --git a/classes/Gain.js b/src/classes/Gain.js similarity index 100% rename from classes/Gain.js rename to src/classes/Gain.js diff --git a/classes/Osc.js b/src/classes/Osc.js similarity index 100% rename from classes/Osc.js rename to src/classes/Osc.js diff --git a/classes/Pan.js b/src/classes/Pan.js similarity index 100% rename from classes/Pan.js rename to src/classes/Pan.js diff --git a/classes/PolyBlock.js b/src/classes/PolyBlock.js similarity index 100% rename from classes/PolyBlock.js rename to src/classes/PolyBlock.js diff --git a/classes/Scheduler.js b/src/classes/Scheduler.js similarity index 100% rename from classes/Scheduler.js rename to src/classes/Scheduler.js diff --git a/classes/Sound.js b/src/classes/Sound.js similarity index 100% rename from classes/Sound.js rename to src/classes/Sound.js diff --git a/classes/classMap.js b/src/classes/classMap.js similarity index 100% rename from classes/classMap.js rename to src/classes/classMap.js diff --git a/editor.js b/src/editor.js similarity index 96% rename from editor.js rename to src/editor.js index eab0397..f72e116 100644 --- a/editor.js +++ b/src/editor.js @@ -10,11 +10,16 @@ import 'codemirror/theme/duotone-light.css'; import classMap from './classes/classMap'; import { functionMap } from './functions'; +import logo from './static/img/logo.svg'; +import './static/css/editor.css'; + // ------------------------------ EDITOR ------------------------------ const keywords = Object.keys(classMap).concat(Object.keys(functionMap), ['notes', 'rhythm']); const keywordRegex = new RegExp(`(?:${keywords.join('|')})\\b`); +console.log(logo); + CodeMirror.defineSimpleMode("slang", { start: [ { @@ -56,6 +61,8 @@ const existingCode = window.localStorage.getItem('code'); const defaultCode = `# Welcome to Slang! Here's an example to get you started. # Click the Run button above to start playing this code. +tempo 200 + # Make a sound called @synth with a triangle wave @synth (adsr (osc tri) 64n 8n 0.5 8n) @@ -139,5 +146,4 @@ function displayError(message) { function clearError() { $error.classList.remove('show'); -} - +} \ No newline at end of file diff --git a/functions/FunctionCall.js b/src/functions/FunctionCall.js similarity index 100% rename from functions/FunctionCall.js rename to src/functions/FunctionCall.js diff --git a/functions/chord.js b/src/functions/chord.js similarity index 100% rename from functions/chord.js rename to src/functions/chord.js diff --git a/functions/flatten.js b/src/functions/flatten.js similarity index 100% rename from functions/flatten.js rename to src/functions/flatten.js diff --git a/functions/index.js b/src/functions/index.js similarity index 100% rename from functions/index.js rename to src/functions/index.js diff --git a/functions/interpolate.js b/src/functions/interpolate.js similarity index 100% rename from functions/interpolate.js rename to src/functions/interpolate.js diff --git a/functions/random.js b/src/functions/random.js similarity index 100% rename from functions/random.js rename to src/functions/random.js diff --git a/functions/repeat.js b/src/functions/repeat.js similarity index 100% rename from functions/repeat.js rename to src/functions/repeat.js diff --git a/functions/reverse.js b/src/functions/reverse.js similarity index 100% rename from functions/reverse.js rename to src/functions/reverse.js diff --git a/functions/shuffle.js b/src/functions/shuffle.js similarity index 100% rename from functions/shuffle.js rename to src/functions/shuffle.js diff --git a/functions/transpose.js b/src/functions/transpose.js similarity index 100% rename from functions/transpose.js rename to src/functions/transpose.js diff --git a/helpers/BufferLoader.js b/src/helpers/BufferLoader.js similarity index 100% rename from helpers/BufferLoader.js rename to src/helpers/BufferLoader.js diff --git a/helpers/FunctionCall.js b/src/helpers/FunctionCall.js similarity index 100% rename from helpers/FunctionCall.js rename to src/helpers/FunctionCall.js diff --git a/helpers/List.js b/src/helpers/List.js similarity index 100% rename from helpers/List.js rename to src/helpers/List.js diff --git a/helpers/context.js b/src/helpers/context.js similarity index 100% rename from helpers/context.js rename to src/helpers/context.js diff --git a/src/helpers/drumMap.js b/src/helpers/drumMap.js new file mode 100644 index 0000000..4c596cd --- /dev/null +++ b/src/helpers/drumMap.js @@ -0,0 +1,65 @@ +import acousticHatOpen1 from '../static/audio/acoustic/hihat_open1.mp3'; +import acousticHatOpen2 from '../static/audio/acoustic/hihat_open2.mp3'; +import acousticHatOpen3 from '../static/audio/acoustic/hihat_open3.mp3'; +import acousticHat1 from '../static/audio/acoustic/hihat1.mp3'; +import acousticHat2 from '../static/audio/acoustic/hihat2.mp3'; +import acousticKick1 from '../static/audio/acoustic/kick1.mp3'; +import acousticKick2 from '../static/audio/acoustic/kick2.mp3'; +import acousticKick3 from '../static/audio/acoustic/kick3.mp3'; +import acousticRim1 from '../static/audio/acoustic/rim1.mp3'; +import acousticSnare1 from '../static/audio/acoustic/snare1.mp3'; +import acousticSnare2 from '../static/audio/acoustic/snare2.mp3'; +import acousticSnare3 from '../static/audio/acoustic/snare3.mp3'; + +const drumMap = { + 0: { + file: acousticKick1, + label: 'acoustic kick 1' + }, + 1: { + file: acousticKick2, + label: 'acoustic kick 2' + }, + 2: { + file: acousticKick3, + label: 'acoustic kick 3' + }, + 3: { + file: acousticSnare1, + label: 'acoustic snare 1' + }, + 4: { + file: acousticSnare2, + label: 'acoustic snare 2' + }, + 5: { + file: acousticSnare3, + label: 'acoustic snare 3' + }, + 6: { + file: acousticHat1, + label: 'acoustic hat 1' + }, + 7: { + file: acousticHat2, + label: 'acoustic hat 2' + }, + 8: { + file: acousticHatOpen1, + label: 'acoustic hat (open) 1' + }, + 9: { + file: acousticHatOpen2, + label: 'acoustic hat (open) 2' + }, + 10: { + file: acousticHatOpen3, + label: 'acoustic hat (open) 3' + }, + 11: { + file: acousticRim1, + label: 'acoustic rim' + }, +}; + +export default drumMap; diff --git a/helpers/mtof.js b/src/helpers/mtof.js similarity index 100% rename from helpers/mtof.js rename to src/helpers/mtof.js diff --git a/helpers/parseArguments.js b/src/helpers/parseArguments.js similarity index 100% rename from helpers/parseArguments.js rename to src/helpers/parseArguments.js diff --git a/helpers/tuna.js b/src/helpers/tuna.js similarity index 100% rename from helpers/tuna.js rename to src/helpers/tuna.js diff --git a/runtime.js b/src/runtime.js similarity index 100% rename from runtime.js rename to src/runtime.js diff --git a/slang-grammar.js b/src/slang-grammar.js similarity index 92% rename from slang-grammar.js rename to src/slang-grammar.js index b0ab8c4..d3e699e 100644 --- a/slang-grammar.js +++ b/src/slang-grammar.js @@ -1,6 +1,6 @@ module.exports = ` Sound { - Line = Graph | Play | Comment + Line = Graph | Play | Comment | Tempo /* A comment is any line that begins with # @@ -68,6 +68,15 @@ Sound { Pipe = ("~" PolySoundBlock)+ + /* + TEMPO LINES + A tempo line is a tempo keyword, followed by + the sound beats per minute. + */ + + Tempo = TempoKeyword tempoPrim + TempoKeyword = "tempo" | "[]" + /* PLAY LINES A play line is a play keyword (either 'play' @@ -108,6 +117,7 @@ Sound { | "-"? digit+ -- int int = "-"? digit+ + tempoPrim = digit+ note = letter "#" digit+ -- sharp | letter "b" digit+ -- flat diff --git a/slang.js b/src/slang.js similarity index 98% rename from slang.js rename to src/slang.js index 4e388cd..0783d30 100644 --- a/slang.js +++ b/src/slang.js @@ -1,4 +1,3 @@ -import util from 'util'; import ohm from 'ohm-js'; import range from 'lodash/range'; import * as Range from 'tonal-range'; @@ -88,6 +87,13 @@ semantics.addOperation('toAST', { }; }, + Tempo(kw, value) { + return { + type: 'tempo', + value, + }; + }, + list(lb, soundArguments, rb) { return { type: 'list', diff --git a/slang.ohm b/src/slang.ohm similarity index 92% rename from slang.ohm rename to src/slang.ohm index b73d8f9..2b35a79 100644 --- a/slang.ohm +++ b/src/slang.ohm @@ -1,5 +1,5 @@ Sound { - Line = Graph | Play | Comment + Line = Graph | Play | Comment | Tempo /* A comment is any line that begins with # @@ -67,6 +67,15 @@ Sound { Pipe = ("~" PolySoundBlock)+ + /* + TEMPO LINES + A tempo line is a tempo keyword, followed by + the sound beats per minute. + */ + + Tempo = TempoKeyword tempoPrim + TempoKeyword = "tempo" | "[]" + /* PLAY LINES A play line is a play keyword (either 'play' @@ -107,6 +116,7 @@ Sound { | "-"? digit+ -- int int = "-"? digit+ + tempoPrim = digit+ note = letter "#" digit+ -- sharp | letter "b" digit+ -- flat diff --git a/src/static/audio/acoustic/hihat1.mp3 b/src/static/audio/acoustic/hihat1.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..776f96311a28ac7cf31fef399b65b7515eec7abf GIT binary patch literal 21342 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 literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/hihat_open2.mp3 b/src/static/audio/acoustic/hihat_open2.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..1c46a695b925d7ba52b53727a28c9c0364dd5cdb GIT binary patch literal 26562 zcmdpdRZtvV7wzEg?(VL^-Q5OE!UmXwrKRn^zGwzl^43=9m6 zj!sW6EG(?9Zf))D?fv?7d3kwz`{&Q!zklD}AdvTGS*l2?%JQ%a3cA5=|Fe+Q1pwfq zq=lJN1wh^XvttA+%KzVu|F0M1W$t~0pc(;dudx4qD8_XW0E$sf()=ke2yhexvVjHw zHfnurt@tmFVfBkB32n`c#r{$t?EVq^69cTu_R!2-29 zi94q{oW&vTbv3=8$iS!E+hSG)bvT=a!P_b)%{fMtZ1Oz8uMABZ3(Q(eR~*~p7A04p zza-8_7--eP^Ba*GC`+EUQIRgrpRT*(&V%b3wRB)#j*cbVZi$<7$!BAw-TIPlu*9Wq zKhycR+!ZeRS?A$GUcBR^i|d08QuOPPZk+{B=k(4#R*up`8@h3e*VZgAuyNENe0@FI zD%<#eT^H}yZOPQ{!B_FkS$T|)5yv%;PkeM;&Lez&S#C2qj@K;?B$=!;TEOzbcI|fN zpIY~Lek`l*+vhLcZ9t8zR7^?$06KhssU_sHwWw{naiP#xEF$~)+*>X@@EP)Am?%4= z6)4N@iEJ1!`)%{b<{^0X@Z_qeuGU(f#x{s7xF$-6udU`I7C>?m1R6ju7rM_ZVoIT_ z_J@-l#N-~RvXqfh;GCEs9EOFBcFr>v5|YVK;Ex6=V_^#7ahn;JD2s^EIZDD-WsB&W z?rr;85@9qX7T`PmN^nh~Qsst~n$5o@SPb9?vAq7-KRONIKkfcoPV!oZe;+8~5#9PC zb}PPofl{N@znS%eH^>k>T)3utm}OB<%DX%b@)h#!;TUOhYqA4d20=r{mljoF0?<|q zEu~zYj;FoUI8q^QT^9KI@fq^&;izE%04f(vauH(PaG-)Y-5&0~Vob5hTB!z{;73eb zZVeU92ozYaWyKfG2WV!zyzVB(i+d#3lP6V@B6ZKTOXJ9TB~t`+1Tc9r&!gHRl|lMW z+tEVu$!|MgiEbXFuiVCqPTa_8I1!9ivoFaAQ{n`bhEd2{w@#DX=vQ`w(4!@<;A=u$ zao%o{HkzWVrq-p%#~Y&6L?Auwj=Lw7tyI0MCN*gV zzc4aA4x_^tflcU~XjxMninE6v(_qT++9~$ko+jX-7zkeRkt3_a?GaiS=zd&Z3hi!zE-5exI>ZR z(uVBlMj6YljdMA>!;Ybj5yNdLf8`pqg3m(mh~-qWO`1Y0fuXF!!dNcw;z6lnITAVV z0<0&$r^;nK{lVG_VSsd{+#K68DpICk`or2%VvMs6)Nzg-TnQW%h8Xcxq-C0wN@xm~ z@AxGPNcdQ@N*~BEh|ZRh->S-TWutcR<)JH{pnHgZs68~I&bn3R%scSu%tvW!mRvru zojB5ss!EQQho6|uMoo8py5pdRyfj+=3_=P^&~f+mxuG>fe29ph)Wpz^|W-^K@0}9O+_)oYtsSeFQj!G)*JJ21ToU>?F@dIaA zRKWbAU|mnPr+UaLVHXR;_CDjy+yLVb|0MF2r65a)B8?MeXeTm_>XPazvFZv&rP1bg zt<=cd=o=dZa(?P<2-)b$v=Ahgz%`t&E3&pJrzeqT9*wiEwL|serMq>!i=xq!G_C?z zSyoa8e*qI&pJES2hK2zp67hnAzSS(EFRT6$iuN-gtN3H!=TS}jDXlCdki{g2dnn=F zfBy_GaRdZ>I)rABpok=F}+xuG5&N=%Sgj=%vv|dL{P8YHH^&Xr0ztaT(zfEo3lsp zK4Vfki4j~^@^$b`mXlri=AwPwt25e~Tg6nvP`vo=@kc=J-}cARnn20?(>5#Ua&)^f zA_vpQW*((!;*x^~H=&QL|n}A0)-TVNn+8+BAEciV#=^y&~(EE3RGs|ofwVy*bl0gP)mV!3U$BBP1;rcxSVfz zBp2$&ZHy)3ml%kLWD=Hg<*F#u{vmD&fMD;o^1@-^#v4TF`z}k!>3--<_oYY0186(| z0NB5^0xMgb!4|(04muR^#~DGr*WHhOQi}Lzo zy*Oe5m1K3dqs>2aC%1jAex~-`IVLmW1*@4gC@sxC%ye)SIC%B(d`KAj9&Wc_7*OSZ z0r~E%?Zeh-?v%nC1T`bn)YARHKP+oFVD&SES9gl{eV%zZ zEp)1{{*`M;gEiMzNT)cwCe5**L!#vh3{3KvD~NW@8Q_w#NvrXzqL-K`?*^>W#Q9aq zwTKs$JJsNa21}v$tG-X!|Nf)&tHhv=vzn6`mkRWWkeW6-Y1vOFdYOnKhr#$VB$-{n zz-vvg+v=L!f4SK#)V*~!FA*Uc&DC{XHe)42v@I{pOKHJm+a^Eg=1k%EM!QR?52fq- zV0YrcN8=cHM!&8#XgF{i~QD(lsAi1&)b_JAS`)x z1~vc&-(d$%XW)h@%lstjqgI{Mw7*iI&HD07Amrh5{hR6C2Ym1kn?>@ z6h}pHHC4?3GEgQ{JMC-n3D-HVaouW%Q|#=Po`NJhm+FH>+(!4D>1yCOzOR;mSQ6Ou*gYOBxc?7vKY|bq?#nSbH@CK8JW=Z3d#>b| zm#+i{9-@@Q$ezmaSMXEoEs|n>b)Ws12gm1vdg$AMmPk31!VrPw4I~TcIb|x2LoB!c zg*n_y@YXjiMRAB+hZ8tOzz`rf$Rwsxb~pNpqD5}suomu5yi>rH{lKIGWQO$kMp+9@ z$Y3IUMiN_kOa z!n!>Fha%;8m8s7WgB zEmIefw^F(ACGW=Ld-!c6bXZP2tTpK{!t!GB@xb6IlaV^3T60ue=GMp{l`UN=R|`LE zY3FcW-T=2XYlO!-@jbjk&LNN&@Ezp!ui;gsZ<-dg1T=HKdya#gMU}CHoEbodE1iVA zcNYc$O4B@al$82=Qar37Zb}pWMMTX@RRMZ%nhq*!W`s7ozGTEpyg~GuU*E%W0)>Cjq z*zS=S1#7%UTuph@*-W>bWVr#L571t`;f#YxwoX^R`H2!LqNFH7ZxO2P$QqvM$KYm1s@cu~dz0ArbAPHXj-oQP!& z*&R{JgP6p|1jjK+2hW!%C-ni~fZ0X+)xIZPo=m^yPl97j>P4IW?v7fz(@2wUsjhUw zaB)5&>v|?yq``w4+R|VCe<{io01?|w`&P)0n%<1C4i*4Kmm{b;-IqO{7)1SE?*J&A zmIjD0ZRk02sxqpaN3G!D?1d8-d%517`3+*$S-CKxEFb}+EXNy3tEKrpaaN%@quhw< zO`fO9c>83+b5tsIYH*l@H%Ma?BA@G#+rYD*@ULrG4W)vrra=( zjk*Ab^^Khvpd``#rGt)YEwe*p*aln{XqtAP*f8XaSw~?r!aBW_&{vbF$&p*TTxxCv zRiY<#j+^h0_sn@jOub0R1novOa#u*g8)nKzhY0t3^+F_R6Xi)=Daj+1>u`(=8~Yv? zgkL@?8w99l#Pi-!F9)t)JTpUj!JVP1Mov}H=zJ^qanPGI!nGd);GoeYgsB=s(OCgN zHhPLN*l$(_yeu=f^XNjLM$DvA#o1}SS`8CR#d3g3r2ek*| zBGL+#tDN=1I!beX0kRRluPDMWPPV2X2DQl8PRocs*miNIsLnaYxSU(^TlNpr{JOMb zi7~3WqhA6x!^#hNS4Vf9coD>Tt<3rMgFNcI8+<`DN5%1_`+HKw)v4*_-ipH+m2+C5 z$jSz7b>yC8xNp-a)S(uT(%Oc2$&~H9Q*$6`HQnrQTZeGuG!E{_ z1Ssiq+Qk0vJq?D9CAT&1k1e)*SLVMnWa^pLjizUFZLqsTcn`Ll6uP$~@_O-Bn9=u! zjcCQ5M)z4bTfs3Qy!n8+f6zV&LMZUj`^;f+&GkRQ$Zjes{hob~rvX47?_}DqrW7rx zGD}~IKF;VwDknFfs!RLPdj^iY+&~hhLzh3**<_hEUmXvF@Yg0)&6Z#m8o(`)8`jCm za!@V)-qtLv8c~}Bxyg}HO2Dde8kL*BaB#=2i(>CXZxdXwJ+Q9cfhOYgp3qy9RM?K%S7U7Ah7Vbbzyna`Xz$w{^JBkL*I=N0w(+n)THyY>f7ELC9eUyY1 z1I0<1bY0JKPu$H~Al%XlhHdBxrHM${myK^z->1z)=`(R4*C|>NvyLdb;V`%H*p+q5 zbIxsA{v$jTeLrH?Em(gZFSOUuV${x#hzzA4Kl&wJ7Jsxk^IJe<6NH^LamXguW8O9% zPv2{>A$dT4Q0t($*MT)bCddXXW5*e^Gh(_c^E7V~l$^G4-PJD2J*Yt-&X7-#jz`E_ z?0L<1i257wj;FYi*fv9{xSA5Wg%D7UAhw4Uf3)gbQbp`GaG}8{E5bK8BNXGmW~WLn z)ixP7iOzoUh_ab6hp8OFN|ONuGwx zdw-B~-mrXe%4nU_)#HRM<>)sNy;>lu_de^==#*xmW;2b| zns?ZEa;qzDwW*C=HPt_za0EbT4$-;gu+-u*`!5$FV_P&h@8jw35Bg6h1SIj{{9ZB) zCO-NAPk=`#B2Wr{pcNk9<)&ekN1>9SoHO5|SYy7ZNy=S$$<^i!3E0oNZ{EfeTIt{a z;YLqB@1vsg@x(sd%TfYfXCWz|wq)?Qx&jti?V?=MHJ9b?wQc)yY3JJ`1hV-0)*%0* z1@bIReaC#+JskyNwoXa9phAP&xNCA6k+$WkWT%T|OXZ;xv-vCiN{wwAaA3o>#j zdl&sBS#I2!a>7TO9hm zNK#^>e-*yt)91AYB)LR)mG9Uwg3CB)V+(@4HIhk9AKI+F^tHL@e_Wa9zn%&~Jbf)( ztH(@rkCWEj#qQe|sykhg8Lgdzh#c3=?@>@p)YELc; zBPyIs6PduCt2hZ8PqE?B_s~nZI^mr-Y51g_Sfuu3C_EGMbtuiR@GVBj*J6-Zu&+0h zgiXq?WgpmP%sZt0L)14oU)0x4wsk@Rzco8XJ?& z-x2zHZC2am9nS&6pV5wlB8}7^JJLWaGcPJr%$zRqRAE(Hh#-J&a0wKxz3#ppB{`3f zf%n&u>93u=5H`M=W;F1}`QxjD)275_RZmFfmv9hN7{EiaK3)bhGJ45OFN-=fWSBm_ z$%5PkH_g%qDTomTfOT4_>ww0cb=5X+tvn@UM z#9NSv3Z?_dEZcvng5D|~7xl?N}~x5?66?dkvgw_h56mDBU5YUt(2GhTf{`FA)3`a&JUcK>ZZ zyW@XJ&E3bI+@d4^fYWmH6YSQ9_G|;{Tj-=&&U%Xw=)5!(N^C0$Mn0i4EbCvNH}Ed-?a65(Btd1Mq14m_-AQeU{9u z({RRcreSM5TOha1E$uJ~YuCJgjYb+uRuec z6vi3D#hX*H)B1Xp*34t<(#Tka9Hzbb474XJH7#G}?g1s}b3YpX3Lvxx1D*9J=XMO% z=;9n{Tp7Y;m4D&;FBHOksP?V8iW_|pVfH)XSRy3F{}s^h+K%TM%{Z~0Ou z*=nA{x^;=G(5A^Y#ud9_5uKJEz^&j>xtw@B8%JY`@lxM?9uLN6M}r>wVs!fy9IYD1 z0lk)y`pdw^uJ8N8?ycT!-+kjp`W)!asT)jWp^_3d>gu9a0KUuZ(5wc*kv{H^_g}!E zldrb9jC!v1-;cywATQ#Oo=5xF=<-4tIT?v}ui>_s-q;o5;Z6$^Oa$di>qrf+8u0S* z$}J*R(;_BjL^YPfW$6$Hjh*~b7>P&BRszvTxco(bX>BYr#Jv-xwMb4YwYcPY#Nhh{ z)uJ@Oq=V#k!5-%0{{tvzLBxHsD8cIWKh1R3E-Gn$8i8c1uO1(md^CgC%IOS%$^WUI~UkIs5aAoRjo#t56E zYOpx2>mTTXf6#snLiv=Weyjiangu`@{SIwPF(mB^E(*lG|Mi9JTH|FKN9^j!XH>^Z zZnJT8qv15-9R@)Hix^hc1f;249?E(NrryaC_2bZsueJ0xn{t>7J8c8gkF{k%VPEyM zZM&*s6zuQ~t$LO27*E3_3?_xwN*(!(`tw?)u+@~RL9UfcQh{IMo<@_KuE>gbkorg> zE~rHWZ3J9LCZuIG?aF>l1{dT+$d9bpn3X2rpFy(`; zfZa13T)Up+56#hVRPQ8lvWj6)JT~$*Q)=@yv)QBM?0Ea^-m?R8`Re!W$H!OZtEea+ zcU%Azm$a&;w5dq45PwQ3DKQG7WiV1%p z+#HE0Ca0ix=TMo;RRL1Uv8WiWg2QBC$T+3YDVvLuu=!;YGgFZwOgwxf=)gu@HjOYF z<;dcxX=jZQ>=la6MT2iCN!ZX}bD#z5k{Xk?J)Xf%|4u+Y0&eUn?4M~aqbN|dVWbQ< z^)_W-?Q->gCi?vJ2TgG`aTBUjK8fc~&Spk63+Cm}+j4rB@@L`eY^=zHX z$EEybJO6aT6#!8uTI*I_&V{B3aps-kXsp@fXGDp{XM##NDFFcLLD}pp>M@5ezC1iw z-;WaEu~T^U4P$3zrH?wE9i|o(JX=I|+K`O10|qL*XPWej`|KmA0iWWpO^GXD zp01OFC?wH8(>IfMuD;jAcd5j`(Ph2AQQPgP^e$r0)E@)AAKuRp*{huRtWaD4G^ceO z@LDqke-t*m*w_}DIB2L^VKgtWz}) zs?sQ{FZ;4LFsHsrnZo{3g@w3hZfcg|6ZT|_(2$TjKN!PqLsmnLmYY>of&r`9pkJUiJn*#RsGvkeOo9Z`kR|_S-t~zrbhMg0&1vv{7mc@p1)BSxRQK<~P*FLfGqW?y86} zK1`f2SakKMi;%yuEZb#fLMP}^#7U$8@#I$v6ftCsqZS1sM?;oBHAu1W@>}3Hq2npl z@KZpwc@p_IJ60HlO$ zSn&r z+5Uy^g-|53IE`C%n?a^s!tM8(DPx4B6BRbH;34nrNG6Sr;YXu{x^$KAk2vHVNc5M%6nT!8vMOAy@2l>O zSw!l3@j1f&E)KDLsbEWi(R>X-ZcLsr`zBcz=$f&vLrYAN#my0TqT>%p21cq0DF=6y ze9jHT%+^)VAIx`lT9=OMYI*r#5goRvaMv1?CT23_5K*n%4R&f@a<&q;?wLht5=|4G z9=QY^w|s-lL$Z7_%~XQ{xN@Ytk0|_}#3%K(mKcE4PyloetmH>TS02gm5I&C!EMm`% zh5V$@nvJi9Mzq$&@)e$8rcmQ@OUc>THK7JU1dIfUDnR$qR3hk#Qg@L#!<5YC6a}=T zxrZ0j)C8Y+C5E~So98CEwbw-CU!P@&Ed}j({b!;JS`Qw9(y{DhT+)J6JJiJE&Fgge zj2D{7To3G^vM}g|X2vMmld}syW`#AEs7fDLG6{7S8bYiPKS6hlW=cdsH;T@x{s_a~ z8_j~eT;e`s&1%Ch;joI|5tf9ap5YN!ge}3;sWQ;XLhzRy5?Gz=tx5CKCVcwM7en-| zG=kgH*|mY?g^HDNO-{AC1gXpk3GkSMu)E?;c@f->JZA zR5<~9X{My|>fK@x@7&Nmd87JbB!`f31a#U?SjA@~C3_URK57cYa%q{##HtalFJfhE z6}>YWQ*@sZbviZc8NX5eN_N{6-RtCcqK>zhwy_dO8`0wWrj+}kK05>CzG4~FR#RHP z=5S$=o*zw9CX6lhF;Pi3M{cB|W)-QcR=b#MZ)8&z?WCWV8njG_@_|0*cPv`{0P2P= zVujRncJdOGrFNp&3h1CdPAB2{ceN7VAtXg+30PMX+);OiQdPQWPaRptQ5I4W(|m?o zW~!0$as?!-h&@_q|KK?*d)4D``rvg5Ik|5x>rU)=eEah{xlIe<+MAV12PG zAyhR+SQpYI!JtpQyOW@{%92y-_-M_{6n@Ts8=d#7fajdIBr7fYZm0AJYOggZ@@KuO zCrUo~=nnPp)?>l#w@}Pi_nAT`x4?4!lXk**S!|O^;pOXCw)Qdt!uz-{eVIV#DeX1g za1nu?pviJdG*?ioY&vY7Z4DFJs*-`##;I0OO?-6F3QmUmpQ%=sdLUMq0#!~P<1OyN z!O|}dp6wco`SWx8fXhON`r~_n_1}{JtKA|LO$p!%4zW$k(i`R=_6ZKEUUbC8!^D=z zdhtpMRr*FbPq(VBi-I38#X3#skc~RP{vvC|QHO^YJxOxU9cpBwoKRZdvsquYNfs=n z0OK+lRHEG`YYjw+zN;x=y$Z*QgDBzj{}3lyqR+aB>2`M2@N6fTiGjVz$J}xIrxR9! z5NU%o-8tA@7%BgQHf8p@?2Jg)cqgEQ_Pw3})NV(jrnbPAr@j5f^eYC;!FixjSG?vD zUG5m|z|%~C*Htl1J^#*xG{*mbo zeD_fR`}`2q?8F>3j!GciXbJsdm`TV2v0ytKd86t;D4DwQAxBNXiqvP_P^J+6X59#t zNs8=nIQR}C>eSwEsTb<+vkaS4*a|I82-W(;wBrl2A1^X!m}~}*V*0?PYKDj%+_#wU z<^;JO1I`!b(iEMZ%}lwi+gl8MoW<)AWAI9bC~>#!UZ}avRpeL*!h2)R8X{_L)PK8N zc-Gw+Og5}h&?OU4DPn%n(n(_Ve-1ZTL{DT}q2(e_@+-}Kowj}icOblumY^Jj# zH5@uNq+!F)3rj~%mERUoWLJP9IdtNAp|O{kU5+(2`Uk~1?V3l~Zs9!80aoBZw|Nopb@4V?QlC*27p7*cH4~a5;omEFChcoHiB!=3t%4`kSTF?Eb=b z0r7fVu8u_PI-F8yuV{%Wwu6px9YdLO+9-8mJ>BOu{^CaTi{;1m?NaF-5BG?I_4j+b z3#Y z70R#e%Qe!x2$6Z|eB=11Mo7#j%HUJEoD4k6YvPr;mHG#kA5xXV>uXhM-5mSC+w`WWTIE&WF2p#~+_D`kjC~YXwZ3sr z0HFXCM$}_zhfw0mqN-U2=pR(d%lBpTF^`wOOshtp?*0(B4ECT(>Zj$BG5=~A|6S{^ zc_n(69bfkBBcBcoSma)5ICfa}P%byQGvG#iF($&PK6de!h}q@WM|e7&_GOL5*4|d$ z%?(jgxkbkYw+#`y!&)mEQJIlh^A&!Ik(|KTr}8qVZzJHd-*IEMVh`0Jq?w;E`}SFu z7}NM_wHN*Lz9u1jd#FAug+LCIwKqyi_${~J6-cT7$;os-fRbm(G|Yi2x~NhbSxvcA z0C(1i*F0`s8$Yfp2~ienAs}o7s=(VMP1{Y`dB#x)4(8WtD-YaMOIoGmvp-GxUYUC?pQc3?z95iW1emeI>j&HRn$}s<*9(jgFE=rua z)%SN{>Hm+kshFO`XG9G8OaGVLStE9_2V^OIKOg-SOE^ukU?jZ}sG?wQE05T|MpuUtAZHflu+j zn0tHCRD1MTw-SBVTnL*T{G~iarCS@a)A|z{mXEhPS+Al>49ykZ?$dbrcAEoP!tSV+ zx3uv#+#mB2-H9o!*E4|JCc0M-jVlfk6Z?W}lOC^RN$05Jk2BqNRm!Ent7nt?u?}gm zUXa%JEWUrqGk~)>lwXLmiRz#Tz!^i@j}zA^k%gNTHyIQHjVJ{tO_ZC(4co+%F3so~ z&7}}0qJT@NgNthZY2P(WbqsezLG+A`ZM_7&$yVqSH-ZYLTptOHceMmZnf5rzJ z8dGRF*Eb3YdRPLzm$RDO1yk!>3I6z*-`ezX6Mp=+yG#_L<=i02`@HlGToXJc%#y@( z^U<7X89a74I@9KHtdL6cEtXP_uLCh6!LgrZ4kwT^5T97Wf&L(E)68nYyq)q@JU)XT z1L?YuAr`#qtN=Ifti?GxLQ+tvmN^mTY$x<&-+rmO5HPO(TY*VsWvPH8`NEtH(m?F= zYB9o-umrZ&Lu|^OYp*0)QLEilK*o(xuE`=p5#XLuiGP;W)uKL;W9=?lr<@_{eWvvS~ipkK<1$jRtG+-XaBDA z_*R|Zt}yk9m6Ot~7Bxu+19?Djp9Wth`pI74UR=jb=T#yR^vwwuk71+To_^_9wvRE$ zt-5rcyD91fo->jRl@XMVfxFn-L{4ST(65kHwECq^J{#_mks#qiHRcxbA$OnDY+!0D z%%Ub5L-M3BCNaWf^wV%jE66a`UAKwok^>79&$d&Y1h4t0B>g`<@;3yr?enbrCysuu ze!@6d0DxiuEIcEc(|`CssZBU(kwvM)*2Gjok13;DpW$D;fa`jTQ2({bJ?RcnI@?bA z_qrRRp&>dN7=byYs7oS72kT?Cs<1~kgJ$#6!Q@Qc^lazh>Z_WZcSn<3-e*0^q6fkh zf^wS~Zb2+OYn@R;O<%+MRr)LESn&tlj-@vK`;)d(zXy!*i z9}W>TcP=R&Ov7|fLdD{VJujvjq(b48_Jm8OewG~9ndi{t&2PBLEdGoepOj2Ir}@p! zA-PTxqj?OZ5RnsX-u@Fa)Ra)hFvb*wO1Ss~F$8hV@F}P6`%;rfd3UNyR-Q8*vn5)V zD;o1Yt*4cfv%mi&Y2^ySXV&IwX%25%S3+4k+$Oq0pSCPMkNW%PDJ$``<~vt#bzK43 zx32ctH{PyeZvERuILu7%~#8b(+3 zSMS)Ygn7`8Ax7L?!Wb&0Txd?B=!#lWl`uD5}p0jV$#vmUd^S@`f|rA=NA92FYZpHpu3haI5j+Gpd|BX6DtT>qVNT`e`<0E#Zu zA*S||wm<$)PW9~Ln=pp=`z|ITlW#NMzr?M~u|k`P{?cQKp3~=GO_Og8_g*H5R5#7n zWMeZEG*%Ys{2;{}G7>pz8*?O^w0nNc`j%lf3%9*B*4up6!m86IApK%J|oX(5yq`k3Asz-HbEzbWHxFdXUyave zjd7O0Jl22n)#br_-yzw?mei=YwT}kyWSy*uo{STT0;_8sJ_YSLf2oM>IJ^{NV3(a(SJtzVn*OE zfzp}hfCSS-z|V<`i#fUelak1fyK+-4akr!{nZ=m;PrJ9tVkS@K-XceuOxh*u>j(bb z<^0yy_9D(EXWS5o?s;K;qVX*MN*%njOp~21z<#7_1lWO(p@0a~fQp zlqMJ+97A(xNl&!NxEB@C5bdWlgEVn|D=3aG5lYmQxk&xn)& zstqjB8Bvm`vG?ST5&)&c~GgidG~$Xf%+#C?X8 z#h+s#&7li?}7>In9i7K6#g^R!w zx{(TTcNs1t#E0txK!()4Qd0O{nkgMHIo zCV+N6IQT5ANgeSpPhvtpY4Dn`tr5m0?YH=a%#Mf4od2|c^^gRfi{1&*rp~G%S2_B& z6iLMw39?M_imS>gS$d|_3m4N^Z4`{)J zNY5}zxiBQbiHCApvcN1pBB)SBEWp zvXeF>(o^J*XG`^n&gz}eaWUE31=^)@dK<_6*o@KX{o5p@7V_|l{^{h6`9i40885B> zJ>10!Vd=@`K{XNUU|Vb@r*IWP0pbD4hfTbRm=RD2&g#3(J$ETfZ2=2VkM*2LrkFUk z0&1-&De188KUO2?RE7wJ5F)^_u@vr9U5jA63s$hyS;G_Vb;{MYK3qc3~+qw7th6caHfBg+g z&ne-561WFIP5Vw*KDA-}59A9eEa(**JdB2T%zC<-96WqApsI!SQA>p(t<58$;Ar0J zsWVgEDrRj%?@LWCGNIZw+Sc@#jYAV4SXjR&(7&TLa^fdB{W?!=DLA8B_>3Gkkp?^% z_R9^`tLhJ!9GTs*H_Lq47GFg5L4*sS>#wZdMlDbqM};DDY4$!c>2cEZnIi4a+nz~R z-IdLzJmkk_?JIHLrud@?9uK$p3+>uvK?xrk&d-RmAy!=j6*DcDy^K=L>up)sUNOI8{rmos~A$%CCHOfl*A3L*@s#9`WwkL7*$p37g_|l(pTb8{Ye^Y z&~pwClJ5F^8$Pu)lftldi$I{0Xi7)wgxXbLeR)+Vs=(6;)*xnI$74R$3g{cjH?yq> zX-fl^MGHRm(vNJ5&?}jWF;!lXA+_{Kx4sw-nwZXJl zHXnBCA{D=s#t;q|XB?WXeexX>uSQnFGugd#Jrpo|itamaMP;+4bAm+XA8^tA? z^mJcpe^wCn`#-G!589+G$OhP(jtroKYU#WYy6h}7aS;#|7Y&V$VtB+u<0X))aZPhF zYx-RIbam2Rpu)`8Yp+_MK1*Ls3fPG|U(~5PZr^Ne?>wK3IKPxP;#ehQYyyx@@2l&N z0=G#m#AGH;<1Mf7;gU58ay53N)p`;CaCH}0$xi@tZX3t6GE|wf3&!m7&_vUWnw60qdR?=7m$4?X2 zs)$pADf2Jk<-OcvcdJU@A#d7dw-xvYzcq$PyK<5xz_2^AZC}gLZ$%G9w#>gMM3g_<*|gO=6=PYoUH86G8-A|XBTNL1U*5lliLT~V3P9ZI=Y*5?#dch?77J^82o$Zvbm7s|vqveVyQe(;a{fQpw!D&rqh)k#K%xNJ+}fD zuXV0xC&T2@Bt)G)X6LpY3JX<%O3$)FFj-IGq_Z6%=Ym0ksm9cjV-0a}wf;KFUOvR0 z$~T&@U5qlwVtQ*6Elcc9(?K;vkQ31=jF!Uuo6-#*XTWPPOKtK832Y=BwiI;uB3-G1 zbsI_8FCjRE|I^)DM8(m?-=d96Ai*uT(-5?ANN|^?p^?Vj3GN!a(clo=8X9*965I(A zoDdlkfE!K}jh^JK~(*s(`$md&20s!$qU$ z{uMj?KiTRL0M9!{&qs^VlPB^&*(&p`xcZ#n#$?_91k(z$tcM9cDj`-@MNilBob4C9 zYsC_Q!VOH7aUQO4HBS0M~XnY=Zwjqmj}-)V%HUYp)iKcHI#)b*Jq>h}0# zU~bCMI77R-L{R`NZH52mwa#M$C*go}Nz(ejLxmR*wa3;m2{mPM`&-6K20R(tZbb6> z;*L<#j{$Fm1OGA?qj%V=;7?+#J#$)uDXB|HwN(sZVK#$*^g^3&B-~gE7pW%hoan8jIMtwN(p2K2d+ZG?$>~EgMSjL%3HJ z!<=KOJIzstrePuTBO!B#Kj!aFB&@svg{fj&+IXTk*E~Pc{hDk#er??7G=<5|8lmie zK0<9(Tmdi5*HI>Nb9TqcpAu5NDEH-YFz8&O=%|jK;v->~=Nif-0&iU#9UUafPN@tA zEwd3(fvxH8WR#=j>QRRhFOmnXMhW1*Bi#srAiRQ1%n)l#?u-t=N&-Y|iuJ&d9gciT ztK`eA6j?+dBbfWRRAy+%1j~`s)k%-C49pmLOcFHAqQONbZZkQhc<7DAzN+-P)pj{y z?_c^pj>Ml!F}O3a_GV?q??*>ZW-?j**%sl1j{sJ5(*@x3_U1;?>|S&Y!UgnAM6vC& z#$e{&`Wf+1sk@}=*L^%mZ1y#ib?htZH0Jm@`oJiMG1vCTgpik2_EUvsAl4v}MWGbZ z{(Vog*UBbuIC3d<7V=~qWc&0w?fH@&2k_cHeYE9+4UZ7#)46qkeX9nk1!=TynRf{N zIPXX`f+xy^+xxTHp+?RYRlnt8Lm0$j=ijFW9K1V3x2@*4E)O5Kwn@JjK{?sO{DrQ{FS#OaK~auuV1OtAtw{?su@AAV6)j zi`iHbX^x0k<&_jwjwUt6ate$$wdjI1CwCMY%f{I2^|rVOQh*KGOZGWA ziY4rI5;J9fUfB^Ts%?R5pOpv1w+)Fco^e(tb_)VF-GNAE>8U3!(N2VWwdMD26&0J~ zs|C=v^IM0g?XL`$ z6@S;EEiQ*5cL>WL*C8hJ#hSjrS^SExK~*L-To<=Rk|d*$j>r0Z z12TCfPy&s@<_$BdmE<|S&)jB=a^jP~*u)@$j~DsbOLL?$`~0L7M9n58ZL0ZF1@`Wt z{}6{J#C!{Z-U(>kvRKjlOW%yCwAyDfE0euwaRB-;rdNTvsoRCkC!?C<%Or}dweLFS zfp@LbMyR);%D^OR^JD&Kqn?Q{Dk;dx(0YKP08bC zR5HDPj9n`{xqH+7VBP}E;qq||ZeLH;=Uq9&yI3JpUC=R@U384x>o8F1ogz?6X#b| zWw~6B%=0%8P9!5_|5hldq)<=PBO+%;4_JCD7zseUs?ws-r{f-fC1jN^-MAhXHF9*m zo(+f0GX8n`JXwm8@9dB zhdh$_aBO@Jfr$vO&SLjlHJf*&Xk%P;PbM^!sKX@*8avuU$?lFM7*l&0QeqnF8@=1z&!=ySMZLsC4ctvj7L}3 zdLs|}Pl87+P9|*dD#a$bCHHAJyN$^)j&&nr8wY1Yy=RgJ3m`Z+E@spHMv1Nv9S~*uJ9Luly@HX`6Ra~ zISxfVF$p0J{uhA4=sVY*blI75_A2b5)?e4}P4XHYI`ZcbTavaG`SveqDIg;*(fCEJ z^@}nM3Y2c@KS8sit~S2kp~d^)FD|-`5E1$%6*C5)ldgd(R)@w)iJT5kM!E^B`w?bP zp>u>6)BJ7*)oEiYTXZdH)y{;M|HSL=%z26xWV)Bg3rA)V*Z|&Ksw3QXm!0FktokVu z57TKD%~Lt&`|@8?OrKpM^shx3|DWM`=7A$!``tFmj3#Bc{ z-M0LE_d>t-_uXv3qN?MzVH%?8@SZR~a3;=xL!MJoMFl4wgdrv9Nuv1M ze)hZfE+FELr++T2t~UJsnfvY1JNJms=n}SFc@Bt-1Uw=R7I4n;z^t0s$UFTh=!yvV83cmYm{OSDG&Y!N+t(!;rcmu{GVtA8SD@}n?XDtme|XLK zXo-3P<^JRBGkPJo{%z(X0BAWdnw527mF~vQ*V&_z17r&p0b6X5y$dA7vrYSPi`A0! zI*?Yt!fU7!A=GL&Rm)ZFC=Lw}bwBVg(IO^`+FR>dD2z^A!D;_r%NqhK31fU|n z8Aq6(HP{@vS53m*98-$kaigHY$HqxX2I#8CTm%-14NTFeVdU0xTi+C=f zAD8HzSa&@}JFWad2INw!)&v#Z$X@N&wV^0 z6^5Hzrli0n#W1OUnT@0x%Fk~*Q=Oq{j2l52Gde6@$3nF++#GhC!QuV$Hrh=0iHGw% zPIguHu)Q@d_cl|;1_ee-8HHGP%g@?sep&PU4s%LJGqaqT@q+Ao!~_x+lDywLOlhVS zVwUoiu#`UFF0Jt#+VYT`2CxBq{dz_zR;rIrdmf)UMKxU;g@1mT^7$ow_7U{q-HLPZ z?&g_xaQ%;RhiasW8dNE(LSmo79b1)#rKa8;hvv%x0gX~7N&8SVV}h2<5EXcb#NCVz zqqqTWaol}DoY>WV5X=VHC2p& zxtNOtNZp;gz(#5nRgkl>T4IyPZ%;OQjOPgQ{Rn4M^Po0;XR+-6vfYPBJUS;0A6>h1 z>B#?VLFkDqc+O-+2FoLD&{P^gbS&PJjf-_Aow)5jUnRKumc*3uS9;FOWMsD5#jDa= zEpvD-8xZ#!T<);)m49tHLE}tl9J;LC8PNZd4!%KkQF`6>apS;J z*0S?Da*(w91Dq4=eNSaOru-jRug|vbC?e=QA0}xCsg&b-r|WDC#6}%l<%F9XdbV9ydpbU*W+(Jc{t3;@Pt{5! z__BU|i|eMjx5vW#SC+r1nIrKZr*>!M8K()xvnn;XCJaLSc(us;n9J(x{%0^Tx)y6e)5_U{o{NCynC-`d4cThtz@Bt329Tja}sitIM z5wJL6l?TqW9GJpP6yGh-XK=sq;#}lOlN#Q2Q>K=5YnbsGLm`&7Tot#8l-tAjBG3jD zh~5*C*3~irKXUlA%@Q_(rM6N~i3c!*XRDG&lfaWkWd9`J2VgT|1o;~Ss1Z*Y!3WX| z20-GEmbs>V)o;t_RMAWk!sOj7K~0-8Q<5oW^>Hk7SgUvI^pmPiQKEd?S2aqlV#Dwo zBe*bf(m7-KvogO;TPwRr(1(@o1{;oQUIG#Zp+Vp40A_N{^E~Q`7ZYg~@AzTe`DU>2 zxilz{En}5SEuBeXtUb!Bx(mA{cNYA=%Z2@Xhx=o-sn30l zdCw>l#bF!O?c-}jtz7vx_#U$!&`QK)u=4>w0{iKTAVrL{@W$m_P=m1}A?FnAa%t$- z!mlM9?{(Ni)0%=SCo|m(h4{BQmqgqvzZ(d9BFf&`6^x6MHk?NJkxG3+sR*sI#86ou zZIkNN$g6*_aRTG(k!Dj-dDDl&YKJJSA*3XpvysY;7O%)O7Xy;8TzLIJYh-)g47)+{ zdS8x(t5R=xPv;$N`P}(l7Gp$Sds9E|PX24mLXV+$?i)FfLT$u?#xm1CriTW*%39rE4D zdevl&!4OI2K~I>rUfTVBm6JD^9U_oA+~iFV2$S{`v7FRC3UtpY!*OpYVKnAni~ zkYXbSCLlLqyj&=r$^h_Ia~YYkO{)e#`XA4hBuZh$W3(FgGG;imT95gJZZOut?SWq# zA79;Yrm=qE{-##wt(nDtAOuB;Z`R~^*4>HQ zsgZ!99@a&L(*3f{m_uH&vN_G>auhNql@r&05|DC4zW*LjieH#GWwET=fgqUg(P>Z* z&6YLSZG5Ne(i_ouCXQANp^(V8IX3oRQ}A;LJZ!_&ov@PW_0)Xn3MnAQoEUV~L%6fF zRg}V|vvU4Fh)4mU#^xgFebl$-Z>{2BN_Up2o5RiPNcA3J@kO)qm$PLFGue{H>NzG~ z)pkBU*h_ENxy1Pj)e?y#_x&c+fF;`*_6k9@!yqOjCVNE(+s2$M!V6Di^S-jp52~f_ zgfFFOC#PJ<6E&(>q46~e_8{Pq@RvEgP> zdgoQWP@H^#9EHF8dhx@dp`}jNs{Ryt7zK)A>j;wyXrJ?r>kwn9{E2=(5_%Q zL)Sg;|7U(Rj>9N~10G|CAQ|)>R`*gJfQX3BmC|h3^S9YObtkuVw;(hD_@N1fxYKTrF9kqAw)4zT{(6&oT}Tns==`um&f?UDMs+zG@9PHK{pT_0ilh;4(28Y& z8M^?Vkr!J}R?H+3hNCG=dg~wg8hqGPo?|V42c%@KH-uAkFED$%?n&0TUZnE<^{8)lo z(SM=Zmfx#CP=X4mvi`cULZru>$w6{KCFM#_zsg<4LNY3u<4d(}5@~Sqg<;5entnP` ziF>sBoYr1$)m1ffx4mlb523fHCWI`@&Pd|9s+=KZBk2MNn8TOT zB+EHEL^zwkg}N-GdcX3EQD=7FD0>uJ8jlfWOCPku%}h50kSZNY1IIPgK$wrN*|Of# z2-M#V7f_UoH7@QG^62%FcF-ZvU7iCxD=pkl@u&4mWzge%dCFVHK3JO=)*^4VeN^N;Dadf`4a?D3mxsWXm zN4l`ZOqAs%5Ks7y$+@Y~QG0Job3U<^SJ@AKUQ|RCy+m0QuvHEv(0k?sSDc!BZadMG zxRwyk0M4-?*T)LDIxZ{Ddj}s+P&mI>f?++P6#@kjU2;FEFz^fyPQTcjA#W7^8IYez zWTa+~+jqh%I-T7EoK|(RRMl*L^%u`WVCrWz_KEH1{b%{=TgoCDmc0lY?<_jkYqaQC zRw?4g>Xth5jm6a&rHG;d*k;Ei_XKsi|$N*FKR%a5}lcW(z z`Vx7}5P41IF6-msV^WEa8ME!8EDd`42xt8(=**Qz;M79a)^{;U1}Qss#_@Nh8k&B& zIVPLzJiJ~X#xyfo7!a1KCxouzv5jrhj~DfP*zFs`=rZHUMTql*r#Y;*9(lQDIV2jb zN;9aA8RUXP3!cySzWYR%*hQ9KkOM_i?YP6lM=$G|ow1agxQU=Lx8GLvKcHCZLb z;DSsr5lwi1JVUTq7oTU_``5;(LDL_RrKZ^oy|sY`jTQx$I!jpwE{dL^T_89gDfFRhWTOqx*Q`{HG^8XfAlc$KtbYsA(^?vCRdhlPUv&zFoYhBo zzZGGUl^jc#x~4x4D;y8{?emgIK+HQagx5-s?>OdD`rc&Cac;g{Tf{rLw+z-f2e7JA z+-Qxb_47c6RhS^EOB;2l;fX!$QkH{O;OgDFcy!nVD?ZWt?q1kL z$?KI~w(`iR0@aK9m%++3AAdg_x0&oZNItUDKCe*F0_I_V9KjKa(IWGV9_O2irULnq zU_{HQs>o4U^}5{@ym&_0QJUR&^jjGEl8e>DxYN2e6eep(^vXkIcyV(XIr}OAqve&8 zX62;DlwqG_d6=G+5}nSZQp=va@82fkR2}dZiRMf0SC<_c*P`fn1BUQYlN6b4l3E>^ zEZ!aGAf53e$n3rfnM1Q3`vt11{>7e60Pc;W@|~`oCuop6nFt+wj!MYU`*w0aBCRXY zNC-PhwC>VYXUlk|sMFxkr1~R$BC*&|Q3wml;h3ZtQ4ogkZUwl<^`k!A}~<0_~7`^QH*Mw0!HzS+YicO4n`UZ*%_z=GOrAdzp>#+;EPEz zY_%gPvyIIlBCQfmAL4$K7170T5cE6vrA)KW&)rG75dnX*yyJ2k7Caz-!%W>HO6plk z6;-v{YU+AXbHC_UEiA^TCcF$8qM_2UyKtud;)o!+8ku(A#f3}a(7#{3;LD5RggFhq zdU|$Qa%(-zeacGSrPRikUum##89e?Di9xf>Gz;AMF4^-bOVWsbX=PIV+yD;GEsLxo z5O%8k1fk0`9A-CKvL9!YKJ7_~ zHC+z8db%P${r#;_t$mX!*4EpTWl9VX|siPdqC zbvLVHwfbeU^@f}%={PfVnwxkfS>(BMjE~l4?~Ck2|9Y)2Yg@WKu&qyh-P{BqvG>K! zb`A3ObnM!dPKvmzCc<`64(S#%7xq*|W0(4d&Ixl*)N8pYz82Yh>X_7b^ck=E#_9iK zS%8WCO_5Fj)em_8iTlW#4t)8n|LUHjNZbgg(Gxx~If+vI(0>*1SlW~1exbpS02Vv+ zBYe)yXt?>r7z7gtrjRQ~$`yk5LtNEK9mRSfvFRj~0)l>~2~8W-Ut~)Z!gn`^p9f51Xj2 z%f;Ilq62dcpMQJ@Fh?575#2xk>3{cYFKhmKvkkv??b=Njh1y0tYizeYtVJ9rcCe=} z_cNPgMCQ!KCM>Tp7OpP-;g#ky2C12gqpenl!_R6n0a@>sk{Y!bv@~!PH@K_2Z}#wZ zhbC3&4U4j30@6~{7NjcYMFWrX zG;R`vvgc9O(FLLbbg(-3%zINGs zvQ~##>=&kkZfQQSX41~KxPMt_F%s7Ss_@O&+M8Vt-vs^Zsm=8Xk_DlI4Jpj)Bn0Wc z+2*uVfY<_lfNeT}0oAxkjriNfFqG0TO}4?N@Ew8jjyOi$g+Fvf+!r_Lx<3y=&E5f9 zl}=j&%*vv<@z_{cH}C8r)vtrbVh59E2Lw*y_IR5eSqa&_DQTZ?R)YX*tWSP=qkU>X z%ju?!qb}hdnY$cP<-$8`^d@PdA)y?mY*KlM@K3`!^&Vx2r0c866YZ%?VvYuW3VKe! zbRlq>ZTkFby{=E*l@DIq*rmKDW(sy*RKbtg@h0X7ta3=;#$%5vYtvIw7d>5MMP5JR z=b+YKcGnw@r$@2hn$z91rr4q*E~?E{YGkyqGADTJq-}c}bsGfzd+hK3$8PcXUiQ1f ziNf34n$910?GakqZBLbXvz`P4)OwroOMOokS3GzqV;Z8lmb@qTUqeUQ*NSnJ`Cl;R z#B)31Rh}d;`}yIqY%MOf;K;^POuWa9g=D9?L|}H*z0r{45__dZuL?8p(G*`IK-$v-Oi;I26^a|ZhBqb+Q2U0V7TqVieirc)=Rzktam z^Ml_+h%z-ro%7@$mxcP1VV9t)7-WxR!}KOIMyTmiO?XSmP-8K7{btd})&ZeU@y}TG zT%sBc9^;f#iMc7TdimOpq0ncRtViC2NDtdS(L8@9hfjt^0!7CYoaE-kK>*+d`o>-- zSxUi(>I`NV&@lSs+&;!$9ks)H+w`H^O**Q~#eN^5LJG(j@f{~>gpZHQ=C^RHrP0J0~;LMk< z#{GBY|2?XNUljVkb&+H=!T!H@kpGums5>jWmB=ezk)g$-r|5p<3HrvsJ&byUC>>({ se}2&aWuN^2{~XjEiQVV4a|VnTQOp2zi}v3lpx5C6fF_>&A6$h01$9Hy_5c6? literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/hihat_open3.mp3 b/src/static/audio/acoustic/hihat_open3.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..d73cae1c232135885907d745ac9e3a835ab7b023 GIT binary patch literal 53361 zcmdp-V{}~K8}BE!ZQFKZO>7&D8{3@NMq}GnV>M z+57CzdGviY_%+EA@c$UPwoacv{(|=LQ3n9#T>vofNT?VX*m#7b6cp6-Ol)kNyn-TP zVv;iQii)b5+IohDCKlEKa?xyZibE zN5-e8=N4Bse*WD3b$oVq`TPFq<>l=i4F0&6rJ}f!G#9IYfGhORe=}rO1ps)+si6gx z01)^8=7IJ&-S+Q?|E~x5b@yX~AVUGV0spNN?WPa_!CEfaNDY6aJRe9pU4ibMNQ0Z^^$(bSHP1409!@uw~DpowPp+v@MGk} zbjNbQdj69c2q;L+r3QEjW@hF%Vss|wn@q*DnNgD(duvtopAoU>5@LEtLxIAMFi8wK zv7*cYBKU42%O-wzs&*p**}zlJU#o=`KM%~l2t!}-+eI)Eg>J+%_G0qea@}4Fa0>W= zrs*~h)aqr^7EM;Ooy_mGEwnAsgxmT;O0NtdU?o#J<`ka>=JMEMPd#_dgq$vB{sHDaKt{IDN|D z%MZH|mU0ng5gV&;u^7sqIk%jpoEf5QTx@=}%*%PLH=~Dm`))cT&XJL;wE3~05Jh97yYXhl z5E#?MBA3o92x#-cfFq9WuV29b#(UyAxcd9&hoFo1^zYSn+7dJX01G2Aj3RL%l9UTI z5&+m~Gf??5bEv8)o!4Xz-Kkf!k*dr}7KXJQqi84^+=5NI$H25C>J(f@%q-%b<>Y0f zdUDiV&Fb>V=IUf%AkJay|IT^9)`hg7h9*)a^#j9CHUG_`+gvWm`8;{lP`56%-MWpU zo_y~P?5Qo7?55eh%v7b))-sYeo^5cRMbnsHHcKd6_QHSfG`h#fOo}HwCfJf=B3pwa zw4{SHsgmaQ#no~4cO=u>;9}G;q_?A9x<$bo|DMeo*;;1OS(G|q zBSdc8S(rJX(P8@sa-OLwew$33cp0vQqA7ffH~{mqNFQ|+x0ko}hj)5(PLENL!3)z} zudS*G)89W*Ri;%UHXH>|ni}g%(peZfjE;+xgkSly_0oPX$G}*ev^jYh@KF{RQ%SB@ zJ)`}=L-8nqZ0hf;#H2{I*P9yxfDDa&27u z`;6?sXZ6_`dWJS>;#E*Ww4GjNFjhJvHdzkAVhD{9r6vllkm`;cJH=}ph!{@L4oPyp zG|E!hb8N;P-Q)#P3zIq8vS6>cf)19DPBNx}OOEjZx^efYdc`0es5_EA8ZhyhA~0Sb|r@|C*yFja25T& zhQaS`m`ntKa=}XmY!bkFOa)>_==H z<=I@yuLM+VhCCX5AK$S))@u8))8e;d-7ZWH1F)}4k%5P}dxNqzyVaPJ%!{}tQeO~k zGKf;34{8B-oj2&llu=QOearw!YGDY}E7_FuNK``T6r08qN*Iz23lACY13e_q;5H6T zZ-F1d)fV%U6z+x{p7M!y3)!igMHYpNr1Xaoxv||8ZoM=W87qOobgrNo^LSX%5e7Ar)uzkWZBx^eOjX6oFN^cD*g)>&OVr8DbxjeyO1$w}_glT@?fTZ)D zdD;w_4^y!ud**@k=o2MF?hxo= zG6a-krev^o@j_Oo*HLpak)%si?hBT{MReqRVmm;>OGv6a;3wsOh$-Q)DpS*Ue=%LF zea*~dgmU3e^{s^4E>Y<9QE+hj8?^e;{<(+rw*AXn*2w?(eE>UJEeX^%QOl99!GNK& zJlD-~#EYh%C7I{p+2!u!yg$=QSfF?)n0ISSq-wl4VUUWeUg(+WJJy!_0fsJknubX~ zH&Dl^%OtP|@?=Gh(-)AVn`5w7?_i~}v12SjneSVMs*g@j&h}ak(Z=pt4)y|he`V^0 z#c8>I+hmj!`bXS303kC;%Z<(IhFa`D;z$Ky%q|*zCh7nb2Oj_`u}LGi*q>_-Lq#Q9 zBEX*$txtb14?w}HQGu>FBKhT+OlS9VMt-^l;VpMKwY8ae=hdhesYuvQMX|Uv9ZzAt z`;LS6^a3$si6#J7D5k17X@vvGEQm;&?;%-_+*0Ja{RcCR6sQ!Tj)t33>v?D~1O-)oEUP%n2tc|~+Gx8MPMW{U z00S%0j|p%_qDg0p%~dMN)FFr4V%#37+~t%QFNZkN?^Xawb+P6EtKzy0$m<4TLgB>wA5ly;8Uw6ty0CdL^)W)u9paS(^cS zBF}074i5bT)zZqAwB>#mV-eQ6#4lrl18xn6c%}Euo=+XOU-VCI8dv^ULCMUHF-+Vam?Arl0?Ek zaCC((fL{kK*Fq2$<2CPe{ckx3;r%}lBMoHGo8{n>s|YrCMh5`!VG4{>6`)JEIM;)S zN>lQTRo(v{9Hj7Xev|wnRtDHmuvvD|ENs)8u%5Bw|2qVqQd+OzNs+W*EeO0Ot1Yc{ zAP3Bt4H9yqLlenR_Z3>Ys|M#tm7zvu>c;xF=AQ3^Mu<>@wVva(Z?+c3TdgJJX}L9C z=t0eu&wj2GsZK@sqPj6aHU9{A!Ls_`Xkb}UH2Ic8MOdq|w@ZmH!KwSsE$lIiFM-)X6I0~yz^^2v*T z@Xb&aUUOoPW9UbQdB{{1i|J^LEY}Ge6pP{({-BXP6%_u-MPU$ z=3&W4eJa4}OorWQf``>txJPtkm!Lp{E&F*i(ioeJe?D%cn3?%#SNIp#uz1KG%mOtv z6S`D+Mt5TzJQhsMC{@UQ%l(lR&lK8PzPy?uEo|xUKjy5uW@YNjO!Ec-V`nQR$M(c- zFzdPrd?Z4mx{YGL5)c#%;atb6p){_xVXIaM#@U|y{#epyysE!`uQx1g@SmA!j^dnS zrfL}fjOk?vB5UH(or={B#V&p=GysBJ@B?iT4v=54`3*V%x=0?M(N<$u3tpK*F#!wb z5Ca){cxaJc>O$<4*CDskg#eMlWu$a-Omd;;D17S-YzdD|F5TyD|J6A3`4x5;L2!h#FKW~jY(AEJ~ zbrcbwt)^&V+;aOpw>u@TK zv7IN*8LbuDNz$)T8Tc+bY7e_My&yj-)<&P4QqAeQx_tJ&T=C%B$yFpClqaz+}(VcAr@L${fy1F!gOXQXjwJG3U z{UuZ;yat`*Iz*DGVrz>vT{T_~Y*&?~!8i|KqID+Cizpk)f}!C$!^QxDv~$QAS5T9} zh!N+KcUc1>P_#lZHjvqD2=>TI>c(_jnbhH2tFmvaG)MG<+wFP!vz|E;(W~U7Ks$5N z8-3kH3p=y~Kjt0trHX`^tbil7v1}7#NOJSicC=ak!Wf;kVa6~hqc+8gIdnruc&3yS zwQ2u|n+L!R#_G5!^16}$@ZUa&Bjcp`AdYRKBlth}eLBX5>EnvrP0l?5-6>m0#~bcg zRv2weDq`d$Be9W^&$G%M`Iq(^b4iH$SdSoWG~>Z65V3w$Q#TBlAwM~$q={=P9JAY* z?%lz_CR6V|d-Xg`K$~4PnstEVZiWBd%(F#fQu%LDzwT|1L&YETus4Tf2=)~Tdt=qO zl;`++fK$b&iFHrU+U@=Jccq>48t@C)>$%~413Un31A?P_$}E|r0oe0Py7SOKYAex^ z&6Z`?SupkyO3i`?B~S6qv8+}ZgQe_^-4&b;s;%EZO|^JwQt-B)`5@yBE2k*3Ctr5; z=BHj6;w%N=nH~#!>OrhqeB>$rAxRNoBewmZ!#2Vqu~+=pF@)Z zY{OO_;zkvw>)+raC!q3;DWJ?q%;p;GmTf_5t*71+`bI2UHBzB2&adQW6oftosXcLa zOL%K*W(c^YRp)kUG$Ah0!|VIazb$HR%J5#%-%s;NN?QvqeFcgizBBf$01fm6z6je^ zB$NVM?Sj?-v+hwJ@om*dO))z|wV@F^I42F~d$$RSdH zE9S5W)>5nt#wI_GB_yGzh9rO7kHWsq2|*Be^kGEvhA;WEP$66C{l};dEVcc$3%|EZ0ebuSCWjG!W9kOA!-n-umq?@p+*;?_TOoRfMqjTH zJl(tG*COqpnf7-61}&|zy@D6MFQE(r#waK1jKpR#xo0+TwQ8R9+OO&(Nu?qwS5m0e z!235N&%bqVplWY*1^@sC8GDijb$DnnPXU#Yw1kqEkadD0WDqd~Lo8UE+?4sEi&r9) z&;miKUQZ$}>_OGPdvS7bs_V03Vj4xOBAGpNG>`iJ_jQUs15xy*0)NFP-A}43u<|NM zQmxSz?(+Pi0;2x)BC%6U(=tFL5G1q=A@zuU0dVRC|M5D!i7G^dE z!7`cKM29_Q!?bRlX}X_!PfTC8`I(0+t*3nQy=&V9SCh6}5j-QF3}u=?Zrg&b0)C3` zuIJ}{xrzo4d1u>So4NvFRm~|k(gDAhS!?MOgecFdwt0E_PQeSfOGPms_`MALi)QY@ zE5cjL7Q51EZX{Ta;HUyxf_PM1N_1&8LhQ;XR;x&8u5XCY z7_NAs&PW!K$UrPtL^?(s4J@Eb=NHtp^N#XpN9xfKbi*}z=U!Q8|FG{khvH|_{{qJ8 z5PY+^mlb~wR za-XWUtF+)r{eswqME6}zt>-CZH&M3J_*%e3eTYH9r7||2OWg65`&*3s-iw;A zL4g3Ryqd{UPXjQ_f>&77cM+f)B{v3^G~iw(ctSz5C1o5p$=fXcFp^dp4! zjvsOALF&~$D~KF;+Ik(VZOKi9Od9=`iQt|`@ckFC)4Qk)n7Ko_&& z|H5y^8~!bT3iFNxS^~oxvew;9E$WvfbR*DpQ~%3e>6=F7^qpc!1Bsf2Rrp@)5W6CG zeNnx$+wYO+9G;@Kyb8{}-_tm4jC?SSF=VT8-t3uDEs!}$CkehzBm8Ud7W$!=)iz2p zj95ZaHwmpA@ZHT&44Lg=56a<;y)PD$89AD}5%|hC1XOHhf9r4FE51TWhuUXjX5$YWbL@d#N`YC2tWSU>T(Zt|oPev=wC z>1dXU_HAXP7zvLxumJg95!ak$P0uN?l&-ioG20}s>Lagg)}OOw<(ggei;LBonOP-P zQ~D4Vv729BzBg(ua4_RcQ$b(2+l@GyZ_Qr9g7Fj4LtxAB0rqQ3?1(>zJStX=cVhJ4 zE-ivygVG+~jQd}z>eVlU`ZP`6AZP1@wJ59eD}I3gnmq1XEf1PPvCb?fNtfuW4zlwr zgd?bGGD?jhqec>A6UxnIsnHW0Qos&3$M7Y$6+TWB;0S~yZQs|=R@*)?+@~6xvqzea z5-7ZP3Gx!2E~y1q6a; zlExi#0DuR8Zwn0o(AbG9&5C3XW&o(TKS-zkS~NjpuZ}D4w4((VoPj_Y=# zpAcWNnQ}|I3XE6Fg?9bjxh4UmPvd#IO@}`Q+yGfxI28xTStf%r-3|dd^NNUr*YQ=@l91gJf|Eib^CH ziH4)v<(}$|MX-nuT57)Qi>eo)DW@+yF)HylKX&t3mCi53Jm*}?@1HEY0!NMCB?1d> zMF|afGS;Z#0XLnET|AJ5**#8Nk@0-mPrmz=@8XwUj$q#luyNb_^h`&ZE<7~=fPmsG zCf4Fm3STK@2wyrJ4uI#ERbm+46AJ@sjG8VDiNgnD!2m%aSv2N@1))XgP|cWCR<0_U zx;K=ElMPiWPijnfz-9fWVKS@0Ju=A_Y;K#r*v2M~;u4?qi`?SiP+K&gK;HQ4 zYu*S?ebt`FsgMTFs33-$Kt72F$Ol6$4+~C}$aMDG^YSAvi7Z!jz!UAW%S`bBZFNi(<_` zN0U!fQt`7B5=@y=52tgUNJ12{)o`Uv|8hUMO2f6EU<2kwj;@#SQR?wzbZ+aWZAZ6N zO5Q*H`~f8O_*p+@yKRGLB2E;v%bTgiZQ!Uk0H@U;*IFRYDTP#!Ic*u07^@DN53SLz zc8tu^AkOY464r8QJwrg5MnLa#a}}#yL;O`_r!mV0gFO4v7j|6eWyfQO9I z@>8+6{U~M5eh4n)kTg1%>^p#9fW`esE(C9M!s*`RD|EO_oC{pvJTiK4R6|+GKL4TN zZJzhTZs1;|im?Dy3tt}dv>t*eOG?6dO(m91Vb#G?19% zQ^BQ!V-l2sG70}!VYxJv=2~;Ak_XyZ{QE%lWxv&{x2Fa9$NL21>osPIZ8BQKcrc^vp3Y;rlqr5Bob;w7MOx5x-psU#T@P%xi zi?9_K*b-W$f4>hW()5V<7#g##Srs-#REmcXhHLIsGF(}q8#AJ9^^o`Q4*oVXG!L4f zbXmTr-shw*X+P~~jeW6-=RTS$n{hl+^CmT6_1M)7g_li=M^lusRn3GkPr?Xw<*Lav z?GcPkB0NA}+9a1&*bt?)dOR<)&jDD_MZHd{Gwe?yVa6lVf{OH5VMdym=Y|J+)JRaR z?4NKbp=&TQsC*#_a0LHIh-bq6fbl60EYSq1`_#S(eCNAD)Hb{I;8_sCiRKju3tu!U zA(Y$f`ZXS95C15U4oVprne~(=;$nD?U{brvkg26%!WzBvFPGrl{&K&sjz!U*Er}|7 z3hM>WYHRgJe*rl`$ye)~^=yaWH5Z3(MS~L%X}Ct<3wQ3qP(C2JytQy$foH$o=j8xy z0GoV7t}P$6yASEgqW~RtE{en#`Go_i6lw& zj^F==aS%WH!66Rd^>J zn|5U5Zx{L@DKbL5@_=tZAlL1bR+`b6EiUnfgbvb;80Obefs#K7w40Kn>O-+ild_AJ zxTe1-HKl*cBnM(JhVGH`3Ku1h$j7DE$~v*~KF9<3c?Cwh@7W>ljz82PY?yXm-n@tA<}qMVse^fCrdKFTp#rCi3VK7s?eKOP8)vi&RT-V;$h%pGF1;bO zy3FANt(fQVRlU@G)AOeg>(C>)BJE}#S|bRJkssxTT4*3MKh;v|)~Ze)T#8}HW5L-^ z22cOUMuJYOe->G^Y@ibTLjEwgZc07ry{Ck7JLyg5m2z&X%5%S&I^ahDc1y-g<0%mG>z#KKl08pr$;8|{EI^_<&i-NEobD9F)hq| zJkgB_?8*+jT8;)wb((Mfb1LgPRMHC<%|ciIP=9OMt#z%v6k8na}P917$m z%vuo*FPx5`4G;7#C4XZzP$@CoSWc-_Y{SIgP12E>GfC@Vup2wl>|w9)o&)FzFp%c?4PJE zBXSr8*L(N$X`z2&)7;MwZ82~e);hYrA`iCSNDr0cA zi3p2{G9AsRsVXO29m;WuS&r9xm|vsJj1*)5wN;tA74KnJ6he9|Tb(Ymcz~kbzHVb) zY0=t`qd@xtA|Bmbn3nQGO=YPV?%K$zag0U~fIayWFH1|0ap-6snoZ?4QdZ^(Oy|i~ z(|`ytJHBhPLSwt)uQFO(u*C?MtyPyTZO9mR+i#|;rOrQ<^W(e>=-d`&PPD=$Ws%X= zB7!R>Ooxk&MeY0)WhFsP(;2%3Lq#L5{vd*2Z4o6Dr1^rosa?B<+hOr}++)7?-Q7T? zdUfbmAu_Lpt3(nxV0AoAk^S&H4Jrj%4^dJ3{PSwy>R$F6Y-plVBz(}d!*UmLcz7_a z5Odlf^zSspJ@pdG(LpO+cTJHcRBgyZG~=(*ebONSmY-uXx+s=%KPH$fhISuf2*B9G zs_C+6)|fBh1yYZsjgJ?I7HS7D86Y|Fm%pQ~f@+A2Oxb0L_{EYfHl#Kg3IEXE0uZpr ztGlUK-O`Z5*L}nZ6oTR^7kylVBLIq<540C_>JtzB^p*?N$>z;^Ecvl(?QSpInB3PB z-YSoYW~;j;B%)r7G})A^QQQ_-XG8bd7cjo|P#znwW6idl#t)wUq7h$!ki?9=P{+r? z!jhBN1I*hFVe@X*PRR8XciB!Xmta{JoIo~OMIs+7esekCjH&&jY;c&&NT3xh9dDFA z;;QvJ&wZ~JYfvMx$N%@GUf%MU`YI#uiX$=O@gOE-B&JBRk`_r9wf=#L-v#sj^ogoR z;;1&&!Jy3;3~n(o9*_(W`TE*p_ns33USruA*R~}8SQmF9Unxg9w;I4$*L}vBFo|6< zx)FD@iCGviiTx-%Wo(Z*$Ha^TtF@9zb;PHrOr3YNLlncyLV-af_xS-aNb*E%&bEry zUcq*!&C$yW<)vd{Vb+h?y*smzk$kgRHvZWH6W-eud-_v`B+7tO>*RVF6{7@07I!8_ z;=MQ=2cjFq3r=&OAl6Z({#PWM{^i;sTYX=Y)LQ=p)t|^|W@3i>yhSqJ!&rD=hdw1m`ssr!BD z?vcZ$Z3I$TE96rxiAWdO0&4o&hiH!cs-tGK?oK4*lgH-IX1JpaKR_19Pqfc)0-)_u zZVmfTY;koPvtOQvw#IdqG&AFIT9~U^iZSYUebt2n+LF!|a%?>z<>}Ko{n4~-{<aEJpec-oD#{56``Yo@Gc^tcl^w-EN2E#zXuok)pM$}D`DBj^ zPk%GP15fY$uQgR39OB}8aX^4JRUif6C@;%MJO|cn27n%%0*440yqbeNu)~gbP$8MXw=!d@S)mbx~El~`yF>H-O5ZR)-m4gKc(v~1aT)x z<&NL)hNBSQ=OZAY1PaK{ittS|1XD79AmCiBQ#g5ryFB?#;*9UKoS$u3Pk3v&5|P!Q zNFr96bC2MO%RV%n#pb?y_c$TMt^m`+5qB|y?VFjkq}_dqb49g)VUVcp+)GHCSOeew z7w5Du_37sMPQp-&x~X2woZJ&}0oYX6!rnvD#MdLiL(Ws=4O9}ri=fA*h!mh^kr4Q<`kqp6Km2LD6HX=T4_@YR23b%Sblj@hdOl^{Ct~(1bnh1&H7g>?0ot1%UT^& z8s(x+{P@myBAY-?rNZ>EG)KCxCRg|IFOg+0eL+AzblL_F(T|+^qeApCfZ)ySC@w}Z z0E8nF0(;a@N^};{!l1@ja7YNLnM$MxDIvMwMJ1B&&?2H;1wL?yg+GE~3CEL7$Jv}m z2uM0%zF5@xTLXXMxx4NZ{!OWjNR=EnYu{JagK{J`*b8Rt~fAtE=O1n!h@8f;4 zp*-ePw{2TMm$C(aXrRK$CVv{`2A@-}1eoSgD3kwar%TN$N57>m8*IB_0~?c`gb#;% z0z`_;$2PM=>Apo$H>xW*ZwFG;(3d+@UyAm4fnRFCV3H4)_Ga?xeuo;71ln^NTF7<_ zriaQht#wBy7aLOb&c*=kL!{1N6QehV>4iW-3?|bnmifvX>t&^P+oMW9KS&8jP%c%B zrr-szi|Nr%-`WOVU{TauVF=V<8q#i8>#`1-=Q`8Rb*q0fc2nh6)`v?zRpPE@FM`M} ziQzoA60<Q@b;^9jiR=(D3Z)!#^AjzOyrIDO`+Y0_ci7Qm-b zNn7S|J8R<6Oj(j=HZ#!xZmiVCcQstG3@o`^VPRo=*nZmBPU<~g_gkeIn zQNmKlZS^=-OKeqmaoKdr$hBoN$&~C*xqVc>~Dr$L768X!2FXuHW58dutcL$f^~EcCew5h;m#PyPxN^=yI z+4E+ptcY)Ak6o6wor%KLS%!IVhu6|RINDUJja<>SI5~$)p7r*1r-pF;JD5iA)CBh{ zR|%DNa)+hWytG4nCI=E)oMjq8F`JlhJ3>Jk+oNZ`qMrYDO^1)9>bihbLPwaPHZ#W~ zeYf0F3lNP&xOj)0Yq9x@#eJpVJ%^FKkC(TD@wiOdU|?~IuLJz{&;dT-ymZ$BU%uDA zcx9@gLxwsR(?l;YWKxiiDeqdLxJ*)V;&T56B=jONN7$7&KUV|&O`qt98Z6GFTX@2CvsN`=(55KTBqqj28_?oDu zbKG~jM4Dp`wayJ2&C{uF8{?lHYK9BTM@`YpX|4AoC@jp#6e88^h1w^nrjpV%w-nh? zo<(BmDvW>IH_!xJ@RvKQ^eXV@%0>95Td7Cjap|FYPR00pS1I-`BGP0F@5kuLJTKxM z2y(Sb#tQ3j>sRaj$_x)P&nC{5ojGzAmaWTODnR{gaaY)zbm+#pPkd%Y8O@uq=;}3d zv&V7K^A*9W!gmHgiM;)p5uxCcid4uv5^78B&Qhj~D%U(&wKV-=E5hbNx8|uW(mbg)KJ1|PO2jV_Ubt!}j758p&MpCR%9r+BqSIJTTW*Xx zGKqz(E)^RP+ zp<&TF77Q7>mX95u+`Ql_D6Cqpm6fdGqg@ZQSWPZRDp0S&ogLHFm8_XV!sn@~Hw3t# zlEwV(CkUZ_EQE@7StO9x@y9T+K!=O9IX;`>Z@YlRZtfdakG{G#HwY5Smt1*hHdI(Cz&zTjnvINb zHy0Y83~o*lOM;MoSRc3QO_j$pmMAyINg083usD zL0%Pxjx8+4(P=)|d4si5AUvq|%*~GNtcn3bHHsjj1Uyf$*7!%Lj8tSV@p-K&*)1P` zCV;zRQyWOyv&PWYucD3&VkfC?KRG%0b5*7-;np-)XO#kd;evfy$wr`Z^8K`2hu(5; z%X3>vVJJZE8;ScJN|Gj{W~{&G+A9s>LBv9>fQ&J;63-^q6wwuT2(zdZ<3`V9{&<<; zU)xCKUuN3d2(?a(6+9DJVu?KEH~GzyJ!H{DrlH2}>6Oh>luq(BB=VUR%wf>geULAY z#{%M;54@=SF&ckp=BxF|93y-vyX7h>6tok3EYBD?pb5?lTn&EK^xg76{sQ=v}l&cMGAA@znEEw8ve%Dmkmsn3SL; z(zNNv^|L2xaoxBx2PKb(Eu2kj{y12ml!K>%0d_3NhIg&_TzI6ucfLvUKac2fb*)@a^8EYq1ruY~awX=G zrc$C#V-$ZqE>LG$tp(a)NEr#3@j&}j|Zxxe3C@52?0ae5JTb`B{j{y^a)%{Hm8Enn4c4YA9EP9V%p^FI`Rx|p z(M1sHA$nc$P;9@}_w_$6?-@Us1ceBT0T__&Mlo4=Ld4+|6`c`(AyZ3W%Y^IsGrPyQ zWi}b=5kTk3dk#fPazw%~NBtbxt)IUbYXbFLQ6Oy z;2yO#K{S$TwFs(>)uhm8B{XFugtdEgJP)GJ*PR=u9xYLk$F+=RLb308Oqw$-$h4=Z z3RWmx0axL3}_&V%uS39yf5`|}&U?CM!;;Ib^vu6oNClXb;M2{@a zAz#M6mWs!;hr#4oDZO;`_xE4r9-eDZ5SY)iwa=}Jq;k-pkf($?D)iL%4ZEmfVk7q< zqiv1*`zpd0fYulIDhQ@6uRBN)_0ftg?<<_RfkM8=t{8_2vd>qH|L~ z%G}f8n-0#eixD<8JTEEPH{6nB$9Ptkn1m3y$*^NcM<-x5g}}fH!&c7w_R-fFwsR6D zZkUNgx@0rJ94zT0u+O;SS0Gn#5mk>H7&bI#S1zZHvg|PtY1E@>RQq7Ix<<=<_6={I z2T2W`Wr7Z6)SRbArk`+W1h#i4yC_8^7yl7=83G^qQ3O_0cBTyeS55#>%Ls_i_N5P& z04N(jE}5dYe|Dakrr4(Mr{c~iQ2I&)d{>?KOk`n79S*yB1UZz;sWZ_&IBo5*4GQsm z#%_@+KmC2G50sFgU9U_!c~MPFQX-A8IYP|eG*EU{j(*T>2B9`gXsMaW`3JSx#vWNC zW#xs^GxuMzwD*p0#~Y6OE^IZ`)?C$5@&V!%swZ49tZINp9!LSB#zl@Jtsj(JF3(D@ z?y?*!fd3k}GPJj8foC_$UHRocj)PIf*NOoOVsMHn;}$Jfv#?E}RHqHB?3GMiy}8UN z!()Q>_J;I@P(lxt3XBDXwg_Spg^DVpU2g@H2$U;8s{72aj#abw3gsQRStpak3<&PK zW$L2d;T@dma?s6hB?BR?H^1{ z*O1!lrBu@_sPeR_C3TsdT0bc9+|h!FvnAHkW=yCha&g>j&WBI=>9BJ>)>8R0oAaaD zwQ$e=y3{!SgyM`h?}+Y{!1S%Rn6UMCL9=nY)ghg( zoe(NSQmaIFGNit0=spw&w#R5vc5hp5eYG#1kGS~_m~IUEr4 zI`DoCzLb43?2{_I2!1S;8?iy2b`=*#0nrhgVv-9FRp2tHneO70L+D~a?n_gQK2!3@ z?mRhtVjuxjMo+I1q)K684Bay!1P=nlCd93iGZDi}Ij6)|j$y95R+%+gjQ9^>|7C6|hzy;AugsuWVKlOuP8eABa&n@rch_g-!Ga zn;m@ExG0De0{66=bE>8beI>eFOl=uogj&k>J?LiRLSRri(%w-V+CirAW}FnPHs1H$ z1d_s|&}0-`I8^LH3-a(ob1A4FxrPk}SqJ)#17wj6KIdGVHF z7#X}gPDZV|O14E$WYpegpLNZepL}VTcTPSO8t{i;vlR6HaQXmVaqqsKt(uEq&4T9p ztjGX`*vKeF2t6slp{*>w|BwYO##l30=;IcRQRC78?M)g<>~s!^hizJ+(0$4u!Wc(z zSo$6Ns8q^#1WVsMUfXU~PX9Ca^oXui*{J^%-i6S{m?G zu4z!Z>|%;_oaw%-QW+VIOi@I3)FTiyG!c?aQ8USL@yG?!SqyumX!wn(GS{&dFjXq&59u97L8tGoU?#(%Z;lRuG_pdAPAj~Bzm2CF*Lgm z^d%RXL&-0;tk2Moc$J6$l6!S$%)+HoD8RBtXJ&2I^fLlo^`Wg4aeFvi^m62AL9KDm zrP77EmK!ZmR@~-_kvX^`eynHn8m#j6wL|CnGx(|`@Qc-o;>Wgwb)ko{D?_^2J&viW zxS>K`sKkAnJ+AN|`Z99N8IkIHxMDJ5LeXOatC>{`IzOpbAg?|c!k#8I`dVrhO(=_dciD7ys6>ichVItI$+%CSzzao#UniM~ zG5y42G3HvpM7if9B)m>CNm1|3ojJ|{<6?Mn(eDEp1;=$MVN$C*Az>(8^@*`h>wCDx zG!h9KkZGcv$7O|uihzIF5{NZEp^Q54&zQah!|g_?-l-^>vk(5)>qVt6AT-mLI?)+S zN&P`OWw?9XNxy$vgkxuZb1|(`T~3u|a?+>T?%oN{r7~(t-IJHw&mysN1YT%q^ka*| zr~2(|JPKzx_U#)Wq>9!Owt&kOxWjpW0dKWTuCz&o+c8OEvrmP#Z!y=MSLeiBWcCBb+K zW>qi_2mC%HwHR>LRXr;N8J8gtLs(26Iwr!9`+*w?K}rMW>_qiw}fNJ#QW7AF=7#5ZnuD=4%wlOR`G?EhYe?%J{48CGcQ=3 zUr-3x8)qP5Ta%BT81*gpcQg*VL>bYend4f{Hj#w2U;@-vYje6v8JsVhW0z@(UE{jc z48kPEFa4f0ooAV-6QwPY^d8V%&`z@nR%zZtdQo}R=K_ym(^L3LGC)}^+5!%318dfP z_9#zNmIEOH9NatEMvbc-k0-CM)^Phl3+`k{uZEt;!;U^Of$l<=!Z83?b2=nc$rM%w zULGR{F3B1@f+wLOhA-Jy__ld0PNJX(dbX+@Bef!W< zDsDI|vFs2ZiAmY7FtDXV5s2roa1iK7Sbpj^?NpKwwBh6{`*x*r%_IDj>Eq1(k{6Mb z)!moK;Rg*0-bqwb!?s!9wYM~@4pJEUp*T|3*DEzSnrx1knK4N45JxozCHFguH&j!3 zv?5Cwn95;qVSn2Meforx?I=)dc7bp z^0d8s`}c=$!J1OysEu*M(aJO-B~(kjS6rMTSP-MBwrdJ!_{@4-N|{Kw&l{$j_A_|b zx_cRnE4-MCPg4qI{r+PP-x`O@?Kx;w<=xiWj&rZ}EjCEz-wi~VfuFSnm2cQuNFF<8um#XIB%s#~~zOrtZ_b&&S zeAXh_`qWU;0tPFI25sGgZ*#Q3T^(WOAAv6!015%#ftOiekv`g=*b@FtXdFSlh$dN8 zT#89@?^{NnH7x=lyceCtVo*GOrKO&5nHK>gN0NXQ$+h==e1$65Ks&*nFKcuQp*6`d(_akd<6~ol8?O~Y zcO$A5Gpy{Yl#wz@s($$M@n=lXpJpokZO|ywnmIDqNcZTTs>1J)C*Wv~mdq`Y{o=b` z9XK{kidcpkgm80e=k^)MSx|NKaEo^}xvK}+3os1X`Nm{Ymlh;@Y@_QP~$ zh$I8|7azY$-dy0AcGJo$T=2tE-tQW0-e-RjjSU#&C?dU*s0v0kIJ%-wFiHij20F`$ zZ`|OQlv%F#_e;|6@0q^Y4d9nEr zdSU3F1T5m_ylA+H_uLi(m)#Njuk;i12l{pb+4nU{7tUNo74hw>50SL!Sa#oRkPgjt zsYkc#v1l1_O{vD31X-5TN4L$@&-z6&@Fd*RdAMr(Kh=50V3x_Gja4+czvCrl=Jjy7 zB^
RImXv~3!^1+?mnZTD|(43OwI55Z0Xt07LMN1#TO?0o2eO<&}Uo5Z!$`@7gY zl*@`DRop*yGzqnDfrC7Mnrxi$U0esbw&|IGxs4FNS44yteo!t@Gqbm(s5)7wyaek& zD7P5SB`y9P5u1gaoxJlm`f+*IAfA$Cw7IDS^PB)cTwxX$W6R^zt@J_DO51Vt7toE$ zj$Ac1*1J2&-Z^k#h}G(@5m=4{WvPTxcSWj`+vu4s=jzGd9y>bKUb;yr@5H|aieQ{= z(L*=Z0;+qro5h8A7YONM3~!|mi~Y6j)#8vQLHShMfG_Xv7u-iQZ9icFq(H|}xYXDH zax1r3#k8uF#xI5Eke*m7tuQ~#+;)PU6cWoQAY?0QPe0|*(%ejYIui>r`VTf}r>ZTg zVgJ!|T*>^zrD!bwX;hUgV{U#Wv5wJDv0zwr$(C+tgZZ+vaN9Zr851 z&DCDFa%?zeQN7_wqw+_|C2N_K*Tn>G&D$xc`R zr>#;5rx`LbSBMW8;l_>b84xN7lyUP4uslM!VhYDZ3IRE!tAw(miE1%bp>2qNg^u;#R(mZ z%nc*tRc^d@CzjuRog84>%aGMO1VU$u5_mN$#`WK!O?A)B305)6wE+I#0XuDd2C`c9 zJP~baHKHPx2FfYJOnJn4R42>HO#NKVR@;yBIcudN%*5>d77#WCFh{T@XULv5L$+9{ zn*9PVYs;9OPj@)#!8&CBw%uPTWl~W+6Ekgt#Q15Z*SBKhW~VlCsmv-^B_eA&jfmqO z+k}><VH##cUts7K zSy4pHXyK#k(X@YMn^-93K+-1^rg}1>0ocjOXucGv4OQzge7V4CNx-IM{5s%`xq9y` z%cwSz39VVe?N{S!7Iw34KOL$-aXmd~(%|k8iFaligx1;H(JkuNU5=wuH=++TwQ{kN z$V(b!pa^-bkI_fNpi<96<&u%*L(70PD;6r1nhI_82yNZ!rKKe^8#7E)ldR`f_(UN;H|=DMeCa>}&Q9-OJ9e-EYGjp43o2!F!msbW&rj;qh(WyduraNKIx*!<-` z+R15ST2{LDaj^dJ{yOGPcPNdK@MDE5U>uSy32XNP19q6(7TE#7wy1gZlB@uW!6r^d z*NcybhQ^h|u$~o3CGr)>#C><-H=9&Iyyvq=RcgV`7>cGJyz1vTc1F2~^(27d?uwG5 z;2m$bHktl;zWQ74%_nMx){xmiMBarba_8u)v_jmm@6?)0U+Sr_=UKD^*<7_3ZC~e@ z@S7xiv?*N0JF$9@yjcX2&EhmhD}3LGGwb!bTG|~`ey@`R*?YN)_tj_0c(XHeu8X=k z+sM*G!6{M6GGFmHK|>{0r@;{HOuF?5cJ|Nai%I6&X}Jh<1l*1ec8uD!dRe}_5564= zKL!>46-2Fh)Ry81sla*QVJ82D1e3PB-j|={{^Qv%iJIOG+t>gUjB{y;;lE$#40=CU z1Jiw`kHNR6l06wrXaKk`A??toOmZ9z$_n8uu3GwTvjl9Xz#BGzdJ@~Z3B zUc8$VPpHhvFHwg$=o|DYz62r)ej)u*v=s`$IwcGa#oFcHk*?opsSnaqNbIPk(#&Gq z9GsLRC}^E9ij0=(%o~!Gn*UZI>>eZEJIyqvtjMY0s*U2bsVmCqAPgE#UFsB%aEAN; ztZm(D4bw;Nd^jp}@x08IXqz$>Hpaj#AqbO7OQZ@xa1o*{{ro)XRm>3TpeOxf&k0o~ zdCS1F^`q(kdr zZHmnG9=DUb(nKrW`ev9HnMFatXFv%4up7hIN~69J!P1q zHSH)vShRIC!x&}DDKQChns~dC2ZrC7T81Q{)N+WU1E#fMi{uRZ_>>%N$8$DJlGztm zgEn!2GhaA2>`QJd!hXjV$i1zeVt$Nw8R6D`bd=6z=LeBW8v)|4?L2Vq$z#GXnqS|u|BJG`b7aAmF z3Mq=&5JIWPtEyj?(<`?JR?9>$eze<8Rj`F*_q4cZpjmIwbFhOxKIp9z^j0ea0+~MR z%+(WsbD1{Mm5BJ|QzL9uQEAyPL&Jt42+9C7QScBER7`+YmnJo3n2J|<_DUQ&NNhwk ze~GXZmTb|2U5w?;0QTCS{u!|;esLwurcP)iLXsAOG37sniQzmh>=)+6?t~5s7Hv zj-7hqjtQ!$?G>z8r;Zou5-zCh~K0@GUe2Y|`vh zuj|^%$_i$L3BFsp`27B}ckQJe7s|D$++GWSi6rTQcvFo{p%dvfK?f?WX%h^H9yH9O z^nqSQ!En1>dp~IS__5HN&bOq5p%S1;!!=OekeIWS7G*BRmP7Abgd$Pkl+!G?Z+cE2 z0~Ny9$@_`3x{TBxc$v;sFgNmtUnh0bIpq@-lIr+prZ4{VwTFbq6B)WW6Aj%urSC1` z8u?A5!}EC+{ssQLj!KG+)|6Z^ERYD1V*C&yDJ2-Np~akzQx4vFJN$G(sTTL7v~nWs z-xKO4lggv$FCR^I+Lv$04EU?k((9rJrEq>}tf$_8Nv>pq6^7e9uYpH9Zneo*cT?>&BhuN0{S*+aYHmTEn zugQSnqiW(hKwWM_W{%{=1c+KJa(DX!1kwSygCz{s>pQ8#@?;riPB0KKNcf#niExuS z?J^mBA>Y9LWf)=-J|r2uIi%ubLigdi_>AvY8F(Th)TmG#xN9OB&9xzkgH|c$t)PqVLjD)p5C)lL77(i2XdL+pX5e2r$6k^-k*Bi$thmQnSO5?K~p%*tm2E z@)brsM4NH{M_dRTNzj77JZ~}kcRF7(@YKrw&VLJblkWUS5axwTR?pwpG3XOQQp7w{ zqGH!icj2hQGsqudo+6@;WmQ_O8bjQBW-|&!#G4~}F=NXZ>Jb5`rh9(nU5rK0IYIZr zb*f_)r`8D+T0oln8Q2q4NoV1{71k0`-Rb}{9aphE&-<^n-B%YcY(NiXGPn1_g$Nj* zxvcd=$$#0657#`0zNs97Cnb8ypBa6Rf`FfU)Q{^2Ma-ew@ zJAX<~m*GTQ%AX>udz=I^mYZE)P*B0YP&4MptFo-Js(Rhcu}LUtkB=~RT+doCGu52NUE9=pjb@BZO zU<)a0ZJy1o{iH|d3O*sAOYiUoJ-t+nEoB+fKoP-JHZgips^>9QCRx;=pp+r7Jm217 zs>NE9lVTh{T|`DJGZ*~`N4*RqW|G&EgMu;MMFmo9eA}{Rwe(*8(4ip|$s1wd&N+zp z&Yov`B~Jbz>*`9OmLQLY3?87BG*q|PcT2MEvqH5?h072lexrKuu6@~?1-6%hUw0QS zXJ8`y)&CjfW}Y@4M^%=woBJn)2ZqmKfv`B#YpCKBV^*UKjhj@7eDquurqKBDyF48a zifuyWTOYNxqi@tVQsrQMZW@WzhOf!bZr0YO8H&>uqt-CZlV$ppFtkVFHpLnytCacw zMu(*k__Rdu=%DP%3c&LNPv1myYl64nGww3Pyc}FrQIGtvZQlvS+x^i%r^kx2v~J#zdxI?pcaHLT>Wsx)0(VB3 z-(nn0b;BmiewI5o9cjd(|1M?3BzLr{!Zt;!s0A3GuMIg^4dWOdP2@6)Yh;^{4*ENSu03!gv$J>4-GkHsA17Kn_*b9X z*=?pbz=*alEbl+$lS5e`LHW6f9m%452_oiB?f+qLofF*EPF@3f zNtHX(%7UgW5WRL01rY%^iYgV~F^`eF)G~udZAXxXqj*%FIu*X|X-}6JN0Q{mI!<5U zOrsQDm%QO56?(iXezvU8SnAiwJ$Ce%N)x4yt;fpJ$T<+m&gO~R@>qk2e4O*ctWaB6 z*n?JUxHSc{uhWpFzavnrhthhXg80=aZWTi(&q_1GBmwdi?$U?5|11$3prcr6IlZ-FPQi1QPm zCIeImB!Fgjb2=TDZY-0B3cwU051S%HgEy2A9%d#JDV>3y&?mi}DPIs_ijUZyuEDd! z^HKZO)sgVkiDM;^bRQShrL3I`uW`j5PWj84>!?p6J>@`seIbJmV&3g+T{_cqs>)b3 zt4;&^@QwhzII%!gk?l#XF^X39qDOPZGE+O;TKR4u`nqj|1U(0QHr+#cq=ItP`FBPi zhR60pt|ZJz)W5}#Ja{p=FceIR>Tk|@J80D^e~03EA{RWd z8QoC}a79mk<$C80Bo^J<_?Q4)ek^=^?ajQ~J-7;INSDV-3L}e?AcN(O(HcUE4Rs{K z!k)F||KewZ3=s|i7lwjkjwKa=*=~15mQbEZ&;HjTLoPwIR(>`odfJ5ZB7rIPmrbD8 zYB_d4wT|=XWPFU^M2X3*${(HeCTISgGRoC@wNk>*tnob3Y|ViZ5a>F~=!l~LeZI=r z*-ldI=A~yCJBuUSNmvB{5Tquu3EXdL9}xfM^L0k|E1)EQjv&UzjIFz$-=i#YfNJgSO|o%Qb;g4e#K`V5ieL{sInW z3>0iUaR#}@l_yONb91GVPeABG<{mTh#flNh$WZms>?9eC&-$foR*5~CVY_Rhg4XHa zfCSTqm5CHbHsQ2f@dt?G>!j4tqeVCSonb*+%Z6&0dI#A&Dthf?3i~XO_n3B+K*%RTGpt_1kE)1 z2pyixZRV8RR9nEPP4TpBHBqj3Joy_!tvL384N2Ik{ZjJI2m51zUrF=yf2N-9SpN;H zPXIU-w|Re6#h;93|2Ik#b!>3Yw(!aw|0j{_c;e56JXP;23O-Y4=DfLepJF*J*TRH1 ze;g6VoG4k7#*)4mO0tH!5vqC&ZqqqzZ|Qt2^K^6B;5a4U5Pf;a<+!W%-UAm{je+f% zX>Xm(# zdD&D2k>Zvz7A_SFEU6S&f|44`K5fsoSwciOYD;TmSp?JlXk=WT(LAcne(iemdz-}u z`gh2ldz3Hx{!lG=+B~(~sPYtXKjYu=cs!eUsh`)dc4NF=16C0C;yG3BFfc*eImVb< z>K#&990d4jJlmBNu8>++1!UYRwtZYT@aIMHx`6u-a7AqbIbY{0*+Hksb2iN)luXOh zP{NuK<)ZR5@>kqw>_*84sM;8YJkR^u7bhU z;yw5Rl(#db!4LzDrQ(7oVQ*;;Eph3`m1I>aK6Na8Mna~P0?UmC3z<3;Qnv+2-ZnCb zApZukX1mcJcQ^sK%=JtRq{@dCGvN?c7A1H28s#ES%-|aPd|^V|zH#C(Ar`wU?y;Jv z&rjI^FyuFxO#e==a{YVh*7iDVrXMkTNbiW@$JmFco11ts;8uRo+SKW)BxH2$iYpbL z4rdcA$GB!$_gGktsi#&>9nuh;Qz&Ve2__IY2kW~V96LHhS~oCs=1 z)w+6Z3uLEW>?dXh1Xr`%kpy^RDrmXyx2&&xO>+k=u{bRy`{gk0m1j|FS8b9 zbYZD~xsn0rELZC4dTd|B@J$NJIaPO z7qz?I+u$Sle!+Hy4{-W0q34}F?&LYJ!!ghsUD%sM__!K{{BooXUllWh-kj~)6ht|< zO!cOCr)5G%nI9;(p@mh{w@9i7T`Y}o(UUd?c}2xoUarEehniDB)-k?^+4E@Z5oRfA zOW7f{e@<7(oV%HRVqC^CX6V$4(Q=dLz^m@OBM`PqLo>a01OeZsP|Q7DCl<3G*zk| z7{Asr{z6-M6TOHsF?}d`H5JQ!tH@Nhh%vXIo2#ya+%dK#X6jsKDkEvQ36?c@Ak?_7 z(-a(ZNp!yeEpwZ`1cN^I*VgV9W;-M3mZhjdu_7`kn6RpipaLI)#ISzye{qeW)W@i{ z7K1El&Gkuu*73n2vci=H^0`HSzSraR>eL(kF174t+yiqEZRV@-GnSE?kB6hX{cVCr zcrixS$6Ep|&fG9g<(ww%ns zj7Qf`Y8^?gzy>U?{MMG2m~76kXPCTl`f;Ouo5*%c8A%#+uKV%|emYH{$L&1O3%IZ2 z@fLXj&i*jWDX-~*6w{_#K|3OP7sEkMA|KA-Z^o*WKZ00Zs{@q9Pvp8$amg4fLRLNs ze8Yaeb34_IBKzuE+=e2kT%NOeX+JrN{+N=~#ZZ_T!y4s6#A-F$o+YS;L>XyWLlAWS zDP_DwEldz$*ocwkx+(elcBExm&t>4T`5*qRkQkj_xS?H1o+-bSc>~s0uWKG(c8@{t zzHHR!?H*uIqX$fVEXo~AeBa?2&Ok6Q*cj%a3)A7H=A&RvH+rIuOM2 zw^TmGcN2A0g3Q{_-vogfV;0}&IDrj=OQAuKXOxvi0-B-v=|t z71csvwLaFhRY}uab25jOs25@!m$X&P>WqR^<=GfMXEP!fZ?k<8leGC{unNxV$_s1d ze5)|FTnCh!PkN~LwjZ4R_RzHhyzEmdX3JNgNGbm0q$hVlPuJ=qQ?cBbowIjgj91(A zn*Wh63i^fn=|NPuoUjrV=HeD4&)*yFPvix$hXIz6C$d zC(l=y!i^6>IWz*(Wjx3Jl*Fd?PMIF#zp=D1>5vXTp-qn|YaSO^RJDq;iLO-|uXMwDsvN{LEw8vths@E9`k&nS47qQu<))!zJ!( zdEDOedEZzpv`s}hr1f}i(Xa2W24!04u=t~E5AK=atbTmydc_*;)@9O$xwZJw40e|I z$5?Gp)4PToWrzyz9e+@U5orWwv^6yvz2^4zxevJ(bgSRNVoPu%2MWRUidO`0{?u5_ z@B+Z20|~@C`#(=)A;6LgoSmSe{#1nh&YHwYrcIBySb-#+W54WLfzPL7hMJA-Zqj?P zDyD=E>Ce;!GQB<*VV3-J_MkIp9(`M7FH-4t>nAZv4R#SeHH`a39Jm) zg&qNfRB}pGY&Bl7x>?iBvQYK?1yF5-PrreIXhBYpe)Lup;kmSt&?1!2wcohDhaFc! zQ4U`%-)UBX>vTC*6vhw*1Bh2K_gun)gv^Flv^A$It4fI_2+>e_vIZYAQb zCMlcE-7mje2_5ZR3TN*sdF`VbMx>mxX@sNoX;)3>%QZTY`>s13l%|}$n<~)Yu|Ft! zA@j`}oBGgWZ+a2Jw4Y4ODaK-&13zeBZck?8MZIsM+9CgUVdk~z&Jws%e$?O8^?Ql8 zl*ZD*Roj|}2=&1jV%c*5)vzGZ9KusMV3FY!h%U6;+6>{)ArTRyNu*t?WzZ{xXcAeL zXXS?e3MrgrW{OV|od}7>wnMD}QRHaRZiapOLa_&=3KU6NfYJs~1ZQrU7D9pqjty#i zBBek3FSBt6+(zX!5~gmePk7_(pMrSfRYxy9+i6yqOlba&{yTd%Lg0#`X8sAN>A(@x zV96D6Vh8K3aPm;~e|ngNE3ApGSIS2h0xyMOk0Wdwb2lZ6(Tbu#`hq0qh$)}*7A1yz zg=mAXsmp3Fj92z!Xw!BaFZz~pDnZC`9ATT^<6b5$8FSQn!jFn?sq}1V(yb%x4($5< zbe#e9?eJI(QSZDDs@(Mncz+{N7&+2JgT|zYCDd^1vgQ8eN&cp51g;uuLcq zO9vzeDQCsvaffhKK%jVZk}FY+P=zx>R7Ixt_kP04+<|i+lThz=n(S>okaZ?3i+&|!33aJQE+Q*3q7Fz$FESB_Gi`!}%cmv84$oHq>xdgmEv zz%7#w4bHO0+i_1Zl!BP$<^rs*8Q3-r^SHrX-8V5h>TjJ zP29%DTPH%rM%Q~OSbpVw+6m=RRAYRTL>(+Fq-9hui`dK?S)}|@56^~sPQnMhuVb3a zbv8AKucuOYEbq7_u*xuE&N#UZHsRmeHGxA^%dU-5TB2Bfn^5}eu*+66>sU)Po8#}V zxUA0CqA#x?-OaC`UmSpig}or}3yI!7Q4o-GAUo@d<`_Cmy+0s*99lgJ9$L)oJl9K7 zJiePR!7jE^A#}*B6pPNMS7K;+s$mBoa$0v!{=`YEmSCpR&Wa-jAHTq3RsToDnNV#5 zm#ZF@aSpW|zbhyHzK~_W_Y;jtJ1_QL zXz(u-Ea`Re4!Bu6V{Q`jr&?^?D5Fhg)*ewNm*oVQ}k~3Jo-8_Y`Gusy5n(N|P*w1Brcp*7wu$DsQ08NCej)ghY0+rh_tNTTDP}xf&X~q1Z`G} z3!WU5DD@T&)(m1Y$C}G#&kwXIr_v{2 z6tGnZ#p=5tsVHaO7$wt3`QLyET;5Y|@uiY)&m8{{_ZUW_J5TriS`=f zO^Yx%j@qIbyaR4Q=Ps?wj+!>cWdEduW&e_6qEDQ8o4?F9+ptY zjULT;I-l$fSnm;u<8be{d=TeZ?k;*Edo?#b)9Ha{K#nHnA~_c&z*b~|MT2KXQEY|g zik}2q95EsfZ5~1f`EzE)BZ5lL9?$WctIR37i+QIFt>@=)0&^i4tvVG3;0`p7uL%*n3`sZd9LYw!_1|{Y%0Tmn-+Xqg)2AH_ zBB`7Ch2vQSv6&{OBx;EypVV%Tt%-bdwKatYG=E{UI}KQBb)(C3vbfYjA#)?;HonGq z3{weCS=GV`_)o(TThBjnz&d9;#?vv!R4Vn5LAS<{1+}u$Svts{P<@!5!&PqhIqtr1 zcjgs(i~7G!YsmDQPJE3>EYDDU-bcZ)mK&!aKMEha4<{UL9OoJ9a06a+5l(T3FEd?7~^N9I>hP;kYRxF)&GFv|q`& zq=N9pS^%DqN#i6uYPG@<@V#1auw+nx=pvdPch}*8AB!LnSw}fLBGWxEFo2WCdl^Ms~cEEPSaU>Z-DdwVBV;P3%9!U5CI8M@_%EaJ%sW;1j`BmE??^ zagNOt&=+F<9gMio`dPXsgIEnx8jtOwo;XaGaRNB_P6aa4mTeWYa}E*#v~)q*b$zf)Orb9g9_g1xCXLU5vc`l!7pp)dT8#?L}d3s?ZXxr_u3i z%2zi{Hmk(D@jtYMn@-=Kn1$a-&x1kFZ=i`l(edDG4eY+1z77xO3LT!SX0u$s%UO0V zc|9UWDFq1uGioYnMY@p)&3$x6^P`YhniV|-=UN->_oz?bUX|t$^!8cm>6a)tzio$J z;ZaP!)L_}S=tSeQU({=HRZe_=%ws}~@}!^;_GUQs3b%ALr_xRS^cI1KF#sNXt!BBj z6%s^p4tVP4-*1pOOr(;{bS6^TEJfz2y8CeJ>5RbP+PC_8Zv9KL;?|5;MDMlOf{uqz zSu*Bzc0@3g_lC`ERAl>5uwUD-viDg;TFN;GLt~?2*V0y-JubiLwUac~PPF=FCiif1 z)~np!J~jk-G4}27g1(H?PJE$Zjwfrjt&8!*nsLpt%^JD%-Pg}gQ$heKmvYT3s0QwXlM*- zX)zBL5}OXdWsZ*b%K|{AMn;{{r)q^Tif{3awvX;h#pl)hyq~kY^)x_EojFXVjSy9jjU^)bcSgMMItf zU4w}Wqjp`sRN8U9>rx;EREsj(wAwzo$I=Y%{kuU1yQbnHDjo_qScVB67|zb!Vr3vu z48hJ6I16NMVIJA}F{#Pi?G7fdyuR+w?k9f~<$g>%Y=AS{KzqMW1L}HXJm|$>;7s9> ztq@8!wcG_benrVcV%I%DBllCvWb{jr^JVf$07jIWyXO&n4O;81$|;P28B+zlX@r^i z#8jomJw`XE_@?DPnyE;m!}x#LBC3PTeQuBw?9uz84&PX*s-e{NmA*fnXBCicK2ow0 z85J68B#z7m$kDEui%f9)2EN73bTdq%9z)qO20S^0na5e+qj&t(m!R9*o^N!RpZ450 z>#rCulJhf?o6O3(6KI`P;q_qf!3kVR?3&Y=dQctp$mkA_BtbvB0Lwi)N z!=LfL`fK08Ghdg-;GDOn5!gF$!F#O=P8|ThoV0`s%NDB97>|SUGnFzBRgNWh^~}#z#oEIE)BTLl<(~($DBorc_&kA z?QQzI&F&0v_D8yq|XlVVJeIwC{gLtshJEl<(v0u=mee zYi#H?LlEGE}!+yY)SKfPwa|>zk{IQe^-LQ6E7J7gH<^2~o#07thQJlRyYf;DXl6P@}8& zmDOBhK+hn+28bnnCWGdsbt%mHI$EI^r0F>y$vaF|8L|Au-tL)^F+{JRw&f2OH>>j^ zbpo>wuQ;bVC9V_`og}q-6e(q8WK1g+WJ1F0dGkmMO`gNwIpo8qc;u*qzydf_iUjr z54%zx_n|MnxJ=4!d>^%X6&SM0J0_hQX5(A3gYR7I^~&VeHd4TPc1JJ$GcMii&##+zu5rO?buI*M{=C_?|X(d$8qG04Am;!cGObKVNp zDgKhcig$Syxkx&f%h-Q6=N#o?2h}}2wJFE^|KyTBGqzSJ4ybRLlu#!6hK~k`Z2=tq zL`ah&%w&rm1@9ONFAX084apKm0W--(KpV?*lEV$>v{Eh~uk8rqaXErFtt1)Xo>8gC ziElB&3fHd*%dy^CZ|S15+xb!(L2s9P!^b{DZ0Q-{Svd0bfQK|Xi*Qf)bD#|#>Xy2p zdM1LD@croxp;{+d=bnh_Scf%VZw;3eYggxAD>ZJ7>?&?(%S@d8T2=xwth0VMm4Y>X zd~)sBDsugX(f-bu&qFsTr8@r*2fi-J$z9%G3FkX21Q>Bp62#(5)N{g|lZ*ce&t0YU z6;-@SA?YhWD>m`JtGs|-9QIFe?Kcm@rYzu}K49MVP1RlA_BK7;;;Jp>N*+t@a5A%u z@*khKnw|%54|D}IFGSlKYY$W{ZD7EwlPA09*TLZ6+t=VViM*MaSaonz2ZgHAckZX+ z%1KJ(dPoX9s*x}p3#Qf47z(BDoiQln@HLqgr=QnxbQaty?NfbDMg93cMpz7y0?YIl zW=gtR5*SMyov_7SkA&=U5ThAJZRT}jSO~|3)h0`=I|1dn2x%)59m}IObT0c0^lTn; zYpRU|M#ArHypdu+wz1o8vMe%iKDuo%Ig=iR%)6pxk4}ZSTYT2(AnOoEO zBsPQSj84PuG=crTa}iynud8A57+MnwJVksh^jw)DClpbFa}C6*M3IJC@p#rocWXM}7o48-9ZRor2B`H+=)rT31~z5~=hG zQp*!c@>?CM$GRU;940+gU1&ub&Q`sTlu(Kf73RO_eJF?{OlVo=h1eql*qKkFXxpc{ z=C(Z}7X&)uW_ZW*vPmQVA?^YHX`vDN?Br=2+sR_^(s zJk7{$&yp386b37eFnZxGv?y{kDb{RtQu>X4d7cwEs|25DIi5~O4@{2#>x%?LV} zDA=%^nv2$D^PRwKPC0Ft>P^#$5)U4tufSbBAeb2BX1pU0G|<4<+4WkrQi*#ki`Q5W zb{~he&OF6Rl>R6Qz1*`?0uV`@djeG-C{FO{%s*c!LTJgSJZ(oo=z_2_9v^munOR z#@G%+#RNDCaFS!C%!q7WVvLhzwlH7APig@J5oh(=N6^WD4n2c)UGP&-lj&t&eqWci zR-O|r3S#0&ifu=;(P9{NB;cz(0RAtj)C(; zqOV`r@+=0KiBQXG7&cD=B~^(WALNd@b8|feG`bzdcsePOxh?H8opQB1u_;85`O!RD z#bZuIYanNtkbij4Cv18Xah?=78ho3Hyr!-VuWb&L_f!$+4p2-xT`CZEm`*a%u|py@ z$J~&GYIV|kXbO5PX^A;Hn}m?-j6!A zmCICCfLCLpC1Q@O!DgqyA6t{o8rR?0A7zee`Wlcp!OQES`?xv7MN9e~-1PwhN$2+0 z_G-yoDOb+>X);k;Ue+T~a#l%HZu>+?a@y3T8aGxj!@L6Dz@m8(#U)(|9H@e=7C4{ zHl)@HZ@zimQ}g&?!Nqa4R@za?j!(Mx8w9KuN0PD9DSPt+Q$2s3NI? zSu(9?DN`pv!RpZVH4^JN+0?&(1@+?M-5@ELpqJ0|*`Ol(>6up31W#*!yOE^PaXWqS z>84rumejPvsk#fQg;KjTt&VNCT`wJ3c{uL${usfHTpIlf)b;U1`?O(7uL1fv z0PQ{T0QXm!8WS@lB)#|D#w!{4iX_62q@lx5*{3)!q$-z6L{ivda#T1X)ohr}gR36p zcf52wW}5JFyl}sB@m_Yz)2tqU?mownf-(~S+guYD2DFLlXL458QrrHqr1RVb?VdhG zNvZ3iduCL(FdU~!W4Y=$_4{977ATnmeW6(8BC zIm|gMa!L^*jQ`)+vkrjWcb4~8wN7C%hfjc(q#*cKMtd{BOI8s==?cD@k8#^7CE>QH zpq&j0|G5_8sYs$2KhH}PJ5i&i*{84Q^SZ(233^3A8h>SL43Qj}&`W;b)29Z4Ezv(P zhaqiS2C3?G0eq}IJM~QE?UIG~Y)71@siU9W}Gji3troZM(FVR2kxND(m0$?^b+ z%LxZy^|tw6$EV zubMbr>De#g)xmxX{p)G8yml6K=4+j9YSE^4WqDlhn@tmbY(4pzqtaTZK8UBn z{OH@QAmUcs1HX)1v}npN{k5l1+pJ^*0hadIs5-q;^!)N5C%#e{i|0(JREoS}aanwS z97$PCGns9N+DxdSC>)Z^R*BWYeqRrM@T0)1SCv%o z)9tfo@Eu5DR9UGcww9574^12^gOQE@#VqJ z$KN#vg+GlwH!K!^gABf%aNWMgEzI06V_p=IxsJKHK6^{-}`~m|ErayrNd< zhGVyQSWa_ALsNxYntwY|D|yb-g5t6(mJ`y-qidYHvpO>vuCFIUj7%=wpfg(P#GzI( zbUH)hcpIi(M+8SqJFz?#v^lw|ILKDUhDpLJuJl4RG2>5j!vq$q>tW00edW7p^83@( zxNDEo+Xv^Dw;sd6BIYWj2knd_7Aj+2u3qvWCIjW9(4p=@mDr5nni0b#cN=ay094ES zEkwBC9eiu>%CsIa==}-c%UxI?X}O*#C5Du2GWDb| zw4q|OZSX52zs0vlUzk}yJJ-#Jeek76EsfYv4dWQ8O4$$Gr_DsU9tQ(1fLas$6QLxN z0UZRI=4hyOA_BIDM=b?KkkQdD0-2*+5lh#lTCYdx*QQ3aZ_%e5sjsGiK%>~ffxDhH z=2&`2+J9#c*!?8vI_|EdLdHJypR}-{3x9SX6)+P@;ej3kU}>=<`ddDwzgh6enfBQ? zM@vEzO}jy|Yi30Q9a<({f?S{5-Wpb%ix>V?|>dBj{9q_!W;wd%|NE! zuLErc69=B-@es?0P^xp8RBqd6aoE|Na002&IE)zTyq_C@&y zL{fScrviqwO)lvxODaw8nIfq`r>_eiiS{}^QIQh-2!>p08qKznN>GrRQaWymUdSka zxXdBe;=<$%Zjs=u?!8ZuYc?9{*UI0KI5ZPl(x;A2jGu@Na>9i${JEO2(T(Ec2DH|s zfyG@U840Z;INDK^2)}x%fOEt!v1BKeqRBsYv(#mD##aK*W}CGq9<+c|axX7-=^mdY z$i-$kBowjAy$;*t=a*tB;|z)RJmYW2-jU%@*c|m7n6&F+;(~-%f2UNa1{B zyS8`1xIAPtwR}3QVV4yf30|JMBC4ic82_=Zb3Z9g{ljgi4$1>WxXP5-=hCz~e^<)= zPoDGQ_i3N}Fh(I#f4&;Xn*=i~%={;m01=>1MjlGJ$g~CTX2!vNCP4hPi%Q)s($haz zilIW_R*;hb`fJSLe32;D$u?j>2e>si7D@2`gb{HMCn%Th?0FRhImv0dbr!Vrb;xc}Qa z9fBbu2lIPD|AH`m1evV8nCt9`C?_7FdPgZq+ja%dqt*J-*!T#XkklD{ZGf!z>3qMZouqLaq<{;S0m_w``#a>i3O+9yj=I>P{yi>&x)MMwfNFcC14`iBH!I1=s?{5PTyT!``* zBpL*e=Smh3qttb|uCWVI=;T>hr_U{Zaqz7}1I*8-k!JRz#de3k4&+bu+8hhIXx`za z%zU|iAQKl?E}xWKJXCf&*B8nlw8Q_KE^LIQXS57SE8C88t}EG~;)PmDoWD9Xih@bE z#9~4t!6WIGIkX}V*_!6W2v6kLU6OeO5i`6+OvYm01dBR!SaWI{>LFt z>aV)NE(M}tKYmJ>(qJU=dZzrjTog0CzU4yToq(epbY@ri@@%(uCMGP@gyH8ATq@2E z|HkJE(*Z74$PFjY6&ujb+nwr4XA#dp5jYFq`}NK$p%^}i0L!d}oy?7sjGtmWB;ytd zuT_|Nl$zbz@1i+XO~btV(+U=%;w6z&Po{)n*&SIz4K~9#z^IT}&IpDIdMku8?!-Wx zu~I7FLPa~p=*Q5!swd2c1;5Ik*YGk@227>*!*n#~NMwYO(fFR*?tAVLzsmkIlc9jhWHKVV_=iwQx~4(|eS64hhCn%DI!5+$ zbT$;PHIk>$kkitgE=3MvJ6`$iJ41gGB76WhAG=xbVOBL3N_pX%q zseI&JHPSFHAh#mTUQ%1EmLvlGrC+)o`hhN2^%Hz*fg(gCMXK03RkqF$aLORnN=Isx zueO)1H){Cj8DD&D$y{RQxT0)yz~l&VTpI3}LBRrFZIGFkC1X)e?^&7ywpv3O44Nc%p}eLe3o$(TGuZKMmnYjVhy}IZE)-2fr z;Wn{OUfBy39xA8%7BmbkmB7f^u!`u&?FrL3j@7cU)D>m!8XkUc-uJv2y|M~T+C9)I z8mrnH|L3lq8Yj;+siFFbL?#M8x>tC@(W7#Fh^SAo;i$${ljITOngB(W9!N)Cz)1mD z6f)N^R)fb6B1=zHYKAchy&e_6xJ*k2theEq33ne~+C3R(F`7z8tubj%ULHo7oYq1D zBLUV~Ml}QSQUSVgv*xSpTAk&zh&1@$ewzG7D>wqZm|3OzIze8n(p^hKd5lgHZDT7w zQA}k$z13=0D`6ekT^VgVc4t)OOZtw)oVG_Z=F4&T{{!+s4ZoJLgx8qi#2VrIU3#je zt!p9w`>-7w-K9SM$p?L2 zq4AZp2Q5Q7vG)fZ2CJIj!-b5I4 zu_13blvfkI>2 z*DaytqW}A#Wd48#q-;fdPfbucz!;1e000}MofYk2iNL9VVsH=u0GIFUUc8{bFQ;_t z{>G!%xQ@@Ozt{a*|EX5lyNNh~NvM5Vi7hdxBvcf%m?McqtjLsG_70seM9ApOnb%X| z5fKJm*DPqAjoulmfl{r68zu?5L5UKiIt)MrYG$N!eX0rrg>Ak*ek6=`#z>=~*(rsm zPzvO$jbJp{>gjb2bgcIJI3vf5!m`||J_@IcOSNm+){(T^TKg0j)RUaeAq7)8fuuo! z3sjN_qYEyHb(KOMnG%ESYKYZCG?iso@>r1y7@f0HVFIF*6E1}t2w8edIgu3EiBu9| zC=e`#wO8d=EGRm8EeGcc(R0qH=i7?Rhq0XQ6JsiXx2ThXRjG zRZVkSA2$mans1#(-51%r_Few=|3UwopqdnM)_&y4QSRUN|NmBt)z)m9jT9QL91cWC zh%I{EM_9^XTvHZ8%aQffX|NT75TbBH!XpKKQ_s8zPgtxactq2TFkC^(U@q4wHNz4f zKE=LTUe=hgGc?LeiE7*zgcWN^5|LpO6{&_i0cm--ZZL~Ach@HgOyd;}u^9Vw*|ti3hC4+CQ~5C{Y{0z7ZBG>sV2 zHt`x1n{lrg!i+4lI5MFj_TsXs#ip^%p-Jp@uxMDi#gc7m)KbDDVQ}&gihdy2xv(hL z+bnF5QEIEw!ibVONpD;X*p$Xj_n|wkv+w=%i;B8>rM|Ts778JaYOu>1EWDbKl-80! zxVUk0B1RbjgjT>biWNRzvtil*sJp2cDQZ1Jk##sDdQm`*AJU_u?O34E7hZsjGoIpWzz=){TtBgtIhDU>IVNjY)G+ITkAgo@T zh9@qodNmx9NJ2~vB@r2lh3i!M_SXudP<~k+kJI{d_qGGm=2=}w4#ENPX$?a|>j_o} z4J|*Z==8Y^sHtZq6T+jAXsOulNqPlRY~!d)WO9Yc<;!fl-kbNquf*1S?>h^*nNQ55 z4$^-%jWO)RRV-rFk~o4T{6^g;H| z?U`|Z`SZTy@BopM0t$00$nGhasvuG9kCTU<|HHAs^dJl+rLk2%tH5j3de(FQ+5cCz zeWOqoQ<5Wr@TiCgU5SM+`5+YoA(g^}wXV@qhFs6efGG>GdI%K!VqWr+3(G7TPfh$L zVqQf$=<|HJ7py5HIN^5qaScSG^0E9mTBaA#EW2xjhsd{+1VHC+rki24E|pK!&|G&# zAmNJr&8@-WwCQ3d?PdczG|(KKQArwYH(?Ag40BMHNNuC@W<#S7M3rwTe9?caZIr4G z3RY8P2dR}tb^rUYWaoee`e?*sPh#jvX(){dBD@=Yl@YAHm4PS&p`;KD$j>D_y^|JU zVLjtppK5I1qxxUJ=X2}RYwu3ex7)aw1}u0iaU(e7v614-39Zu*F{!t1w(h&&+L$yM znX)5e)u4*hcswS1khBVgwJxglmI#W53=$BFCE|&W=&$lgo!hD1%8wvjb(3g#3c6b-X&j5p+X6uh9d;*6T4QpKDHJ{$ z5&d$;KrL(P*OoB>WnnAJGWd4ft-+XxQ00dr-0NnI(osrk-Dfa%a}sx(Imsk)<`~82 z90yAC{U3n^igu{xD^gQQTLUuo6zs_735h%|*wo{!ySfIOJv0vq%GM|pd zP*3W~MTXf#_8dH@3s~eMw%37|0K7Q#e|MrRd`Bd)$YLOZNpP~Zo~YsLa+4L!6GHRC zOlD;zA8*SqUUIK1?*B5#mxLSkIk`oZBO^$jn@(dh<6DO0a>B)E&v&znA6llJ?~u3d zvm1`GNG`;`_Z4LEmNhM3k{MG&nSrUO%eVn^**S zQze~A+th}#<1<9P`ybMgMDcK?qtF2q7GPuyr!Z8*t}r&Ik6YSEs>&(m{^6sWBVEky z>6o#J|JDC!x*A))arDrM>IERksCI8+w&SvrV%-EzOef?J8f2~H-X=mHg@}Prb$Myx z_3KhoJm77*!XfF3lKn#M?*MnKau zwWeH`UHf_q5|b*kk&yC)bGXET^9EL8rIwE}|H(*R&vB=a=wUCZPc=LlV=zk{#w3}C z=Y-$AO8T8?m3Fq>G}p;a;mb;rSj1gP-fktdtD}iWNp@_*F}Ko`Y8K_v>*?uZT+o!t z6ryPXtNG-mDi@iac?nHSJQ$d345inUF_i%u0 z6$lHssGPv!A%MA{cnCNyQRSuvn^PVh2$m06S!T+a4W5UR5xFU?VbiT?tR^l<|E(UI zXDj#`?Y27FlW8Xjbt1@rXhLavRAC}j+tlQ_k45*L;8qoKA`L?X1C%)xnOH#xF5CYF zt9a3mg(R8u=Pq$W2x=51JOBH@WYPcz-f2W*FE^-LfcR+)A}}4cIR}ie+{t>RA!IO)=%h-+ zsMU_EdsdQ0kYbIb=1w^S7`VlYb0^QL2+x!j(l0zZ5el?tQXMxFPR9;)N|kX*T_l&{ z)3PpAvu2!@7?+l+%(%1jaNO6bS^CtR)w#XhNInp~%!A!&uJfBc$?UDrIv;z_XrI4Y z7~5xJ(AwCYm}8BFytLyLt=H+(1Q4oG{=(Gd!;|?7pSqUkshgV_KyFAkxbV#i2S)R42N6IsR)U^XoPwYfn~rXh1eNt*a5FFc=M>0=9sfvSes35_(F<5dJC3Y%D}UWTIpg@{4VsDLOy)|R3| z5sT5kwG0Kolm&L+m~EBX>O{j_?h{?(5k^~FmkN?t>N#wU7okRb0_{kPB@vgVo?Y4l z)$)=CwU4W4^M>*Z6fMU>XU!{ksvIguIp#D0&7Kf_>#I9?T(Wt2QQUM*#Zbr?wTl5ttcli zjkSf|!L;qQu3Z*(d?N)*Uu9$E^v#;8Z*i5Ct$6OdgbyTCH7l_&q=HS*^>G-$1(_W( z{!SY3&XQR%aT04X_u=>X5uikd79-AZqf!`cZ|JcH_#s zTrQu+Zm8dh9(}heqT;9M$IGoig6&(hD@}3h?4mraB6akP$(4dYcsUn!Om4!tqwpJPiNWJfHF8{vcx((Kt{ny?35`6}$!{B>s1S}g zC4Q!Cg#GJw;J}LODUMAttor2O9#blBIDr7r8RM5P$-SM8c@^m=d(&+MW^WAqxM;)u z+~(6M+ibM$+dJ3UdwgYgF8jxNoTOm!LRi&Gte$69DhsM zJp{!;mvThX$%ffdvTT`2SDW60+iAL!`|GJrn=07Zd@;{xLX1)8{@b)y=w}wv{LyxK#i9z+}w;2cnBX<4-rDREn642qU{6UNr@+Jl=_*AfaR+ zieTgI1S}JqjSU4oWd4lC*J)62utw45f7m-EYi}xsqv5-5Kd6sjE&G+8Td~A&BTVtm z+2OD%KZ_cV7&SBaF0iSKd&XsDiH4`IUqgoq9im~b1a|8kg{5bccOYgep`Ry6LBDzE zCV_-Zbe)qM=gU(k`EOZG=O*@9Vi2MIBej^OxOV7U?{j;kPT(o zc6|QRBP>cLevcNtv6q}$jyWPps$D700%Jpz1lIH%5r^ z2tq0MDU*l*jUl;h!=NGrHOJaRdJefQlvsx0hlZYC6q!e@HC*6Zc*`7H8i~p6&eVsO zRce+j#_n0Qx7bKCb5ytEQK?k57~IaSFN}!=NwEF3RNBtsbVDFWCy(Q5tnaP36}-(% zs#YdTFu$*h9kvvWktU=%so7jr`-s67nBL6VMU=!Vx{hQ|f+=m14dBFamH&riTEO(OiO-TcYa}zaYUm-AV!TMssU3u-IK-OrDhgN(jT{}{+^9G z^!B1}<4SZ|-8(ULVEeawTHJ05zyJHdWYT~Ku#Q3Fk2j)V>S$R6BCZ@&rwffd-bp$k zV>BZRgmxnSPj<7$trM8%avh4{c5Ru22&bl{t0$1xn#!tZjq&5dGF#y$;X7oN`!QW; z+kcGN$=qlz*4bK|8QPrHWI61xD$*L9Bv(wvLkWX6Y?xROdOX5=tW==s#!Q~-r!4|# zj2~%a$SIMwi$M}Kn#)&M21+B$#QP~>aLlt==0e% ztC0(NoLYx~2_#3@rw-IJDCw9uhjY^~_RW7u~xuqyNW+iM$Ozh{*phr%b8FtKF z$(*s(ahRP#W3YpRF3_y;wjAn7ZK}YBMzf0hOZ@h$A?7-TRD`OXH#1Dl8Oj73HOI1X zM9r32B#PwO0liTA)qPo_>Kk1bnHk(-%G8nej-dG}NcKiba*H~VrgT0b%F33*J0^6Y zQ_gfvu#?9_$5zR@Gx__vDBt@!)`Y+~P1Wk2pIZ96^Zb6RE|CrD z;Hr4RWW(z(HF{u4h-w%kULBe}1&ut_ z!Gj_qFffkX{du;fTwgsMD{erar_NsPpGF-hyBNp=jf`nb(5!eor%X`5ob4r~YEYAv zB-r`mS@}pCW&OCi-J%<*QjmSwDIVIjr#qxwlAAq{yr#GC|1nmO<8H|(E2y`k9OW!R z2JEoX?q$FGKztU6pIsErbB=#J+Z@1<%qZbh(3QxV8MC3~!i2Lvc_}P2r_PZO%6Y&f zBnld>={_hNArlWCO~eR~77sWgl?)aL1cg)k{okkh>M1y+LBxoSB7KS`1PY07n_Pnm z0LX<);uQ{W+xWsmB7=O3#6X0>**mBpV-WQ00E!Rnb;xeeWiyil3j@g7;;7fsj42>{ zyE%~NTgN9T=0~p*EmWC2J=I!Myj z44!H1?hlL+rXE7i(-Aj@*t0b~Y0H2s?YMoRc&&)FPDK<^-CEwf(Z089GV(LFHa0g> z4)+^#$~KD0axB=_4rsvR1qR#}M(ZJx34HGNKN5h9&ghS`r$Iqn#seXiSCG%v{{Ql` zt%}8Pq=>u)vkUCL;U2qW|h}N?laM6ZRGr1SJl!g!bxtoryeYorQ|9!w0G~)GbtaVoU*vW#I zJyg^{vXhA-k}WBHnbp|Kc4T);soaMo=OQSiphF1R3AnLPgv)1)%yyYn(w+Gb>e8oU zre;+fAw~vJG^B_PC)_1f&AD-rD-_6ZAwc+$x~)MnK{X^3aJxW962~tW%f^b@rM-Gy z)Cm5*D@caNp@~12_lJuHJCASt(e(<3IkcDST@5T znR5sbpiZinW-4hor2#2igD1!(N&z}^j}@blRWwQum<)@_ILo)yF2r)fwz#U-D3i7^ zic13X%lI&!YDXvVvk#p&i4u-0hzzVH_ez zB#R^NPF~9=k$v@g)X(uvZgBe z0$lr$RIyq^O*b$Y0nDT_WkH$oHDc>u?Tx78X{C3e;cx(F>2^NOTzZTeS*Sd<0u60I zk*vFy*ni%VG7=Wv&j0(sWY~ZQWspHjPekxoX$Y+ZBX1oJ zDF=+O-ifdnpx6+NF(DC?Rp_4g;wcPD(3-$xT3qXzs>>X8AxjH9xev09IP*}HP7dxN znjb*>rTAHD4u7;n-~}3C!%cJVYM<$-`ztqG?c6!zkAo_jRF&aQ*zj7l{#DBoe~#Gf z((RO|Wanba{Qd9gnsMeo@aS`&Cb~ysYFU!SOeDpeTV8oqltd##*HRdy107kYI8!0( zeN*X`vvoaC(y`mea)@x~IOJ@ta@$#^;Pl_8Hwc{GF6yff&h(@FP{OVKuKVr#e4V`@ z_KA&$tb8dZSr!NWVd$rS|5g4w-}m?6b6nTp<6Zi-wZ48|cxtV<;%%hdNg#6JIh+DY z3LFAhM!NN(QZ$8tOC^e|3wW?l(*`Z05@9UCI~Ozp&!I3w!#3w?KQ6yG!>-N7CDP~m zjk-Kfj1tbD$t5H<&7=_9dbepV&8mt>PSw3m`a^L1-6KaP6)$HRz1XyFiho)04eY2&qi)A!_Y3zAxf_L2W4)Z^q?a0Qw zAJ@NQY4pG1{N~1KeP{eUvrz0&jyv5cOzvR z&@Qi#6{-q~OGXlOBsbS2+?^M(+wv%8UnA07l(a0J&uDk)DS9MKqZ4E0mw}KFEE*F< zrqa-CD*`+wqoI2XFRcxps-$c7T-$rSno~|m5ltl;L>*9OAQ^fUslayJm6TafG?mCS zT$p#5aS66RFCCZ;1(3=#o@o1-OuT|D1gl_f5cdG&-t5bWjmO{r0H zO){F*3q@`=C~M^SM<59-y|f-jY00S&)yLWmBaV;V|NFpX=Ku$Ij6v&+HZ$X2dyxEiOQ>CXfTe*Mrv^U!6{8Su%5j594)P7{=Q66uf^6*Z=c8Xm50vO9=Bc8 zly_O8NM+@ZErN_#o)QW`BcVlxK-6hjeQ0Ae8Azc;Mm8SE^byRkI7iGj82LvdAYWq15v~`F@1Dt(BJVabc=2*S*CN`T}o16Ye&3L51fxfh^ zlIZMnq)(Znx+|0vq74;VQhKkkP@WdHBB>U!Dz?t?l19OikxZK?tU3}+jL{7-5UDE< zPWqD`_XtN#1sp{Tsyc$}G8I`=1j5CfH2{-@z&<|_Y82v#v!b_Ys!ZA1QYPYUHymvc z3p5T?M7V^y5T_!-G~i%U0t9dvj0toDgq8q1YIF$%lMP{?t#(@5U0~;y)$<=TR$St3@FJ~6M0Nmb(IxKd2+L1>$ zsbx7l7{|jaYdWTqY7&tijaIRzmr!K0Yqqxd>gU_rWHj@iNiWdgAd~2mCQ-;1(y1p+ z(VL1&$=RrxtqhcvHfXDAjC3AmOKZt_X+j_7?C#z?S{Jl`%1W+wU#hWp31+mzYxbib zA^CZ~c4XMv?)lZ~?9?M5`lM0YPEkw*BXOq;uH+NdVb*4{AE%q%P1(1Zd#9a9$16K{ zDNXwf&E#gaAYlTALBbnFOiNLq=%Z|0n?Bp5gr@?T8TNe7_e3Wvu0);XBpl(m>qSA) z^Wl>LQN@ca3|!(`V6g}O|NrzBk}<^ENk)M&pkoT+2Zp9=L3QNUv^)uQ)Pt(uBf%3d z%Fjd-VF13MB#MJE;(g794L?AgN<4E#wX&s)sSQJzFoB5H_|lpI&}Ff)Lnny$B}(EH z2CGRJq63VtrN_hh($SSL4<&4k!{rV{sg^d-r&Ef9vnm_^`@m%7fCqn#!Rt>n@?%M; zd<^y4sFx&*wmt{{zT7>CFQpYPg=-a`i;sH z)anYO%kYZNjch3>&Ks=G;q{2)GRa9V=eG`>i`100BuCTxB*4xho_q z6|^-omV%*Qx;v5^vuo#9Q@zbx;d|xm*kUbnC0Mo`pXL3$<{A)fIc!i9B#ErVB!y9@dTzr|w1qK~SJ!P6`xgiwlCb#{x85-rEjJ zsEz{Yo{c|_cGY7yhE^vZMcUOe#+OvKDI1!fIh;ubc6qlRBZ3xFLv6cbQn%tXPQH|O zrc_0hL`1n8Lb)=4prD9S^GJwDNKq{L=|UP|wdP#R>87NC3*4N@AljD7!)9?gsJx-t zrj<&PbxesBFB#Tja+_Y&U~VEMJCoqQQDicgejEuNJOhBLI5|e6!5?!Zw~oXsS`Qxxh=Yk7eFcO-!U2O>I*t<28;F9&juWBnp}rdFF`71HSqjOTdnTB}uQqP17y;X}7<`JH?67hTO#K!;oz+~_M2hEN^%TG-5 zY)Ob(1Os3l@;L)7Jk!a#vY{j}jW{B~t0j9AR0xj7i)$E?W^imk1O!BYxm_IyqLM=q zQ;-KGNg_lLw8;XVK8UepgOwUaxu=&EkZdFE0#9jH7=E)tNja-kxx@rw;MCt&R;2b~ zj55+-)I`^C&^?r<*wO7HEO;!;Bnq$-SGha$Z#=%K)EQqeP2D7SSrWqRDRJWf$D zv8ijp6>q29NVy)V^^%Wqw-lj#@n zs?4c~l_=Dy_6b`aD%EOdiq}-T3ypi5U1f1$gBhQ9gu85ocuCx~H$`rLC$W@~#0HSm z{rX6`D4!gbDKig#TAZ5V;*;=YAc_^)Z?2-u#Xl`eB7GoY49c&)no!1K_IcG`pjU#- zK(~CR0!Oi)J^IzvJG9Bxon5^~yo~FswF(NXZAyagXHVU?dd+vbU8>>}rw;dUV#Fq? z|E8*|%?3tdC*qunhph<}%8m>hbn+{-Y12A+N`L>?BmbmXUHoGO}SrJvSgI=OMJ2X-1oEeElK~p2*16%O$2o!9>OY zME4M&6@L1rMI(0s7Ca(oijRc!NI!Z;0&`M`f+!$xW;eeWd*3i+9%E`U20`&OsG9YBh6XxT*wP7 z)3ToF*L&?Uk8ae2+n7ZE;HY z`*Yo`)e=W!azxv05@|v#0CO>Aa$JOXSBZp*CHeraOdNr%H%6Ar;(su}S9ksN`HcQa^V7DKv8+ZxqwNLyV`3hQjcnjRK=O ze-BU9?5+#YU#4o($NGWX7I(OXWm10Igt&8IyUCcZ3vd|BCGi7KM$lP@7Fi+$Rs?0_ zZkJ4is~}eTyft~$TzfRK%sx8l#LSVlRcjxuU00YM}SMfoZLwgXX1rP@#K?q@XT&dWx5F+gZ zL#!mNJrS{$!LZ{dbs1~{EP3M(8?fiC#=9<(Lvi`&(_&mN!uz=qr;SM@vbsqmT5?wm zJ*`@DNlhQ4y_E%NT4r6B%VuMDrM5>#0ObSYrV4<^fsrHxDUiT~5r0D^|NFpX=X%P?#n39X>#C=as!MV#PH|6LEc6qSUN(%|rgk==6twH& z+%LV#qA9qdK3Uw3WybGXIhj`7oANuJu7gr2Xrhup7>jZ?kfu$|o~2KJ*^WWp;ro^x z;oAF1l&lOuiVRqcF7~0kz4Uvi{V!$rP%WgRPFH=2nbK@E^bxd(31Qj_pH2k@d!005 zN~jf0(i$MnXOZDf8gr1b<&w8z5hu#UJTUV!3AmP}@k;LVxeq#P2_1kTra<7=l`>W> zM?UmL8kKhuFx?iN0!18XgN7;_H*u^>ANz3K^qj-1SuZn^mX`@m%N z00-2MLE|q+qGjmFNem;T9hyN0tuWmIgr4DK5RQ0yY0e#+%Z$55abd$b+gyUhC5zW{ znt5jS%R5%J67Q@uadl$MKUX{)(#y78Clb-7r=~}`WA~iB`;u$xG%^r@GuZWHxesz} z>~@Sb^)|_=&#A_oRr~(7i@GW!4!^qlRE?E2cgWo-jk6iLF=kT;(uRbBB1CNv39LBUG{O?bJGu|p!|X51*6j0aLc zRpW(n3Uyh$@3orxuBIDW@;yiD7CQ54#EWe-2e@c6Bm|T|lT2!mFpMDp7wUkGFS?Rn z_ENR@eqBXpd$6j&PO}{hC9TL&VTOhlBJTml4&`py+UDF^9w+jm3ff)zg(;1lNQpM| z|B%yB9F7)h7ZJ9>BMPbfbu&{_I;B$P)V|EBRs5x1HBo^e@p9!Af%PPjg&#W zFvy4A>LiYTm9b29<}=>D=Y4najg39udfGjBd@dS3Ixz+iJ$fk&Q_-m&W&1<+ zxiY@Xv45Q3Tk`u-^%Ppo*W!XZgV+6!19ZvW;oCZV!}}I^$+cYGZ5-za)sit z9_TW;wXlXf*h(XNiky4YC!gOjIgx5cECMG@%C}|ji0Mt?(H1GGR3M|w^p<07sMQ%z z=m-cP9L*ylY}G}Gh_#Z>sw4!sadm5Ll(9ck?T;^YG;g1D)0a)lnLD!=rXI5uCraYW z)3CpCE~?ZtdKguSqd6eP@ic@|7^X#w0S!N!kf+CVWeWU-I}d*r9bzt=RdT13(HKjM z^y`GuwX&x#2GO5BjWfzQ;>`C_(hpyTsa7_}yHb)fecro|61c|MDGq8!x(0=lDT)94 zuw?lF2Qh#`>n}9&YYf;~3?r-_4mkylJk`mLq@nOIj-0-vMCF+-c%9oQ!cxjHTa}SX z>J;pb-PS{*xyqC*x{4T=i;KNXqK@X`&)%J{>vw!|y~d_%kE4`|w$WQg7k@oTdohPb z+180wrD4Zl3LwJ@2PC5iUCZqLt-s`W7%N9}VFcbz^CPPxxqm%MSX)C;$kfTA=4>3E z427IhYU%AEM7(U5BhbmWQ^X`9Ux3UM0~IP2NtTJ(4HFg>XuHyBMF<^0e!`*0fAngS z|D1r}3gY?LjdK|v~vsU|}Fv4$1bJBVpzWkzVH%>R;J(<%-dK#^*g19GzU_>Rvr{ zk63*R&AZ2FNx$^7i*bCh(28?YWp$!kGjSkiFhi|SP7Ep}35lV=>88pklDveYjAVb& z5yqk9R9I3>1hnf2Hvq31z}pJJ(aN$Z3^Za63JmJ*@b~9sZXSR2+oobOSEVQ{0iK~D zaLSL$CVdHIysYWB{&i7DTBD_Q*-xs{+o+R?7=eNSScywa@6ZcB_U$=zx{`3oxK`#0 zU4JWU?aq%E=)3B2))9GBiZHt7N~NEx{(qT_lY=DoMwlhMbe(&}gqyc+}&h(j1El>bN5fcXWHth}^)fs^IV z|NFpX%>V~4kU`@t9$;H$xbFR*SWQZ=xdd(<*u)R23DQjm66tm^@aA(y=zMl_m7Y9gw|=3 z_v-o89!lEgA%Xa@s=)GncJ#mdSh?u!73k%1kF3U8jrWnNw~ zTw{}6eo~I=U$x0xRbnVni7pA~mnq!R58Mt=X+Z=MDkYU`67agv<&QLlkQ1?FiJmCP z;V`LSxVW;W9gA0At!*0rffJ{0)lpl;l`W{;jJ({T<81_xgh$m{(-hJWrQ*z*vms3i zXcSZf216$9nGo`Tyl$%KkvX}XOH9m&R4K`{<#Sp_BV5awoZ8B+Jei}w zFrKO!?rvGdjkZ;60>V?xiYgyIe2Qf{n3VEifp+ehafomw9zBBrj_?~@RlWl&_CLG0 z$fIO8XAr|$r(jDq0-but%vDMT0`uIBO1~=*C(EXqE!hJ1$!~D7ru65%K0j$&+d-4l zw_Hn6lo!%c8oq6h1$V6L}rpB|>m910HR^EbH zn`woR4&$(~(dxzN zX~;sG%pAUf091XTHtri}(2JhY7BeVK~co``@m%100$9}LE}#}@M4JAY78U99uh$VjWFDSw-g}c5DW=BRCmQP{4O$%zTAK1 zw}ci8wP_LsESqCPL!`b*0(t6XJQCwK6Jc-h@U5x+vLcj@)e9!_tWC-)?_)%-}GCYc4;nS7U6w= z#{aXv`FqbCZMf1+bku>0xZA0Ppm2+Q zWjmc`m0)ga6E9~QOO4D!Cs0Vji+dntY5xqJnknj7n&-Qd8Q%@di{oy$I#XBHRIlVi zFh(D!(X-^ls|WEb6iBT8GnVdE%n;X+(qK!dBdlHkxsyf&GwC3>Y|2 zFeFp&M9{_pF-9o|v_w^IOqCzmD&%g}7W_Em#!57~KQ$HgLR9ZZ%l0@)NbShwYUJO_ z9H^EO8tvm`V%qWaGW1U{{SBQ<0fDYO5!!jW&rq>IYh`xzTw9fDeI7{Vll8|(TJFkC z!dP>CSMdM)z+~wF2S|`XV~jNLYiqbkEFwM}+A9gIJk!axD4`@^j^L>lBuLe8Z<}nF zF)M=L-MN&*6opji8=x-oAti>5{4?$&9KiERky$Y zr{xID0}X~777;xT&7 zRZoknQTuCDlnn}I9NpEWmr;*z%V)*Iylo1m8Pl_Y6G3tw$}N?SlN#!MN8*XJutA)D@UkxF z?qr*yyH*x|n?-n^#h@9rgV|4xr5jL|zS&ht_48*k^u+RNHVVC?5Oh?I6$oZQ`;sx{ zli9b=^I5OP?|jB*IgI3gye-wPlu(zuSE*$J&wBLC=W6 z#5^LSZ6feQLbZXaarY#cG6e>d6lucPkq|{NR8Z(JkowFT7846SZYUKpA}^(Alqo!`XNH|rwo0HO%cqOb4%L2~m|Gt~a%5#lLxSpzEVNTO zD;Sfn_k|gu8b@@3#Jv7l86&G$8L<8vI?M>OKBNU67K~FlGyD@J2%=QOI4xQ-lBQn| zG9m3PcP~*A^Z)y>Wbgt9B#uE#Og6Gv#E6UpVp|Ojb|4LK@z$__> znhZb&e#f!}7|g~dEF1tZB;=@y8bzSP!DG%4nF)&yQQ&x!8erozED&YH=E%A0Xb$Vl zS^xci>HC!)TP2oO-H|kLL_Eegfq@|VEmXXNN}vP)+49b}D1za_@HBLf=a;D`1IhRGyEm!iv=t{z%IaU$xgczIN`e=idNBB(kfVeQwvB%YE4rKGYc zzNC`5nM~z#2Mm~@EMVI`c`>!`yAjeOx93ciU)2;$PIlN7FK7PLY{1pcn=uz|oA&srCQEFp_Sxj`bg* z2BkS4e7e-l0g)P+-Z=3ou@JPH(E*sKHx_YR;K?LXI|3-0n)ZfJ9b?L#J~3q42PZhe zqyaSO z)V4`MSa;*>Yl-!1*^5n1mP`L*C)oHOTGZ0cOcTz$b5tVB3-bRz=r`gNz~Ml-YK_&u_gdg!&Ll)ClpP21wo4MI?DCf{Y=Bp zc5sT*E;6hjBBO(yFj#3MCaKDLs$0yTb*s+)E@7z`r9Lfl6@-yB=HiD;|8<<47Fs6pdog?EgAMtK)8q`d17ou zJ>IBX0OXFK2n7}-5R0RM>;sVY0}1NM?hj$<43=-GX$2it*#Xuad_y2pgg`FWRWsQl|40$>Pf7$al4|xc7N=4d8)uLr%D~T`dBxq!H5JwJ&A%GO~I~!qfb{9~y*}Ha=)6q<* zeid*_52Qk|F&84{_twvr*6sZ-*1=zw2WWP7W@{deB93T<0^YM1OK1ZDxIp5XXn|<> zG-MQ5X2SWyFKi|t-cvktkNZr8!QI$us5=w~MNwfCml_+ItIDPu69Y->EQtXeLx_SO zg9So4;tJ*$l$&r_0U=e7p1FDh(}-GWh9Rs-Y3`;|t(BYjdpvJ$I)2cuM_Fz+R@+P( zqDN&^XAj-?j-sufV3_~=uw?3h28d_GYb;F2atruc1VfS;d8HHVFxBD3rJ*Pg41n*n zY{X!gj_oi+qDRau!nbgC*`}@zyjCS3`u6dL+YyDk*$^VN$ok@hJj6EhVAF`rW+hL~%Lp*@MAh8P+l zic&;ODOE~QL$x*3P$XzdX^KeAN+YUF)LI zwO_uq_g??CzVBhLwSWH$*>EfID0dsG*TP;*IbngK_prjKd`X~Q&gX~6B5&}0N&b_|%4FmX zT8i|t`4eZeRUmHhjG6`08VHW#4rhV-S(fY5eXK=gPtSX^QEpE+F#G+O@@nwZ=}J;? zP_zQXj`xT_(;0PY@!;@9kOJnDzPO|t3H-3{+FjA|*NU}S6p^L(Pro5IZM_5b8+UBg zb2P$pc&I6j%b*WSsc6Du_n65S$`g;&=JWuWUMiwP@BvGWtV zB{d6MGO8p!r$kf8GsTF3YnX#~9A zmGty?ITd}w5}0_%TP^{deO{BGR^e7Bu*3S}AoLYO2;6E5u_(%r>qNfJLw+p?@Q4?m zOD;-(wvv|#l z!TvEgXNNZ9%WH~dRndBpbJvKV7>C8TMx&}o^n32+Wcf#JF$6kKtuB_DK|dg!ap z=J9Y&+@<(RV7-p|7EYsi*%QHGi(7)TNmFv&=xqw0|2u&$@`zNtr{$CUtb#{0GZYdI z2DZ&YQJ=UjCQE#2x@P>w;BEMYXiIyyfLpALv3E0iq0TcG$I8sh+-vB4;M;h9pjd^7&pXQlIt#$t2XRu#EZ zA*t;V1`l>8@%)e!Gx9`Uxao}w{nWRz4ZF`<>KtcIJ)gC(xl%V2yi-2oj)%>qb3 zig0`#Y&?qtwJT|1t@6bt2qi-`K4tv0-Y`h=KD&-&W~+)k*wu{m*2@`0PnSrF_y$L( zdB*Ldhh7h_LDY;U+pLqAty&X&u0#8^`*D=!7IxEX(}1n8gTyDDSBgKx_v2Myq1GBC zMvkBKLX5P_OvdLr+%W#yz_^;Z1FC@TBOCE!GA=5;Y~_~ClXH0LRKlenL!OUujq2MT zc`)#N*?BFdXT2=ss{$^01wB=0NW)cXPpDPuEU-OF&lRNG5l>vl^@w?%WW!Gik@wa! zi5;l1BmCaVC6(^7^5T}Q7eCLOH&%p^m&d8vYb#FGaxaYRd)p{ZCj=K{MBRzK z5h-E5oLBtb%QY%Em5Dr*d4t+Ys?~R(@z4}S1+1>h5#!)xC?`v&a4p&WCU#EBStWvZ@4bInu5aAMSTAJ zQrZlJJ%VzX^{J|emKKs%2rfs3rR+?MS&6OhtxToiQXnLuhLmd-k+)h6zd7wNpL8=* z5voro#50ISD$&x#wpd7^4p(_?2`Z|a>7Z0e2pUfU$fK)V?$-EUr#dK*wFQak-dvPj)u!|UbAbcQblB&S`tajq`g zZ~Nz&@&}b4y>$Wc)>}!yN|q#nB>%Zeu8yC76OuT7kLmo(4SH6N@!kW^;{)Z{QmF2J$u>mJnEf zIRBD*A&$=B#Jl<7b2*i_O~)I{S+M&=?Hz~*kSr>LzlOl9-kv7E`u*XRUq=tU$%d#0 zf3sV@Bv}chq3rDC)-gU(@IzV)*DuVd0UENz!F`M)?s)gGw9b+tkz5xNev^SdtqZJ}W8$5Pi*Jkp zTSkWOBaTlbZzHk>MeByE>(in@pY=?|Z3E{UT&q`lZQtc8I$sZ%l8hLu)KqYzWmPz& zU*v7@xNl~-8R}iL^W(QuQ?u(Y_RmcJY@q&eXN|85zFza$!6CqXV(2Ml&?}k-$1d=M;&Md)qk>t}*Tin-U49 zXbDp_OH>N2wq|^!d_GlveE?{$Lt2RB?hQG$U79mnbsyT;AlunO|6Dooq;5n!s$O&9 z0Gf@U<#!E?C>Ufum{)kob|_K+RFy^dF+GrexP zuOiwG8oQtX{##%-J>4iZdozcVdRoTDS_aks)(}wsPj~p|*n_RMOZf>4K mYxe(%a0h!Lg!!B`As`BX0`LI+0 literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/kick1.mp3 b/src/static/audio/acoustic/kick1.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..bf47ddecbc9406b6c35ab911fbe358111fe5cf63 GIT binary patch literal 17165 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 z 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 HwDaEp2o5cR literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/kick2.mp3 b/src/static/audio/acoustic/kick2.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..20bc0d9ca50d67da6f447fec7dae819f6c52fec3 GIT binary patch literal 20555 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 literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/kick3.mp3 b/src/static/audio/acoustic/kick3.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..eecfe74d26fda6946ae76a8e5cc37ebf9caceea7 GIT binary patch literal 26609 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 literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/rim1.mp3 b/src/static/audio/acoustic/rim1.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..1022da1272e72fbb82d4e28a277cc07149015df4 GIT binary patch literal 26113 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

b7bfAlr`GZ^ZC^%MDghg_-4Y4PB#Jm|c_W;o} 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 literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/snare2.mp3 b/src/static/audio/acoustic/snare2.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..5cd3e44fd7b1a71d27e248eee014961b7fe1ed7e GIT binary patch literal 29323 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 literal 0 HcmV?d00001 diff --git a/src/static/audio/acoustic/snare3.mp3 b/src/static/audio/acoustic/snare3.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..be2f489ec203dda686f5e074ec99cb7dc976b646 GIT binary patch literal 27055 zcmdqIWl&q+8?GH7xCVEEOL3Rt?hvGSaR^qtltLTa-6>9R*P_K;in~jTlp+OMppZj< z|M&fTzMnO-GqWapCVORH>wa`09ujQ<|CeC|b#r*W1^@Zt0RW(N01OO#d}3lsN-&s( z<;4p=K0aY#2?-e)B_(xrZEbyhV`F0r3mY3K)XmMy>)pE#A3{SzqoWfN($YSCDl9B3 ztEp*fYHDxq?HwMToSd6mS=rt`I5;>xy|}o!xx0IOe0oA4o`1_$LsnB!fLlz=6S(>B z2{{P?03k3F%9ADl>H6Puymjzl{`bZI(*yA^^ZbI4N&yyuKmf+`Tev6yATdy+ncsE6 z07C!iF7g3K zOZXfaoEFkCM~ZwgY=S-5YxXveP6t!HLh6YfJ*kYJO=#>@-GD)WX)~QBdhg|DGEB%> z`GXzd$HGeGpMZ9CqyhKC&&dLy9=5U)*bX)Qk-fBM_uZXF_uvOH@boK&l5t}cw*={r z&<`5xPBgHlZnp06cOrJllXb5?;~7NB3rlF)Q*^7V%dYcHkkou1z84mMDWP2LMpJlf_&Yks}bB2t-+m&BvLkd_*Yic4_JD zUY$LkMRa55+Q?HHqvrW!AyVh}IUj%b(qxbDecyS|7k*gLFCcLy`;h{)=u@z!hC;vq zQuGLBN-T!TP-Ij%4yPb>q@|49SAtneeZ1z==sK}B`&RSmcz2#S>!%pOcDq(~k7 zDfz)jf7PmzJYE*y!tNP4_bqa#hi6^F`ORPPR@su&_BuF5=ZXLdbOHBJf;dTSqphmd z^iobFj)r1W`5rrP^Of%_pPi&WBT*g2Oa?c)`4?fmZfXM~Ec<5ZjaklLxk~d3Vc+c% z74md7HmDo7xNVQiO3V`(z3jc)v^G0a^XwNE^D8h8nRpC-y!z6ZIS6>HQF^V(yRx>> zGWRL4aP>1JeQ49-@K2tx+u5CYWm?g4#rKvqF<&CjYEB$ga66|Nk#r~GrWatz`wS=P z`>X5%D`FS`fMeNT%B1D2zt3Rr&24RCtyVx_LxqBcl!@fQ8x6#cWWc2X5@Yks^GC$w z^n)G^(s|>Uk%BdLA&ZuvEV>-9$J|9Kfgm^UNtw8E1G82&&SUZm4c*5N^cq|kM%W*I zd})rV-e37>&Tbl7q?_?Bt-A*I$jCmn2Jz5qy8ytrb1?b&1_;0gV+{5J089qO2Dx1T z40iy-?_dCsU|%)c+NC7c^c_|4ZCd+ev1(m}on3*)Nst z^Q7x+n9ww-UQFv&#P7O|xDI>eL^;qlT`Y1%olrJ;y>%NeFKHH?+mDNZ!2=R;I%{tZ zq|fT~ee7R9)_gQN<@TYgs-^*8b2SbE0DEClC~!?P-5>O+)(0~EOlNrOYr#ruU;rnO z3V=Ckw9@d)-)Jm_PggOGQb5VfU2GIk0Z?ED&)QCuZ+^Pw*H(f>_=t5>R=0Bz(L}`) zS^*%bC_xrEN@=(eJEwA(7iGvtyUaEw3U{kP$zLQ<0Q0mAEoN^RF`P8bCV699;t5gpFMGnWs9Qq1;gz(oBx6j_p=iZ2dH{su4vW5^J0z%!AZquTM=p*G3sDyi#?k zK3d1jnhFJ@9aBIy`I;vz^MZIt*2zDH(A$n9irw3Thr{|dMz0`z&j9&-sWt79daFn3 zjb}Qy+eXS%lpQ9j^ltt*lc`s7Zp+=Djgu2$eOr4tAD1}pyTm`7?nk_?NEn$n$r)sn z8maZ-R9MZZ9Nzq}Kb1Ibqa{wptwt=IWwHz-W0-ma-Noo^uT4e9OzD5Jbicz|E9TK_O>pr}3C1D`7cR9gV3iQ~D-kaQc z-mOGH{@WlEq94jl z{WIscB6GD(Ps+6Ezm2(v4=Us#dn~s4)an~SEj{fj24!|J0``RMqt8Z{H*4(lF1JL$R2_| z#K6Ox?hZdwX@wKu5)wzF@rG;Ct5L4kS5Dn;DrU5_1R5CsHHt}tYf5R(nREMCVdaYI zpT!nC8!H>eU$$v!@ZYt0_$*8tFwT_5t_}rkvHkipwldLH%k(qeP2n{7m-vRy9@mz8 zB$&FEGsLU0p+%l`k5JjubuxO#TdZ)91z@m^c&NAC4knv$)VI;Lm!av!h<$#WbbW=I zF1ty+7BEJ^XA)E~#dw`)NObV*;d?rvzvI<$6dY!oaQC@9%-2Sc*U7(arnGG>^Nx!c z7oT9AD|{q&6^ycZt252CZqnl0AfoiH75SJFLvY2m;KN*N1Cr2bj9b~!?;s^&b0$sk zBQf=3HUelSl{&qUuYdmM+VKfSFaRLPiy7bns%%IWbsoxw$nmqV?dAwtjfTrH_$mP8 zBt=zFc%8<+^L|e2Mse;`qlTev26iLeivwTU>mcNTH(1O(QLEl0S8}7}JjL$$g{)%w zHR-4+SOSXVG3Bl4HEA4g%TQ*yK<>*lRt$O8 zoVTmAunYdFzxY8QM0EV%_flKLvvYyz1uD1i`HvxWV z?dMDWa8z6djbe~WNF zQ2{SRY{1AM7>1(GUp8R>g?wX?F*1lzZ8%M(F(r|Yz7lvLHI|pl4RYhQo+E5cwv{U9 z3l_v?_EIBH_tjS-Nb=Mt8;BK9@bl4X;}2HgM)hLg4*|3XRhq?@23xBq51OQggn81D zpUYEDraaoMMF!xt0hsa?~c(iTy|11q!;6gWkTjrX~9h#=B?Yz=8QHvE3Pf zN&x-A^E9Dirqzu15Lva@Zat%d(uAC}yavkdE%CGMgwoz@KgYi}(HuF76JVCv8u$%| z)1TAEn5zOU`?mZ6c(MlY9D=CJwblqlk9Zg~d$rPcw|(s9@JBcx5D!oJ2!vAI^9H?l z>Q}I{dFrmiQpjep3LEAI5v}urJ@M~h?Hl4Du4IuOb4e5 zmr70)@eP-9|24T}^oStg$0Thtc|&11GWO=-P2e~We^oTNW|8e*3`*eXu3$s_cd`!& zjgKex6wqd4Vo8WGkigHV(VJw6D#Pv)Z>Pfn{qd(9H&eD|3=abxdL%vQ#NBc1fSDLC zz?g_e@Wd%Ebi}N_;v|>)sE`5C$DeOYlMRUHRw#!?mcNX+BFq$vX|Tq#1KD5;$s5lZ zVZ#kTZ+NPX?X1HozPQ&ize@HBZ7YnN+q3&Lft?n7YfS-7je!V1dyk<_eq*d^So&G$ z=;$M|zsg=zdRA)-OG(6Pg(2a@01^XAev@nlEWy#6AKwP*8psho?C;^|hO!Q&{MrbV z$$-2Y^YL=a<&At?F0Csu%1CDxx_eDFJNL5^8uTI>c)>mY&UkY5qc-CEJ!0Z1kTQy^ zLun5ThylKSzcx-gTnjW|?_QSrjjhINmp{u^S{@EVlLdU=_qFYt5*WmJ<_xF;%^+~Z zM-7W$;5&#JMdId`uF=@oRrrKy@`WvOf&l9 z-^|Jy3_6V{g|cd+EEJq({G3!2NOgVup@ZQ^P;VOGH1s9#dt&{cR&^R-mv^BX(Th53Z5hq}^d6-QR8sxK;{qs8)(VVIHeCT>tI zgFmXid5RwQ6vf)lB8IrtL)7M1geax`OU9rH49K+Lf^F;-W`d9ygm8mPHRPK3ar$FX zId}^c@{z(L7y_w6bz5T@*cbJ`0{NfVh;#$NIg}d4`l}N{-kDt;7#`#; z*p4e(%<0GcBR*TupZke3)<5i%Syp=Me_-Q*l7Q*G(HNp1Y_$#1@s;~i_H<`eGJiS8 zMvka2re;cr#tU&6R=iMSQ;n$7aHZPH3b{E=wdy)E5T97INP2j5H1@vuGdg*h*LaZE z;uV%4Ra`GgW-dSqz$3PlVAW3c>g8#maDZ3+_&F}yFyD2 zFqwlyUJ^xUMNAIjl|^EQb6KVFx0Y8~`|aTs(Q}3y-bl(1*!e|47>CE? zypKjph{QIr3M(rKOCbHHJ=4f!{*E(V8X_`uI~d*1SsCiwV#(OzlN?_@_1hC}RPZl4iWR*GoR@O;tVy{KF=lCWY)xBhm0I{`Fce zNcycdY2ky?X~JVA#KLN+E|#7sk)P|mqu?i@lAg7PQ*M@G&HhjCEPa?wmiTHBLU3Lk_|IK3I~fVvR@p; zjFut^oJV0IHA*7P?NTl^S(|*}yf;RUyE*z*flLVZY|}XhaDw3Ur4k})BkZQ@``)UdqG?AO&i2UZl7$(_#V!kyqtlRy^|@5#p8 z7rSZ?R|6+R%4ub@G=sTZj83s^HPK}*+{)7{!z5Gfo3F-No8N=Te0BD&|o%cr8mb3-`hyzd!70aJ>ClsW@7?_@?X@&dWlemQf z+k+j7WYkivTz{^02%R}avwpn%?9gK$gunO?3`7}X9)Vacd6y9;4~PPmg|1Ub%A^m2 z!M4RR2j5arQ_(fC$tlT^*)02#USe=>qab&1d3VM3=`svAlE?aX#mZS!Bn*n-xO)hr zfkz~w`fOCnv_Bt1IuiGv1Cp9V3rT~f9L}>hJ7rTl}jgiQAoslMl=V9U(tc zqDgd_fMdb~FQ`i+qP7C_)WY@W6?G;kMFi_!bNBK2$z(yG7{H{m_q|B0#+8uoTgJV` z+qfIO*=wOAOXkOjd7S#n69q6bk{)HzFrcs4jT5{?5G`*n4v57p2Pc$LgAzH(@X9w5 z2jf;f18|XtrO}MVdvk;0hBT zr%EX}G*|8)2^%odD973N+8RdGz2sfbR*3SlSo%ydq2M{ncYluUJQmv`Z_c5S1bJdk zdq~7uEooo-ZYxf!b@BG9t_(Xj^~j@?PCn>{McUi(6Cwd8CeeqS*kz(@e4C^B1c+_3 zy$V4f`>}#zT!J|x0CEsmvOsW9@ZA=v`-CN#;;=JmF{&8794Xlpkn>ABf1wizwtC5d zhH$C=u4ibJAhu!30BSo!fo|^E)UU#6cB+!y4*4B6E6$C1Isd`&Wny8<>-V39+XQBr zMhi|_MZFqiBgdfT3MInB7l(3q(d^-TY3(9z$HbsiL)fbkW}hK5#*yIf>?x!bt#3Hqc#z>Bmy}4SXo>P07yE39 zGmSpJpLx>1=!|aj~@cJDK^f1lR6Nc+D`ArU;j2o{C2Kbw8~nD!~he1 zlh(qjez#&d=Oaj>a%MXWR>~?x64+Uk9R<9KE7;|&Y%eKBu~lVF%I{Sj<0>$JV|VD_ z55}N)a%p}8Y_C)*&Ki~RYrud77z+}h%UOaz1{IQZm@Fhxgfzf(elL$f4VpY@@A!t` zKKFy_*I3#8)lSn%xr#Oyai93TCb_NpJEt)tM&Dc=(9>LkGSU042b=fO);5wgm+Ir% z-nnp+;a`>iBVikccH;2$fk)F{2=<=`OsQKa@uPmVAO*(oFX3t^7gwg&zxDzil_A~m zNyrm|8X>GmR?<&a`S(I%Fmo!=IK?xXKhm||N|OOrrQU{R(eQccjT0?jN(h4Wv2znq zoBQQoWQBM-s9ZMXwuJ#ur(FQZ=;Tm)W8(ySIi0l-eh!Ftw$8E6K65_}L*Y?9(=gJU zsbE>f!dnxf((|@$mJ)9^nj??WSDA^ONscu6cDMts`~XW=f0584o!zW_l35~ja$-R( zrL~p;fb(%^)8JPcvbRKf1l~EVxFa(RCHnmVqMU?-C=B!HS{-T5=fuUhf3!1t-8#qHr;%LT-(7lOYbO1~Roc=|sjVdy)}x ziYh3U3Q}y%y9w&bFwmh?y4w5ItFd_z8LCX5p(CLK@Li^|<^(G!oP9fzymIxLLQZn-WsL3j`v$3MtroH= z7A?XCJkdOGBD|>3LCC?#QkzrJHb%**v1)r4dbrR)nY-v}mzTKeK6ET`(dbU95VdDU z=kd=UnLUFQ1n9~S=&^9%!cC_OSJrsmfly{ahcW`m3vO3o;N%7R!%<7~%+pd1Q% z`hMBqo#4M!o^DKfu$tJ%;8t>O(j_yp4l(4`w+2`l?sW-3_3sE?=)Pi zqt^&ENYznww-ZHM_8D(Z`=X}TVk0IJBV-3ZO6-U1gx1T!GG8|mB%8XF&NZrq7}OI* zl_h)${66-f59FR_`Kn5}+-8?*H8@?qA~-of`}2^`xRt2B`AdH$M#nWm6E(f4I@h(L zdn}7STwCwctfD*HLeKEY*|ERLCExIRnKM)l;=nRkE#%li{q|Vrg~7+9FQJj96QEuS)ucQ6}^h8iCx8xR9j&nvIV8v%L& zO(CWq&hik9^!zoDI%o^!Lpw>A2si17N_^frd(h8=4)VltljvA}N*YM1Aiy`>=-?!B zLUc7uUCdPypnPu}K_-5)3cF19H*G>tWfDtURH2yyP(Df9C0&JfLIMLyts7==(_Z*} zNH`^x){019DSU=O_+}uCgx6w)#*K|k4Nqo?^Ostdnr&Sk5zAa)RKxM7`{4>#gQ?fP z#|QC9mW?qsabSR{NzCe+fH{#wjUbfLSbd?A>_^j5^kM|m$j%xd!>le z)s9mS8p4iD1>{rDR)`{~Sm;cWtH2Lt4aGs=I-milVyJQ`P*K$EA5&2IisN$NTbj5SMXlTGt9JEST0ohzsJT_ z8%B@$v4X1LZ+miiZ1qkejAbf`GmO0ajwUfCu0<+fm_sFX&^scM#Qt;P#Q3Dk*%l;q zwS`-g@lHyAjdC)BIpFNIWf{c8`m3tnRa|~a6}FNu%2|`Xv?sGg+JmW|g?tlZ%HguO zJ;oX7%6TYYPK`CdlYEHB>854+GDF%I(e$Cm=c!Ew9QtkKOPZVq8h|ttqaxYphhheA zEvX}r2#G>W{6aQcrrfpf#R|$f|8f@5EO3G`u^d|ZQcK<{b=W*AFpRF7BO+Z?K+;O0 zH`M|CD0T^1Ild4y!Hj_)10p5*^j*pS9^|8v9FTJafv`%d7!WMyfWE8|FYw!v4;2&vtN!vQ)E8x&a9uAc>f09;Go8`*J2c=klbfM4g z1A-QYK8o8h$o*VFVWG+@mh@CXZ5ys-?URJxbAr6ud6^w%B<9u;osT{L+sywy=X~u| z^udHdm{SS7-lBkAd@?>34Xh@Wtc(b8hf)`45@B!{3}YvTg_d_DdUWwsNNO9rPOn+AwDaa;;2;wFe~NA>9deT zCAG5d(^@$HMjE3PA4P-880MUu9Qd&ewmu$-$|{p+B1%kw0}ERdoU!Hh#q(k;pynSK zD0Eheb*CbpXPW`frO22WD#-yDwu&_Ebk?!nar%o^?**n@=(JNu%SyP`$UAH4c<(k% zIaR1{T_3BSyzVPFwlAX(FXjw!tN{Sf1+X|dr%sI4B>DtT{+hme%0_56KIU&fendFG zSR$%9u$L)qubx+;GIYUTY6K0{&FPtx>--XOEX|$@X`1YOo#-#L} zG5tdaF|dDTB*gQN1s+N#?wv6l#(l4t)=Cl{rSwM?=hA%mw^bJaXd?OodS$>p}JX2?ubMrvG<(mEB zG>lE9vw+e5#^+Ug?pEQ);{P9*YlHi{ZW$O7_ld(EiDEDXWrLkEm*`L=uij2@g-3aa zd<1elda+ZV$Jhq7%4NR+8@8<=7ilkCS7zYyolg1I7-zgLTD`HicJa1^N@~zGjcC!KEZZp#~O8xCrcW!FK8Gu zO7skFdtzNwfpmm;RkA_4P6mEbP_HwJeLqHt%_|age8>y?lYZ+{1&#XV;dA1D?sDch zvdrVOb)C0aS01KdsRLfdOOllOy;nRph_wi;K(VFlUfmnTB@#FJ# zT_rX?K^_c5E-fo8|LK*kN-?8iqU$jzlUV-_C`u5S2n*&E%1X#oj75Husv?o0!Nhi4 ztvD6;Z1;(@3lnc-H3tcLbA~VjW2HE8g6;RTVw0svB5baWb_LYq?v0`*x)udrXl7Jd zsp2-(wTIF?AeC2At>yXIW z+@XA!T69jwWURkuVP+HL#gD)wa23hLJ}-i!u3ZG1rg! zw>tqa>+5IHK9$XiD&3PEzkJS(vl5dJ6}0jxcn^-HnkpWWwT!As5T7{9<#_xSnJ075 z{&26a=@{k{N=S%_xvquj{Z4dL(IES3m>n9+rc>WJ9O)4%Xr&yi!e|x26v_t9D~an* zPRpJl8_JcQ=Qh=htaX(88@^dHEJ;=?oeoU2BYTCsv9d?K!athy)8!^LVkQ`|7+C*)Q9Jg2o*Ly-O zv`SNxCU?>#OH$qo)LH1m4LsG5_x7V^N`~SD=a*c^TMy-tWbyzck*2ejct9RKY(fxK zsJRth2T6Px+sDW==@!7+4t)jM-&ufdbyf+9$mBWKH;^Dny%wk=c$>*^y zJAkg6(MMXVXrsvHVRE#V-nK0k45$)eb;POu5+w1Qn18xb| zB`M;y0)?`;3FBclqf7dRVwhSaGUYos_-c{kKM5DeK}x{j-g>Y!w=qaR(_Io(G3D|R zw|FST`gkT8TE*>|N6)+Q(Zsebd!16N=vR^2nP}Abv9n}!vDw^h&N}V=5k5A)*US>~ zR7R<|1T;M%-)y2~<(wg7yQNYaGgJy$oe3c-(yl+AKHv5~39O*WGf0FXvr9e- zS(~A6q}rx9Z>4PY*C%s}#3F3B6i^b}&^(?69$o1$AQ*v}ZesBLQ|O!Q(BGYrZt?7&fp zW7y-&>|s)Jl)IxcHWgRuLz3sY|47&ZpcOifJ9Emx)7vCJ7~5wg09RXN%K3kE^yS}VV1)m)!><#`2ZWyy@0 z=FQD<)yX`fr_5sVKolroOj# zh~1jjsZ5>-^9T)V&rYNt-@D}^2sahzSrJLnDs#;7JC z1;OnpIsG@&0_*+4fW$2YDh*;19zj^R3bC!FLCnU{$4zLJTusb10<2f|nJ>Fv)kz+? zmNM&4mLvb+dAHMVg6U8&5_8)Q{ygz~Rq#>nd~(fi|+GZGHi z_HZHQ7GDcy5@LBzHHMuK5QJX=iVg}sxFnj^8x67>YEj2NTG1#mt<;KkDb{}GrtokQ z5SFW$k5n#G9LI`5iH*+vUl0i+O?Mc3;L-4-FCc&XmspZ5Wc^XUwv!3?mskQ|t*b5H zP&ZTOPOzK z*Vzlu=w;kw?hzBGOFoPrkt-oyPOUhNU=@qpoG#vuB)$BqE!=3h@R-omch~to(CO5- zYx5IV_M?$q*;Q_?FDYZF`J3y^7G;xcUt-W1F^ybs1{18ZG#%h24hiV{#cuMzbJODg zK#u6KVblI;w`nouFSY%gQt3h5B7Pf%JNhU?p1W!1KV#6-_X4rD6c<3m8# zkg(dfSgrtta9A>j(H^@D2P^&rYt{hEM**K4e-rzIa|o{?DJ5?2B?f+8Drx-wj*x&k zCqaBh^62nEe~D9h15?9AwEa=asp^riGnV#Cp@NiTa1KR({lOt-QAI$iy@8NKh2pzo zf}5cWZl7t1$~>XilL;$!T^sg0`-AGJ7#`Jah<*9H<&`e#1_$*ws`EeR$aehZV7IejgJ*;G*{xSGAJiCPVEnyI?FX208Hl+?~220wLiN0xJ>iWb4v{! z%STT=>$8vPXV1&e|EE1q0JJamqwkHZb~t+fm$ryApr5je*l7n?9S{Hj26x)mACGQ6 z98|u_GJMWhPZ+B7nyJAxY?*`vD{-(cq8JEa4r3U_JI+9z;pDCuSEmfsi~?G$Kot)7 z7+V4DH14VdzRjI?@$9HA$3$ou;g4omWxR7s<(6H=@q3*l^vlUu$yM!JVtP6f^1a3i zXq2GOHzBMvZZ7rK0rxg)cB1*>q>Ar}PL3>;8oCY7Rt3{)0+)@)RloRi;g z(bNmL)jiG1_vN(gI_a-Gs_ZJ_Q^b6Xjbp?M`x*6q@qJE={mZCV$Myoa?`cseT|F&C z>{_GAerwd-^Wc~A*y1hN4KG07>KM|sHBfN$2>$%3>0_a;x`aWM|6jdl6QlUg%sd?; zWf3WzyC-bf?m0(4xwu(Fm4(&JG( zqB+q?|BaGyyPrjWOy(*&F>DVU$_^MDcL(PcU&s-}k&FW8i9mmiUJ@s@;nM0~l&~3@ zbo7x%X#rabjeAHLKJiFM@^Es=nS6}W;BVmHJ=obJW(<$1qV^m5P2<^BJCy1SamDuF zw!^D`Z|4iL1?cT%j&dI0jfgHd`(G-U_MsX2`6cvtIt6a0yNsj6Cpjif8euC=(zI7r zQJ2gJg$8p`7XKsRCxCPns`{MN_Tz;8M*Nh)&K#44uPdA9G|NY4J*HdR|2*^mMjc{N|E)oYEI`drZOUbclplnSgcLzlAzu?q z#7hE+;^B+bv5unf09a3enz zBH^k5)#G!|$?Giw9UKxao}9#(pIHk(&dkY-TVCY6EatJ9flG3*-W(|t*JtnbbSi1@`La$-$;68Ad7DWip4NLH8eNnX7@;|> zD|mk_Vae*CL~>*@Kest{UAPh+(|rQSu1cSnz>ncO339b+e4h(#vt08>8cYb5Gyy!e zOkKjMhP;YJncbC}b8=MG&yYTv|7ie^Au^H3iypXVlRpE|et3xjh&1xX#t9DsOL)jY z9DoN!y|y5{kY0@iFbilhM*(SL<=!$&(padKKRb$;r-oxqnDEqZ7Y@{E`4%_w+8_K} zWUqfNZ=k=7SAMTSbHxcJkA03&XtIiF&LnvvpQF`(MRo$d2+H@Ui#dC9KBT}u!K!TC ziQa_9l{pSeZW{F3Cu%L6S-~Rtt?=xcGa`^_z{2#s1UBNl=ZyGb+6#TvgLVGtet}%G zsDiBsT1BEmkYy9!+Sw#ERAF@@r$Qw{ zvkZRk7}vkwIOg6ViD%8%K5Gut@vX1aqJ5M#x&s$lV<9)lN9?g1Rq3OlhZNs3NSHO8 zird#Z)sLf-FDlDn1PDnbvqU?vD8LuYtUy7y--$bpuiw~donvFYp-8d4ebwRj>$$`B zJtT=Sc9+TfS`{Vd8@|>he})~qal|C8;VGZ(obV60?iBC$5y7F~4;w$@n4jW5*}vWX z@bd@r5s0UE!Pnz${JA(=usV6A3^3g+=qw1j z=(&vu=)K1lM^eEoXx3;aU2Fl1tanUj@<=t{7i7Fju)hA-@*tFshLk|5RZ1O`I7^zS zG+1unM)37GxczFeghj?kTd)dX`uXJ%^8nfHWgw~GV zW(8Rf8-F9+qdD|nbf&TT=(JFR_l=OQYI1TMxvxrnbs^s1CjH>U-w)(&;klX#<-mX1 za|S?{c2xG#5b~$_UqOwUB7y3R_w8uM|FmbZGpFu$YO5vo1>;WuFD3M=6O4~|m0*?3 z660>sIfZWi23q2fQ&q($TZwum^zj*+XXB1|Zce*~sI50UKDY5Jy-Fe|Ejr<~5f%!X z`J|-C$RY3!Hini!0Z8-_$3Z2`WsURW^u@}aW<1#}7@55cFNo2eDyKDOi`YSzV|?N7 zs<`)a!`h!bJbyJ(9Z5fV&9L@RVXr=G%v(EtLnw?Xo}D(JTCw6+b8mIxRir8!+A(aD zI)XGq&hi-RP#07SCkiEm3cM_wN27{%VTw|B2?i2|W7!{z%^Dy-u;^wQhjK;7)U+0_ zLsZiATz?K3#hPpwpCt|W7{>;##qDPSa^c28hcI_-tZcHeLPh7^*3HGurFEF zvE%XHxcye1q+S3JPUSHSkpYa?jnq%{XYOL9_nj+iigV5uo8COfONf89XT%dc%Ew-w zSGI*{iIcyf9*1BDkh(}C%1G&Ft%vO0izQTyOp$&-kL+HG^-CLmtqXT}eJ;Uf+j8jI z>_iuy4J^vK3dcMRtD_b4uRjiprC#Ah(I)W>eTZc-F_8HyNh^OtpuMx-oQgzlo{vXb- z4TOz+yn*0!7>%QK6y+J1h()!5?H5xoC6J(n7ORXr2}VgC+M(J-kAmNKcaWY)6#)CT z^`pqi>_M7$a`HD_MEt~O3Rr3RLA_4}F`v~zdZ+$m7GGbK_YKa0IBz zf+o#lx0+fwn)z}#yhEUUR8ZB9{Ai*-ut*TJ)-rLWi6cob9a18;D=UWOn{)Uhqx(iGTELRX5ZAAE3M|rW8Z{C+ej7ixbhSFgUZbvI?`v2w|*uphw9>6?z(D>=c?%rn*JI^~*Hq zZDY4ytTu7B+}FdJUxsS^w|7L^wZ&zP_}IGNQmSOjP`( zA>76$^B-}v{IWz-yom=a-#{xaueC+3l=O)7qL2 z)(;gmYozU0rm4Eg$HG6w2yv_P`15e#7}U(f2W!oljjwa9qj_3aZJ_`{qb?)1TVlmj z{`UEd-*ab+YUC!aN4Mge(GZFA&nm&Gu7UyKOgf8z`{_d&26UB5IdET02)mN5+{A^Y z@Mh{}gplAL2&UFC&#(m4P#UD-Mr9>{O4v|v)Hj+;M3-hNMAJLEho+lQ((tDyeE6_v z*H1&OHA;IaT5Da&+{{GQ@yJK3`z|&gUx$f@U{= zjVeZF(jiHQ$F^Q>H>>wbc^YwJCgl&N=Q7Fgnx@=8cv2q#cdI+a3B9@<{Ib~OJLOe|7`%gU0-e|W z2Wfq3=I_dQ?nj%rj>FO8r(Awd#wYX5Ewk4asZa29x&>|%8+R+F{Ihm90CdgxA!kk@ zYc{}t?IScDvP3n!%Q8LxYb5$4V$|K=-X1TByYp{+v!MlH>gEuGHCqH=$^;x zeRVE_|6-mVmaE>ve4O^9!j|DTQ=gu~kBG-j>F1yp(RAy7BIFlgBSReRQL5QE9~!xi z%s^m+L5X6|>&~njEiNah!mBHT!HWS+#u+2{ql80^*%Mq^w(b~Guq_nrd;EcIy27=~ z9dJ#JQPPJ5)%7YDA=stAoZHuRug+7n99=^m7#xSUV`fRZ3(3TzP3Ci@p&Nv$VZIEN zZg%s_Og96|%EjQ_4ZzI;uD5q><|mdtnV4MEeM??olgS5Vu#hvl*36gHwnOyYxn4@M z)3I}8(^bUzFIic%EVcC$kBRv-{a(+fuH=drp)Z!Gm=N!><5}z+FS@Gy_ST7OyyV^8 zzRFKL;hM2`AJH2RZv91sz7<4L$f3;s$VJ3AssnrqQwDKP*nk>(@0Vxq=ZL(%TtZK& zvyW=il96Z}iV?5o5f6x`vcT6p_o(YfNtkTO3Q-#xphcO;22Z5{UK+kNF?1|_4HOQw znbFkbB?trWTD3user!<}T1VM0H-qi;D~qqMN211Tb@UJ-v4u&qkXaex$*Hz4^GjQX z*r@GE4xZVXDK_uu-Z`@>5gS>md?0?|sK541mtq>)tg6Fx=|An60ibusC_ESLu6PUn zi@9jyWkJ>OjozvMwU20;^}VZ67ft|acOxY$rp?a^dblu$Z2990iY+BAVNh!&5YAE< zDqLFndQq;csm4`~LD`DIdq0y~Qr)s-uXwIEiU-ny*k$dlv8_2SB8`vOZf)mP-h<=L zGl!%#wO?j^IgWcufF5RAL~nF6>c4AKcaN$pnvv4Zv{z8EMk9)@JD|-ZHHnZ?q&l2+ zFmgR7W3d?ILv4ZU53=>DtWj8*o|yN{JpSixJtZKHOOS@@_A}g*4(;k~wcAzGXygG2# z`&@Rc5yN8h4@KB#t0vLH+OCx1(W`RAGlO_nY4X&BN-_Q83}1ym1=Er!M}n*c@MTPv zR93`)a064}k;Y|IzV1;hefF6;_$W+KOs5oqb*&M`kdqO(&eXPAm-?c?_H!5L^LVT{ zeY<+?|Ix(cJdZ&w8<)gOCUFHx9g@J3h~aL19#oa-!2lX|7Y%h12}$GsfgxL?TQpE0 zk6eb?4s+*&Q<&;29GKw}UGK0~EcW~LG*n=bjYn{9&MEu9mioj-;>TdACazLYEz{|e z7#SK1MwLy|!J-tUC*}w^3NR!Of|Ny#jV2bSm;58{D*!z#QGTCOXy>_2CE(ei0^`Zz z$4T-55@C$I&#h}3>B)GaQ$vPjf`P5*tMvTYryB1B3n#g+*)HNN;p*Ec*#q*UmYPe`M`kET%J5%-#!(`ZWMg9F?YiqB)wl7BVfEgLIle@ft?2bvq$F#$zkI3AfCHQbbTu@PFFlJ= zk?}~{t6a1TQ7zoW*k~1v6rA)Zh@Lu@>SWI6)R!o_j2EBH0f|-UOUs-}ud6tT2pGhZ z*;(?BIHUCM;Ao*v&_T?>LXIEKQ0_*@9~VKY9lZWwi57k&u8mbv*wXYh(}@)5Oy7q+=EiCR{oEP^L?>B^G3ynQ2A3H`$45&yqC9*F zsLU~`vC32(?}Cv0yfK-hemXb>cA0tcl zZy}y1-F{6$R%83gyGb{(+I{r&4XCm~Mz#goF9~b{k_ABtil<+5V-FftEFxa;7{2DX zZ~j)|3&NQAx!X*|j5=hMExf5d6%Fj->cJQGJ#B#Hl= zS5gW6Uvt9Ono>fQ5}^biLK}3q6^OB5$g-DJR%=OaK!w7Y*ky)Jb9(s;G9uHABxpvq zPmXy5VOBSb9g%AWg_~K&jq|*!z%HxH8>MXTRc}429dPf0y)}E<^9j$K64g-l2st-7 z<6yOt0_ZntEMl0-ew^?O(ogiSr>5IXpT&e&q?c_xJ5Wtu$v2~gAx`ieYFxJU3ma65 zlwk6zC@>`3MHwa`MGfOCG6<~u8^I4=84e;t@j(9N@+~fSY8We?JiA5|PqiAVzbZ#5 zQ$juuzA6G^&sKEoQj(3v@vn)VdHmP7Z{oR5B7uTvGhjP<-LXO?b_NnG&2De|ERL6< zL7gv^vOIC2phLDS081CC6cl1p2R;0bx);tJd(ZY4{#qa00!mjHk`>g=(E*u)xZxS0 z*d-*ohe`&J(7e=xuC=^ZLyUo~99e&ceYLdd%*s+gy882rhjgrcLY4<_Dmse#D~6r> z&QzHc7tDQfy}VQgF^Q5|gm(_SbEbNj-<*BQ_GSuRWsDaCAsrI5`8CTZR?$|Sp7@MV z{PZwU!QRZx_&@D^S5T8t*KX)VdXsJl0Yi}vA|gTvB{WIsO$mb1dsWoXJA}}SNC~|M zkfI3Edv69odKDEEEQtA||95WA{4?j~%$%F^USuZkypwrn@0DjiYwc$}+f4u0Et=(^ zagKBs5OYA7x*&62s8F9Xtb##N>i!lP88;;!1rTEBLiN&yIah^Q&u?}CUN6{RKU0|9 z1(p%UN>8%`fx6-}VV*-M!mJDf6!^_#Ersz(jpnDD8hI`(@0t9AJ&Otpt?%6N z3;W$3EZ&!~YGGrw86`g5)37hr^F$MgK4;2GaKEPE6m8>NJDL0Xy#9*5MZs(Fq<0A$ zdNv}AY2)fME`K9#9Zl0kia2QlV`20^q4t#m4d$AL_uaLCe>tQdrm);wa^L&WssG@O z3Pn4 z!us~5-?S4}whT?c5O#rhm`FWkTP_`$nNYSl`_#>wav&b^1jmzYvxxM9j0tfK__!Y%}FDiKp6aCYG$sIzm}^;w={ zJ%lye`8QIpIcTqRpyk%oAqo6jAjGiR*?=NVN58mHv~2vWKChwH*Rk@KnC6aQ1GqvM zc?O0XnEi^8f9cZN+eB6aa3c9kGt30S3$*8mwmkIkms?QlE!1%{^4k`}-tfw3 zK66fuO*;I1Q_!pQQ-sUcnTJK*njAjmQ^Vks4nG0;YvK;%cwt|5iL~d1h0O-ibro

$p9;1<1G^uOBg~iuE!UYQn~wzMF$Yde(Y$Y9I3)_;t|9H)0kIm4HH|9hIy8u6k3tFF*yq%g!B-YJOe>VPYkhY% zseb;=MXC&*sLz3|iwRu}z5DvosF_W`FW)kKj#N$rxdnDlL_7f(=ah9K<^wm=FH8^- zlR4gUPAX~bnKO3MUUD2loy8jt18yW=;o+K+Of%mA12)3txjj`K2#A=lEv73pvA{WG ztE|`5X;oI*OeR0X^||pH-p{Qib?7~u#jnuC)Lr{BAg=rI4hz89PW0Fz7GVL1T+Rt$ z9oJsbrDL(WFX^dwM((yWqcRhX|0ZV+H)M4VZW%J5{Hk||FnIgKdGc!<<1A9CFt8nA zpKhzz=*&2G2X-@YiKpTk`PL@um+_66fi%ukr7(v-{s;4FF&u{sJo~>+OHb*U7az1e z)2i=zRT4k{1Y7g;4Q3Jfn6BzaFf6T`HBvDQ32PN|GT+OQt0q`_@)~S@w``T&W}UwQ z^IQAs5IVy4Luw>u$qpC7h8tGVw&SGBOLk!c?@2y6yaL!wM{zMJUw05!XV{7Jet5Tw zn!8%6xBG`EL|pADr@9CYvMpO%(ztp(oZKuv&RWL)$Ezde()it4rA>1Wf7OEqaUW~7 z58s9Li08KR@9us6wzwF$q9@(-r?qu)UtqO|iIyTp9IO}_V;rl_YupX|G#$Y%pzqzr z!bTqc&3;XFEbY$`dRV%`0P89*Bs;(g^JmfAYs9-U-9MN(vR!sNshe z@UQ-ZaSIsDLrJCX+ui>ZWr8G(OOhdUcLIvG>`B%%BJ(b`%AZxnd`+13)v9i6zwa55 zr2yE+V1YKMj+#zj4yL{K8?=C4OfpMr;P!#rgSv@$#z6U%i~u^Pm%K&{ZlipR*KgloAwUO|kfycT~zy(D*EDER?4S{$+ z9jNT&xKN_AXz{j9s%wHSQy%cHRp$BQV%`%8hF{D z8|Z@_rezR15rC30ad<^Ev{PYCALd53uow#)mx3)^7IBd9oVf6(#m2%+U=4NWH@@c2 zJ@gH)R*ed+q%qK2TJl3NRzAs9iZpcSumIK^KGPW;n6l^uZ4@nC8D5^6-F9xy_5E8z zQB-Rs@QsSbk0NoW?~$|LI@WLZ@b3AbKPr)_j^Qn5WVF%W8(MAuibVRvmD|wG7ZP!@KapTjQ!<;k? zGK~wHgf6K3t57D>c;^8~oNW#}t0;?NEc0L}@MK z*~v;T>9Qyam>b)Nsb2ziC1r^3+3NTt7>wP*fDJ88Z@eiBbejG(A)f-L(0Xuh$Y(eE z>0)BE<&U-4a9fphGHdA1m3 zy~3tyV=exU9tHLB{yeC4=H+-51~6^dg(b^huMLIpk}w$B^}G+fvK8zXo) zW|L_-7#Jk4ndSN#S5X^RreXLMOcewp;BymUQ0rw8CiOkvAwf+V6q0NhWQ_#+?)`>K z<+1nRQnRl%h;!AkWMCrY-VMJh&#J7}k(kKpOLcqbHo4GIgMZ!PFjD-k;fE*W4pT@6 zuJ8SmLY#q>K3gQ_;2P?+(`Co)SsR5ytO&bB@fVHC5EVThwVJ3Qp zvLpKII`|7n2d^u)-#ucN1o8NV$)~fDn2hB=^`Acfnd&!j3v6lUgM%5NO;4v5duh!X zc)^D9^BN!3)rTTmsi~oF!}@y6I^-0iRV26hUF3R-O~fa+;(}p9Vpb`qm%P_Z3Uf!m zLR%Gf4tb+kqo2?ibYBmvc%L%~L_Dx?x=P-PK?pYICMsA}J(FrHPxG%&&@|w3e@gGB zfq}PjH@6EnDOaT@McgfE^*)k9js*aStf^T-zk0v~-{n=!FAVC(n_n$DM(PWSI?=9i z8HOUCdX&oX!3ecQ2*Gu2cIm?h5qLc17t9QpA< zozKh&*rnVc;4REvEp<8NS(dnKv5AZ+8G4&tq5_qj4Pjra=h1R`FKWgBBTAkb~j z{z%b=*g@T)N*0$Qeo<1-C4g>}S{JON#RQdj67gB#vz{u^Fs@DYrOM-Z;x}T~Mc$LY z61P9~dqrN$NAp8z&KNH^e;BnIaB8h+R+%ncXbppHKn>98Hre+akhgFa7P7&yl%5>b zPr{lrE?9$0AF>Ob ze0B=)Byt%Mrlk23vK~I8E0KGgHziZRO$|PPC={rN{Vg@X5ymp@zE0?@GVU)xpayNgeJu;LKfCuH`gT4CPPL&ndyxJ&>qhj=REDd% z1DlOjOfaFOc2f(Xa>LoG0P7;PHs9;_5OKkj6c2_WNK0edhV1;tKsFG2`lYq7qO}96 zXiWUotz2LI3c~Hxk&E&w9DEX6CzfXj%pJQExa1e1m$RD_=c`g9UtkG zhW<%>u}J*&W_2>r;?#ynJSso?R^@fn`Lgf57)vSnGiplK^^Rk_wWI`#BeV}l22gj= zh~{4FA9a+G;58DNR5$KEClzNPw9!*?c>2S3+7vwD_)G~oD@jysWv4cvh?gb z0gmhygAP-_#K4y$!z6XV+|SwIy>0dbU{dNFee@kty6c&5az+&iV`C>NUsbV@hAisV&y_K)I410knb&Aj(*mGe#y9 zH3Z}=LPpE|R5y0`nZdC-m|MU0o#OQ*D+YMx*~m+*bh2r~f95*X_AO z`2m2xgs~P(=>7~q*^|Juc^rD);V8G=9?ERZh=ne$3?pi?zjW ziBptToF|r;0t`sr)^c_!YlQ!!mtt!+58$RaJXz&z0n4=ncjF2F* z9kJ;B3j0U&R;EIc&__ph+?dND8)@%1Qaw2uDJ&O6@FAR-=hqjbZ2&J+*ux1$U)idN`-OW`|rQ z##n;IE0oIHlq%R>oYP}FN$I%*vVvYkMQy4Sp(g6#$Z2$RUEoG56Dau<$PURtNxXqBZ015VuMMUnRA7ZY z{xT60&O@Wk|J-4A0W?V%7^x$2N&)B`N(ll0 zwKW)PZ(ZxI1pMoWG>E?=<%z2dA~YA9lub_<_oX|`sva%nrOECuJM(%RyHJQb2*i8b zQospWdEj88SqX5+s0E~C$l=g$huu4bE_ymIoCaH=A!>op;byHvl)j}tD5=!Xk>Uer zm$ss*T?B;ompChVowz8-_Zj4`QSiGB^Kgl84id}~gN%O9*ZRfIXC1Z7SP8>f9#uUA zOCM(*$J^VnM4Biu%Jds@>_~PfF))=PpmPbVVvi`5E@Ojv;k)G4<3E<#XW;I0rZ_iO;Xbe@x51LgnlvWm7rHn;sylcVz-GoLKA z*t4?Y>GZ*}_JzdchMMKMWrKWZyxW|El{PlaH@u{r6@OJpRsW=5S#_#3Uo-oz?YyX5 zCm5+2LUX$h6n#;vHX+jKBXsr&vi0%BY8QrBVzhT@e?|2T-eO0iu5dnAvgm) z)p8tcE>hRJkaiZUHkIrX>7suZ?#hzQST-wHZA>L!rG$87G4yUUs*jA}NLN3yejwAQ zdX7rY-hdCegzISe5wOX(VnN9I7&J@F?|iY})jvsW6#T%k{Yn_qKU|szS35AC;kc<| zKuDw4unb#V&s?EHZyCUIB{190mM}@@aQV_p40aL>i$L0*=txaPusx;#N=*|fjQ$}d zo<7W4V{7|dG)vtQsqvTwT0#*A$yUclu(9pY8?OqhYblK8gF!mv6ZXc_+&#MK3Tl;D z&UR)=#;EjC+>>-6iWVw9?V9rxW~;9!sZD<|ZVOFQO2RlXrEaaTAMOkkfGeIFj7hTc z00J8I4F~}ErFm$2v>9IJL+pmE;5B2I9_kN$xXG zv8xKR=0<8w2mZweX1iu(rCh9{2nhea`~9#v5}Gd zSp1%+2eM3j#^2>-wqe_B92fwAj@)Kr;ow!>+e)>T0>jYmg>T|5Q|*c)g6j1-LJt4! zotfMwF~i@jMB;#W^3dVSn;;mbKi-#h$=C`c(E~E0vd($(piqx?UxIgB&wIl>PYnG& z_-hkunBAG>N=}pO!P@q{SSTmkgOP%Y1ic5-%CA17+6qUlLsxmGJomPQ^XO5|K9N<8 z*3ylXo=gWE;>{z&FO8(cO^*uMgjG}985H9oHJNZX@eXcb#7OhS3q1M6UXDz>U%aYl z#FL(aTz1*Jl3E;v%O$gM2BIk3uFnd}%|CRup9h?`;o8Ki0A3?sgdP*Jceu* z;?L76-`#&p=@_om!cwl>Kf4@{VO|~X>HLK>)54WzQMpsb1m!xg3=Z8=YjG3I0;iY^Yt~0=KSy8nfhfe*4!` zA|atgC+KGVp@oiQBk?4xNy&I0#x=F;-{t*@Jb$n?gx zU}-yyc@9h!hixma#fi$B@sZMyWbf!&E7dw2>x_A(j}EWwFq*&4ja~noN z3g&uNELFb739HR9f^8up86b{UZmHMi3()~sT48$ns#SGn&a(0hc+C|#2Bq+?=*eEVo@Fiig!#%T%VdStl=z^s$ z)peCgJvuTn_1`v^+FK4l?I+ho)_r%EUo}3sl6cP_xYNDhHQ-%;Ex}_X1SlR9vTSCd zW+)mC*Byq@I3)5}g~|2EL&JJwvK@?#KhY!T5?I6S_bSp=h1l^tbn4Y+a*_L7cfZj{ zxk=U*g=%F3p*lW^0p#mxjNu?0s?#mUkIHyUgu2z>n`M5kMOAk1LZ-@Wz2~s%g4(Fl z@0dM~fy=L$jss`nkT&o2Z{1h;g%}o{=Qz6N9_?{}G2uv`qet5<@%|hRN%3q!C@XR5qsQ;3&c|0t^u=|f z){UpKv(n-MuD4>y5#Z}(f$#YCKC9eHvdIeUg9}T4Z?DCZ0iC%9x@{4j-Lh~nyT0V_ z&2P=^jlES|oGubuAA>rrAl^v(WO|9u2Zzzm@cEHB;<9%2bhDbN^F$AlCtB=|T+Hf| zt$S&y#zxwZO)J$~J1KpmCK(?S0sh#tA)L$m`fV*J%E93)S6Bn;r`R{L;aaeBxuEhC z!C(>E2HFJ{RM;?)U#$Q=Wmg;A7&%j?jROv%6x5R(Qu>BOj3IPfvG($oD|Cf@wXUjWeBm+XdzRQ#ovSr zNaj$HZBP1!1n@pnp5oFPU>E$IlAV2BrS{gkcBV9tOZfMJf?CVFuF@A5JXtAG^+LAP5k1M ziWNk8JYT*s$iy5*BV9B!c_fkM_~5L9LHa{Oe~dy_40T<$B}>`O=HP`A{e-s0mZ)?vJ}e_c_F+MI5VX>Vs^ zuw}|?%?MGny$XPH3h>>Wo{qRM4~p#qH+xmk-ssJB63Sc`N7$A!fgYW5(NO>+1nCmh zxn#OIhQPDDWZ~PwyyOv4)P8BXLXVQQ6{(nMGgzN%3^4OV3M49AmkUD`_IzXD&pwuo z$c7d<~jk*QP@p^83^s)Tve2vfTNbqrvYTwA^mcGcY(iYcVDQ0qvK5qN`=> zxnu45SzzhUqqf=TY(M=4xfuX0IY!gNWevcC=1wd`lZoX_3;Z0%&}IXQHc9gEDhk4e zs#Ij#wPGf!-u}2SGHqoh$r?&V8E+t~Ts?cuZt90Fq{HZ)e1A$E;d?7As}Ps4N6X^+`?L99QE>dYSTGhtBkt`3K*LaROiaLqqYE@8X#S^zoCL z)3&Y2KhNAh^lTBuoWAUoX5YVchrI{;`nN@(?8>t3==ZFHi`Ctfug@<2d~K0jZ5>HF z?+tc3lbwj!xc>RxfNM-k<>8>k&-pjPdNFzLtasA{!1qe?e$qCeX=&8~G(l0lOP|qi zupgcg=ZSwlluXqV{~UDb)Dm@m5fA^wFWx)X^-qtRC>*;FiM3N1rio_&zfWA@?%X*k za*8ix7 zna6}T$_j~>_C9uVn?2QA&}De&D_fSY3Yva>xj~O|8su%^1EUU z({U~aC*OE>h3R#uMVo4KP=lZO13qc%R0(BC%0TF-qe~;SW=Cr0jNU|d!Az01dZqM9Epc4jWB|bDbCV0g zZ1KhIKlOi-;&NNMhzng8ydCowb~nW?)F96l%*^8$7x0uNza@NDy9K)A;xcWaG^x1 zd)z_Uc2+-C2H8wA`10d=%ygu`{r%XBzbQ#zN<&RnVGJRn3gCjlb zLXIwzDcoVcO`!ex84*w_TsKZ)vCdLoOSm}G4Efo*%wnWJ({48rha~tdS3epfS%Tdv z{iH=P*cvjJryTI|1|hWH^?AFqz3Z2jyjqI_+-rIF5x+&Zyz&IGpC7!i$Qxo_%9%SY zv*WpMgC*Ku5SwJv4#0bf`WQbld8mdebrno`7XSoIekY0$pPfI+J0f}BEfOsbNKEz* z@sLz$>YN$omu+6w<*k~Yl`OW3iUdTA0T3a~%phM#x5SS2XkMPJqsI+?RyICf?nVKhN$&vv^mfXm_%JQa6;Y`IN>OXh7sRWknrQ+&?-KaJI@#`Go* zCwz1RS81l-ubq7i0}bt%bR5Z>&ZQxX+QK0>s;>&aO#~rJGj6v?8yt8((C})lDvscb z8#3Nw3}9)G?;&?VQqRS1PxsH$hiCS*_e!u{zMGe`7bD-IcK6XrU* zu>IoCz!r{CCHQ{*gS$T1=Bpl(pB%=kgs7vh*WhicbKmg-HFs6{x0;e0QRL5qs>s5v zO)e!}rC<*(tWUW#t&%^*k#!OP1>>mr0zp|3Q7t^tUkA!|_Fs6X#{C+a}pJn{U(nyfq0< zd)K7g^)vBVWC&5kYxl;HpJ%9u_K4D_;|H(Gx|oMo?(e^6Ess!}3q3new4-WQ$h7Vi zC+vbdmfc-|lFIqybQ+op9D)X9=uKZSn|nEr*LPsG2C)zKN8Hl3P=s>n?YEW}_J=SW z|GmtU!iIt5v5Q0hfJ>)H5eq5@P~%@Wl@-A0=Qt9l7wGwW!Uw4~%O!ctSR*s53jo~i zCT-^5T}^in|M7Vz9{W=#2G|zn+ag)xN*~)>B_b3843exG@0hJib-7=6o{(U)aULv~ zG2dK(8>Z4zRcN6SPrdi(WE(-?FS~c{0`Nii?x}c;@NAL!2&s%anxY`}RFvk)gtD2CB1=sU#lptFRTy z&D>uZ=cJc`s0l)d>-3r@j-qyS6z{XSoo@4Jc=v~YFt0*c*zbdtq5r$J z{Neqo|8?+;lw#H2i+GN9+(e(M=xDl0YkL1@f|$O%V616yBTde~3HtZo|M-CcP<}|Y z{@;G`e|+-)-z1Fy@m$^UN7%^`@GX3Y$NoQqO=Ef=FaU5SA>{vIu>W5TA@Q8WaV_PG ZBtWBr)G_~`w + + + + + +

+ +
+ + + diff --git a/src/static/img/logo.svg b/src/static/img/logo.svg new file mode 100644 index 0000000..b996054 --- /dev/null +++ b/src/static/img/logo.svg @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/webpack.config.js b/webpack.config.js deleted file mode 100644 index 1ebe4ce..0000000 --- a/webpack.config.js +++ /dev/null @@ -1,16 +0,0 @@ -const path = require('path'); - -module.exports = { - mode: 'development', - entry: './editor.js', - output: { - filename: 'site.js', - path: path.resolve(__dirname, 'public/build') - }, - module: { - rules: [{ - test: /\.css$/, - use: [ 'style-loader', 'css-loader' ] - }], - }, -}; From a3ab7de063bdbc4b89b1d07b6af68924e926a142 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 11:24:10 -0500 Subject: [PATCH 02/16] Replicating changes from /kylestetz/slang --- README.md | 60 ++++++++++++++++++++++++++++++++--- src/helpers/parseArguments.js | 1 + 2 files changed, 57 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 17c9822..f654dad 100644 --- a/README.md +++ b/README.md @@ -98,6 +98,43 @@ play @synth 💡 Try making multiple play lines for the same sound to make polyphonic melodies and drum beats. +## Rhythm and Note Values + +Musical notes and rhythm values are a core concept of Slang, so let's look at them in a bit more detail. + +**Note values** may look familiar to you if you've ever learned an instrument. They contain both a note (like `c`, `f#`, or `a`) and a number that represents the _octave_. If you imagine a large piano, `c4` is the C key right smack in the middle of it. `c3` will be the C key one octave down from that, `c5` will be one octave up, etc. If you're unfamiliar with how the notes map to a keyboard, [here is a handy image](https://3.bp.blogspot.com/-X7bigGKA1ww/WdA-5CZ0e3I/AAAAAAAABWE/MlQ5xkgSEmICpi3HGpqnRn2gwKX7bdz1ACLcBGAs/s320/piano1.png). + +Note values can also be expressed as numbers. If you've worked with synthesizers or electronic instruments before you might be familiar with the MIDI protocol, which among other things represents all notes on a keyboard from `0` - `127`. `c4` is equivalent to the MIDI number `64`, and to move up or down an octave you can add or subtract `12`. + +Here are the notes in the fourth octave with their MIDI number equivalents: +``` +Notes: c4 c#4 d4 d#4 e4 f4 f#4 g4 g#4 a4 a#4 b4 c5 +Numbers: 64 65 66 67 68 69 70 71 72 73 74 75 76 +``` + +**Rhythm values** describe the _length_ of the note as a fraction of a _measure_. The longest possible note in Slang is `1n`, which in music notation would be referred to as a _whole note_. + +Here are all of the values and how they line up, from slowest to fastest: +- `1n` - whole note (the longest note) +- `2n` - half note (half of a whole note) +- `2t` - half note triplet (3 of these is equal to `1n`) +- `4n` - quarter note (a quarter of a whole note) +- `4t` - quarter note triplet (3 of these is equal to `2n`) +- `8n` - eighth note (1/8 of a whole note) +- `8t` - eighth note triplet (3 of these is equal to `4n`) +- `16n` - sixteenth note (1/16 of a whole note) +- `16t` - sixteenth triplet (3 of these is equal to `8n`) +- `32n` - thirty-second note (1/32 of a whole note) +- `32t` - thirty-second triplet (3 of these is equal to `16n`) +- `64n` - sixty-fourth note (1/64 of a whole note) +- `64t` - sixty-fourth triplet (3 of these is equal to `32n`) + +When creating a rhythm in Slang you can freely mix and match these values. A good rule of thumb is that you should aim for all of your rhythm values to add up to `1n` or multiples of `1n`; for example `4n 4n 4n 4n`, `4n 8n 8n 2n`, and `4n 16t 16t 16t 8n 4t 4t 4t` all add up to `1n`. + +Sometimes you'll want to pause for a beat without playing a note. This is called a _rest_ in music terminology. Adding `r` in front of any rhythm value will turn it into a rest (and it will appear lighter in color within the Slang editor); for example `4n 4n 4n r4n` will play three quarter notes and then rest for the length of one quarter note. + +In addition to the rhythm notation you can also use **number values**, which correspond to _seconds_. Slang runs at a tempo of 120 beats per minute, which means that a whole note — `1n` — is exactly `2` seconds long. Writing `(rhythm [2])` and `(rhythm [1n])` produce exactly the same rhythm. This is useful in other functions like [`(adsr)`](https://github.com/kylestetz/slang#amp-envelope---adsr-osc-attack-001-decay-0-sustain-1-release-005) where the attack, decay, and release all accept a rhythm value. + ## Syntax Functions are contained within parentheses, much like in Clojure. The first keyword in a function is the **function name**, which is followed by all of its arguments. Any argument can be a primitive value or a list (neat!); if it's a list, Slang will take one value at a time and loop back to the beginning when it reaches the end. Check out the Reference section for lots of usage examples. @@ -142,14 +179,29 @@ _Pro tip_: Any number above 11 will wrap around using modulus, so for example 25 #### Amp Envelope - `(adsr )` -Creates an amp envelope which contains an oscillator followed by ADSR values. The attack, decay, and release arguments can be numbers or rhythm values (e.g. `8n`, `8t`, `4n`, etc.). Sustain is a number from 0 - 1. +Creates an amp envelope which contains an oscillator followed by ADSR values. If you're unfamiliar with the concept of an amp envelope, check out the _Typical Stages_ section of [this tutorial](https://theproaudiofiles.com/synthesis-101-envelope-parameters-uses/). Amp envelopes control the _volume_ of a sound over the course of a single note. Since amp envelopes contain oscillators they can kick off a chain of sound. +`osc`: An oscillator function, e.g. `(osc tri)` + +`attack`: A rhythm value or number in seconds corresponding to how long the sound takes to fade in + +`decay`: A rhythm value or number in seconds corresponding to how long the sound takes to descend to the sustain value + +`sustain`: A value from `0` - `1` describing how loud the note should be while it is sustained. + +`release`: A rhythm value or number in seconds corresponding to how long the sound takes to fade from its sustain value down to `0`. + Usage: ``` -# Creates a sine wave oscillator with an amp envelope. -@synth (adsr (osc sine) 8n 8n 0.5 4n) +# Try each of these envelopes one at a time to get a feel for what ADSR does. +@synth (adsr (osc sine) 8n 8n 1 4n) +# @synth (adsr (osc sine) 0 0 1 0) +# @synth (adsr (osc sine) 4n 0 1 2n) +# @synth (adsr (osc sine) 16n 16n 0.2 8n) + +play @synth (rhythm [4n]) (notes [c4 d4 e4 f4 g4 a4 b4 c5]) ``` #### Filter - `+ (filter )` @@ -351,7 +403,7 @@ Primitive values: - **numbers** - integers and floats (`0`, `0.25`, `10000`, etc.) - **lists** (space-separated) - `[0 1 2 3 4 5 6]` - **notes** - `e3`, `d#4`, `f2`, etc. -- **rhythm** - `32t`, `32n`, `16t`, `16n`, `8t`, `8n`, `4t`, `4n`, `2n`, and `1n` +- **rhythm** - `32t`, `32n`, `16t`, `16n`, `8t`, `8n`, `4t`, `4n`, `2n`, `2t`, and `1n` - **rests** - `r32t`, `r32n`, `r16t`, `r16n`, `r8t`, `r8n`, `r4t`, `r4n`, `r2n`, and `r1n` - **special strings** - some functions take string arguments, such as `filter` and `osc` diff --git a/src/helpers/parseArguments.js b/src/helpers/parseArguments.js index 3733157..dfb505f 100644 --- a/src/helpers/parseArguments.js +++ b/src/helpers/parseArguments.js @@ -15,6 +15,7 @@ export const rhythmMap = { '8n': DIVISION * 12, '4t': DIVISION * 16, '4n':DIVISION * 24, + '2t': DIVISION * 32, '2n': DIVISION * 48, '1n': DIVISION * 96, } From 380e9f3967861f5ad966791496a402ceb153c80b Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 11:24:38 -0500 Subject: [PATCH 03/16] Removing console.log --- src/editor.js | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/editor.js b/src/editor.js index f72e116..f591d85 100644 --- a/src/editor.js +++ b/src/editor.js @@ -18,8 +18,6 @@ import './static/css/editor.css'; const keywords = Object.keys(classMap).concat(Object.keys(functionMap), ['notes', 'rhythm']); const keywordRegex = new RegExp(`(?:${keywords.join('|')})\\b`); -console.log(logo); - CodeMirror.defineSimpleMode("slang", { start: [ { From 6c39ea5129dfa1ab51676cf7fc43cfa2511616d7 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 11:33:34 -0500 Subject: [PATCH 04/16] Removing duplicated slang-grammar.js, using slang.ohm file instead --- package-lock.json | 1167 +------------------------------------ package.json | 1 + packing/webpack.config.js | 4 + src/slang-grammar.js | 128 ---- src/slang.js | 2 +- 5 files changed, 14 insertions(+), 1288 deletions(-) delete mode 100644 src/slang-grammar.js diff --git a/package-lock.json b/package-lock.json index 427ef77..123f349 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1064,12 +1064,6 @@ "long": "^3.2.0" } }, - "abbrev": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", - "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", - "dev": true - }, "accepts": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz", @@ -1193,12 +1187,6 @@ "integrity": "sha1-l6ERlkmyEa0zaR2fn0hqjsn74KM=", "dev": true }, - "amdefine": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", - "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=", - "dev": true - }, "ansi-colors": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.1.0.tgz", @@ -1245,16 +1233,6 @@ "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==", "dev": true }, - "are-we-there-yet": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz", - "integrity": "sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==", - "dev": true, - "requires": { - "delegates": "^1.0.0", - "readable-stream": "^2.0.6" - } - }, "argparse": { "version": "1.0.10", "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", @@ -1294,12 +1272,6 @@ "integrity": "sha1-7/UuN1gknTO+QCuLuOVkuytdQDE=", "dev": true }, - "array-find-index": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz", - "integrity": "sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=", - "dev": true - }, "array-flatten": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", @@ -1333,15 +1305,6 @@ "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=", "dev": true }, - "asn1": { - "version": "0.2.4", - "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz", - "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==", - "dev": true, - "requires": { - "safer-buffer": "~2.1.0" - } - }, "asn1.js": { "version": "4.10.1", "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", @@ -1362,12 +1325,6 @@ "util": "0.10.3" } }, - "assert-plus": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", - "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=", - "dev": true - }, "assign-symbols": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", @@ -1392,18 +1349,6 @@ "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=", "dev": true }, - "async-foreach": { - "version": "0.1.3", - "resolved": "https://registry.npmjs.org/async-foreach/-/async-foreach-0.1.3.tgz", - "integrity": "sha1-NhIfhFwFeBct5Bmpfb6x0W7DRUI=", - "dev": true - }, - "asynckit": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", - "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=", - "dev": true - }, "atob": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.1.tgz", @@ -1424,18 +1369,6 @@ "postcss-value-parser": "^3.2.3" } }, - "aws-sign2": { - "version": "0.7.0", - "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", - "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=", - "dev": true - }, - "aws4": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz", - "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==", - "dev": true - }, "babel-code-frame": { "version": "6.26.0", "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", @@ -2391,16 +2324,6 @@ "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==", "dev": true }, - "bcrypt-pbkdf": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", - "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=", - "dev": true, - "optional": true, - "requires": { - "tweetnacl": "^0.14.3" - } - }, "big.js": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/big.js/-/big.js-3.2.0.tgz", @@ -2419,15 +2342,6 @@ "integrity": "sha512-XBaoWE9RW8pPdPQNibZsW2zh8TW6gcarXp1FZPwT8Uop8ScSNldJEWf2k9l3HeTqdrEwsOsFcq74RiJECW34yA==", "dev": true }, - "block-stream": { - "version": "0.0.9", - "resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.9.tgz", - "integrity": "sha1-E+v+d4oDIFz+A3UUgeu0szAMEmo=", - "dev": true, - "requires": { - "inherits": "~2.0.0" - } - }, "bluebird": { "version": "3.5.1", "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.1.tgz", @@ -2745,24 +2659,6 @@ "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=", "dev": true }, - "camelcase-keys": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz", - "integrity": "sha1-MIvur/3ygRkFHvodkyITyRuPkuc=", - "dev": true, - "requires": { - "camelcase": "^2.0.0", - "map-obj": "^1.0.0" - }, - "dependencies": { - "camelcase": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-2.1.1.tgz", - "integrity": "sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=", - "dev": true - } - } - }, "caniuse-api": { "version": "1.6.1", "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-1.6.1.tgz", @@ -2787,12 +2683,6 @@ "integrity": "sha512-vftg+5p/lPsQGpnhSo/yBuYL36ai/cyjLvU3dOPJY1kkKrekLWIy8SLm+wzjX0hpCUdFTasC4/ZT7uqw4rKOnQ==", "dev": true }, - "caseless": { - "version": "0.12.0", - "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", - "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=", - "dev": true - }, "chalk": { "version": "2.4.1", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", @@ -3068,29 +2958,6 @@ "integrity": "sha1-4+JbIHrE5wGvch4staFnksrD3Fg=", "dev": true }, - "clone-deep": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-2.0.2.tgz", - "integrity": "sha512-SZegPTKjCgpQH63E+eN6mVEEPdQBOUzjyJm5Pora4lrwWRFS8I0QAxV/KD6vV/i0WuijHZWQC1fMsPEdxfdVCQ==", - "dev": true, - "requires": { - "for-own": "^1.0.0", - "is-plain-object": "^2.0.4", - "kind-of": "^6.0.0", - "shallow-clone": "^1.0.0" - }, - "dependencies": { - "for-own": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz", - "integrity": "sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=", - "dev": true, - "requires": { - "for-in": "^1.0.1" - } - } - } - }, "clone-response": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz", @@ -3205,15 +3072,6 @@ "integrity": "sha512-EDpX3a7wHMWFA7PUHWPHNWqOxIIRSJetuwl0AS5Oi/5FMV8kWm69RTlgm00GKjBO1xFHMtBbL49yRtMMdticBw==", "dev": true }, - "combined-stream": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.7.tgz", - "integrity": "sha512-brWl9y6vOB1xYPZcpZde3N9zDByXTosAeMDo4p1wzo6UMOX4vumB+TP1RZ76sfE6Md68Q0NJSrE/gbezd4Ul+w==", - "dev": true, - "requires": { - "delayed-stream": "~1.0.0" - } - }, "commander": { "version": "2.13.0", "resolved": "https://registry.npmjs.org/commander/-/commander-2.13.0.tgz", @@ -3268,12 +3126,6 @@ "date-now": "^0.1.4" } }, - "console-control-strings": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", - "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=", - "dev": true - }, "constants-browserify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", @@ -3561,15 +3413,6 @@ "source-map": "^0.5.3" } }, - "currently-unhandled": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz", - "integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=", - "dev": true, - "requires": { - "array-find-index": "^1.0.1" - } - }, "cyclist": { "version": "0.2.2", "resolved": "https://registry.npmjs.org/cyclist/-/cyclist-0.2.2.tgz", @@ -3590,15 +3433,6 @@ "integrity": "sha1-7H6lDHhWTNNsnV7Bj2Yyn63ieCk=", "dev": true }, - "dashdash": { - "version": "1.14.1", - "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", - "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", - "dev": true, - "requires": { - "assert-plus": "^1.0.0" - } - }, "date-fns": { "version": "1.29.0", "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-1.29.0.tgz", @@ -3730,18 +3564,6 @@ "rimraf": "^2.2.8" } }, - "delayed-stream": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", - "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=", - "dev": true - }, - "delegates": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", - "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=", - "dev": true - }, "depd": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", @@ -3908,17 +3730,6 @@ "stream-shift": "^1.0.0" } }, - "ecc-jsbn": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", - "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=", - "dev": true, - "optional": true, - "requires": { - "jsbn": "~0.1.0", - "safer-buffer": "^2.1.0" - } - }, "editions": { "version": "1.3.4", "resolved": "https://registry.npmjs.org/editions/-/editions-1.3.4.tgz", @@ -4036,15 +3847,6 @@ "is-arrayish": "^0.2.1" } }, - "error-stack-parser": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/error-stack-parser/-/error-stack-parser-2.0.2.tgz", - "integrity": "sha512-E1fPutRDdIj/hohG0UpT5mayXNCxXP9d+snxFsPU9X0XgccOumKraa3juDMwTUyi7+Bu5+mCGagjg4IYeNbOdw==", - "dev": true, - "requires": { - "stackframe": "^1.0.4" - } - }, "es-abstract": { "version": "1.12.0", "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz", @@ -4516,12 +4318,6 @@ } } }, - "extend": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", - "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", - "dev": true - }, "extend-shallow": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", @@ -4619,12 +4415,6 @@ } } }, - "extsprintf": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", - "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=", - "dev": true - }, "fast-deep-equal": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", @@ -4889,34 +4679,6 @@ "for-in": "^1.0.1" } }, - "forever-agent": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", - "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=", - "dev": true - }, - "form-data": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.2.tgz", - "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", - "dev": true, - "requires": { - "asynckit": "^0.4.0", - "combined-stream": "1.0.6", - "mime-types": "^2.1.12" - }, - "dependencies": { - "combined-stream": { - "version": "1.0.6", - "resolved": "http://registry.npmjs.org/combined-stream/-/combined-stream-1.0.6.tgz", - "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", - "dev": true, - "requires": { - "delayed-stream": "~1.0.0" - } - } - } - }, "forwarded": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz", @@ -4938,41 +4700,6 @@ "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=", "dev": true }, - "friendly-errors-webpack-plugin": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/friendly-errors-webpack-plugin/-/friendly-errors-webpack-plugin-1.7.0.tgz", - "integrity": "sha512-K27M3VK30wVoOarP651zDmb93R9zF28usW4ocaK3mfQeIEI5BPht/EzZs5E8QLLwbLRJQMwscAjDxYPb1FuNiw==", - "dev": true, - "requires": { - "chalk": "^1.1.3", - "error-stack-parser": "^2.0.0", - "string-width": "^2.0.0" - }, - "dependencies": { - "chalk": { - "version": "1.1.3", - "resolved": "http://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", - "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", - "dev": true, - "requires": { - "ansi-styles": "^2.2.1", - "escape-string-regexp": "^1.0.2", - "has-ansi": "^2.0.0", - "strip-ansi": "^3.0.0", - "supports-color": "^2.0.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "resolved": "http://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "requires": { - "ansi-regex": "^2.0.0" - } - } - } - }, "from2": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz", @@ -5530,18 +5257,6 @@ } } }, - "fstream": { - "version": "1.0.11", - "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.11.tgz", - "integrity": "sha1-XB+x8RdHcRTwYyoOtLcbPLD9MXE=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "inherits": "~2.0.0", - "mkdirp": ">=0.5 0", - "rimraf": "2" - } - }, "function-bind": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", @@ -5554,74 +5269,12 @@ "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", "dev": true }, - "gauge": { - "version": "2.7.4", - "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", - "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", - "dev": true, - "requires": { - "aproba": "^1.0.3", - "console-control-strings": "^1.0.0", - "has-unicode": "^2.0.0", - "object-assign": "^4.1.0", - "signal-exit": "^3.0.0", - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wide-align": "^1.1.0" - }, - "dependencies": { - "is-fullwidth-code-point": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", - "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", - "dev": true, - "requires": { - "number-is-nan": "^1.0.0" - } - }, - "string-width": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", - "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", - "dev": true, - "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "resolved": "http://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "requires": { - "ansi-regex": "^2.0.0" - } - } - } - }, - "gaze": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/gaze/-/gaze-1.1.3.tgz", - "integrity": "sha512-BRdNm8hbWzFzWHERTrejLqwHDfS4GibPoq5wjTPIoJHoBtKGPg3xAFfxmM+9ztbXelxcf2hwQcaz1PtmFeue8g==", - "dev": true, - "requires": { - "globule": "^1.0.0" - } - }, "get-caller-file": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.2.tgz", "integrity": "sha1-9wLmMSfn4jHBYKgMFVSstw1QR+U=", "dev": true }, - "get-stdin": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz", - "integrity": "sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=", - "dev": true - }, "get-stream": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", @@ -5634,15 +5287,6 @@ "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", "dev": true }, - "getpass": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", - "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", - "dev": true, - "requires": { - "assert-plus": "^1.0.0" - } - }, "gh-got": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/gh-got/-/gh-got-6.0.0.tgz", @@ -5864,17 +5508,6 @@ "pinkie-promise": "^2.0.0" } }, - "globule": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/globule/-/globule-1.2.1.tgz", - "integrity": "sha512-g7QtgWF4uYSL5/dn71WxubOrS7JVGCnFPEnoeChJmBnyR9Mw8nGoEwOgJL/RC2Te0WhbsEUCejfH8SZNJ+adYQ==", - "dev": true, - "requires": { - "glob": "~7.1.1", - "lodash": "~4.17.10", - "minimatch": "~3.0.2" - } - }, "got": { "version": "8.3.1", "resolved": "https://registry.npmjs.org/got/-/got-8.3.1.tgz", @@ -5923,22 +5556,6 @@ "lodash": "^4.17.2" } }, - "har-schema": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", - "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=", - "dev": true - }, - "har-validator": { - "version": "5.0.3", - "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.0.3.tgz", - "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", - "dev": true, - "requires": { - "ajv": "^5.1.0", - "har-schema": "^2.0.0" - } - }, "has": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/has/-/has-1.0.1.tgz", @@ -5990,12 +5607,6 @@ "has-symbol-support-x": "^1.4.1" } }, - "has-unicode": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", - "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=", - "dev": true - }, "has-value": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", @@ -6229,17 +5840,6 @@ "statuses": ">= 1.4.0 < 2" } }, - "http-signature": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", - "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", - "dev": true, - "requires": { - "assert-plus": "^1.0.0", - "jsprim": "^1.2.2", - "sshpk": "^1.7.0" - } - }, "https-browserify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", @@ -6352,12 +5952,6 @@ "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", "dev": true }, - "in-publish": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/in-publish/-/in-publish-2.0.0.tgz", - "integrity": "sha1-4g/146KvwmkDILbcVSaCqcf631E=", - "dev": true - }, "indent-string": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz", @@ -6787,12 +6381,6 @@ "has-symbols": "^1.0.0" } }, - "is-typedarray": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", - "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=", - "dev": true - }, "is-utf8": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", @@ -6835,12 +6423,6 @@ "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", "dev": true }, - "isstream": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", - "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=", - "dev": true - }, "istextorbinary": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/istextorbinary/-/istextorbinary-2.2.1.tgz", @@ -6890,13 +6472,6 @@ "esprima": "^4.0.0" } }, - "jsbn": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", - "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", - "dev": true, - "optional": true - }, "jscodeshift": { "version": "0.5.0", "resolved": "https://registry.npmjs.org/jscodeshift/-/jscodeshift-0.5.0.tgz", @@ -7029,12 +6604,6 @@ "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", "dev": true }, - "json-schema": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", - "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=", - "dev": true - }, "json-schema-traverse": { "version": "0.3.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", @@ -7047,30 +6616,12 @@ "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=", "dev": true }, - "json-stringify-safe": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", - "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=", - "dev": true - }, "json5": { "version": "0.5.1", "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=", "dev": true }, - "jsprim": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", - "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", - "dev": true, - "requires": { - "assert-plus": "1.0.0", - "extsprintf": "1.3.0", - "json-schema": "0.2.3", - "verror": "1.10.0" - } - }, "keyv": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/keyv/-/keyv-3.0.0.tgz", @@ -7438,12 +6989,6 @@ "integrity": "sha1-soqmKIorn8ZRA1x3EfZathkDMaY=", "dev": true }, - "lodash.clonedeep": { - "version": "4.5.0", - "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz", - "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=", - "dev": true - }, "lodash.defaults": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz", @@ -7479,24 +7024,12 @@ "integrity": "sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=", "dev": true }, - "lodash.mergewith": { - "version": "4.6.1", - "resolved": "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.1.tgz", - "integrity": "sha512-eWw5r+PYICtEBgrBE5hhlT6aAa75f411bgDz/ZL2KZqYV03USvucsxcHUIlGTDTECs1eunpI7HOV7U+WLDvNdQ==", - "dev": true - }, "lodash.restparam": { "version": "3.6.1", "resolved": "https://registry.npmjs.org/lodash.restparam/-/lodash.restparam-3.6.1.tgz", "integrity": "sha1-k2pOMJ7zMKdkXtQUWYbIWuWyCAU=", "dev": true }, - "lodash.tail": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/lodash.tail/-/lodash.tail-4.1.1.tgz", - "integrity": "sha1-0jM6NtnncXyK0vfKyv7HwytERmQ=", - "dev": true - }, "lodash.uniq": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", @@ -7570,16 +7103,6 @@ "js-tokens": "^3.0.0" } }, - "loud-rejection": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz", - "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", - "dev": true, - "requires": { - "currently-unhandled": "^0.4.1", - "signal-exit": "^3.0.0" - } - }, "lower-case": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-1.1.4.tgz", @@ -7631,12 +7154,6 @@ "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", "dev": true }, - "map-obj": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz", - "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=", - "dev": true - }, "map-visit": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", @@ -7778,86 +7295,6 @@ "readable-stream": "^2.0.1" } }, - "meow": { - "version": "3.7.0", - "resolved": "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz", - "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", - "dev": true, - "requires": { - "camelcase-keys": "^2.0.0", - "decamelize": "^1.1.2", - "loud-rejection": "^1.0.0", - "map-obj": "^1.0.1", - "minimist": "^1.1.3", - "normalize-package-data": "^2.3.4", - "object-assign": "^4.0.1", - "read-pkg-up": "^1.0.1", - "redent": "^1.0.0", - "trim-newlines": "^1.0.0" - }, - "dependencies": { - "load-json-file": { - "version": "1.1.0", - "resolved": "http://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", - "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "strip-bom": "^2.0.0" - } - }, - "minimist": { - "version": "1.2.0", - "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", - "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", - "dev": true - }, - "path-type": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", - "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" - } - }, - "read-pkg": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", - "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", - "dev": true, - "requires": { - "load-json-file": "^1.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^1.0.0" - } - }, - "read-pkg-up": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", - "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", - "dev": true, - "requires": { - "find-up": "^1.0.0", - "read-pkg": "^1.0.0" - } - }, - "strip-bom": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", - "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", - "dev": true, - "requires": { - "is-utf8": "^0.2.0" - } - } - } - }, "merge-descriptors": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", @@ -8060,24 +7497,6 @@ } } }, - "mixin-object": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/mixin-object/-/mixin-object-2.0.1.tgz", - "integrity": "sha1-T7lJRB2rGCVA8f4DW6YOGUel5X4=", - "dev": true, - "requires": { - "for-in": "^0.1.3", - "is-extendable": "^0.1.1" - }, - "dependencies": { - "for-in": { - "version": "0.1.8", - "resolved": "https://registry.npmjs.org/for-in/-/for-in-0.1.8.tgz", - "integrity": "sha1-2Hc5COMSVhCZUrH9ubP6hn0ndeE=", - "dev": true - } - } - }, "mkdirp": { "version": "0.5.1", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", @@ -8129,7 +7548,8 @@ "version": "2.10.0", "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz", "integrity": "sha512-bAdJv7fBLhWC+/Bls0Oza+mvTaNQtP+1RyhhhvD95pgUJz6XM5IzgmxOkItJ9tkoCiplvAnXI1tNmmUD/eScyA==", - "dev": true + "dev": true, + "optional": true }, "nanomatch": { "version": "1.2.9", @@ -8195,34 +7615,6 @@ "integrity": "sha1-VfuN62mQcHB/tn+RpGDwRIKUx30=", "dev": true }, - "node-gyp": { - "version": "3.8.0", - "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-3.8.0.tgz", - "integrity": "sha512-3g8lYefrRRzvGeSowdJKAKyks8oUpLEd/DyPV4eMhVlhJ0aNaZqIrNUIPuEWWTAoPqyFkfGrM67MC69baqn6vA==", - "dev": true, - "requires": { - "fstream": "^1.0.0", - "glob": "^7.0.3", - "graceful-fs": "^4.1.2", - "mkdirp": "^0.5.0", - "nopt": "2 || 3", - "npmlog": "0 || 1 || 2 || 3 || 4", - "osenv": "0", - "request": "^2.87.0", - "rimraf": "2", - "semver": "~5.3.0", - "tar": "^2.0.0", - "which": "1" - }, - "dependencies": { - "semver": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.3.0.tgz", - "integrity": "sha1-myzl094C0XxgEq0yaqa00M9U+U8=", - "dev": true - } - } - }, "node-libs-browser": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/node-libs-browser/-/node-libs-browser-2.1.0.tgz", @@ -8271,67 +7663,6 @@ "semver": "^5.3.0" } }, - "node-sass": { - "version": "4.9.3", - "resolved": "https://registry.npmjs.org/node-sass/-/node-sass-4.9.3.tgz", - "integrity": "sha512-XzXyGjO+84wxyH7fV6IwBOTrEBe2f0a6SBze9QWWYR/cL74AcQUks2AsqcCZenl/Fp/JVbuEaLpgrLtocwBUww==", - "dev": true, - "requires": { - "async-foreach": "^0.1.3", - "chalk": "^1.1.1", - "cross-spawn": "^3.0.0", - "gaze": "^1.0.0", - "get-stdin": "^4.0.1", - "glob": "^7.0.3", - "in-publish": "^2.0.0", - "lodash.assign": "^4.2.0", - "lodash.clonedeep": "^4.3.2", - "lodash.mergewith": "^4.6.0", - "meow": "^3.7.0", - "mkdirp": "^0.5.1", - "nan": "^2.10.0", - "node-gyp": "^3.8.0", - "npmlog": "^4.0.0", - "request": "2.87.0", - "sass-graph": "^2.2.4", - "stdout-stream": "^1.4.0", - "true-case-path": "^1.0.2" - }, - "dependencies": { - "chalk": { - "version": "1.1.3", - "resolved": "http://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", - "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", - "dev": true, - "requires": { - "ansi-styles": "^2.2.1", - "escape-string-regexp": "^1.0.2", - "has-ansi": "^2.0.0", - "strip-ansi": "^3.0.0", - "supports-color": "^2.0.0" - } - }, - "cross-spawn": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-3.0.1.tgz", - "integrity": "sha1-ElYDfsufDF9549bvE14wdwGEuYI=", - "dev": true, - "requires": { - "lru-cache": "^4.0.1", - "which": "^1.2.9" - } - }, - "strip-ansi": { - "version": "3.0.1", - "resolved": "http://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "requires": { - "ansi-regex": "^2.0.0" - } - } - } - }, "nomnom": { "version": "1.8.1", "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.8.1.tgz", @@ -8367,15 +7698,6 @@ } } }, - "nopt": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", - "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", - "dev": true, - "requires": { - "abbrev": "1" - } - }, "normalize-package-data": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz", @@ -8423,18 +7745,6 @@ "path-key": "^2.0.0" } }, - "npmlog": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz", - "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==", - "dev": true, - "requires": { - "are-we-there-yet": "~1.1.2", - "console-control-strings": "~1.1.0", - "gauge": "~2.7.3", - "set-blocking": "~2.0.0" - } - }, "nth-check": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.1.tgz", @@ -8456,12 +7766,6 @@ "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", "dev": true }, - "oauth-sign": { - "version": "0.8.2", - "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", - "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=", - "dev": true - }, "object-assign": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", @@ -8700,16 +8004,6 @@ "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", "dev": true }, - "osenv": { - "version": "0.1.5", - "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz", - "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==", - "dev": true, - "requires": { - "os-homedir": "^1.0.0", - "os-tmpdir": "^1.0.0" - } - }, "p-cancelable": { "version": "0.4.1", "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.4.1.tgz", @@ -8956,12 +8250,6 @@ "sha.js": "^2.4.8" } }, - "performance-now": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", - "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=", - "dev": true - }, "pify": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", @@ -9791,6 +9079,12 @@ } } }, + "raw-loader": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/raw-loader/-/raw-loader-0.5.1.tgz", + "integrity": "sha1-DD0L6u2KAclm2Xh793goElKpeao=", + "dev": true + }, "read-chunk": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/read-chunk/-/read-chunk-2.1.0.tgz", @@ -9897,16 +9191,6 @@ "resolve": "^1.1.6" } }, - "redent": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz", - "integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=", - "dev": true, - "requires": { - "indent-string": "^2.1.0", - "strip-indent": "^1.0.1" - } - }, "reduce-css-calc": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/reduce-css-calc/-/reduce-css-calc-1.3.0.tgz", @@ -10095,34 +9379,6 @@ "integrity": "sha1-KbvZIHinOfC8zitO5B6DeVNSKSQ=", "dev": true }, - "request": { - "version": "2.87.0", - "resolved": "https://registry.npmjs.org/request/-/request-2.87.0.tgz", - "integrity": "sha512-fcogkm7Az5bsS6Sl0sibkbhcKsnyon/jV1kF3ajGmF0c8HrttdKTPRT9hieOaQHA5HEq6r8OyWOo/o781C1tNw==", - "dev": true, - "requires": { - "aws-sign2": "~0.7.0", - "aws4": "^1.6.0", - "caseless": "~0.12.0", - "combined-stream": "~1.0.5", - "extend": "~3.0.1", - "forever-agent": "~0.6.1", - "form-data": "~2.3.1", - "har-validator": "~5.0.3", - "http-signature": "~1.2.0", - "is-typedarray": "~1.0.0", - "isstream": "~0.1.2", - "json-stringify-safe": "~5.0.1", - "mime-types": "~2.1.17", - "oauth-sign": "~0.8.2", - "performance-now": "^2.1.0", - "qs": "~6.5.1", - "safe-buffer": "^5.1.1", - "tough-cookie": "~2.3.3", - "tunnel-agent": "^0.6.0", - "uuid": "^3.1.0" - } - }, "require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", @@ -10373,193 +9629,6 @@ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", "dev": true }, - "sass-graph": { - "version": "2.2.4", - "resolved": "https://registry.npmjs.org/sass-graph/-/sass-graph-2.2.4.tgz", - "integrity": "sha1-E/vWPNHK8JCLn9k0dq1DpR0eC0k=", - "dev": true, - "requires": { - "glob": "^7.0.0", - "lodash": "^4.0.0", - "scss-tokenizer": "^0.2.3", - "yargs": "^7.0.0" - }, - "dependencies": { - "camelcase": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz", - "integrity": "sha1-MvxLn82vhF/N9+c7uXysImHwqwo=", - "dev": true - }, - "cliui": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", - "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", - "dev": true, - "requires": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wrap-ansi": "^2.0.0" - } - }, - "is-fullwidth-code-point": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", - "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", - "dev": true, - "requires": { - "number-is-nan": "^1.0.0" - } - }, - "load-json-file": { - "version": "1.1.0", - "resolved": "http://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", - "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "strip-bom": "^2.0.0" - } - }, - "os-locale": { - "version": "1.4.0", - "resolved": "http://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz", - "integrity": "sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=", - "dev": true, - "requires": { - "lcid": "^1.0.0" - } - }, - "path-type": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", - "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" - } - }, - "read-pkg": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", - "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", - "dev": true, - "requires": { - "load-json-file": "^1.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^1.0.0" - } - }, - "read-pkg-up": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", - "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", - "dev": true, - "requires": { - "find-up": "^1.0.0", - "read-pkg": "^1.0.0" - } - }, - "string-width": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", - "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", - "dev": true, - "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" - } - }, - "strip-ansi": { - "version": "3.0.1", - "resolved": "http://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", - "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", - "dev": true, - "requires": { - "ansi-regex": "^2.0.0" - } - }, - "strip-bom": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", - "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", - "dev": true, - "requires": { - "is-utf8": "^0.2.0" - } - }, - "which-module": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz", - "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8=", - "dev": true - }, - "y18n": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz", - "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=", - "dev": true - }, - "yargs": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-7.1.0.tgz", - "integrity": "sha1-a6MY6xaWFyf10oT46gA+jWFU0Mg=", - "dev": true, - "requires": { - "camelcase": "^3.0.0", - "cliui": "^3.2.0", - "decamelize": "^1.1.1", - "get-caller-file": "^1.0.1", - "os-locale": "^1.4.0", - "read-pkg-up": "^1.0.1", - "require-directory": "^2.1.1", - "require-main-filename": "^1.0.1", - "set-blocking": "^2.0.0", - "string-width": "^1.0.2", - "which-module": "^1.0.0", - "y18n": "^3.2.1", - "yargs-parser": "^5.0.0" - } - }, - "yargs-parser": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.0.tgz", - "integrity": "sha1-J17PDX/+Bcd+ZOfIbkzZS/DhIoo=", - "dev": true, - "requires": { - "camelcase": "^3.0.0" - } - } - } - }, - "sass-loader": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/sass-loader/-/sass-loader-7.1.0.tgz", - "integrity": "sha512-+G+BKGglmZM2GUSfT9TLuEp6tzehHPjAMoRRItOojWIqIGPloVCMhNIQuG639eJ+y033PaGTSjLaTHts8Kw79w==", - "dev": true, - "requires": { - "clone-deep": "^2.0.1", - "loader-utils": "^1.0.1", - "lodash.tail": "^4.1.1", - "neo-async": "^2.5.0", - "pify": "^3.0.0", - "semver": "^5.5.0" - }, - "dependencies": { - "pify": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", - "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=", - "dev": true - } - } - }, "sax": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", @@ -10608,27 +9677,6 @@ "integrity": "sha1-o0a7Gs1CB65wvXwMfKnlZra63bg=", "dev": true }, - "scss-tokenizer": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/scss-tokenizer/-/scss-tokenizer-0.2.3.tgz", - "integrity": "sha1-jrBtualyMzOCTT9VMGQRSYR85dE=", - "dev": true, - "requires": { - "js-base64": "^2.1.8", - "source-map": "^0.4.2" - }, - "dependencies": { - "source-map": { - "version": "0.4.4", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.4.4.tgz", - "integrity": "sha1-66T12pwNyZneaAMti092FzZSA2s=", - "dev": true, - "requires": { - "amdefine": ">=0.0.4" - } - } - } - }, "semver": { "version": "5.5.0", "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", @@ -10742,25 +9790,6 @@ "safe-buffer": "^5.0.1" } }, - "shallow-clone": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-1.0.0.tgz", - "integrity": "sha512-oeXreoKR/SyNJtRJMAKPDSvd28OqEwG4eR/xc856cRGBII7gX9lvAqDxusPm0846z/w/hWYjI1NpKwJ00NHzRA==", - "dev": true, - "requires": { - "is-extendable": "^0.1.1", - "kind-of": "^5.0.0", - "mixin-object": "^2.0.1" - }, - "dependencies": { - "kind-of": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", - "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true - } - } - }, "shebang-command": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", @@ -11026,23 +10055,6 @@ "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", "dev": true }, - "sshpk": { - "version": "1.14.2", - "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.2.tgz", - "integrity": "sha1-xvxhZIo9nE52T9P8306hBeSSupg=", - "dev": true, - "requires": { - "asn1": "~0.2.3", - "assert-plus": "^1.0.0", - "bcrypt-pbkdf": "^1.0.0", - "dashdash": "^1.12.0", - "ecc-jsbn": "~0.1.1", - "getpass": "^0.1.1", - "jsbn": "~0.1.0", - "safer-buffer": "^2.0.2", - "tweetnacl": "~0.14.0" - } - }, "ssri": { "version": "5.3.0", "resolved": "https://registry.npmjs.org/ssri/-/ssri-5.3.0.tgz", @@ -11052,12 +10064,6 @@ "safe-buffer": "^5.1.1" } }, - "stackframe": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/stackframe/-/stackframe-1.0.4.tgz", - "integrity": "sha512-to7oADIniaYwS3MhtCa/sQhrxidCCQiF/qp4/m5iN3ipf0Y7Xlri0f6eG29r08aL7JYl8n32AF3Q5GYBZ7K8vw==", - "dev": true - }, "static-extend": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", @@ -11085,15 +10091,6 @@ "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==", "dev": true }, - "stdout-stream": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/stdout-stream/-/stdout-stream-1.4.1.tgz", - "integrity": "sha512-j4emi03KXqJWcIeF8eIXkjMFN1Cmb8gUlDYGeBALLPo5qdyTfA9bOtl8m33lRoC+vFMkP3gl0WsDr6+gzxbbTA==", - "dev": true, - "requires": { - "readable-stream": "^2.0.1" - } - }, "stereo-panner-node": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/stereo-panner-node/-/stereo-panner-node-1.4.0.tgz", @@ -11222,15 +10219,6 @@ "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", "dev": true }, - "strip-indent": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz", - "integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=", - "dev": true, - "requires": { - "get-stdin": "^4.0.1" - } - }, "strip-json-comments": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", @@ -11318,17 +10306,6 @@ "integrity": "sha512-dQRhbNQkRnaqauC7WqSJ21EEksgT0fYZX2lqXzGkpo8JNig9zGZTYoMGvyI2nWmXlE2VSVXVDu7wLVGu/mQEsg==", "dev": true }, - "tar": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/tar/-/tar-2.2.1.tgz", - "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=", - "dev": true, - "requires": { - "block-stream": "*", - "fstream": "^1.0.2", - "inherits": "2" - } - }, "temp": { "version": "0.8.3", "resolved": "https://registry.npmjs.org/temp/-/temp-0.8.3.tgz", @@ -11566,44 +10543,12 @@ "integrity": "sha1-LmhELZ9k7HILjMieZEOsbKqVACk=", "dev": true }, - "tough-cookie": { - "version": "2.3.4", - "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.4.tgz", - "integrity": "sha512-TZ6TTfI5NtZnuyy/Kecv+CnoROnyXn2DN97LontgQpCwsX2XyLYCC0ENhYkehSOwAp8rTQKc/NUIF7BkQ5rKLA==", - "dev": true, - "requires": { - "punycode": "^1.4.1" - }, - "dependencies": { - "punycode": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", - "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", - "dev": true - } - } - }, - "trim-newlines": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz", - "integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=", - "dev": true - }, "trim-right": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz", "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=", "dev": true }, - "true-case-path": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/true-case-path/-/true-case-path-1.0.3.tgz", - "integrity": "sha512-m6s2OdQe5wgpFMC+pAJ+q9djG82O2jcHPOI6RNg1yy9rCYR+WD6Nbpl32fDpfC56nirdRy+opFa/Vk7HYhqaew==", - "dev": true, - "requires": { - "glob": "^7.1.2" - } - }, "tslib": { "version": "1.9.2", "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.2.tgz", @@ -11621,22 +10566,6 @@ "resolved": "https://registry.npmjs.org/tunajs/-/tunajs-1.0.1.tgz", "integrity": "sha512-wx96nvUbGsoIzF6WbQESWz0XPFBZYSmZ0bEyb9YR6vvuIAyZLmpQzieYUhT/b4uEUs0rMMfB9ty+S9aLjklheA==" }, - "tunnel-agent": { - "version": "0.6.0", - "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", - "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", - "dev": true, - "requires": { - "safe-buffer": "^5.0.1" - } - }, - "tweetnacl": { - "version": "0.14.5", - "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", - "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", - "dev": true, - "optional": true - }, "type-check": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", @@ -11900,66 +10829,6 @@ } } }, - "url-loader": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/url-loader/-/url-loader-1.1.1.tgz", - "integrity": "sha512-vugEeXjyYFBCUOpX+ZuaunbK3QXMKaQ3zUnRfIpRBlGkY7QizCnzyyn2ASfcxsvyU3ef+CJppVywnl3Kgf13Gg==", - "dev": true, - "requires": { - "loader-utils": "^1.1.0", - "mime": "^2.0.3", - "schema-utils": "^1.0.0" - }, - "dependencies": { - "ajv": { - "version": "6.5.4", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.5.4.tgz", - "integrity": "sha512-4Wyjt8+t6YszqaXnLDfMmG/8AlO5Zbcsy3ATHncCzjW/NoPzAId8AK6749Ybjmdt+kUY1gP60fCu46oDxPv/mg==", - "dev": true, - "requires": { - "fast-deep-equal": "^2.0.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.4.1", - "uri-js": "^4.2.2" - } - }, - "ajv-keywords": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.2.0.tgz", - "integrity": "sha1-6GuBnGAs+IIa1jdBNpjx3sAhhHo=", - "dev": true - }, - "fast-deep-equal": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz", - "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=", - "dev": true - }, - "json-schema-traverse": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", - "dev": true - }, - "mime": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/mime/-/mime-2.3.1.tgz", - "integrity": "sha512-OEUllcVoydBHGN1z84yfQDimn58pZNNNXgZlHXSboxMlFvgI6MXSWpWKpFRra7H1HxpVhHTkrghfRW49k6yjeg==", - "dev": true - }, - "schema-utils": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz", - "integrity": "sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==", - "dev": true, - "requires": { - "ajv": "^6.1.0", - "ajv-errors": "^1.0.0", - "ajv-keywords": "^3.1.0" - } - } - } - }, "url-parse-lax": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz", @@ -12068,17 +10937,6 @@ "integrity": "sha512-w/hry/368nO21AN9QljsaIhb9ZiZtZARoVH5f3CsFbawdLdayCgKRPup7CggujvySMxx0I91NOyxdVENohprLQ==", "dev": true }, - "verror": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", - "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", - "dev": true, - "requires": { - "assert-plus": "^1.0.0", - "core-util-is": "1.0.2", - "extsprintf": "^1.2.0" - } - }, "vinyl": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-1.2.0.tgz", @@ -12495,15 +11353,6 @@ "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=", "dev": true }, - "wide-align": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz", - "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==", - "dev": true, - "requires": { - "string-width": "^1.0.2 || 2" - } - }, "wordwrap": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", diff --git a/package.json b/package.json index 455e4ed..1b99db9 100644 --- a/package.json +++ b/package.json @@ -36,6 +36,7 @@ "html-webpack-plugin": "^3.2.0", "mini-css-extract-plugin": "^0.4.3", "opn": "^5.4.0", + "raw-loader": "^0.5.1", "resolve-url-loader": "^3.0.0", "style-loader": "^0.21.0", "webpack": "^4.10.1", diff --git a/packing/webpack.config.js b/packing/webpack.config.js index 1ad1e34..20792a0 100644 --- a/packing/webpack.config.js +++ b/packing/webpack.config.js @@ -30,6 +30,10 @@ module.exports = { } } }, + { + test: /\.ohm$/, + use: ['raw-loader'] + }, { test: /\.css$/, use: [ diff --git a/src/slang-grammar.js b/src/slang-grammar.js deleted file mode 100644 index d3e699e..0000000 --- a/src/slang-grammar.js +++ /dev/null @@ -1,128 +0,0 @@ -module.exports = ` -Sound { - Line = Graph | Play | Comment | Tempo - - /* - A comment is any line that begins with # - */ - - Comment = "#" any+ - - /* - SOUND OBJECTS - A sound object is a '@synth' variable. We - can also access part of the sound's graph - using dot notation, e.g. '@synth.osc1'. - We'll only accept soundAccessors in a few - places. - */ - - sound = "@" alnum+ - propertyAccessor = "." alnum+ - soundAccessor = sound propertyAccessor? - - /* - FUNCTIONS - A function is anything in parentheses. These - will power blocks and arbitrary tools that - might spit out lists, numbers, etc. The syntax - is inspired by Clojure. Notice that the first - type of sound argument is... a function! This - enables is to write nested functions. Imagine: - (notes (random (chord major E3))) - */ - - function = "(" listOf ")" - soundArgument = function -- function - | range -- range - | list -- list - | rhythm -- rhythm - | float -- float - | note -- note - - /* - GRAPH LINES - A graph is a sound declaration followed by - one or more pipes that configure it. Graph - declarations will be additive, e.g. two - line with '@synth ~ (osc)' will create two - oscillators. - This definition is slightly longer than it - needs to be so that we can make the first - tilde optional. Either '@synth (osc tri)' - or '@synth ~ (osc tri)' will be valid. - */ - - Graph = soundAccessor "~"? PolySoundBlock Pipe? - - /* - Sound blocks look like functions, e.g. - '(osc sine 1)'. You can string several - together using pipes, which will literally - pipe the sounds together. - */ - - PolySoundBlock = MonoSoundBlock ("+" MonoSoundBlock)* - MonoSoundBlock = "(" listOf ")" name? - name = ":" alnum+ - - Pipe = ("~" PolySoundBlock)+ - - /* - TEMPO LINES - A tempo line is a tempo keyword, followed by - the sound beats per minute. - */ - - Tempo = TempoKeyword tempoPrim - TempoKeyword = "tempo" | "[]" - - /* - PLAY LINES - A play line is a play keyword (either 'play' - or '>'), followed by the sound we want to play, - followed by a pattern. Each pattern uses a - different enclosing bracket. They could also - use a SoundBlock-like definition I guess. - */ - - Play = PlayKeyword sound Pattern - PlayKeyword = "play" | ">" - - /* - PATTERNS - The play line is expecting one or more function - calls that determine what the sound does. Those - might be things like (rhythm xox), (notes E3 D3), - and (times 0.2 0.3 0.5). Determining what tools - are possible should be a *runtime* concern, not - a grammar-level concern. - */ - - Pattern = listOf - - /* - PRIMITIVES - Here are the primitive types we're working with. - */ - - list = "[" listOf "]" - range = "[" int ".." int "]" -- number - | "[" note ".." note "]" -- note - - delimiter = " " - - float = "-"? digit* "." digit+ -- fullFloat - | "-"? digit "." -- dot - | "-"? digit+ -- int - - int = "-"? digit+ - tempoPrim = digit+ - - note = letter "#" digit+ -- sharp - | letter "b" digit+ -- flat - | alnum+ -- major - - rhythm = "r"? digit+ letter -} -`; diff --git a/src/slang.js b/src/slang.js index 0783d30..3da4219 100644 --- a/src/slang.js +++ b/src/slang.js @@ -1,7 +1,7 @@ import ohm from 'ohm-js'; import range from 'lodash/range'; import * as Range from 'tonal-range'; -import grammarDefinition from './slang-grammar'; +import grammarDefinition from './slang.ohm'; import runtime from './runtime'; const grammar = ohm.grammar(grammarDefinition); From 97e2bb57f4dcbf8e233017d2de3ed6813930ceeb Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 12:55:17 -0500 Subject: [PATCH 05/16] Seteable Tempo --- src/classes/Scheduler.js | 3 ++- src/editor.js | 2 +- src/functions/transpose.js | 4 +++- src/helpers/parseArguments.js | 45 +++++++++++++++++++++-------------- src/runtime.js | 9 +++++++ src/slang.js | 2 +- src/slang.ohm | 5 ++-- 7 files changed, 45 insertions(+), 25 deletions(-) diff --git a/src/classes/Scheduler.js b/src/classes/Scheduler.js index 1cfd3b9..857420d 100644 --- a/src/classes/Scheduler.js +++ b/src/classes/Scheduler.js @@ -55,6 +55,7 @@ export default class Scheduler { this.currentTime = timestamp; this.interval = setInterval(() => { + const rhythmMapObj = rhythmMap() while (this.currentTime < context.currentTime + this.lookahead) { // The tick length could be a number or a string that starts // with 'r', indicating a rest. @@ -65,7 +66,7 @@ export default class Scheduler { if (typeof nextTickLength === 'string' && nextTickLength.charAt(0).toLowerCase() === 'r') { rest = true; // Convert it into the appropriate rhythm. - nextTickLength = rhythmMap[nextTickLength.substr(1)]; + nextTickLength = rhythmMapObj[nextTickLength.substr(1)]; } // We're only ticking on beats that aren't rests. if (!rest) { diff --git a/src/editor.js b/src/editor.js index f591d85..627a7e7 100644 --- a/src/editor.js +++ b/src/editor.js @@ -59,7 +59,7 @@ const existingCode = window.localStorage.getItem('code'); const defaultCode = `# Welcome to Slang! Here's an example to get you started. # Click the Run button above to start playing this code. -tempo 200 +TEMPO 200 # Make a sound called @synth with a triangle wave @synth (adsr (osc tri) 64n 8n 0.5 8n) diff --git a/src/functions/transpose.js b/src/functions/transpose.js index 99bd9fa..72e1dce 100644 --- a/src/functions/transpose.js +++ b/src/functions/transpose.js @@ -15,6 +15,8 @@ export default class Transpose extends FunctionCall { this.hasWarned = false; } next(passedValue) { + const rhythmMapObj = rhythmMap(); + console.log(rhythmMapObj); let nextValue = passedValue || this.data.next(); // Unfortunately transposing rhythms won't work @@ -30,7 +32,7 @@ export default class Transpose extends FunctionCall { typeof nextValue === 'string' && ( nextValue.charAt(0).toLowerCase() === 'r' - || rhythmMap[nextValue] + || rhythmMapObj[nextValue] ) ) { if (!this.hasWarned) { diff --git a/src/helpers/parseArguments.js b/src/helpers/parseArguments.js index dfb505f..16f67c9 100644 --- a/src/helpers/parseArguments.js +++ b/src/helpers/parseArguments.js @@ -1,23 +1,25 @@ import List from './List'; import FunctionCall from '../functions'; -const TEMPO = 120; -const DIVISION = (1 / 24) / (TEMPO / 60); - -export const rhythmMap = { - '64t': DIVISION, - '64n': DIVISION * 1.5, - '32t': DIVISION * 2, - '32n': DIVISION * 3, - '16t': DIVISION * 4, - '16n': DIVISION * 6, - '8t': DIVISION * 8, - '8n': DIVISION * 12, - '4t': DIVISION * 16, - '4n':DIVISION * 24, - '2t': DIVISION * 32, - '2n': DIVISION * 48, - '1n': DIVISION * 96, +let TEMPO = 120; + +export function rhythmMap () { + const DIVISION = (1 / 24) / (TEMPO / 60); + return { + '64t': DIVISION, + '64n': DIVISION * 1.5, + '32t': DIVISION * 2, + '32n': DIVISION * 3, + '16t': DIVISION * 4, + '16n': DIVISION * 6, + '8t': DIVISION * 8, + '8n': DIVISION * 12, + '4t': DIVISION * 16, + '4n': DIVISION * 24, + '2t': DIVISION * 32, + '2n': DIVISION * 48, + '1n': DIVISION * 96, + }; } /* @@ -52,10 +54,17 @@ export function parseArgument(arg) { return null; } +export function changeTempo(tempo) { + let min = 30; + let max = 500; + const newTempo = Math.max(Math.min(tempo, max), min); + TEMPO = isNaN(newTempo) ? TEMPO : newTempo; +} function createArgumentFromStaticValue(value) { + const rhythmMapObj = rhythmMap() // convert rhythms into numbers if we catch one return { - next: () => rhythmMap[value] || value, + next: () => rhythmMapObj[value] || value, }; } \ No newline at end of file diff --git a/src/runtime.js b/src/runtime.js index dbc3ef5..b441093 100644 --- a/src/runtime.js +++ b/src/runtime.js @@ -1,5 +1,6 @@ import Sound from './classes/Sound'; import context from './helpers/context'; +import { changeTempo } from './helpers/parseArguments.js'; const model = { sounds: {}, @@ -17,6 +18,9 @@ function runScene(scene) { case 'play': parsePlay(operation); break; + case 'tempo': + parseTempo(operation); + break; } }); @@ -55,6 +59,11 @@ function parsePlay(operation) { model.sounds[operation.sound.name].schedule(operation.patterns); } +function parseTempo(operation) { + console.log(operation); + changeTempo(operation.value); +} + function clearScene() { Object.keys(model.sounds).forEach((id) => { model.sounds[id].destroy(); diff --git a/src/slang.js b/src/slang.js index 3da4219..00da82d 100644 --- a/src/slang.js +++ b/src/slang.js @@ -90,7 +90,7 @@ semantics.addOperation('toAST', { Tempo(kw, value) { return { type: 'tempo', - value, + value: value.toAST() }; }, diff --git a/src/slang.ohm b/src/slang.ohm index 2b35a79..9b326d2 100644 --- a/src/slang.ohm +++ b/src/slang.ohm @@ -73,8 +73,8 @@ Sound { the sound beats per minute. */ - Tempo = TempoKeyword tempoPrim - TempoKeyword = "tempo" | "[]" + Tempo = TempoKeyword int + TempoKeyword = "TEMPO" | "|" /* PLAY LINES @@ -116,7 +116,6 @@ Sound { | "-"? digit+ -- int int = "-"? digit+ - tempoPrim = digit+ note = letter "#" digit+ -- sharp | letter "b" digit+ -- flat From b552b6270be36f6c6ce8b098eb2d02ced4155aa6 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 13:02:03 -0500 Subject: [PATCH 06/16] Activating AirBnB base lint --- .eslintrc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.eslintrc b/.eslintrc index 4ffd05e..9c8bc19 100644 --- a/.eslintrc +++ b/.eslintrc @@ -1,5 +1,5 @@ { - "extends": "airbnb", + "extends": "airbnb-base", "parserOptions": { "ecmaFeatures": { "experimentalObjectRestSpread": true From 6d0771c86491d79dd22f08d3807fc0f8394ef85f Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 14:31:06 -0500 Subject: [PATCH 07/16] Linting to the space --- .eslintrc | 9 +- package-lock.json | 110 ++++++++++++++++-- package.json | 2 + packing/server.js | 18 +-- packing/webpack.config.js | 208 ++++++++++++---------------------- packing/webpack.prod.js | 44 +++---- src/classes/ADSR.js | 3 +- src/classes/Block.js | 25 ++-- src/classes/Delay.js | 4 +- src/classes/Drums.js | 11 +- src/classes/Filter.js | 18 ++- src/classes/Gain.js | 2 +- src/classes/Osc.js | 11 +- src/classes/Pan.js | 3 +- src/classes/PolyBlock.js | 33 +++--- src/classes/Scheduler.js | 31 +++-- src/classes/Sound.js | 55 ++++----- src/classes/classMap.js | 14 +-- src/editor.js | 170 +++++++++++++-------------- src/functions/FunctionCall.js | 2 +- src/functions/chord.js | 9 +- src/functions/flatten.js | 7 +- src/functions/index.js | 18 +-- src/functions/interpolate.js | 10 +- src/functions/random.js | 2 +- src/functions/repeat.js | 7 +- src/functions/reverse.js | 1 - src/functions/shuffle.js | 3 +- src/functions/transpose.js | 8 +- src/helpers/BufferLoader.js | 35 +++--- src/helpers/FunctionCall.js | 23 ++-- src/helpers/List.js | 10 +- src/helpers/context.js | 9 +- src/helpers/drumMap.js | 24 ++-- src/helpers/mtof.js | 2 +- src/helpers/parseArguments.js | 27 +++-- src/runtime.js | 57 +++++----- src/slang.js | 50 +++++--- 38 files changed, 564 insertions(+), 511 deletions(-) diff --git a/.eslintrc b/.eslintrc index 9c8bc19..2906401 100644 --- a/.eslintrc +++ b/.eslintrc @@ -7,17 +7,19 @@ "sourceType": "module" }, "env": { - "es6": true + "es6": true, + "browser": true }, "rules": { "indent": [ "error", - 4 + "tab" ], "linebreak-style": [ "error", "unix" ], + "no-tabs": 0, "quotes": 1, "semi": [ "error", @@ -28,7 +30,8 @@ "error", { "devDependencies": [ - "dist/*.js" + "dist/*.js", + "packing/*.js" ] } ] diff --git a/package-lock.json b/package-lock.json index 123f349..a55ab15 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10444,6 +10444,22 @@ "tonal-note": "^1.1.2", "tonal-pcset": "^1.1.2", "tonal-scale": "^1.1.2" + }, + "dependencies": { + "tonal-distance": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-1.1.2.tgz", + "integrity": "sha512-1tigEt+qrCGNHVsNJdBwyN/+nYr3kPNobLvKP/TWMGipArMAh01zNuRb/mGHym0ov2M0AuYo05khRG3C7v6zxA==", + "requires": { + "tonal-interval": "^1.1.2", + "tonal-note": "^1.1.2" + } + }, + "tonal-interval": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", + "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + } } }, "tonal-array": { @@ -10463,6 +10479,22 @@ "tonal-distance": "^1.1.2", "tonal-note": "^1.1.2", "tonal-pcset": "^1.1.2" + }, + "dependencies": { + "tonal-distance": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-1.1.2.tgz", + "integrity": "sha512-1tigEt+qrCGNHVsNJdBwyN/+nYr3kPNobLvKP/TWMGipArMAh01zNuRb/mGHym0ov2M0AuYo05khRG3C7v6zxA==", + "requires": { + "tonal-interval": "^1.1.2", + "tonal-note": "^1.1.2" + } + }, + "tonal-interval": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", + "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + } } }, "tonal-dictionary": { @@ -10476,18 +10508,25 @@ } }, "tonal-distance": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-1.1.2.tgz", - "integrity": "sha512-1tigEt+qrCGNHVsNJdBwyN/+nYr3kPNobLvKP/TWMGipArMAh01zNuRb/mGHym0ov2M0AuYo05khRG3C7v6zxA==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-2.0.0.tgz", + "integrity": "sha512-RnY3r4FQwjyXE0eR3qjUG8hfs6vBPXThk9y94eU7wMQ2mLKinP2dW/DdgUF6ORnJ36jnTCyYLEAPp23yxrfXDw==", "requires": { - "tonal-interval": "^1.1.2", - "tonal-note": "^1.1.2" + "tonal-interval": "^2.0.0", + "tonal-note": "^2.0.0" + }, + "dependencies": { + "tonal-note": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tonal-note/-/tonal-note-2.0.0.tgz", + "integrity": "sha512-ZUeAloZQE2L3lhobVn7yCX7tT0x+iim26EIkZt8P7f5i4LCxbw/NifS2MgdcCL0Dh+CnaoGD/YMH9QhRmX7Tig==" + } } }, "tonal-interval": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", - "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-2.0.0.tgz", + "integrity": "sha512-pXobehztDC/dlZsQT5KOca/7wszBjrAULXFlvpzzWPgsCv3808fdN6mR3g/dTZOEG47AP6CpzAxZzNBgbJbCXg==" }, "tonal-key": { "version": "1.1.2", @@ -10497,6 +10536,22 @@ "tonal-array": "^1.1.2", "tonal-distance": "^1.1.2", "tonal-note": "^1.1.2" + }, + "dependencies": { + "tonal-distance": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-1.1.2.tgz", + "integrity": "sha512-1tigEt+qrCGNHVsNJdBwyN/+nYr3kPNobLvKP/TWMGipArMAh01zNuRb/mGHym0ov2M0AuYo05khRG3C7v6zxA==", + "requires": { + "tonal-interval": "^1.1.2", + "tonal-note": "^1.1.2" + } + }, + "tonal-interval": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", + "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + } } }, "tonal-note": { @@ -10512,6 +10567,13 @@ "tonal-array": "^1.1.2", "tonal-interval": "^1.1.2", "tonal-note": "^1.1.2" + }, + "dependencies": { + "tonal-interval": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", + "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + } } }, "tonal-range": { @@ -10523,6 +10585,22 @@ "tonal-distance": "^1.1.2", "tonal-note": "^1.1.2", "tonal-pcset": "^1.1.2" + }, + "dependencies": { + "tonal-distance": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-1.1.2.tgz", + "integrity": "sha512-1tigEt+qrCGNHVsNJdBwyN/+nYr3kPNobLvKP/TWMGipArMAh01zNuRb/mGHym0ov2M0AuYo05khRG3C7v6zxA==", + "requires": { + "tonal-interval": "^1.1.2", + "tonal-note": "^1.1.2" + } + }, + "tonal-interval": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", + "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + } } }, "tonal-scale": { @@ -10535,6 +10613,22 @@ "tonal-distance": "^1.1.2", "tonal-note": "^1.1.2", "tonal-pcset": "^1.1.2" + }, + "dependencies": { + "tonal-distance": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-distance/-/tonal-distance-1.1.2.tgz", + "integrity": "sha512-1tigEt+qrCGNHVsNJdBwyN/+nYr3kPNobLvKP/TWMGipArMAh01zNuRb/mGHym0ov2M0AuYo05khRG3C7v6zxA==", + "requires": { + "tonal-interval": "^1.1.2", + "tonal-note": "^1.1.2" + } + }, + "tonal-interval": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/tonal-interval/-/tonal-interval-1.1.2.tgz", + "integrity": "sha512-Kj3GPWqRYuQN0SeE86CxLMMgm++fPueWLDHONmx1CZw6NMIyMpml3DQkRpY0PqNpr3y6TbQ0NP2jBAHVLtwEpg==" + } } }, "toposort": { diff --git a/package.json b/package.json index 1b99db9..6e5322b 100644 --- a/package.json +++ b/package.json @@ -18,6 +18,8 @@ "ohm-js": "^0.14.0", "stereo-panner-node": "^1.4.0", "tonal": "^1.1.3", + "tonal-distance": "^2.0.0", + "tonal-interval": "^2.0.0", "tonal-range": "^1.1.2", "tonal-scale": "^1.1.2", "tunajs": "^1.0.1" diff --git a/packing/server.js b/packing/server.js index 52a89cf..61b50a6 100644 --- a/packing/server.js +++ b/packing/server.js @@ -12,8 +12,8 @@ const autoOpenBrowser = true; const app = express(); const compiler = webpack(webpackConfig); const devMiddleware = devMiddlewareFn(compiler, { - publicPath: webpackConfig.output.publicPath, - quiet: true, + publicPath: webpackConfig.output.publicPath, + quiet: true, }); // handle fallback for HTML5 history API @@ -31,11 +31,13 @@ const uri = `http://localhost:${port}`; console.log('> Starting dev server...'); devMiddleware.waitUntilValid(() => { - console.log(`> Listening at ${uri}\n`); - // when env is testing, don't need open it - if (autoOpenBrowser) { - opn(uri); - } + console.log(`> Listening at ${uri}\n`); + // when env is testing, don't need open it + if (autoOpenBrowser) { + opn(uri); + } }); -const server = app.listen(port); \ No newline at end of file +const server = app.listen(port); + +module.exports = server; diff --git a/packing/webpack.config.js b/packing/webpack.config.js index 20792a0..a5a4051 100644 --- a/packing/webpack.config.js +++ b/packing/webpack.config.js @@ -1,139 +1,81 @@ const path = require('path'); const HtmlWebpackPlugin = require('html-webpack-plugin'); const CleanWebpackPlugin = require('clean-webpack-plugin'); -const MiniCssExtractPlugin = require("mini-css-extract-plugin"); +const MiniCssExtractPlugin = require('mini-css-extract-plugin'); module.exports = { - mode: 'development', - devtool: 'source-map', - entry: { - app: './src/editor.js', - }, - resolve: { - symlinks: false - }, - output: { - filename: 'slang.[name].js', - path: path.resolve(__dirname, '../dist'), - publicPath: '/', - pathinfo: false - }, - module: { - rules: [ - { - test: /\.m?js$/, - exclude: /(node_modules|bower_components)/, - use: { - loader: 'babel-loader', - options: { - presets: ['@babel/preset-env'] - } - } - }, - { - test: /\.ohm$/, - use: ['raw-loader'] - }, - { - test: /\.css$/, - use: [ - { - loader: MiniCssExtractPlugin.loader, - options: { - publicPath: '/css', - name: path.posix.join('/css', '[name].[ext]'), - } - }, - "css-loader" - ] - }, - { - test: /\.(png|jpe?g|gif|svg)$/, - loader: 'file-loader', - options: { - limit: 100, - name: path.posix.join('img', '[name].[ext]'), - } - }, - { - test: /\.(mp3)$/, - loader: 'file-loader', - options: { - limit: 10000, - name: path.posix.join('audio', '[name].[ext]'), - } - }, - ] - }, - plugins: [ - new CleanWebpackPlugin(['dist']), - new HtmlWebpackPlugin({ - filename: 'index.html', - template: './src/static/editor.html', - title: 'SLANG', - inject: true, - }), - new MiniCssExtractPlugin({ - filename: "[name].css", - chunkFilename: "[id].css" - }) - ] + mode: 'development', + devtool: 'source-map', + entry: { + app: './src/editor.js', + }, + resolve: { + symlinks: false, + }, + output: { + filename: 'slang.[name].js', + path: path.resolve(__dirname, '../dist'), + publicPath: '/', + pathinfo: false, + }, + module: { + rules: [ + { + test: /\.m?js$/, + exclude: /(node_modules|bower_components)/, + use: { + loader: 'babel-loader', + options: { + presets: ['@babel/preset-env'], + }, + }, + }, + { + test: /\.ohm$/, + use: ['raw-loader'], + }, + { + test: /\.css$/, + use: [ + { + loader: MiniCssExtractPlugin.loader, + options: { + publicPath: '/css', + name: path.posix.join('/css', '[name].[ext]'), + }, + }, + 'css-loader', + ], + }, + { + test: /\.(png|jpe?g|gif|svg)$/, + loader: 'file-loader', + options: { + limit: 100, + name: path.posix.join('img', '[name].[ext]'), + }, + }, + { + test: /\.(mp3)$/, + loader: 'file-loader', + options: { + limit: 10000, + name: path.posix.join('audio', '[name].[ext]'), + }, + }, + ], + }, + plugins: [ + new CleanWebpackPlugin(['dist']), + new HtmlWebpackPlugin({ + filename: 'index.html', + template: './src/static/editor.html', + title: 'SLANG', + inject: true, + }), + new MiniCssExtractPlugin({ + filename: '[name].css', + chunkFilename: '[id].css', + }), + ], }; - -/* -module.exports = { - mode: 'development', - devtool: 'source-map', - entry: { - main: [ - './src/editor.js', - ], - }, - output: { - filename: 'slang.[name].js', - path: path.resolve(__dirname, '../dist'), - }, - resolve: { - symlinks: true, - }, - module: { - rules: [ - { - test: /\.css$/, - use: [ - 'style-loader', - 'css-loader' - ] - }, - { - test: /\.(png|jpe?g|gif|svg)$/, - loader: 'url-loader', - options: { - limit: 10000, - name: path.posix.join('/img', '[name].[ext]'), - } - }, - { - test: /\.(mp3)$/, - loader: 'url-loader', - options: { - limit: 10000, - name: path.posix.join('/audio', '[name].[ext]'), - } - }, - ] - }, - plugins: [ - new HtmlWebpackPlugin({ - filename: 'index.html', - template: './src/static/editor.html', - title: 'SLANG', - inject: true, - }), - new FriendlyErrorsPlugin(), - new MiniCssExtractPlugin({ - filename: "[name].css", - }), - ], -}; -*/ \ No newline at end of file diff --git a/packing/webpack.prod.js b/packing/webpack.prod.js index c723c9e..d568976 100644 --- a/packing/webpack.prod.js +++ b/packing/webpack.prod.js @@ -1,26 +1,26 @@ const path = require('path'); module.exports = { - mode: 'production', - entry: './src/editor.js', - output: { - filename: 'site.min.js', - path: path.resolve(__dirname, 'public/build') - }, - module: { - rules: [{ - test: /\.css$/, - use: [ 'style-loader', 'css-loader' ] - }, - { - test: /\.m?js$/, - exclude: /(node_modules|bower_components)/, - use: { - loader: 'babel-loader', - options: { - presets: ['@babel/preset-env'] - } - } - }], - }, + mode: 'production', + entry: './src/editor.js', + output: { + filename: 'site.min.js', + path: path.resolve(__dirname, 'public/build'), + }, + module: { + rules: [{ + test: /\.css$/, + use: ['style-loader', 'css-loader'], + }, + { + test: /\.m?js$/, + exclude: /(node_modules|bower_components)/, + use: { + loader: 'babel-loader', + options: { + presets: ['@babel/preset-env'], + }, + }, + }], + }, }; diff --git a/src/classes/ADSR.js b/src/classes/ADSR.js index 5bf3304..f2390f3 100644 --- a/src/classes/ADSR.js +++ b/src/classes/ADSR.js @@ -44,7 +44,7 @@ class ADSR extends Block { sustainLevel: 1, releaseTime: 0.05, gateTime: 0.25, - releaseCurve: "exp", + releaseCurve: 'exp', }); } @@ -95,6 +95,7 @@ class ADSR extends Block { } // TODO: only create gain for osc, otherwise apply to existing property + return null; } } diff --git a/src/classes/Block.js b/src/classes/Block.js index dbfe9cd..fd523de 100644 --- a/src/classes/Block.js +++ b/src/classes/Block.js @@ -25,8 +25,8 @@ class Block { // This input allows us to give each // block a consistent interface without // having to name it all particular. - this._input = context.createGain(); - this._output = context.createGain(); + this.input = context.createGain(); + this.output = context.createGain(); // Some blocks will want to implement // polyphony, which really just means @@ -35,7 +35,7 @@ class Block { // to other nodes. Implementers just // need to call this.getPolyMode() to // find out which behavior to follow. - this._polyMode = false; + this.polyMode = false; } instantiate() { @@ -43,6 +43,8 @@ class Block { // its audio graph. The methods getInput() // and getOutput() give us an easy way to // connect everything together. + + return this; } connect(block) { @@ -58,26 +60,33 @@ class Block { schedule(start, stop, note) { // use the timestamp to schedule calls to // oscillators or what have you. + + return { + start, + stop, + note, + me: this, + }; } destroy() { - this._output.disconnect(); + this.output.disconnect(); } getInput() { - return this._input; + return this.input; } getOutput() { - return this._output; + return this.output; } setPolyMode(flag) { - this._polyMode = flag; + this.polyMode = flag; } getPolyMode() { - return this._polyMode; + return this.polyMode; } } diff --git a/src/classes/Delay.js b/src/classes/Delay.js index b777390..48fd167 100644 --- a/src/classes/Delay.js +++ b/src/classes/Delay.js @@ -1,5 +1,4 @@ import Block from './Block'; -import context from '../helpers/context'; import tuna from '../helpers/tuna'; import { parseArgument } from '../helpers/parseArguments'; @@ -36,7 +35,7 @@ class Delay extends Block { schedule(start) { if (!this.getPolyMode()) { // update values here - return; + return null; } const delay = new tuna.Delay({ @@ -51,6 +50,7 @@ class Delay extends Block { return { input: delay, output: delay, + start, }; } } diff --git a/src/classes/Drums.js b/src/classes/Drums.js index fe0fec0..44d6e54 100644 --- a/src/classes/Drums.js +++ b/src/classes/Drums.js @@ -1,7 +1,5 @@ -import { Note } from 'tonal'; import Block from './Block'; import context from '../helpers/context'; -import mtof from '../helpers/mtof'; import { parseArgument } from '../helpers/parseArguments'; import BufferLoader from '../helpers/BufferLoader'; import drumMap from '../helpers/drumMap'; @@ -28,8 +26,9 @@ class Drums extends Block { } } - schedule(start, stop, note, envelopeMode) { - if (!drumBuffers.length || loadingDrums) return; + schedule(start, stop, note) { + // Removed envelopeMode from parameters, it's never used + if (!drumBuffers.length || loadingDrums) return null; // we only have 12 samples available but we shouldn't // burden the user with that knowledge so let's use // mod 12, which allows them to use chords, scales, @@ -55,18 +54,20 @@ class Drums extends Block { // Finally, if we are in mono mode, just connect the osc to // the ouput. sample.connect(this.getOutput()); + return null; } loadDrumSounds() { loadingDrums = true; // Get a list of files const files = Object.keys(drumMap).map(key => drumMap[key].file); // Load the files! - const loader = new BufferLoader(context, files, list => { + const loader = new BufferLoader(context, files, (list) => { // set our global variable to the list of buffers. Done. drumBuffers = list; loadingDrums = false; }); loader.load(); + return this; } } diff --git a/src/classes/Filter.js b/src/classes/Filter.js index 0387019..94fba7f 100644 --- a/src/classes/Filter.js +++ b/src/classes/Filter.js @@ -26,7 +26,7 @@ class Filter extends Block { // the schedule method will take care of that; otherwise we'll // end up with the second value in a cycle on the first // scheduled note. - this.filter.type = typeMap['lp']; + this.filter.type = typeMap.lp; this.filter.frequency.setValueAtTime(11025, context.currentTime, 0); this.filter.Q.setValueAtTime(1, context.currentTime, 0); @@ -41,7 +41,7 @@ class Filter extends Block { this.filter.type = typeMap[this.type.next()]; this.filter.frequency.setValueAtTime((this.amount.next() / 127) * 11025, start, 10); this.filter.Q.setValueAtTime(this.Q.next(), start, 10); - return; + return null; } const filter = context.createBiquadFilter(); @@ -51,17 +51,15 @@ class Filter extends Block { // TODO: envelope mode to return filter.frequency as property - if (envelopeMode) { - return { + return envelopeMode + ? { node: filter, property: filter.frequency, + } + : { + input: filter, + output: filter, }; - } - - return { - input: filter, - output: filter, - }; } } diff --git a/src/classes/Gain.js b/src/classes/Gain.js index 94aacc0..39c0f7e 100644 --- a/src/classes/Gain.js +++ b/src/classes/Gain.js @@ -22,7 +22,7 @@ class Gain extends Block { schedule(start) { if (!this.getPolyMode()) { this.gain.gain.setValueAtTime(this.level.next(), context.currentTime, 0); - return; + return null; } const gain = context.createGain(); diff --git a/src/classes/Osc.js b/src/classes/Osc.js index cef8e9d..82a3165 100644 --- a/src/classes/Osc.js +++ b/src/classes/Osc.js @@ -1,7 +1,6 @@ import { Note } from 'tonal'; import Block from './Block'; import context from '../helpers/context'; -import mtof from '../helpers/mtof'; import { parseArgument } from '../helpers/parseArguments'; const typeMap = { @@ -16,7 +15,7 @@ const typeMap = { sq: 'square', square: 'square', -} +}; class Osc extends Block { constructor(...args) { @@ -34,11 +33,11 @@ class Osc extends Block { osc.type = typeMap[this.type.next()]; - let noteMidiValue = typeof note === 'string' ? Note.midi(note) : note; + const noteMidiValue = typeof note === 'string' ? Note.midi(note) : note; osc.frequency.setValueAtTime( Note.freq(Note.fromMidi(noteMidiValue + this.detune.next())), context.currentTime, - 0 + 0, ); osc.start(start); @@ -59,7 +58,7 @@ class Osc extends Block { return { node: osc, property: osc, - } + }; } else if (this.getPolyMode()) { // An osc has no input! Not sure // what to do about that. @@ -71,6 +70,8 @@ class Osc extends Block { // Finally, if we are in mono mode, just connect the osc to // the ouput. osc.connect(this.getOutput()); + + return null; } } diff --git a/src/classes/Pan.js b/src/classes/Pan.js index 55a940f..839c3cf 100644 --- a/src/classes/Pan.js +++ b/src/classes/Pan.js @@ -25,7 +25,7 @@ class Pan extends Block { schedule(start) { if (!this.getPolyMode()) { this.pan.pan.setValueAtTime(this.value.next(), context.currentTime, 0); - return; + return null; } const pan = context.createStereoPanner(); @@ -34,6 +34,7 @@ class Pan extends Block { return { input: pan, output: pan, + start, }; } } diff --git a/src/classes/PolyBlock.js b/src/classes/PolyBlock.js index f045767..74d7710 100644 --- a/src/classes/PolyBlock.js +++ b/src/classes/PolyBlock.js @@ -10,20 +10,17 @@ class PolyBlock extends Block { instantiate() { // Turn the block model objects into Block classes. this.blocks = this.blockDefinitions.map((block) => { - if (classMap[block.function]) { - // We're doing the same thing that the Sound - // class is doing with the blocks here, but - // in `schedule` we're going to do some tricks - // to link together all of the sounds in a - // polyphonic way. - const b = new classMap[block.function](...block.arguments); - // Tell this block it's in poly mode. - b.setPolyMode(true); - b.instantiate(); - return b; - } else { - throw new Error(`PolyBlock: Block type "${block.function}" does not exist`); - } + if (!(block.function in classMap)) throw new Error(`PolyBlock: Block type "${block.function}" does not exist`); + // We're doing the same thing that the Sound + // class is doing with the blocks here, but + // in `schedule` we're going to do some tricks + // to link together all of the sounds in a + // polyphonic way. + const b = new classMap[block.function](...block.arguments); + // Tell this block it's in poly mode. + b.setPolyMode(true); + b.instantiate(); + return b; }); } schedule(start, stop, note) { @@ -38,13 +35,11 @@ class PolyBlock extends Block { const connections = this.blocks.map(block => block.schedule(start, stop, note)); // Now loop through them and chain them together. - for (let i = 0; i < connections.length; i++) { + for (let i = 0; i < connections.length; i += 1) { // If there is an adjacent block... if (connections[i] && connections[i + 1]) { // Connect them! - connections[i].output.connect( - connections[i + 1].input - ); + connections[i].output.connect(connections[i + 1].input); } else { // We're at the final block; connect // it to the output. @@ -54,4 +49,4 @@ class PolyBlock extends Block { } } -export default PolyBlock; \ No newline at end of file +export default PolyBlock; diff --git a/src/classes/Scheduler.js b/src/classes/Scheduler.js index 857420d..a1f90f4 100644 --- a/src/classes/Scheduler.js +++ b/src/classes/Scheduler.js @@ -1,6 +1,5 @@ import context from '../helpers/context'; import { parseArgument, rhythmMap } from '../helpers/parseArguments'; -import List from '../helpers/List'; export default class Scheduler { constructor(patterns) { @@ -22,7 +21,7 @@ export default class Scheduler { // currentTs will keep track of which // tick we've scheduled up to. this.currentTime = null; - this.lookahead = .04; + this.lookahead = 0.04; this.startTime = null; // Loop through whatever we got and overwrite @@ -31,17 +30,17 @@ export default class Scheduler { // is why we're pulling arguments[0] out. patterns.forEach((pattern) => { switch (pattern.function) { - case 'rhythm': - // We have to special-case rhythm argument parsing - // for now because the xoxoxo-style pattern is not - // recognized by the parser as a List. - this.rhythmPattern = parseArgument(pattern.arguments[0]) - break; - case 'notes': - this.notePattern = parseArgument(pattern.arguments[0]); - break; - default: - break; + case 'rhythm': + // We have to special-case rhythm argument parsing + // for now because the xoxoxo-style pattern is not + // recognized by the parser as a List. + this.rhythmPattern = parseArgument(pattern.arguments[0]); + break; + case 'notes': + this.notePattern = parseArgument(pattern.arguments[0]); + break; + default: + break; } }); } @@ -55,7 +54,7 @@ export default class Scheduler { this.currentTime = timestamp; this.interval = setInterval(() => { - const rhythmMapObj = rhythmMap() + const rhythmMapObj = rhythmMap(); while (this.currentTime < context.currentTime + this.lookahead) { // The tick length could be a number or a string that starts // with 'r', indicating a rest. @@ -79,7 +78,7 @@ export default class Scheduler { // this.currentTime + this.lengthPattern.next(), this.currentTime + nextTickLength, // note - nextNote + nextNote, ); } // go to the next beat in the clock @@ -91,4 +90,4 @@ export default class Scheduler { stop() { this.interval = clearInterval(this.interval); } -} \ No newline at end of file +} diff --git a/src/classes/Sound.js b/src/classes/Sound.js index 967c57f..6e33ef9 100644 --- a/src/classes/Sound.js +++ b/src/classes/Sound.js @@ -24,7 +24,7 @@ class Sound { this.idFactory = 0; // This is for debugging. - this._graphs = []; + this.graphs = []; // ======================================== // INSTANTIATE @@ -41,7 +41,8 @@ class Sound { } nextId() { - return `--${++this.idFactory}`; + this.idFactory += 1; + return `--${this.idFactory}`; } appendToGraph(graph) { @@ -53,14 +54,16 @@ class Sound { // Add to the debug graphs array in case // we need to poke around. - this._graphs.push(graph); + this.graphs.push(graph); } createGraph(pipe, index) { // Create a new set of connections. this.connections[index] = []; - const model = pipe.reduce((model, block, i) => { + const model = pipe.reduce((m, block) => { + // i removed prom params as it is not used + const theModel = Object.assign({}, m); // A block can either be a simple Block function // like `osc` & `filter`, OR it can be a polyblock. // We have to treat those two cases differently. @@ -69,30 +72,29 @@ class Sound { // It seems like PolyBlocks aren't going to // be able to support name variables? Tbd. const thisId = `poly${this.nextId()}`; - model[thisId] = new PolyBlock(block); + theModel[thisId] = new PolyBlock(block); + theModel[thisId].instantiate(); + + this.connections[index].push(thisId); + + return theModel; + } + + const thisId = block.name || `${block.function}${this.nextId()}`; + if (classMap[block.function]) { + // If the block was named, we'll stash + // it by name in the model. Otherwise, + // give it an internal ID that we can + // use to reference it. + model[thisId] = new classMap[block.function](...block.arguments); model[thisId].instantiate(); + // Add this ID to the connection list. this.connections[index].push(thisId); return model; - } else { - const thisId = block.name || `${block.function}${this.nextId()}`; - if (classMap[block.function]) { - // If the block was named, we'll stash - // it by name in the model. Otherwise, - // give it an internal ID that we can - // use to reference it. - model[thisId] = new classMap[block.function](...block.arguments); - model[thisId].instantiate(); - - // Add this ID to the connection list. - this.connections[index].push(thisId); - - return model; - } else { - throw new Error(`${this.name}: Block type "${block.function}" does not exist`); - } } + throw new Error(`${this.name}: Block type "${block.function}" does not exist`); }, {}); // Append this all to our model @@ -109,15 +111,14 @@ class Sound { const connections = this.connections[index]; - const length = this.connections[index].length; + const { length } = this.connections[index]; - for (let i = 0; i < length; i++) { + for (let i = 0; i < length; i += 1) { // If there is an adjacent block... if (connections[i] && connections[i + 1]) { // Connect them! - this.model[connections[i]].connect( - this.model[connections[i + 1]] - ); + this.model[connections[i]] + .connect(this.model[connections[i + 1]]); } else { // We're at the final block; connect // it to the output. diff --git a/src/classes/classMap.js b/src/classes/classMap.js index 10747cf..30acc11 100644 --- a/src/classes/classMap.js +++ b/src/classes/classMap.js @@ -7,13 +7,13 @@ import Pan from './Pan'; import Delay from './Delay'; const classMap = { - 'osc': Osc, - 'drums': Drums, - 'filter': Filter, - 'adsr': ADSR, - 'gain': Gain, - 'pan': Pan, - 'delay': Delay, + osc: Osc, + drums: Drums, + filter: Filter, + adsr: ADSR, + gain: Gain, + pan: Pan, + delay: Delay, }; export default classMap; diff --git a/src/editor.js b/src/editor.js index 627a7e7..636df70 100644 --- a/src/editor.js +++ b/src/editor.js @@ -1,59 +1,17 @@ -import { runScene, clearScene } from './slang'; -import context from './helpers/context'; - import CodeMirror from 'codemirror'; -import * as simpleMode from 'codemirror/addon/mode/simple'; -import js from 'codemirror/mode/clojure/clojure'; import 'codemirror/lib/codemirror.css'; import 'codemirror/theme/duotone-light.css'; +import { runScene, clearScene } from './slang'; +import context from './helpers/context'; + import classMap from './classes/classMap'; import { functionMap } from './functions'; import logo from './static/img/logo.svg'; import './static/css/editor.css'; -// ------------------------------ EDITOR ------------------------------ - -const keywords = Object.keys(classMap).concat(Object.keys(functionMap), ['notes', 'rhythm']); -const keywordRegex = new RegExp(`(?:${keywords.join('|')})\\b`); - -CodeMirror.defineSimpleMode("slang", { - start: [ - { - regex: keywordRegex, - token: "keyword" - }, - { - regex: /[a-g](\#|b)?\d+/i, - token: "note" - }, - { - regex: /\d+(n|t)/i, - token: "beat" - }, - { - regex: /r\d+(n|t)/i, - token: "rest" - }, - { - regex: /0x[a-f\d]+|[-+]?(?:\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/i, - token: "number" - }, - { - regex: /(\+|\~)/, - token: "pipe" - }, - { - regex: /\#.+/, - token: "comment" - }, - { - regex: /\@[a-z$][\w$]*/, - token: "variable" - }, - ], -}); +// ------------------------------ CODE MIRROR ------------------------------ const existingCode = window.localStorage.getItem('code'); const defaultCode = `# Welcome to Slang! Here's an example to get you started. @@ -74,11 +32,47 @@ play @synth const editor = CodeMirror(document.querySelector('#editor'), { value: existingCode || defaultCode, - mode: 'slang', + mode: 'slang', theme: 'duotone-light', indentWithTabs: true, }); +// ------------------------------ ERROR HANDLING ------------------------------ + +// Stash a few references to elements that we'll use to present +// errors to the user. +const $error = document.querySelector('#error'); +const $errorContent = document.querySelector('#error-content'); +const $dismiss = document.querySelector('#dismiss'); + +$dismiss.addEventListener('click', () => { + $error.classList.remove('show'); +}); + +function displayError(message) { + $error.classList.add('show'); + $errorContent.textContent = String(message).trim(); +} + +function clearError() { + $error.classList.remove('show'); +} + +// ------------------------------ CONTROLS ------------------------------ + +const $run = document.querySelector('[data-run]'); +const $stop = document.querySelector('[data-stop]'); +const $status = document.querySelector('[data-status]'); + +function status(str) { + $status.textContent = str; +} + +function stop() { + clearScene(); + status('Stopped'); +} + function run() { context.resume(); const value = editor.getValue(); @@ -99,10 +93,50 @@ function run() { window.localStorage.setItem('code', value); } -function stop() { - clearScene(); - status('Stopped'); -} +$run.addEventListener('click', run); +$stop.addEventListener('click', stop); + +// ------------------------------ EDITOR ------------------------------ + +const keywords = Object.keys(classMap).concat(Object.keys(functionMap), ['notes', 'rhythm']); +const keywordRegex = new RegExp(`(?:${keywords.join('|')})\\b`); + +CodeMirror.defineSimpleMode('slang', { + start: [ + { + regex: keywordRegex, + token: 'keyword', + }, + { + regex: /[a-g](#|b)?\d+/i, + token: 'note', + }, + { + regex: /\d+(n|t)/i, + token: 'beat', + }, + { + regex: /r\d+(n|t)/i, + token: 'rest', + }, + { + regex: /0x[a-f\d]+|[-+]?(?:\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/i, + token: 'number', + }, + { + regex: /(\+|~)/, + token: 'pipe', + }, + { + regex: /#.+/, + token: 'comment', + }, + { + regex: /@[a-z$][\w$]*/, + token: 'variable', + }, + ], +}); editor.on('keydown', (c, e) => { if (e.key === 'Enter' && e.metaKey && e.shiftKey) { @@ -112,36 +146,4 @@ editor.on('keydown', (c, e) => { } }); -// ------------------------------ CONTROLS ------------------------------ - -const $run = document.querySelector('[data-run]'); -const $stop = document.querySelector('[data-stop]'); -const $status = document.querySelector('[data-status]'); - -$run.addEventListener('click', run); -$stop.addEventListener('click', stop); - -function status(str) { - $status.textContent = str; -} - -// ------------------------------ ERROR HANDLING ------------------------------ - -// Stash a few references to elements that we'll use to present -// errors to the user. -const $error = document.querySelector('#error'); -const $errorContent = document.querySelector('#error-content'); -const $dismiss = document.querySelector('#dismiss'); - -$dismiss.addEventListener('click', () => { - $error.classList.remove('show'); -}); - -function displayError(message) { - $error.classList.add('show'); - $errorContent.textContent = String(message).trim(); -} - -function clearError() { - $error.classList.remove('show'); -} \ No newline at end of file +export default logo; diff --git a/src/functions/FunctionCall.js b/src/functions/FunctionCall.js index e4b8b84..5b495be 100644 --- a/src/functions/FunctionCall.js +++ b/src/functions/FunctionCall.js @@ -14,4 +14,4 @@ class FunctionCall { } } -export default FunctionCall; \ No newline at end of file +export default FunctionCall; diff --git a/src/functions/chord.js b/src/functions/chord.js index a2d0968..51a6cda 100644 --- a/src/functions/chord.js +++ b/src/functions/chord.js @@ -6,8 +6,9 @@ import { parseArgument } from '../helpers/parseArguments'; // For now let's strip the spaces out of the chord names // to simplify the arguments to the (chord ...) function. -const scaleNamesMap = Scale.names().reduce((ob, name) => { - ob[name.replace(/( |\#)/g, '')] = name; +const scaleNamesMap = Scale.names().reduce((srcOb, name) => { + const ob = Object.assign({}, srcOb); + ob[name.replace(/( |#)/g, '')] = name; return ob; }, {}); @@ -32,7 +33,7 @@ export default class Chord extends FunctionCall { // figure out how many times it repeats ... const repeat = Math.ceil(length / notes.length); // ... repeat it ... - notes = flatMap(Array(repeat).fill(null), __ => notes); + notes = flatMap(Array(repeat).fill(null), () => notes); // ... now take the exact amount. notes = take(notes, length); } @@ -42,4 +43,4 @@ export default class Chord extends FunctionCall { // the default for a FunctionCall is to return `this.data.next()`. this.data = parseArgument(notes); } -} \ No newline at end of file +} diff --git a/src/functions/flatten.js b/src/functions/flatten.js index 2b64075..ec73e00 100644 --- a/src/functions/flatten.js +++ b/src/functions/flatten.js @@ -1,20 +1,17 @@ import { flatMap } from 'lodash'; import FunctionCall from './FunctionCall'; -import { parseArgument } from '../helpers/parseArguments'; import List from '../helpers/List'; export default class Flatten extends FunctionCall { constructor(functionObject) { super(functionObject); - let data; - // All arguments must be arrays. - data = flatMap(this.arguments[0].toArray(), (arg) => { + const data = flatMap(this.arguments[0].toArray(), (arg) => { if (arg.toArray) return arg.toArray(); return arg; }); this.data = new List(data); } -} \ No newline at end of file +} diff --git a/src/functions/index.js b/src/functions/index.js index 5b8c236..df016c3 100644 --- a/src/functions/index.js +++ b/src/functions/index.js @@ -8,17 +8,17 @@ import Transpose from './transpose'; import Interpolate from './interpolate'; export const functionMap = { - 'random': Random, - 'chord': Chord, - 'repeat': Repeat, - 'flatten': Flatten, - 'reverse': Reverse, - 'shuffle': Shuffle, - 'transpose': Transpose, - 'lerp': Interpolate, + random: Random, + chord: Chord, + repeat: Repeat, + flatten: Flatten, + reverse: Reverse, + shuffle: Shuffle, + transpose: Transpose, + lerp: Interpolate, }; -export default function(functionObject) { +export default function (functionObject) { if (functionMap[functionObject.function]) { return new functionMap[functionObject.function](functionObject); } diff --git a/src/functions/interpolate.js b/src/functions/interpolate.js index e2c87a8..71729c7 100644 --- a/src/functions/interpolate.js +++ b/src/functions/interpolate.js @@ -1,5 +1,3 @@ -import shuffle from 'lodash/shuffle'; -import { parseArgument } from '../helpers/parseArguments'; import FunctionCall from './FunctionCall'; import List from '../helpers/List'; @@ -10,11 +8,11 @@ export default class Interpolate extends FunctionCall { const toValue = this.arguments[1].next(); const steps = this.arguments[2].next(); - const stepInterval = (toValue - fromValue) / (steps - 2); + // const stepInterval = (toValue - fromValue) / (steps - 2); - let values = [fromValue]; - for (let i = 1; i < steps; i++) { - values.push(fromValue * (1 - (i / (steps - 1))) + toValue * (i / (steps - 1))); + const values = [fromValue]; + for (let i = 1; i < steps; i += 1) { + values.push((fromValue * (1 - (i / (steps - 1)))) + (toValue * (i / (steps - 1)))); } this.data = new List(values); diff --git a/src/functions/random.js b/src/functions/random.js index e9b0265..c3bbd59 100644 --- a/src/functions/random.js +++ b/src/functions/random.js @@ -16,4 +16,4 @@ export default class Random extends FunctionCall { Math.floor(Math.random() * this.data.length) ].next(); } -} \ No newline at end of file +} diff --git a/src/functions/repeat.js b/src/functions/repeat.js index fcbb9ce..57a6999 100644 --- a/src/functions/repeat.js +++ b/src/functions/repeat.js @@ -1,5 +1,4 @@ import FunctionCall from './FunctionCall'; -import { parseArgument } from '../helpers/parseArguments'; import List from '../helpers/List'; export default class Random extends FunctionCall { @@ -16,15 +15,15 @@ export default class Random extends FunctionCall { if (this.arguments[1] && this.arguments[1].toArray) { data = this.arguments[1].toArray(); } else { - data = this.arguments[1]; + [, data] = this.arguments; } const repeat = this.arguments[0].next(); - for (let i = 0; i < repeat; i++) { + for (let i = 0; i < repeat; i += 1) { this.data = this.data.concat(data); } this.data = new List(this.data); } -} \ No newline at end of file +} diff --git a/src/functions/reverse.js b/src/functions/reverse.js index 0bc184b..2f020be 100644 --- a/src/functions/reverse.js +++ b/src/functions/reverse.js @@ -1,4 +1,3 @@ -import { parseArgument } from '../helpers/parseArguments'; import FunctionCall from './FunctionCall'; import List from '../helpers/List'; diff --git a/src/functions/shuffle.js b/src/functions/shuffle.js index b4f2018..08f914b 100644 --- a/src/functions/shuffle.js +++ b/src/functions/shuffle.js @@ -1,11 +1,10 @@ import shuffle from 'lodash/shuffle'; -import { parseArgument } from '../helpers/parseArguments'; import FunctionCall from './FunctionCall'; import List from '../helpers/List'; export default class Shuffle extends FunctionCall { constructor(functionObject) { super(functionObject); - this.data = new List(_.shuffle(this.arguments[0].toArray())); + this.data = new List(shuffle(this.arguments[0].toArray())); } } diff --git a/src/functions/transpose.js b/src/functions/transpose.js index 72e1dce..198d058 100644 --- a/src/functions/transpose.js +++ b/src/functions/transpose.js @@ -1,5 +1,5 @@ import { transpose as tonalTranspose } from 'tonal-distance'; -import { fromSemitones } from "tonal-interval" +import { fromSemitones } from 'tonal-interval'; import FunctionCall from './FunctionCall'; import { parseArgument, rhythmMap } from '../helpers/parseArguments'; @@ -17,7 +17,7 @@ export default class Transpose extends FunctionCall { next(passedValue) { const rhythmMapObj = rhythmMap(); console.log(rhythmMapObj); - let nextValue = passedValue || this.data.next(); + const nextValue = passedValue || this.data.next(); // Unfortunately transposing rhythms won't work // easily the way the rhythm strings are passed around @@ -47,7 +47,7 @@ export default class Transpose extends FunctionCall { if (typeof nextValue === 'string') { return tonalTranspose( nextValue, - fromSemitones(Math.floor(this.amount.next())) + fromSemitones(Math.floor(this.amount.next())), ); } @@ -59,4 +59,4 @@ export default class Transpose extends FunctionCall { // which some functions require (like `shuffle`). return this.data.toArray().map(item => this.next(item.next())); } -} \ No newline at end of file +} diff --git a/src/helpers/BufferLoader.js b/src/helpers/BufferLoader.js index a1258db..cc112fd 100644 --- a/src/helpers/BufferLoader.js +++ b/src/helpers/BufferLoader.js @@ -10,41 +10,40 @@ export default function BufferLoader(context, urlList, callback) { this.loadCount = 0; } -BufferLoader.prototype.loadBuffer = function(url, index) { +BufferLoader.prototype.loadBuffer = (url, index) => { // Load buffer asynchronously - var request = new XMLHttpRequest(); - request.open("GET", url, true); - request.responseType = "arraybuffer"; + const request = new XMLHttpRequest(); + request.open('GET', url, true); + request.responseType = 'arraybuffer'; - var loader = this; + const loader = this; - request.onload = function() { + request.onload = () => { // Asynchronously decode the audio file data in request.response loader.context.decodeAudioData( request.response, - function(buffer) { + (buffer) => { if (!buffer) { - console.error('BufferLoader: error decoding file data from url: ' + url); + console.error(`BufferLoader: error decoding file data from url: ${url}`); return; } loader.bufferList[index] = buffer; - if (++loader.loadCount == loader.urlList.length) - loader.onload(loader.bufferList); + loader.loadCount += 1; + if (loader.loadCount === loader.urlList.length) loader.onload(loader.bufferList); + }, + (error) => { + console.error(`BufferLoader: decodeAudioData error ${error}`); }, - function(error) { - console.error('BufferLoader: decodeAudioData error', error); - } ); }; - request.onerror = function() { - console.log('BufferLoader: error decoding', url); + request.onerror = () => { + console.log(`BufferLoader: error decoding ${url}`); }; request.send(); }; -BufferLoader.prototype.load = function() { - for (var i = 0; i < this.urlList.length; ++i) - this.loadBuffer(this.urlList[i], i); +BufferLoader.prototype.load = () => { + for (let i = 0; i < this.urlList.length; i += 1) this.loadBuffer(this.urlList[i], i); }; diff --git a/src/helpers/FunctionCall.js b/src/helpers/FunctionCall.js index 804c7e2..f7d3b07 100644 --- a/src/helpers/FunctionCall.js +++ b/src/helpers/FunctionCall.js @@ -1,12 +1,12 @@ import * as Scale from 'tonal-scale'; import parseArguments, { parseArgument } from './parseArguments'; -import List from './List'; // For now let's strip the spaces out of the chord names // to simplify the arguments to the (chord ...) function. const scaleNamesMap = Scale.names().reduce((ob, name) => { - ob[name.replace(/ /g, '')] = name; - return ob; + const object = Object.assign({}, ob); + object[name.replace(/ /g, '')] = name; + return object; }, {}); class FunctionCall { @@ -34,15 +34,15 @@ class FunctionCall { } next() { switch (this.type) { - case 'random': return this.random(); - case 'chord': return this.chord(); - default: - throw new Error(`Function ${this.type} does not exist`); + case 'random': return this.random(); + case 'chord': return this.chord(); + default: + throw new Error(`Function ${this.type} does not exist`); } } toArray() { - if (this.type === 'chord') return this.chordList.toArray(); + return this.type === 'chord' ? this.chordList.toArray() : null; } // ============================================================ @@ -51,8 +51,9 @@ class FunctionCall { random() { // Returns a single value - if (this.randomList) return this.randomList[Math.floor(Math.random() * this.randomList.length)].next(); - return this.arguments[Math.floor(Math.random() * this.arguments.length)].next(); + return this.randomList + ? this.randomList[Math.floor(Math.random() * this.randomList.length)].next() + : this.arguments[Math.floor(Math.random() * this.arguments.length)].next(); } chord() { @@ -62,4 +63,4 @@ class FunctionCall { } } -export default FunctionCall; \ No newline at end of file +export default FunctionCall; diff --git a/src/helpers/List.js b/src/helpers/List.js index 6cfdc13..cf85046 100644 --- a/src/helpers/List.js +++ b/src/helpers/List.js @@ -24,19 +24,19 @@ class List { } else if (typeof listObject === 'object' && listObject.arguments) { this.values = parseArguments(listObject.arguments); } else { - throw new Error(`List got a weird value? ${listObject}`) + throw new Error(`List got a weird value? ${listObject}`); } - this._currentIndex = 0; + this.currentIndex = 0; } toArray() { return this.values; } next() { - const value = this.values[this._currentIndex].next(); - this._currentIndex = (this._currentIndex + 1) % this.values.length; + const value = this.values[this.currentIndex].next(); + this.currentIndex = (this.currentIndex + 1) % this.values.length; return value; } } -export default List; \ No newline at end of file +export default List; diff --git a/src/helpers/context.js b/src/helpers/context.js index 5d47d00..86f6ffe 100644 --- a/src/helpers/context.js +++ b/src/helpers/context.js @@ -1,9 +1,4 @@ -let context; - -if (window.webkitAudioContext) { - context = new webkitAudioContext(); -} else { - context = new AudioContext(); -} +const WebkitAudio = 'webkitAudioContext'; +const context = window[WebkitAudio] ? new window[WebkitAudio]() : new AudioContext(); export default context; diff --git a/src/helpers/drumMap.js b/src/helpers/drumMap.js index 4c596cd..814c354 100644 --- a/src/helpers/drumMap.js +++ b/src/helpers/drumMap.js @@ -14,51 +14,51 @@ import acousticSnare3 from '../static/audio/acoustic/snare3.mp3'; const drumMap = { 0: { file: acousticKick1, - label: 'acoustic kick 1' + label: 'acoustic kick 1', }, 1: { file: acousticKick2, - label: 'acoustic kick 2' + label: 'acoustic kick 2', }, 2: { file: acousticKick3, - label: 'acoustic kick 3' + label: 'acoustic kick 3', }, 3: { file: acousticSnare1, - label: 'acoustic snare 1' + label: 'acoustic snare 1', }, 4: { file: acousticSnare2, - label: 'acoustic snare 2' + label: 'acoustic snare 2', }, 5: { file: acousticSnare3, - label: 'acoustic snare 3' + label: 'acoustic snare 3', }, 6: { file: acousticHat1, - label: 'acoustic hat 1' + label: 'acoustic hat 1', }, 7: { file: acousticHat2, - label: 'acoustic hat 2' + label: 'acoustic hat 2', }, 8: { file: acousticHatOpen1, - label: 'acoustic hat (open) 1' + label: 'acoustic hat (open) 1', }, 9: { file: acousticHatOpen2, - label: 'acoustic hat (open) 2' + label: 'acoustic hat (open) 2', }, 10: { file: acousticHatOpen3, - label: 'acoustic hat (open) 3' + label: 'acoustic hat (open) 3', }, 11: { file: acousticRim1, - label: 'acoustic rim' + label: 'acoustic rim', }, }; diff --git a/src/helpers/mtof.js b/src/helpers/mtof.js index 9038170..6415e9c 100644 --- a/src/helpers/mtof.js +++ b/src/helpers/mtof.js @@ -1,3 +1,3 @@ export default function mtof(note) { - return ( Math.pow(2, ( note-69 ) / 12) ) * 440.0; + return (2 ** ((note - 69) / 12)) * 440.0; } diff --git a/src/helpers/parseArguments.js b/src/helpers/parseArguments.js index 16f67c9..4370584 100644 --- a/src/helpers/parseArguments.js +++ b/src/helpers/parseArguments.js @@ -3,7 +3,7 @@ import FunctionCall from '../functions'; let TEMPO = 120; -export function rhythmMap () { +export function rhythmMap() { const DIVISION = (1 / 24) / (TEMPO / 60); return { '64t': DIVISION, @@ -32,8 +32,12 @@ export function rhythmMap () { If it's a static value, `next` will return that value. */ -export default function(args) { - return args.map((arg) => parseArgument(arg)); +function createArgumentFromStaticValue(value) { + const rhythmMapObj = rhythmMap(); + // convert rhythms into numbers if we catch one + return { + next: () => rhythmMapObj[value] || value, + }; } export function parseArgument(arg) { @@ -54,17 +58,12 @@ export function parseArgument(arg) { return null; } + +export default args => args.map(arg => parseArgument(arg)); + export function changeTempo(tempo) { - let min = 30; - let max = 500; + const min = 30; + const max = 500; const newTempo = Math.max(Math.min(tempo, max), min); - TEMPO = isNaN(newTempo) ? TEMPO : newTempo; + TEMPO = Number.isNaN(newTempo) ? TEMPO : newTempo; } - -function createArgumentFromStaticValue(value) { - const rhythmMapObj = rhythmMap() - // convert rhythms into numbers if we catch one - return { - next: () => rhythmMapObj[value] || value, - }; -} \ No newline at end of file diff --git a/src/runtime.js b/src/runtime.js index b441093..fac5fd0 100644 --- a/src/runtime.js +++ b/src/runtime.js @@ -1,37 +1,11 @@ import Sound from './classes/Sound'; import context from './helpers/context'; -import { changeTempo } from './helpers/parseArguments.js'; +import { changeTempo } from './helpers/parseArguments'; const model = { sounds: {}, }; -function runScene(scene) { - // a scene is a collection of lines that go together. - - // Stage 1: build the scene - scene.forEach((operation) => { - switch (operation.type) { - case 'graph': - parseGraph(operation); - break; - case 'play': - parsePlay(operation); - break; - case 'tempo': - parseTempo(operation); - break; - } - }); - - const startTime = context.currentTime + 0.01; - - // Stage 2: Schedule the sound - Object.keys(model.sounds).forEach((id) => { - model.sounds[id].start(startTime); - }); -} - function parseGraph(graph) { const { sound } = graph; @@ -53,7 +27,7 @@ function parseGraph(graph) { } else { throw new Error(`Tried to access ${sound.property} of non-existant sound ${sound.name}`); } -}; +} function parsePlay(operation) { model.sounds[operation.sound.name].schedule(operation.patterns); @@ -64,6 +38,33 @@ function parseTempo(operation) { changeTempo(operation.value); } +function runScene(scene) { + // a scene is a collection of lines that go together. + + // Stage 1: build the scene + scene.forEach((operation) => { + switch (operation.type) { + case 'graph': + parseGraph(operation); + break; + case 'play': + parsePlay(operation); + break; + case 'tempo': + parseTempo(operation); + break; + default: + } + }); + + const startTime = context.currentTime + 0.01; + + // Stage 2: Schedule the sound + Object.keys(model.sounds).forEach((id) => { + model.sounds[id].start(startTime); + }); +} + function clearScene() { Object.keys(model.sounds).forEach((id) => { model.sounds[id].destroy(); diff --git a/src/slang.js b/src/slang.js index 00da82d..437a277 100644 --- a/src/slang.js +++ b/src/slang.js @@ -10,6 +10,8 @@ const semantics = grammar.createSemantics(); semantics.addOperation('toAST', { Comment(hash, text) { return { + hash, + text, type: 'comment', }; }, @@ -28,7 +30,7 @@ semantics.addOperation('toAST', { }, Pipe: (char, soundBlock) => soundBlock.toAST(), - function: (lp, soundArguments, rp) => { + function: (lp, soundArguments /* , rp */) => { const [func, ...rest] = soundArguments.asIteration().toAST(); return { type: 'function', @@ -38,7 +40,6 @@ semantics.addOperation('toAST', { }, PolySoundBlock(monoSB, plus, rest) { - // Because of the way we wrote the parser, // normal non-polyphonic blocks will still // hit the PolySoundBlock definition. It's @@ -68,7 +69,7 @@ semantics.addOperation('toAST', { // This is will be a list of soundArguments. arguments: rest, name: name.sourceString, - } + }; }, // soundArgument: s => s.sourceString, @@ -90,7 +91,7 @@ semantics.addOperation('toAST', { Tempo(kw, value) { return { type: 'tempo', - value: value.toAST() + value: value.toAST(), }; }, @@ -98,6 +99,8 @@ semantics.addOperation('toAST', { return { type: 'list', arguments: soundArguments.asIteration().toAST(), + lb, + rb, }; }, @@ -105,24 +108,36 @@ semantics.addOperation('toAST', { return { type: 'list', arguments: range( - parseInt(arg1.sourceString), - parseInt(arg2.sourceString) + parseInt(arg1.sourceString, 10), + parseInt(arg2.sourceString, 10), ), + lb, + rb, }; }, range_note(lb, arg1, __, arg2, rb) { return { type: 'list', - arguments: Range.chromatic( - [arg1.sourceString, arg2.sourceString] - ), + arguments: Range.chromatic([arg1.sourceString, arg2.sourceString]), + lb, + rb, }; }, - int: (neg, i) => neg.sourceString ? parseInt(i.sourceString) * -1 : parseInt(i.sourceString), - float: (f) => parseFloat(f.sourceString), - note: n => isNaN(n.sourceString) ? n.sourceString : +n.sourceString, + int: (neg, i) => { + const res = neg.sourceString + ? parseInt(i.sourceString, 10) * -1 + : parseInt(i.sourceString, 10); + return res; + }, + float: f => parseFloat(f.sourceString), + note: (n) => { + const res = Number.isNaN(n.sourceString) + ? n.sourceString + : +n.sourceString; + return res; + }, rhythm: (r, num, beat) => r.sourceString + num.sourceString + beat.sourceString, }); @@ -143,11 +158,12 @@ export function runScene(text) { // 3. reduce the current set // by appending tab-prefixed // lines onto their predecessor. - .reduce((lines, thisLine, i) => { + .reduce((srcLines, thisLine) => { // If this line is only whitespace and a comment, // let's return early and ignore it here. This will // allow us to support multi-line calls with comments // interspersed. + const lines = srcLines.splice(); if (thisLine.trim().charAt(0) === '#') { return lines; } @@ -193,11 +209,9 @@ export function runScene(text) { // Those seem complicated so instead // let's be marginally helpful by // referencing which "command" it is. - throw new Error( - String(match.message) - .replace('Line 1', `Command ${i}`) - .replace('> 1 | ', '> ') - ); + throw new Error(String(match.message) + .replace('Line 1', `Command ${i}`) + .replace('> 1 | ', '> ')); } // Next we give that to the semantics tool // that we imbued with the `toAST` operation. From fc1b672e3be184c4b9dcd8420f073055572862b1 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 15:05:16 -0500 Subject: [PATCH 08/16] Adding dist/ folder to ignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 3401686..5cb49ea 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ .DS_Store node_modules/ build/ +dist/ deploy.sh From 6d300862eb4d5952efe2c971d3b6684bfb168050 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 15:07:05 -0500 Subject: [PATCH 09/16] Enhancing build script and adding a few others --- package.json | 9 +++-- packing/webpack.config.js | 1 + packing/webpack.prod.js | 81 ++++++++++++++++++++++++++++++++------- 3 files changed, 75 insertions(+), 16 deletions(-) diff --git a/package.json b/package.json index 6e5322b..db28c98 100644 --- a/package.json +++ b/package.json @@ -4,10 +4,13 @@ "description": "", "main": "index.js", "scripts": { - "start": "npm run dev:lib & npm run dev:server", - "dev:lib": "webpack --config packing/webpack.config.js --watch --progress --hide-modules", + "prestart": "npm run lint", + "start": "echo 'STARTING' && npm run dev:lib && npm run dev:server", + "dev:webpack": "webpack --config packing/webpack.config.js --progress --hide-modules", "dev:server": "node packing/server.js", - "build": "webpack --config webpack.prod.js" + "lint": "echo 'LINTING' && eslint --ext .js src packing && echo 'Syntax is ok...'", + "prebuild": "npm run lint", + "build": "echo 'BUILDING' && webpack --config packing/webpack.prod.js" }, "author": "", "license": "ISC", diff --git a/packing/webpack.config.js b/packing/webpack.config.js index a5a4051..9327a56 100644 --- a/packing/webpack.config.js +++ b/packing/webpack.config.js @@ -6,6 +6,7 @@ const MiniCssExtractPlugin = require('mini-css-extract-plugin'); module.exports = { mode: 'development', devtool: 'source-map', + watch: false, entry: { app: './src/editor.js', }, diff --git a/packing/webpack.prod.js b/packing/webpack.prod.js index d568976..02c00c9 100644 --- a/packing/webpack.prod.js +++ b/packing/webpack.prod.js @@ -1,26 +1,81 @@ const path = require('path'); +const HtmlWebpackPlugin = require('html-webpack-plugin'); +const CleanWebpackPlugin = require('clean-webpack-plugin'); +const MiniCssExtractPlugin = require('mini-css-extract-plugin'); module.exports = { mode: 'production', - entry: './src/editor.js', + watch: false, + entry: { + app: './src/editor.js', + }, + resolve: { + symlinks: false, + }, output: { filename: 'site.min.js', - path: path.resolve(__dirname, 'public/build'), + path: path.resolve(__dirname, '../dist'), + publicPath: '/', + pathinfo: false, }, module: { - rules: [{ - test: /\.css$/, - use: ['style-loader', 'css-loader'], - }, - { - test: /\.m?js$/, - exclude: /(node_modules|bower_components)/, - use: { - loader: 'babel-loader', + rules: [ + { + test: /\.m?js$/, + exclude: /(node_modules|bower_components)/, + use: { + loader: 'babel-loader', + options: { + presets: ['@babel/preset-env'], + }, + }, + }, + { + test: /\.ohm$/, + use: ['raw-loader'], + }, + { + test: /\.css$/, + use: [ + { + loader: MiniCssExtractPlugin.loader, + options: { + publicPath: '/css', + name: path.posix.join('/css', '[name].[ext]'), + }, + }, + 'css-loader', + ], + }, + { + test: /\.(png|jpe?g|gif|svg)$/, + loader: 'file-loader', + options: { + limit: 100, + name: path.posix.join('img', '[name].[ext]'), + }, + }, + { + test: /\.(mp3)$/, + loader: 'file-loader', options: { - presets: ['@babel/preset-env'], + limit: 10000, + name: path.posix.join('audio', '[name].[ext]'), }, }, - }], + ], }, + plugins: [ + new CleanWebpackPlugin(['dist']), + new HtmlWebpackPlugin({ + filename: 'index.html', + template: './src/static/editor.html', + title: 'SLANG', + inject: true, + }), + new MiniCssExtractPlugin({ + filename: '[name].css', + chunkFilename: '[id].css', + }), + ], }; From 6c5967c30daaaa3d22d58ac564f4ad87a35c2f05 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Thu, 4 Oct 2018 15:27:37 -0500 Subject: [PATCH 10/16] Removing /dist folder from the repo --- dist/app.css | 555 - dist/app.css.map | 1 - dist/audio/hihat1.mp3 | Bin 21342 -> 0 bytes dist/audio/hihat2.mp3 | Bin 19358 -> 0 bytes dist/audio/hihat_open1.mp3 | Bin 21445 -> 0 bytes dist/audio/hihat_open2.mp3 | Bin 26562 -> 0 bytes dist/audio/hihat_open3.mp3 | Bin 53361 -> 0 bytes dist/audio/kick1.mp3 | Bin 17165 -> 0 bytes dist/audio/kick2.mp3 | Bin 20555 -> 0 bytes dist/audio/kick3.mp3 | Bin 26609 -> 0 bytes dist/audio/rim1.mp3 | Bin 26113 -> 0 bytes dist/audio/snare1.mp3 | Bin 20142 -> 0 bytes dist/audio/snare2.mp3 | Bin 29323 -> 0 bytes dist/audio/snare3.mp3 | Bin 27055 -> 0 bytes dist/img/logo.svg | 27 - dist/index.html | 32 - dist/slang.app.js | 47832 ----------------------------------- dist/slang.app.js.map | 1 - 18 files changed, 48448 deletions(-) delete mode 100644 dist/app.css delete mode 100644 dist/app.css.map delete mode 100644 dist/audio/hihat1.mp3 delete mode 100644 dist/audio/hihat2.mp3 delete mode 100644 dist/audio/hihat_open1.mp3 delete mode 100644 dist/audio/hihat_open2.mp3 delete mode 100644 dist/audio/hihat_open3.mp3 delete mode 100644 dist/audio/kick1.mp3 delete mode 100644 dist/audio/kick2.mp3 delete mode 100644 dist/audio/kick3.mp3 delete mode 100644 dist/audio/rim1.mp3 delete mode 100644 dist/audio/snare1.mp3 delete mode 100644 dist/audio/snare2.mp3 delete mode 100644 dist/audio/snare3.mp3 delete mode 100644 dist/img/logo.svg delete mode 100644 dist/index.html delete mode 100644 dist/slang.app.js delete mode 100644 dist/slang.app.js.map diff --git a/dist/app.css b/dist/app.css deleted file mode 100644 index ed026a1..0000000 --- a/dist/app.css +++ /dev/null @@ -1,555 +0,0 @@ -/* BASICS */ - -.CodeMirror { - /* Set height, width, borders, and global font properties here */ - font-family: monospace; - height: 300px; - color: black; - direction: ltr; -} - -/* PADDING */ - -.CodeMirror-lines { - padding: 4px 0; /* Vertical padding around content */ -} -.CodeMirror pre { - padding: 0 4px; /* Horizontal padding of content */ -} - -.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler { - background-color: white; /* The little square between H and V scrollbars */ -} - -/* GUTTER */ - -.CodeMirror-gutters { - border-right: 1px solid #ddd; - background-color: #f7f7f7; - white-space: nowrap; -} -.CodeMirror-linenumbers {} -.CodeMirror-linenumber { - padding: 0 3px 0 5px; - min-width: 20px; - text-align: right; - color: #999; - white-space: nowrap; -} - -.CodeMirror-guttermarker { color: black; } -.CodeMirror-guttermarker-subtle { color: #999; } - -/* CURSOR */ - -.CodeMirror-cursor { - border-left: 1px solid black; - border-right: none; - width: 0; -} -/* Shown when moving in bi-directional text */ -.CodeMirror div.CodeMirror-secondarycursor { - border-left: 1px solid silver; -} -.cm-fat-cursor .CodeMirror-cursor { - width: auto; - border: 0 !important; - background: #7e7; -} -.cm-fat-cursor div.CodeMirror-cursors { - z-index: 1; -} -.cm-fat-cursor-mark { - background-color: rgba(20, 255, 20, 0.5); - -webkit-animation: blink 1.06s steps(1) infinite; - -moz-animation: blink 1.06s steps(1) infinite; - animation: blink 1.06s steps(1) infinite; -} -.cm-animate-fat-cursor { - width: auto; - border: 0; - -webkit-animation: blink 1.06s steps(1) infinite; - -moz-animation: blink 1.06s steps(1) infinite; - animation: blink 1.06s steps(1) infinite; - background-color: #7e7; -} -@-moz-keyframes blink { - 0% {} - 50% { background-color: transparent; } - 100% {} -} -@-webkit-keyframes blink { - 0% {} - 50% { background-color: transparent; } - 100% {} -} -@keyframes blink { - 0% {} - 50% { background-color: transparent; } - 100% {} -} - -/* Can style cursor different in overwrite (non-insert) mode */ -.CodeMirror-overwrite .CodeMirror-cursor {} - -.cm-tab { display: inline-block; text-decoration: inherit; } - -.CodeMirror-rulers { - position: absolute; - left: 0; right: 0; top: -50px; bottom: -20px; - overflow: hidden; -} -.CodeMirror-ruler { - border-left: 1px solid #ccc; - top: 0; bottom: 0; - position: absolute; -} - -/* DEFAULT THEME */ - -.cm-s-default .cm-header {color: blue;} -.cm-s-default .cm-quote {color: #090;} -.cm-negative {color: #d44;} -.cm-positive {color: #292;} -.cm-header, .cm-strong {font-weight: bold;} -.cm-em {font-style: italic;} -.cm-link {text-decoration: underline;} -.cm-strikethrough {text-decoration: line-through;} - -.cm-s-default .cm-keyword {color: #708;} -.cm-s-default .cm-atom {color: #219;} -.cm-s-default .cm-number {color: #164;} -.cm-s-default .cm-def {color: #00f;} -.cm-s-default .cm-variable, -.cm-s-default .cm-punctuation, -.cm-s-default .cm-property, -.cm-s-default .cm-operator {} -.cm-s-default .cm-variable-2 {color: #05a;} -.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;} -.cm-s-default .cm-comment {color: #a50;} -.cm-s-default .cm-string {color: #a11;} -.cm-s-default .cm-string-2 {color: #f50;} -.cm-s-default .cm-meta {color: #555;} -.cm-s-default .cm-qualifier {color: #555;} -.cm-s-default .cm-builtin {color: #30a;} -.cm-s-default .cm-bracket {color: #997;} -.cm-s-default .cm-tag {color: #170;} -.cm-s-default .cm-attribute {color: #00c;} -.cm-s-default .cm-hr {color: #999;} -.cm-s-default .cm-link {color: #00c;} - -.cm-s-default .cm-error {color: #f00;} -.cm-invalidchar {color: #f00;} - -.CodeMirror-composing { border-bottom: 2px solid; } - -/* Default styles for common addons */ - -div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;} -div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;} -.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); } -.CodeMirror-activeline-background {background: #e8f2ff;} - -/* STOP */ - -/* The rest of this file contains styles related to the mechanics of - the editor. You probably shouldn't touch them. */ - -.CodeMirror { - position: relative; - overflow: hidden; - background: white; -} - -.CodeMirror-scroll { - overflow: scroll !important; /* Things will break if this is overridden */ - /* 30px is the magic margin used to hide the element's real scrollbars */ - /* See overflow: hidden in .CodeMirror */ - margin-bottom: -30px; margin-right: -30px; - padding-bottom: 30px; - height: 100%; - outline: none; /* Prevent dragging from highlighting the element */ - position: relative; -} -.CodeMirror-sizer { - position: relative; - border-right: 30px solid transparent; -} - -/* The fake, visible scrollbars. Used to force redraw during scrolling - before actual scrolling happens, thus preventing shaking and - flickering artifacts. */ -.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler { - position: absolute; - z-index: 6; - display: none; -} -.CodeMirror-vscrollbar { - right: 0; top: 0; - overflow-x: hidden; - overflow-y: scroll; -} -.CodeMirror-hscrollbar { - bottom: 0; left: 0; - overflow-y: hidden; - overflow-x: scroll; -} -.CodeMirror-scrollbar-filler { - right: 0; bottom: 0; -} -.CodeMirror-gutter-filler { - left: 0; bottom: 0; -} - -.CodeMirror-gutters { - position: absolute; left: 0; top: 0; - min-height: 100%; - z-index: 3; -} -.CodeMirror-gutter { - white-space: normal; - height: 100%; - display: inline-block; - vertical-align: top; - margin-bottom: -30px; -} -.CodeMirror-gutter-wrapper { - position: absolute; - z-index: 4; - background: none !important; - border: none !important; -} -.CodeMirror-gutter-background { - position: absolute; - top: 0; bottom: 0; - z-index: 4; -} -.CodeMirror-gutter-elt { - position: absolute; - cursor: default; - z-index: 4; -} -.CodeMirror-gutter-wrapper ::selection { background-color: transparent } -.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent } - -.CodeMirror-lines { - cursor: text; - min-height: 1px; /* prevents collapsing before first draw */ -} -.CodeMirror pre { - /* Reset some styles that the rest of the page might have set */ - -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0; - border-width: 0; - background: transparent; - font-family: inherit; - font-size: inherit; - margin: 0; - white-space: pre; - word-wrap: normal; - line-height: inherit; - color: inherit; - z-index: 2; - position: relative; - overflow: visible; - -webkit-tap-highlight-color: transparent; - -webkit-font-variant-ligatures: contextual; - font-variant-ligatures: contextual; -} -.CodeMirror-wrap pre { - word-wrap: break-word; - white-space: pre-wrap; - word-break: normal; -} - -.CodeMirror-linebackground { - position: absolute; - left: 0; right: 0; top: 0; bottom: 0; - z-index: 0; -} - -.CodeMirror-linewidget { - position: relative; - z-index: 2; - padding: 0.1px; /* Force widget margins to stay inside of the container */ -} - -.CodeMirror-widget {} - -.CodeMirror-rtl pre { direction: rtl; } - -.CodeMirror-code { - outline: none; -} - -/* Force content-box sizing for the elements where we expect it */ -.CodeMirror-scroll, -.CodeMirror-sizer, -.CodeMirror-gutter, -.CodeMirror-gutters, -.CodeMirror-linenumber { - -moz-box-sizing: content-box; - box-sizing: content-box; -} - -.CodeMirror-measure { - position: absolute; - width: 100%; - height: 0; - overflow: hidden; - visibility: hidden; -} - -.CodeMirror-cursor { - position: absolute; - pointer-events: none; -} -.CodeMirror-measure pre { position: static; } - -div.CodeMirror-cursors { - visibility: hidden; - position: relative; - z-index: 3; -} -div.CodeMirror-dragcursors { - visibility: visible; -} - -.CodeMirror-focused div.CodeMirror-cursors { - visibility: visible; -} - -.CodeMirror-selected { background: #d9d9d9; } -.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; } -.CodeMirror-crosshair { cursor: crosshair; } -.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; } -.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; } - -.cm-searching { - background-color: #ffa; - background-color: rgba(255, 255, 0, .4); -} - -/* Used to force a border model for a node */ -.cm-force-border { padding-right: .1px; } - -@media print { - /* Hide the cursor when printing */ - .CodeMirror div.CodeMirror-cursors { - visibility: hidden; - } -} - -/* See issue #2901 */ -.cm-tab-wrap-hack:after { content: ''; } - -/* Help users use markselection to safely style text background */ -span.CodeMirror-selectedtext { background: none; } - -/* -Name: DuoTone-Light -Author: by Bram de Haan, adapted from DuoTone themes by Simurai (http://simurai.com/projects/2016/01/01/duotone-themes) - -CodeMirror template by Jan T. Sott (https://github.com/idleberg), adapted by Bram de Haan (https://github.com/atelierbram/) -*/ - -.cm-s-duotone-light.CodeMirror { background: #faf8f5; color: #b29762; } -.cm-s-duotone-light div.CodeMirror-selected { background: #e3dcce !important; } -.cm-s-duotone-light .CodeMirror-gutters { background: #faf8f5; border-right: 0px; } -.cm-s-duotone-light .CodeMirror-linenumber { color: #cdc4b1; } - -/* begin cursor */ -.cm-s-duotone-light .CodeMirror-cursor { border-left: 1px solid #93abdc; /* border-left: 1px solid #93abdc80; */ border-right: .5em solid #93abdc; /* border-right: .5em solid #93abdc80; */ opacity: .5; } -.cm-s-duotone-light .CodeMirror-activeline-background { background: #e3dcce; /* background: #e3dcce80; */ opacity: .5; } -.cm-s-duotone-light .cm-fat-cursor .CodeMirror-cursor { background: #93abdc; /* #93abdc80; */ opacity: .5; } -/* end cursor */ - -.cm-s-duotone-light span.cm-atom, .cm-s-duotone-light span.cm-number, .cm-s-duotone-light span.cm-keyword, .cm-s-duotone-light span.cm-variable, .cm-s-duotone-light span.cm-attribute, .cm-s-duotone-light span.cm-quote, .cm-s-duotone-light-light span.cm-hr, .cm-s-duotone-light-light span.cm-link { color: #063289; } - -.cm-s-duotone-light span.cm-property { color: #b29762; } -.cm-s-duotone-light span.cm-punctuation, .cm-s-duotone-light span.cm-unit, .cm-s-duotone-light span.cm-negative { color: #063289; } -.cm-s-duotone-light span.cm-string, .cm-s-duotone-light span.cm-operator { color: #1659df; } -.cm-s-duotone-light span.cm-positive { color: #896724; } - -.cm-s-duotone-light span.cm-variable-2, .cm-s-duotone-light span.cm-variable-3, .cm-s-duotone-light span.cm-type, .cm-s-duotone-light span.cm-string-2, .cm-s-duotone-light span.cm-url { color: #896724; } -.cm-s-duotone-light span.cm-def, .cm-s-duotone-light span.cm-tag, .cm-s-duotone-light span.cm-builtin, .cm-s-duotone-light span.cm-qualifier, .cm-s-duotone-light span.cm-header, .cm-s-duotone-light span.cm-em { color: #2d2006; } -.cm-s-duotone-light span.cm-bracket, .cm-s-duotone-light span.cm-comment { color: #b6ad9a; } - -/* using #f00 red for errors, don't think any of the colorscheme variables will stand out enough, ... maybe by giving it a background-color ... */ -/* .cm-s-duotone-light span.cm-error { background: #896724; color: #728fcb; } */ -.cm-s-duotone-light span.cm-error, .cm-s-duotone-light span.cm-invalidchar { color: #f00; } - -.cm-s-duotone-light span.cm-header { font-weight: normal; } -.cm-s-duotone-light .CodeMirror-matchingbracket { text-decoration: underline; color: #faf8f5 !important; } - - -* { - box-sizing: border-box; - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; -} - -body, html { - height: 100%; - margin: 0; -} - -body { - display: flex; - flex-direction: column; - padding: 24px; - font-family: 'Roboto Mono', 'Andale Mono', monospace; -} - -#editor { - position: relative; - flex: 1 0 auto; - display: flex; - flex-direction: column; -} - -/* The top flex column that holds the SVG and the error box */ -.banner { - position: relative; -} - -#svg-title { - flex: 0 0 auto; - display: block; - width: 100%; - max-width: 628px; - max-height: 80px; - height: auto; - margin: 12px auto 24px auto; -} - -#error { - position: absolute; - top: 0; - left: 0; - right: 0; - padding: 12px; - height: 100%; - pointer-events: none; - opacity: 0; - transition: opacity 0.1s; - background-color: white; - border: 1px dashed #fc5e39; - color: #fc5e39; - white-space: pre; - overflow-y: scroll; -} - -#error.show { - opacity: 1; - pointer-events: auto; -} - -#error-content { - position: absolute; - top: 12px; - left: 12px; - right: 24px; -} - -#dismiss { - position: absolute; - top: 12px; - right: 12px; - line-height: 10px; - font-size: 20px; - cursor: pointer; -} - -footer { - position: relative; - top: 10px; - font-size: 12px; - text-align: center; - color: #28bed4; -} - -footer a { - text-decoration: none; - color: #28bed4; -} - -footer a:hover { - text-decoration: underline; -} - -/* ---------------------------------- CONTROLS -------------------------------- -*/ - -#controls { - display: flex; - padding: 6px; - background-color: #eee7dd; -} - -#controls > * { - flex: 0 0 33.33%; -} - -.controls-center { - text-align: center; - color: rgba(0, 0, 0, 0.25); -} - -.controls-right { - text-align: right; -} - -.button { - display: inline-block; - padding: 2px 6px; - border-radius: 2px; - line-height: 22px; - background-color: #8dc154; - color: white; - cursor: pointer; - text-decoration: none; -} - -.button.red { - background-color: #fb5e39; -} - -.button.gray { - background-color: gray; -} - -/* ---------------------------------- EDITOR --------------------------------- -*/ - -.CodeMirror { - flex: 1 0 auto; - padding: 12px; - font-size: 18px; - font-family: 'Roboto Mono', 'Andale Mono', monospace !important; -} - -.cm-note { - color: #8BC34A; -} -.cm-variable { - color: #FF5722 !important; -} -.cm-number { - color: #00BCD4 !important; -} -.cm-pipe { - color: #9c27b0; -} -.cm-comment { - color: #d3ccbb !important; -} -.cm-beat { - color: #ff9800; -} -.cm-rest { - color: #ff980085; -} - -/*# sourceMappingURL=app.css.map*/ \ No newline at end of file diff --git a/dist/app.css.map b/dist/app.css.map deleted file mode 100644 index c7e722e..0000000 --- a/dist/app.css.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["webpack:///./node_modules/codemirror/lib/codemirror.css","webpack:///./node_modules/codemirror/theme/duotone-light.css","webpack:///./src/static/css/editor.css"],"names":[],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;;AAEA;AACA,0BAA0B;AAC1B;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0BAA0B,cAAc;AACxC,iCAAiC,aAAa;;AAE9C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,+BAA+B;AACtC;AACA;AACA;AACA;AACA,OAAO,+BAA+B;AACtC;AACA;AACA;AACA;AACA,OAAO,+BAA+B;AACtC;AACA;;AAEA;AACA;;AAEA,SAAS,uBAAuB,0BAA0B;;AAE1D;AACA;AACA,UAAU,UAAU,YAAY;AAChC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;;AAEA,0BAA0B;AAC1B,yBAAyB;AACzB,cAAc;AACd,cAAc;AACd,wBAAwB;AACxB,QAAQ;AACR,UAAU;AACV,mBAAmB;;AAEnB,2BAA2B;AAC3B,wBAAwB;AACxB,0BAA0B;AAC1B,uBAAuB;AACvB;AACA;AACA;AACA;AACA,8BAA8B;AAC9B,sDAAsD;AACtD,2BAA2B;AAC3B,0BAA0B;AAC1B,4BAA4B;AAC5B,wBAAwB;AACxB,6BAA6B;AAC7B,2BAA2B;AAC3B,2BAA2B;AAC3B,uBAAuB;AACvB,6BAA6B;AAC7B,sBAAsB;AACtB,wBAAwB;;AAExB,yBAAyB;AACzB,iBAAiB;;AAEjB,uBAAuB,0BAA0B;;AAEjD;;AAEA,gDAAgD;AAChD,mDAAmD;AACnD,yBAAyB,mCAAmC;AAC5D,mCAAmC;;AAEnC;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,8BAA8B;AAC9B;AACA;AACA,uBAAuB;AACvB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA,UAAU;AACV;;AAEA;AACA,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC,6CAA6C;;AAE7C;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,wBAAwB,0BAA0B;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAU,UAAU,QAAQ;AAC5B;AACA;;AAEA;AACA;AACA;AACA,iBAAiB;AACjB;;AAEA;;AAEA,qBAAqB,gBAAgB;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,yBAAyB,kBAAkB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,sBAAsB,qBAAqB;AAC3C,0CAA0C,qBAAqB;AAC/D,uBAAuB,mBAAmB;AAC1C,4GAA4G,qBAAqB;AACjI,2HAA2H,qBAAqB;;AAEhJ;AACA;AACA;AACA;;AAEA;AACA,kBAAkB,qBAAqB;;AAEvC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,aAAa;;AAEtC;AACA,8BAA8B,kBAAkB;;ACzVhD;AACA;AACA;;AAEA;AACA;;AAEA,gCAAgC,qBAAqB,gBAAgB;AACrE,6CAA6C,gCAAgC;AAC7E,yCAAyC,qBAAqB,mBAAmB;AACjF,4CAA4C,gBAAgB;;AAE5D;AACA,wCAAwC,gCAAgC,qCAAqC,qCAAqC,uCAAuC,gBAAgB;AACzM,uDAAuD,qBAAqB,2BAA2B,gBAAgB;AACvH,uDAAuD,qBAAqB,cAAc,gBAAgB;AAC1G;;AAEA,ySAAyS,gBAAgB;;AAEzT,sCAAsC,gBAAgB;AACtD,iHAAiH,gBAAgB;AACjI,0EAA0E,gBAAgB;AAC1F,sCAAsC,gBAAgB;;AAEtD,yLAAyL,gBAAgB;AACzM,kNAAkN,gBAAgB;AAClO,0EAA0E,gBAAgB;;AAE1F;AACA,sCAAsC,qBAAqB,gBAAgB,EAAE;AAC7E,4EAA4E,aAAa;;AAEzF,oCAAoC,qBAAqB;AACzD,iDAAiD,4BAA4B,2BAA2B;;;AClCxG;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,C","file":"app.css","sourcesContent":["/* BASICS */\n\n.CodeMirror {\n /* Set height, width, borders, and global font properties here */\n font-family: monospace;\n height: 300px;\n color: black;\n direction: ltr;\n}\n\n/* PADDING */\n\n.CodeMirror-lines {\n padding: 4px 0; /* Vertical padding around content */\n}\n.CodeMirror pre {\n padding: 0 4px; /* Horizontal padding of content */\n}\n\n.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n background-color: white; /* The little square between H and V scrollbars */\n}\n\n/* GUTTER */\n\n.CodeMirror-gutters {\n border-right: 1px solid #ddd;\n background-color: #f7f7f7;\n white-space: nowrap;\n}\n.CodeMirror-linenumbers {}\n.CodeMirror-linenumber {\n padding: 0 3px 0 5px;\n min-width: 20px;\n text-align: right;\n color: #999;\n white-space: nowrap;\n}\n\n.CodeMirror-guttermarker { color: black; }\n.CodeMirror-guttermarker-subtle { color: #999; }\n\n/* CURSOR */\n\n.CodeMirror-cursor {\n border-left: 1px solid black;\n border-right: none;\n width: 0;\n}\n/* Shown when moving in bi-directional text */\n.CodeMirror div.CodeMirror-secondarycursor {\n border-left: 1px solid silver;\n}\n.cm-fat-cursor .CodeMirror-cursor {\n width: auto;\n border: 0 !important;\n background: #7e7;\n}\n.cm-fat-cursor div.CodeMirror-cursors {\n z-index: 1;\n}\n.cm-fat-cursor-mark {\n background-color: rgba(20, 255, 20, 0.5);\n -webkit-animation: blink 1.06s steps(1) infinite;\n -moz-animation: blink 1.06s steps(1) infinite;\n animation: blink 1.06s steps(1) infinite;\n}\n.cm-animate-fat-cursor {\n width: auto;\n border: 0;\n -webkit-animation: blink 1.06s steps(1) infinite;\n -moz-animation: blink 1.06s steps(1) infinite;\n animation: blink 1.06s steps(1) infinite;\n background-color: #7e7;\n}\n@-moz-keyframes blink {\n 0% {}\n 50% { background-color: transparent; }\n 100% {}\n}\n@-webkit-keyframes blink {\n 0% {}\n 50% { background-color: transparent; }\n 100% {}\n}\n@keyframes blink {\n 0% {}\n 50% { background-color: transparent; }\n 100% {}\n}\n\n/* Can style cursor different in overwrite (non-insert) mode */\n.CodeMirror-overwrite .CodeMirror-cursor {}\n\n.cm-tab { display: inline-block; text-decoration: inherit; }\n\n.CodeMirror-rulers {\n position: absolute;\n left: 0; right: 0; top: -50px; bottom: -20px;\n overflow: hidden;\n}\n.CodeMirror-ruler {\n border-left: 1px solid #ccc;\n top: 0; bottom: 0;\n position: absolute;\n}\n\n/* DEFAULT THEME */\n\n.cm-s-default .cm-header {color: blue;}\n.cm-s-default .cm-quote {color: #090;}\n.cm-negative {color: #d44;}\n.cm-positive {color: #292;}\n.cm-header, .cm-strong {font-weight: bold;}\n.cm-em {font-style: italic;}\n.cm-link {text-decoration: underline;}\n.cm-strikethrough {text-decoration: line-through;}\n\n.cm-s-default .cm-keyword {color: #708;}\n.cm-s-default .cm-atom {color: #219;}\n.cm-s-default .cm-number {color: #164;}\n.cm-s-default .cm-def {color: #00f;}\n.cm-s-default .cm-variable,\n.cm-s-default .cm-punctuation,\n.cm-s-default .cm-property,\n.cm-s-default .cm-operator {}\n.cm-s-default .cm-variable-2 {color: #05a;}\n.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}\n.cm-s-default .cm-comment {color: #a50;}\n.cm-s-default .cm-string {color: #a11;}\n.cm-s-default .cm-string-2 {color: #f50;}\n.cm-s-default .cm-meta {color: #555;}\n.cm-s-default .cm-qualifier {color: #555;}\n.cm-s-default .cm-builtin {color: #30a;}\n.cm-s-default .cm-bracket {color: #997;}\n.cm-s-default .cm-tag {color: #170;}\n.cm-s-default .cm-attribute {color: #00c;}\n.cm-s-default .cm-hr {color: #999;}\n.cm-s-default .cm-link {color: #00c;}\n\n.cm-s-default .cm-error {color: #f00;}\n.cm-invalidchar {color: #f00;}\n\n.CodeMirror-composing { border-bottom: 2px solid; }\n\n/* Default styles for common addons */\n\ndiv.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}\ndiv.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}\n.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }\n.CodeMirror-activeline-background {background: #e8f2ff;}\n\n/* STOP */\n\n/* The rest of this file contains styles related to the mechanics of\n the editor. You probably shouldn't touch them. */\n\n.CodeMirror {\n position: relative;\n overflow: hidden;\n background: white;\n}\n\n.CodeMirror-scroll {\n overflow: scroll !important; /* Things will break if this is overridden */\n /* 30px is the magic margin used to hide the element's real scrollbars */\n /* See overflow: hidden in .CodeMirror */\n margin-bottom: -30px; margin-right: -30px;\n padding-bottom: 30px;\n height: 100%;\n outline: none; /* Prevent dragging from highlighting the element */\n position: relative;\n}\n.CodeMirror-sizer {\n position: relative;\n border-right: 30px solid transparent;\n}\n\n/* The fake, visible scrollbars. Used to force redraw during scrolling\n before actual scrolling happens, thus preventing shaking and\n flickering artifacts. */\n.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n position: absolute;\n z-index: 6;\n display: none;\n}\n.CodeMirror-vscrollbar {\n right: 0; top: 0;\n overflow-x: hidden;\n overflow-y: scroll;\n}\n.CodeMirror-hscrollbar {\n bottom: 0; left: 0;\n overflow-y: hidden;\n overflow-x: scroll;\n}\n.CodeMirror-scrollbar-filler {\n right: 0; bottom: 0;\n}\n.CodeMirror-gutter-filler {\n left: 0; bottom: 0;\n}\n\n.CodeMirror-gutters {\n position: absolute; left: 0; top: 0;\n min-height: 100%;\n z-index: 3;\n}\n.CodeMirror-gutter {\n white-space: normal;\n height: 100%;\n display: inline-block;\n vertical-align: top;\n margin-bottom: -30px;\n}\n.CodeMirror-gutter-wrapper {\n position: absolute;\n z-index: 4;\n background: none !important;\n border: none !important;\n}\n.CodeMirror-gutter-background {\n position: absolute;\n top: 0; bottom: 0;\n z-index: 4;\n}\n.CodeMirror-gutter-elt {\n position: absolute;\n cursor: default;\n z-index: 4;\n}\n.CodeMirror-gutter-wrapper ::selection { background-color: transparent }\n.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }\n\n.CodeMirror-lines {\n cursor: text;\n min-height: 1px; /* prevents collapsing before first draw */\n}\n.CodeMirror pre {\n /* Reset some styles that the rest of the page might have set */\n -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;\n border-width: 0;\n background: transparent;\n font-family: inherit;\n font-size: inherit;\n margin: 0;\n white-space: pre;\n word-wrap: normal;\n line-height: inherit;\n color: inherit;\n z-index: 2;\n position: relative;\n overflow: visible;\n -webkit-tap-highlight-color: transparent;\n -webkit-font-variant-ligatures: contextual;\n font-variant-ligatures: contextual;\n}\n.CodeMirror-wrap pre {\n word-wrap: break-word;\n white-space: pre-wrap;\n word-break: normal;\n}\n\n.CodeMirror-linebackground {\n position: absolute;\n left: 0; right: 0; top: 0; bottom: 0;\n z-index: 0;\n}\n\n.CodeMirror-linewidget {\n position: relative;\n z-index: 2;\n padding: 0.1px; /* Force widget margins to stay inside of the container */\n}\n\n.CodeMirror-widget {}\n\n.CodeMirror-rtl pre { direction: rtl; }\n\n.CodeMirror-code {\n outline: none;\n}\n\n/* Force content-box sizing for the elements where we expect it */\n.CodeMirror-scroll,\n.CodeMirror-sizer,\n.CodeMirror-gutter,\n.CodeMirror-gutters,\n.CodeMirror-linenumber {\n -moz-box-sizing: content-box;\n box-sizing: content-box;\n}\n\n.CodeMirror-measure {\n position: absolute;\n width: 100%;\n height: 0;\n overflow: hidden;\n visibility: hidden;\n}\n\n.CodeMirror-cursor {\n position: absolute;\n pointer-events: none;\n}\n.CodeMirror-measure pre { position: static; }\n\ndiv.CodeMirror-cursors {\n visibility: hidden;\n position: relative;\n z-index: 3;\n}\ndiv.CodeMirror-dragcursors {\n visibility: visible;\n}\n\n.CodeMirror-focused div.CodeMirror-cursors {\n visibility: visible;\n}\n\n.CodeMirror-selected { background: #d9d9d9; }\n.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }\n.CodeMirror-crosshair { cursor: crosshair; }\n.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }\n.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }\n\n.cm-searching {\n background-color: #ffa;\n background-color: rgba(255, 255, 0, .4);\n}\n\n/* Used to force a border model for a node */\n.cm-force-border { padding-right: .1px; }\n\n@media print {\n /* Hide the cursor when printing */\n .CodeMirror div.CodeMirror-cursors {\n visibility: hidden;\n }\n}\n\n/* See issue #2901 */\n.cm-tab-wrap-hack:after { content: ''; }\n\n/* Help users use markselection to safely style text background */\nspan.CodeMirror-selectedtext { background: none; }\n","/*\nName: DuoTone-Light\nAuthor: by Bram de Haan, adapted from DuoTone themes by Simurai (http://simurai.com/projects/2016/01/01/duotone-themes)\n\nCodeMirror template by Jan T. Sott (https://github.com/idleberg), adapted by Bram de Haan (https://github.com/atelierbram/)\n*/\n\n.cm-s-duotone-light.CodeMirror { background: #faf8f5; color: #b29762; }\n.cm-s-duotone-light div.CodeMirror-selected { background: #e3dcce !important; }\n.cm-s-duotone-light .CodeMirror-gutters { background: #faf8f5; border-right: 0px; }\n.cm-s-duotone-light .CodeMirror-linenumber { color: #cdc4b1; }\n\n/* begin cursor */\n.cm-s-duotone-light .CodeMirror-cursor { border-left: 1px solid #93abdc; /* border-left: 1px solid #93abdc80; */ border-right: .5em solid #93abdc; /* border-right: .5em solid #93abdc80; */ opacity: .5; }\n.cm-s-duotone-light .CodeMirror-activeline-background { background: #e3dcce; /* background: #e3dcce80; */ opacity: .5; }\n.cm-s-duotone-light .cm-fat-cursor .CodeMirror-cursor { background: #93abdc; /* #93abdc80; */ opacity: .5; }\n/* end cursor */\n\n.cm-s-duotone-light span.cm-atom, .cm-s-duotone-light span.cm-number, .cm-s-duotone-light span.cm-keyword, .cm-s-duotone-light span.cm-variable, .cm-s-duotone-light span.cm-attribute, .cm-s-duotone-light span.cm-quote, .cm-s-duotone-light-light span.cm-hr, .cm-s-duotone-light-light span.cm-link { color: #063289; }\n\n.cm-s-duotone-light span.cm-property { color: #b29762; }\n.cm-s-duotone-light span.cm-punctuation, .cm-s-duotone-light span.cm-unit, .cm-s-duotone-light span.cm-negative { color: #063289; }\n.cm-s-duotone-light span.cm-string, .cm-s-duotone-light span.cm-operator { color: #1659df; }\n.cm-s-duotone-light span.cm-positive { color: #896724; }\n\n.cm-s-duotone-light span.cm-variable-2, .cm-s-duotone-light span.cm-variable-3, .cm-s-duotone-light span.cm-type, .cm-s-duotone-light span.cm-string-2, .cm-s-duotone-light span.cm-url { color: #896724; }\n.cm-s-duotone-light span.cm-def, .cm-s-duotone-light span.cm-tag, .cm-s-duotone-light span.cm-builtin, .cm-s-duotone-light span.cm-qualifier, .cm-s-duotone-light span.cm-header, .cm-s-duotone-light span.cm-em { color: #2d2006; }\n.cm-s-duotone-light span.cm-bracket, .cm-s-duotone-light span.cm-comment { color: #b6ad9a; }\n\n/* using #f00 red for errors, don't think any of the colorscheme variables will stand out enough, ... maybe by giving it a background-color ... */\n/* .cm-s-duotone-light span.cm-error { background: #896724; color: #728fcb; } */\n.cm-s-duotone-light span.cm-error, .cm-s-duotone-light span.cm-invalidchar { color: #f00; }\n\n.cm-s-duotone-light span.cm-header { font-weight: normal; }\n.cm-s-duotone-light .CodeMirror-matchingbracket { text-decoration: underline; color: #faf8f5 !important; }\n\n","* {\n\tbox-sizing: border-box;\n\t-webkit-font-smoothing: antialiased;\n\t-moz-osx-font-smoothing: grayscale;\n}\n\nbody, html {\n\theight: 100%;\n\tmargin: 0;\n}\n\nbody {\n\tdisplay: flex;\n\tflex-direction: column;\n\tpadding: 24px;\n\tfont-family: 'Roboto Mono', 'Andale Mono', monospace;\n}\n\n#editor {\n\tposition: relative;\n\tflex: 1 0 auto;\n\tdisplay: flex;\n\tflex-direction: column;\n}\n\n/* The top flex column that holds the SVG and the error box */\n.banner {\n\tposition: relative;\n}\n\n#svg-title {\n\tflex: 0 0 auto;\n\tdisplay: block;\n\twidth: 100%;\n\tmax-width: 628px;\n\tmax-height: 80px;\n\theight: auto;\n\tmargin: 12px auto 24px auto;\n}\n\n#error {\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\tright: 0;\n\tpadding: 12px;\n\theight: 100%;\n\tpointer-events: none;\n\topacity: 0;\n\ttransition: opacity 0.1s;\n\tbackground-color: white;\n\tborder: 1px dashed #fc5e39;\n\tcolor: #fc5e39;\n\twhite-space: pre;\n\toverflow-y: scroll;\n}\n\n#error.show {\n\topacity: 1;\n\tpointer-events: auto;\n}\n\n#error-content {\n\tposition: absolute;\n\ttop: 12px;\n\tleft: 12px;\n\tright: 24px;\n}\n\n#dismiss {\n\tposition: absolute;\n\ttop: 12px;\n\tright: 12px;\n\tline-height: 10px;\n\tfont-size: 20px;\n\tcursor: pointer;\n}\n\nfooter {\n\tposition: relative;\n\ttop: 10px;\n\tfont-size: 12px;\n\ttext-align: center;\n\tcolor: #28bed4;\n}\n\nfooter a {\n\ttext-decoration: none;\n\tcolor: #28bed4;\n}\n\nfooter a:hover {\n\ttext-decoration: underline;\n}\n\n/*\n--------------------------------- CONTROLS --------------------------------\n*/\n\n#controls {\n\tdisplay: flex;\n\tpadding: 6px;\n\tbackground-color: #eee7dd;\n}\n\n#controls > * {\n\tflex: 0 0 33.33%;\n}\n\n.controls-center {\n\ttext-align: center;\n\tcolor: rgba(0, 0, 0, 0.25);\n}\n\n.controls-right {\n\ttext-align: right;\n}\n\n.button {\n\tdisplay: inline-block;\n\tpadding: 2px 6px;\n\tborder-radius: 2px;\n\tline-height: 22px;\n\tbackground-color: #8dc154;\n\tcolor: white;\n\tcursor: pointer;\n\ttext-decoration: none;\n}\n\n.button.red {\n\tbackground-color: #fb5e39;\n}\n\n.button.gray {\n\tbackground-color: gray;\n}\n\n/*\n--------------------------------- EDITOR ---------------------------------\n*/\n\n.CodeMirror {\n\tflex: 1 0 auto;\n\tpadding: 12px;\n\tfont-size: 18px;\n\tfont-family: 'Roboto Mono', 'Andale Mono', monospace !important;\n}\n\n.cm-note {\n\tcolor: #8BC34A;\n}\n.cm-variable {\n\tcolor: #FF5722 !important;\n}\n.cm-number {\n\tcolor: #00BCD4 !important;\n}\n.cm-pipe {\n\tcolor: #9c27b0;\n}\n.cm-comment {\n\tcolor: #d3ccbb !important;\n}\n.cm-beat {\n\tcolor: #ff9800;\n}\n.cm-rest {\n\tcolor: #ff980085;\n}"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/audio/hihat1.mp3 b/dist/audio/hihat1.mp3 deleted file mode 100644 index 776f96311a28ac7cf31fef399b65b7515eec7abf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21342 zcmdp-Q*b6gd4-b!&l$3^shJ}TNi;GJ@ zKwMlL2n4FAsAy|zfBW{$+}zyG&ehe`$HylmBqSy#COJ7dJ3G6$xVpN!si~>EyL)J8 zXliO|X=!O|>+taK>gwv@;o*>l!%y+{TD~yFTNc@K|hsPlvrnh-7-VH$&tdK;13rMbnog6?Rf4e6M zL8&mi!49b4$OiyiL0@55h+9-}K+YsMAW#Sr0uIzZkvB3Kt6`d7qfU+m2n-gv3WrlF zix$UM!DQ&~JCKNsPQ{Wj!6f|x0FP}IGYB%m2NW}{PH<~C9rdvxlm9EY6CFVg=?bj$OxwXe*^{J77wCd~0R zl*R`#$E^5Y3cG*9ledi59;=%?YJk%Aqxj2ekmA*=QPMGh&a-{c1oW^KZlr;`%g&Gf z;pl5Ti%P6cw_0uN|AC)i@0_nWw)y1kCCT~0BV&TBdQtKY6%GG#Y+T#B)hQ(ApFFpy zatb;7tr5tOUwY&Cc=d#Q&RVTY>*nPLY5!Fthu;G-jCrTJu#~a^k3N7`pO-e|X5PuDiEWS||&?xF*%dcz$pjy@Z)N zLEKhRX(|9X8_HF_gmBq=XY}Y|^VD6oO`IP5Sp2aRpegGk^eDO39RM1iZtvQ~x_41}_C+W;8>z*+lYt@Z)|46?K#GMo{8VMX}j&*iJOHU^MXHFCT*+%)4u1LH~8$ zxWIM#Yk4t_gPTxZW<(P>_Jy>Ek_aopO}N{??CoSn z?4=zhK#10n9?UNGHQ0c+9%|YoS?}&*S|zqXgftNrRqxIvsGn9P1gDd24QN?g-PBcC zyK@^?%f2_;bGlE0u7@OUp|1A_aSa7#RxlD>ozB45TTql@)Z5vy<27{vV}rTp0M8R; zxGZ7)FoGt}(w#N~n?O6|B+tjtDu8J#p*-=yVlvws|B89>+83%cw{i1>ppe;^zZxNW zJ%_fm9U%Z?t}bG{?leMswctDGby-tdB;0hSpv5k7CnezPz%cFI4Z?=w2 zbTMB=vR}N94b9<+`E_~E*GkW^>6P=Y9C$7W<&I5hzkoFJrk(ULGU*h{hx|qy(IFzsQp=fBl7Xs7R8}?4Qjte=ykl4iAQn@cQoA}~ zrlpe0A#J#BEP~2UED~I2yi}#31zd2yeSZh{69O zuXW)Y9@b~_utJgQYTS$8t6ue%Rgr1#AcD#<8v6nP-;wKB-7ZB|*^}7$+8Dj1YSkdSavQ5|?2q10N~o z<8HmI)QbzEWg{Sr3r4^{w9e5ZL(F6p^esBG!eI$_oOG@wa}#6j|EP7x=5IMyTCWug z+DOE_bM5Ll@3_$T!WhTZ(QSUrpiCN|ZQad>w~#!PsUL-~$<*YR<%8{j_kNd=9b_|= znA3xvn0w9`QqqjRl&M_|kyRCzTIMrTA{1?dqD;HLpzQ_N&@r2C^7c1A;H44>r*en- zcFOoQZnvJpo1mAc=cflZn(Kt3*2%M}U8+cZz5;Qt?dO$xwe7c_As&wDD+`9=0q=#i;@GPV9UV_`N+V_6`AVHKt;*)J=i2+1ioBvvq3& zH42r5btATZ8E=0QPIF@`IMq0Z9RF6eIvZ{PG68=HC!r2sCCv1ps)4 z!|a!O&HTH}J;b+pN(?$d>>QdaldO-_bL2GEW$OCjvksZ9?8gw}EE{O%9Iy?BMs*vG zY37-E>LFCkaO=TwysFBh9)d=W;w`P{RQqH`)Ecc6NttQ5O3K$%DaPbFw_Nw@ASC&T zzhZvA5nh7|vGg}R?~^7B1JiA>UN)cn#|&L3vXfp+Cg4%pr+f- z5?n3f#j_%1fae?W@};VeCI}=2x(0zj64O5>D#CRUEK%hg5A8d)6IsSY2IFi@+zIDn zSRL1MLZMwv;9}TBmg&I5#aCXFA{89d_L&H&;Pk@sBwxn+N@$kgGvQPxuen5vf-#y| zxR)%@%e9oUAg9lTo0`6#+C1D{pht#Eu@5>AZdS^zy5y0Ii*l?p*cFUd8L5$_kF!h5 zXr7Q(ic%Yk)rFPCL5x5^u6NN%SKgMXDBW;MJ*D;FuFv9DBHZvKWfN7*=$YTB<$vo5 z8s?HHda9ZE?Mye2*o!h0YQ8$lvqW113hp(-uliwg1Ot+(CVIdjyQ02^U zFN$GMz5WFLGIoJ?%siVfxzMM9!pGF-mBJgRfC0!-0d0b|kB;H`f3s{UVhkXA${oTb z_giGiKlGWa)l*@s@(f@e{hp-pbZII1It@v4P2A&5>|Yw9OBov07di8zrrvbiUDA4>F-cRizbZh0C5l8{_{tt0g`hpYY zu(1f7sq+=OHw!LPs~fDe=`{!2y_Xnvf=gp-W7cI^I&!Rxc9ikIk*zb3ygK(M@Cc zH%GZ)M4oj^;MpE*a(ry6@W+@1I`*-^%>mJFp}dLUc)pycHS&hNr}l z`LoVw%GtuIM$5=_)L>JR=G@~7(`fFknY9MlGd20AE1Z<=)^Gl1R_n&o z_pV)1DVX!6EB&)j!0xf z1GqB5sgcl^^+`^flk|(ku8Q>I9|DXs@`*3!?S7aBT0 z*^FKQ-;hL7I9NLBHk{%r8JSrASVcfdlcOZPU!dj0rk>5!$!lp|b8_OKXaa1w)Of|s zl9ABWCfF)9+LN3z#aN6}NhVdB4?xdsxr%8#co|`%$}~p|MeZDo%CU=N4ab#HL;@S{ zWYD3z(y5|;AJ8lXGF6pf{*+-5=#}Y$PJaOjQ-oqDgK!iE{_?BpG>t0P zhHzwl=A$TJlm@Q|R@}9tr6RK`nnnPfk7@{sCeDm{T-lu)Zb_!&8(x}oldnV5B-1tG z1)P07`$6+S=3mV(wB-@>Q$@2L48nFK_AR&G#-k*QF#>KtMN$$RGb_lwBy^7Y_@Y&9 zE+&@AldDqrALL>-^1w3Yo%3phpN-z_%HY#ZW$SM7id$GZQz~=1y_Yj=U#&cz4!a0x z(Pc)Vz_%DWBV4Ic=2*HKk&b~&ViJ?vvd6fVokaUxnR!6R+V6$YKPuA1`Ky;hYlj~3 zu=R5q)i1j1Kk82Y#aGV&=mtxT46nghLou7r{b8$ci2R$#<=?D zSHGyuY6-{HA4PMZr^VO4Ezk-`cX)f7kF_NTipH-g^x%fbAUixO5g!d6AGsmQ(Q1DJ zft!fHaGMtqQekW_3yiA>+QmvZq9djYt`<3QUXqQ}X=~+14h9|<*1B%}TY22UpU{F- zmK@u`4Y!2SrQdGGsf!rLHu!YlUK*B6M+%3Hg6h`e(?#A9@T5b>U(%`jN5W+w^e;=GkCw3`TLG@uKN8@I>92Yd`cnYpuAd}$k4#gKE(-Ro zo(EN23<9l%enJlFP^6C@i7cm;9#6Qo|19A}^TFs=#|Ayqcdd2JO#E<8{GroZm0hZ) zsRGv-_li0gjEMM)2;O+)U^u2^VnDW7JV-bw1qMI^h6^jKlcP$<8Cqh#c&Y>4_gc;% zIIi8zRhBNHmGZH&uUZTJE!9bPC~&@*e>e$Rs$Q_?$XIO+(x2|K=7Is?>hR1ba$co_ zhfP<6I9;i41r;Y9j$U@MGidy1hBKn{RD&*(y5ik1S=TQ`nWL;@!flUD&xjBy<+}^c zyRNA7bh$t0C2B^Ed-5%o714SRmULrV26Ls#VyO(rS1QN{4(y@hJogU>zLQ!-Cakmb z0RPFtWH-kQvpn;a*%dXB5-9xBD%R!2^~cH0O%40JZL+&q`B>54KIwGb>CXYrq!%@n zSX*EJ$;|DO#IS)lS&l75YFV2s7@{i#GzC_bZI`ILoDsPwu39D@Y^3EcRM-{|2}oI8 z`x^Oj9A%*9!_Q(N4b<{U%r_U(WG@j9u3ahikr8s9E30aZqX8Z;5oGYG(VDL#SvxD^ z-k9=oYNHr3TqB~#_h~V*Emiz}`E<{?SwX}amkq=-5ng+3qyE1;6u8r|2=@3r;NE^U zqEEZ%nGJev68>|cwLs`Mizy#le?zwZ{~~PyuwvS40rvhjKoJEC0KlR4lHhuwPO41v zYL~{A&M-yc?2MNtMdqKxkn@|tbaJ2_1KmDPI-9ICF}5=cPaUkty!&jHtnH}n+3bB~ zNESTbG0|w6wdYAybb6_|F#zZdprLwG$G*7spDcP00D&Hq8Ed*fbE+ zH?mW}rjN)`e`W9dV@tCy?0PV7dOV6%ps;#qu4N~Oz}%9+55oad$9ypAV4`r~s)oe$ zv%lOidZj#?a84@@F?wD4=w4-}-ARM>g8X94Uj~Stq!dwpFd$hJUm+K5uFu`H==&r1 z5Nd!o$9-~$2T{xfj5YQU=oGIWPiaZakA#BvEVE?r^-8QZHD}&+F(iX zb4vC^?gLyy9#ea7Ey6r8Y?(@L3RQz01oN9(fA$|6YrkKaI#OrVCHTmwf@G$hZI5K2 zMN!R2!aZXxphRX#MX6i~f z&oyFcG?6=V{L`NMKT-8CMj1C0|XlP z%WsN#Qq18oZ0Ix?xv^0mD(nDOwuY0CW9(2Z&3G>10YBY`x8=mE>qT~6FZwOiCTl1i! zrK$@%($Hs*)yokjm7tLXvki(C0UpGU7#kshk;&A~6KEAn9FlQFJt|Ka;$hG#bE2Mk zWy#sN2Ujy^ddi^%_V5X%japf)D@Ig*Rj4aCB6 z$g&LAxJyG}oH7=|T^6R5)OFI*Fnopz5UCg5`_)V|xmH0AMW0fIX}37>fznJxRE>_7 zH*0^Davx*r)QqOi5F!>|P4*IUfFWGV3|`4h_9lctAGOB_4NEP;`)Dpprb?Xdyd zECnICLFAwIYz9KRnUDL(DUi|b;l_Tt5I$P*mumsm{`pGW6b89eM`yLB)%h}V8I|hQq4Y) zj;4{xLUYp#VODX7v8rsO&8q3Bix!zi0YgqCt}~)W%ACfU37xb$eJ6bV5G|9#I2vP} zBpWF+kS5*M-SlwqQE38{$|hYr4&}v^tHdf6VQp{7CxGYfk{+~zC`H5jWh#0`t=h~` zN6T!BR-_MG+KJk4hQPX-TDoLJnG+p_W9+OCm%e1GdJ9(&xR3cei`WV-P23dqmbb4) zQZ}rJ7F+YLI)hn#x(Fo0Vq`IIxS8;ID>XeP9*Hs>=Fd?b)<_rKKmBwz3c3{vdH8O+ zc3TK~H@Clkt9}D5?7RtP(Y=4GyQr(m%H6W0Wa3ty?j}V=ZJu}R$7&|D%?cL7=|@h) z9k$?ZaJ2IZN`l*VHiZ%vI_{OGqQ(l@1+sH2z~*TE&SEMWy`q|)@EgeT>~L{3S7$d< zxn!Wm+H}&M;E&fh?vk&}t82&jo6qo7dOo?40M?;bZ9-$RRZRF8!^T8VW&7Y^skQ`J z1v;XNyffN^sS9OReA2Rf+v!Bd@5^R+hO?gsAG*br|B2?819cmZ`Haq+i{75=xAW)i z?u>PM9weD^q`8ZWm?pQ~FioboTPkxt$MCx(eactvEXf z^l>|X`)M_w+Vc?z9cnq|qX_)PCH!C9gKL#S{#iU9UjzJCSCYD{jqc9$FyT<51n`0ayJx6o{8=8#*6t zg=e&)lBfF*uWPQ~(Kh?W!s}+D(1uoq z`0CMt?B~mRSqo+u!wsY+QVWTe)^4@y+2{p0uRFmc)uUhG{cBB46{!+N+B8St?->+P zR>E3K@q6K^OuMi$Zo&mTr!8vB5~xyLfFfl}8L@OYXX`Yw;c>S1n|q((EDlSNqy#(p z7n~Jqrw6yRMgvWR+|!MV^c7o$+?p6g#dQ~SExQCY|C`BvQayAPx& zZagm?9vLOh5lP8CC#>IiJ`E5H;efPvG|DcxE6fd-MMi|ojB_j?DN^#yNGDk*iL)FZ zA+0d1QfjXlBPYd<;hI0fOfK2PgynS6lTy^i*2-XB+tNmOK%`wQ%8RDdweA#TQIk3- zW1HOT=@<^a<2@>yxsQ(h5=TebB18lqPWl?O5n>}4-i@OJoiJ{rjGj%ALnrE^Yhs;U zD=6BmStX!Yj=JH8sZRe@I{Zd`=d3f=o!XiI-GS>#+crO|ZFayRx9YJ5eqRXm@%@Kx z+Pm`5Y#AA;5~Z3J_+h-Y^eCgBI~Y%+A|CjMcri4nSPdrazcQCtiq$Fkj{*wT8Cc?t(ub!w`7QqHweh56V$mJb;@bH zAH%#dmyD)mUSHE>XJtbNkF^!xvPj^+xvW&;IUa%8B7HYv`Y@aP5)#I>`g9?@CpWxnqeJ1+K;zF{2LNU21Jk!oQVSt1R|0{CG$kQxc2Adfx;Wtb94*F~;yjHSB{ zW5l{khov-jY-(OBV*w%yPH_V87`l%(G-Nikqv6=o!WT&|YbiBqQ97A!NsO}y4@@Y1 z;H)RbO_>?4))Hm$$N3(fQG8>3$tx3Ggx0Cmw5+6lK_86IyZ%(c^3-j`$w6R*-t(Hf()wfvJ&GfFFTy5dGq=X5h7Aazb-BlVwq{2^UAgVrp73N8IfT^?V43OL}K` ziG7GsEBZ0B)eog@e=5X6XzJIn-I%$>?%3B|25DxXFIO zyHnKJP~*y^V+PkLI7y1~P>ZSl6~J#cG%M@zqbKI>+q{fz+7KA2`%U7Gnij*Cka_IC z|KgE#09BXfh>xPFu%NJ|FCjSq?@k@-$}A%A9zgo*QzE(+ZFTa>w>fYnBnTpU`I z+;Op(zg3|=aHueO&4X}_qqsN(Okfj3(&3@>g2r@(g$LK$uNOmm=<&>@N@&!mRS0WI zLVT|k8(U;57jLYcg`*UT6VFJu1?Q#Dt!HHDbd(w!8IJzc7&F0T6fi}385t#yZPLWllmuu?*?3XzOfCO*~A+ebn}uq$vf7 zr88}AG0T}S)kQ3`63J_y#n*aYz57tT30+5XXldc-ih-Ys#Gsb8?hy7kJDf+hQEG=~ z@7c92RTgXk@Lk!OTEAdp_Ez|BLNlRj%3c~m0AJmjcOMR_WIf5%r3}a#&jd&3>x)5e zRU1zMpLyczrK>!epqwOFIka{K1#K`aGGt#F)VL|`rrs#mH^%#oNJmKs{`F@0 zOW7|$+-8F#Fs0CBBMQqpI8g(h!uL*Xbzc#celiX+TFZRJ4i%TWyk{z|nW>LY(I&|4 z_@_NL0O(Hr;WtIo2EIV8SV%(vfsrCgoB;dyEx_oPBLJ}Fr)p#`r2p*UpY!g*TtPH0 z9t({pFRB9xEwVb!$ZDWv&s{oSG4&h5*2^+hfsKCEl+mBe^h76~prZDnd!?0^~#kxldRfT(L7z$liC z?m^bz%;`KgwfT1oh_P+sC9v34S!?L5uXGGo2(RgzKdUq4FHuiYut8aL7Zy{`ia$VB zb4vKLTt9|_m4YLeP&O*n1EwNUtjN0l*d`6sz^Nf%38h1Wqp!P?&4#!cswp722H*@! z6XMWdnu!n#r`BB*y_ZkqCa!fDHI-CaE*F>^by6X`D7-iA*2*| z5+>v%q}wkQXnH6}F5E8H;ysQA=bG86)avC~?49f>cdI0ir{ToDb`9|dd!7)dYwc9S zAF!0%fF`_(6Eq>PbJtep%pMgc*m@={BprT167kNZMIBT2rThD(U-%Rod6UVQU%t!H z6aUkmX#jMR+OP=&m#|zvt`+WQMJ{X?DYn5QN)W=R1T8QTB2X)TaIw5^38uED34Mj? zc5~Ul_t2gz{H-S}qicE9I`){u1RfSOkb}(;ObLjTvqux9m)p=f1Cc~*Zzp;XXC|OY z-HlEwuOaybIKFnEP(DUfERB@^L?cK-b?H=2ll2@HdnF6T{13scHnw`(! zxgkJVElq$xev0B%x}@`z1rJA81lpbSaEuGWt0t!WkcoxSnksiagUBpeZvoLJD!%Io(U zgxa;_fjvs(akrq&O(Ba8ddoYTx`brM0vZ0Tn{LKYWqx}m-agrrM9Hgfh(!h?)!AEa zm^J(YQ&K#TBzPZ^-H0J_JN2VEjYrev{7_|c$Dvvle|~E1b=h_ybEQxP>y@%M{gr*H zt%2O&UVM zT@Hqr#3`7Q+UPq@-Um8kukO4)q+dN_#PM}ub}$77V&`De)b51I@7sooW%sAd?g!$? zR(Ks9ZQCk!irG_ACph)6B@DlV)W*s#{n^z+Vcn2CK7Cn^Sj_5HLrf;u6D*arW=k3gdm5&+;>;$m~zypb-}$!V)LzN7G> z*P?QD^SAR0>A>qKFgV`@3pve-z4^Sgm_7P}9{GQZ5jc)0qq^#uFAy`$U@jgbPZ41_dF{K1=$BK18%W_8|WBN-W6rY+I1O7Cg ziHeXUHwtFLcLz}Rb7)?0@Te1d5$DN_nF#yvQb@<)<-PQ&qaYdvd%@J*`%S{OB$T>y zaX*d8NzK=oH=|wIL5XdcVR}1SggRXUg@T%%7kBWHb}<{hQG>^WrU!^R_>|@G#_;}G z&(0h`g@P6jey~cY&Gn0hAhp-XV2jK$nukx9E5Kxc{~{A)WTY$=L8lj(6it?feyfWf z@dfOg$E)CHzB_k*)fSPHu8n1PMYyoPi3El!O*MVkz;y~!X&4)v&^oF~%2YK-&NgB; zF1jhZ9^4x>Y09;)sJ5;CxI~k<<5gkota%7bJ7|Yb<~aXD+bL}$(VTJ9f_}d^`R&}b z$tkhV9&;=?aZ;`*8pPQMN-|<(j!E6_V>Z1W!aVsTsBIy z>3_s+0ia)eMGxhOjin7?z5WrWe2fss;y*zXxBm+@j=SCV=X<@qLuXD-auwxFHvwAH z+QpOvkB51CdRdRO6Ht?|oz~_a{j^3$7c1F?Mp=;4cfW~`BcMrxkgLMttDmN)z1$NG zaJ(ed6H8l~L_xrduB{MrU!p?d*8t%cgbR+FuMNEUbX=KC0 z_GECCkvxNrG_q3&UF>D3j9iH`(%E{$h%Fc4XkjD_J$4ge zibrMHNP*2z@&{r-+&_roMIW&bkJjhsRr9O6L!lieoUj4)_C9u0B5GR_xc}~(e>o_r z!xy=E^pHN{K5~993Z`r~@yEZJ0lB4Haj#Um)6@Q77~#@0dPpW9mKbg%yc8eB0Ga^CEY0{%~U`j(z?Q3S^Q!^_9vAp zw_a&;9b3>ljtoNxrADpd8AU;(|0t1wCtqOHxC&$TAWYE*yV%{vPmwMy%?|%K)hPty zKjH$R%M%6<8Hf#K%A{){$?fq)F%W7RykwlCj41kJxmU;^OXBZFqe@xEhBN3I%-&zC zH^UpNJ}bCJ+g13z7ukxkdQ!VF#dtsdPUf4x@?jdDHW|5eqWoY?)p*esCUqAj1>T4o z+}6Mnl*uw6Mv+}hrrA<6&3{o9k1~{zT$LVDx7X5Q!=GRi8Ds^_&s5<|6)}`S@+)ls z*rixkzs&P!yNlQV3@>A0K2|J+);y9@U+t}3l+Lj$@apl#*B*Re#TFhjDX;-6 zYHcvAC9NyV30_PN)e426qvrGyjE4lTEZ=9PDdK3Sky;|t0U=ktB$bo0f}#pRjj zEU1^F0rg}FQUo3l$6*k{;YR2C^^KAS4Lt2)AbQ(dqw@>b!2&Jf=-{GRTItZtA{27t z_)0u2N;WL^KvUqLTUrMbeO!Hxz`6zE94O)j^!_5m0=k{b`lboud`91PM@XL1$1B%W zYCccdwfA>$dd~Lm+|`%X_vJbiLL#sOU2J}}I0u>~ce=fUw~#|@PiU(MR!NAq$R%QL zabTv;nKDu|J_XaEMjt&yp`rox%C zBuStHMTMS&9v1~_|5lShFvzMu5pGnAnq)!g#M22+;`olu_8_EuR)E4LMj^vCxx!rF z{}ZRKE@s0lk8V$~&Vx%XsMGcJ(^WktbW#gjP!Y#lJXR&Q>qBso|L!_`G-yAlIL3V=;A#6o?R4JeRqc~jS2vG%b}>qpfqgwVZFhl4tj04+h4y50j0%KA^A{%GHZu!szBoMS25hofC4MV zYBcJjipAlh`xZwU9jquRvSPVAW@H1c!Zn(W7i-^4AoS#L+jlKf+dxoeez6YO7jZ>D zXQY`Z<=wfD>grv08}TWljNBks=9X>rpPf=B=2yB0MVEGD!CO;mLrDHPHs`*3ok$~A2V#slwRL% zbE&=?ZLl;(PAOL~&i3nDHZMmy5q1@R=5QaBM+(in38PL)BhGry`ryLK8Rgu&aJsYBBy z@r;^Qc*uI8w!nq%SoQM_QVoh677LrCII#vf7hJLy-QvodW3MI3qIA|!wCPNUhwUMv z)$U2gFy#;7ZITrE!N#*z5_ z;jhsrAb3vd?6HAOL*1T6)y3jaOO8Ne#v^$^$H(nty5#oXD4I+#2+-XibcdpV*UU#L zp*%Q)qZB)?iU1%h7-33)Jy9lW8@(c|Yw}~{cLt}9Gcg#rdmD=tx!iXiA=mSXN#{QC zh_v2*Ct<}x$Z$Ei$Z&PM8R(j+luPw zNDV)mT}LO1DyyT}1~VpgMbI(ZfNiT2o!Ll7U&C=)FJt{;qBivBiTJS7k%IcZauhw2 zz2qXv)!Z1#SAy)G)F062u(4Nka^!`a@u;eu9+9qoqS^*Yh;pN1KAkAvQGI^M? z!jQ?qP&GKbe2WpMdl-v*ze4pXOC9%X;3z+)4DdVa6hAI%#oTGQqXgjoRT#gQA(Hu3 zE9dGP-fDyz`0A-at(4ko5j}8cHahHSz^#8&jx|+N&(FTr_uOm5%`4ifmZiNSwd{A4 zK;<|%r=F+Lsldm+8-1X2*;>tT`GchufyVJluf1&^sLx-osok!5IOcbop=^v<%>%q< z7y2irw*cs-guzQhqF-v3f2<)P4DnyTe4_0Y6^u3_NlE5>LPIg_he$ z))+I6F2R_a+epOm&w?pEFbYBbVCaplGUX6bxz}beIhxh(C)}BJlKf_AC)3bIaPJiRRPAlkORd&|A7(a8yR?j_bXhp%z zG5i^Jjf|Pbu7B+BsG_4;Y^egP7S@AUtGdX%lYPyL{7o$zGn)a0m=_xDfX-Oq3HQi=4(KAFi-i`yMFgKi!TFPyiWlSKhnFWJ*@n%d1kuS zPe0n*hE%`QJUyi+WOVC*T(IoEt>!g$Gqz0-NaJZ8hy_tCHAKd+MxX{m1Zy8oA^{qv z>A$X|Rc+8S1g^W#8&?G(Y!t^~dXwK4r~mEyWdSKGUO)jpQOd4bTq=cyI(dpC{UZIi z<7O{FlwGUhX~{vHhucA|rR2_EzqC2(rqz1Q4M z=5!pKRtwYsu3>vk+oaKcTlOA1+OI*Y+F=ebn^qJBQPe)ukD zOyN>vL;_KMoGUw6`PK3gJht&I**Zk6{4c%c+cOlG`rEIpbHL^DV@*yBbHyS&bEXA5 zHWaw4MjY9J)Ch82%$fvn^zY|dZNG!Iv10?zcaMoSWJopaDj)H!nQ|DQ+we@ej+{m} zMNPhjt96(6Tat^Lu`L`y+K@N3RQW~$Wrvc7J%EpOwsJgb2pAMWV=%oDY(B`D4XCg86 z&%Rd!q1&SeZ9eVW0P>F=B!n=Y4i-Y~XTVs9O=|h6ag|o>PkDXK3JE{kI^~-0bn8yP zvV%68%GbO<9ta#7ublci=4Yr*N=Npa)3q&-y-D$246@a__j$eHsCagJ$rn6${K5nxqz$J&m(#j4$} zCCSoafKReh*(>k(=5eh|kT2(M1aH$ja%rVk^QT+~DTQ0My#gc4PFFR&T z)}?GL3CatHV=Bb2g+@qnf`=D%?`5Ci=nn6oyjcGDh`lO)O}euAwauKO(@j9l z`j(z@#*U0T(7R%8p8?JHM_&BY_ME1`kIa90?Sa zJ-KrSe(%i?D*rZ{XF>azLeZJQC73i4E5mWFWG}&{R9Bj1sbwEEmMO$%dwsa9njKe` z^iNDb0MN3wqL*--gWp29KkZu>uMFj%n95`p?pw0NdP2~TTI}Jg*j^4f9?HXQ19=gk z&oHyu*s`pT;4&wZ(a^t6bYhRuH@Dp?veQ0P_?x!O(Zh~UZ}*%SH%t_4>bW8}#bBXU z-KpVlZCN}nHVZjBa~HKzEWL8(XFPY_p4IYRH312&P<;mRQEQQGR@+8Or1?pahYIiJ z$qKRPO?>gTMmq=~l2{?Toh?p?5_dc|wz^hK8tI%U^mO2Y1D6BI(?0+4f^GsDJ(?C< z*SJqj?}=csIBL+*l0?qcMY#u05m1kbhfjTHVvf+DRJn^bfBiFwp=P!E-I|`T>j%$> zd@}~^VNgq=2UB+?Q2U2ZJ=)mn?3{#{|l>9tj+6$?%mo*auk+wdTc< zET_7v-_Wl&pb{os_3w-D%TL9BPhf-b>YpcAF-|H~;?!|%C(BUSl>`OWSU|8yL_e^c z^17W^(+YpbjB_TA`+@u#+BC_fPMDRioq+I+tSqJo{CxvF%PUY5=jFnPi;IAgI7|tH ziP)c-++(iQJ+&%eEVuGpJdlV{NJuQL&LwC{JKG)IDj__SmbBg2E_U~N%233%TU|4A zs|s{FWomA*!Jl|)=(HJ;n9(;$8iIb)k0te2;c07(V=UUZ$i?fIsVp8FlRae$%PO9z z{zu$rhkIYbpp6{So+b3S3?ex`zPkY2zg#FPd%wjowqsnbJQ(L$LLQej)zj#n67Pdh zFzoq`kNIZvC43G_(>G>cZLrP>bqT4HGOh%y*2j=i>Q4B=p&QEFd2cU_X%t>6yP|_} z2mzi792`kzS4(7g;UKA!*zxt$T9ZpGl&zsLQLa&ZriBUqfX*Cd`F4 zMyP*{GFnDuPncn2N}00?!uK7JA{J3fJqenBZ`TeD?<-Xt0NxO|oXP`_%%OwnW7wk@ zRw!mG%;C%HEr;YMGgT0!LpzsKlH6t7$BSYPqD#4uiOXp{q7SWfa2$-~{Ih?>5~)`g zJ=Ge=E7-5HxD?73&LdaC-I5;kKv*``GM+6*)QeL{UI;0QeH4!3|zRW)ND34$Z3_?sgjL;5|!B7!I}$6{$lDv*^j6@vH3OT{Z~0ESuj?C7j+HaBia zR$widDz%smCVFR8Y0?~3Ly!Njo9hZ{g6p;cX$ifB4w29ay(35sz1I+Wl`2J0q!>Ut z21w`#8hS4R(&a-+=$%jnQ4o&ziIM;$hY~ z_(>T44SLK&9};<%pq0U|JJPj*ctV$XlR_`JKel+x&mkmB+!?0j4JzJ4FZ_coyzV5t z&lS!=LAG~ltjr1A$vP6#%ht5w1_LK-isrmCoy78V;>P&0UHn~cKkrQpLQRRY)2(KF z8{$v3zI&;gLNW=@c4 zb==P1EhHML@fx#-|NPKvbxPTvsd?a0?y|i~=lA1MyuL(DTs8CXWDG}$KL7ot6u{xz z+|t6XV`R1u_PBuKBT4*|l3{W;3f5K{UN`m881`y;VmCp!?Gqyy%yaU1F}q^AWv2N6 zBe449tZ)N~QNc{YNK+_>VqeHmBspojGco&zhO7_Ia?)jKHe5Zp`V=t2g;iV#fcS2i zXQfV-o`f>pb4s{fw2xf<`W&vUDuMhSw3!bE-Z_$&piyRNnvki!8h#f(*26vSE3&7S z44lpj5{l163(!o%5%=_%wO2!vXH<8$3hS{DO(swM-n7s{k2}UZ{5KVJcXYBD-BZWt z%J_UmYsbkoB_B)H>|cC!jSDqwcFfuR@WS)EV9;5C-8sb|!mqNljz2Bv&DPlvH4P=1 zUv+9?bnA$KWKe8%xE_AdrGH09S7xaxJeBiZ#>-cqGs>AqSZ;3WUeY%SBxGF8RH2zGWth!mdzBMWUW`ZWfJ zLr>5bgd<64>A8bp%DKd;y^Jk*#b$neMxi$P) z9Sq=Sj7vZ7QE=5jS>QyiquT}K{gG?KqfN7f`+Zv&9=leVyWKnUj zPNi^t7);nrk$LBuxAiEec5fv;Q*(cKzwq(W?Oi1M)YW4yxs>U1%;9{>V2CdN-7E ze{oicOFAb@8FmULb9r`N!8#B~#F4<_3y`cs6)U>j@4=>ws3%pqf#fBN(;4)#U+rmrP8mwz&m zLreJAIa4APEE(VCXUdF8Eh*a%RksPxK)|6JB{4BSR+|-}@j?lJ0TNKkPG$|RyUI?N zK}Cn%ES0)6AE$_ba6inQW73H!CC#3zb$id2(LpegPt7rwUwsVJd;mKcwU}{;TXsnd zY@36RQoe5Mr4v~nqZ`{9Z$l?e!*r&s^5TdbEG2sU4lOhV=&KBR3U)1&Bh3%z>Xd4< zWV_lU&i7q<`=okuOY|0lmUE7!S#{VqP zhTA4eN*dCN;j9n=gE3pu)Z&$E*pT1!8`y;>5g$=MJjW|OqB1Nn=i*deMmKSx6>Ux( zBT@~&oW*-4BS(i3CySS9qR3wkF9>Fx2Aw-0`T^*+*u#8}-~@wk`sAV zX{3JtMXNM0TSV%}Ajsh3(WL$JKwPZZ8GL0i!S~mZa;=BD^Al-nCsNr`v;QrMkR-)!oP^ifRtPp zj6(j0o!#F(^Xl|KJMqf&LXY8HGz4=jKEB`;L%p~ENh@c#f!-<~pZ?2FL3P@dO4Vs= ziCKme=2Aavp7sg6;~Oxm`@S6jfs3itf5&9z^16E`dvg6F(ljtg62%&$!PxYo>M6El zIZ|S0C?6UKA{f6FN?)bu8Zlu$3G6Gtu z@|b=;Bdn^==JHqA7=MdBEC3SJO;a62sFS0#r;;LqlrVG+d+%>v;5n2_bn)0F9)V3z zDD<(Q;Q$4eJ_kt;_XwVHBbqyTHyh>kDAe~c(3T>3W=1#Ghp-0b=Pu!5Qoj3@Vn3(6 zzV{{1*U$XUckI2pGUk(3OikV+AHdXBJuBK&4rD&tSQkaL)UPRdvmh*F1cyAdZluem zZM@s-Vm_J}hKww)M=t-YpAmoCewC+x@F(Etv$S+n)T2P+iFYQbi8UOKCDkKe7_oR; zNoYylc$aX>Y@E1_wJ%5G{@7f6B4{d%ADWGB>e40Nf;NA!Tu>!mvd|?0$=aAGnB*N! zXmjLEyj_I&>&fy8Qscn%$(GDXwu)mOy1T>Tt^B)w zp59x$>Tm2rWR2G5twHRt_DR$!mkfyDKje>2xGy2as6p+(wVa?pFp{3mxfPo^FwOsNQhh3ROC$XCi* z`IMl+et}MiRcZ-5KbbRH*U#M|p39DlvDWolmpG5hvyNkhS(B6qv>_i>`_KpC;$N?m z2h7Jvegm7%hL9F+iBiHNR@|06&4HBIo~pNak7p%YXGqp!AgTJ+n;((sEk)hKpA!uw zu!yi|7qez1&ZPN0gcnSVVFRhk^IQ;3aTI)18d}-2P<~FkU8h5_+GZU+FuuHt(Ljl9 z+(YN&+Sz}daJSvtQw*81!pBp!#42Offo`4k&(%;u!!-Wm8b?x7S*Q20zswXSEsFpZS!VZCQyOD zQ8t-2gl+2ke*Kxi@oy%5xzwMuIK;YGTWvsYboCCUq-#qGf18<{3>hwo3PkRGmf^PL zT=VSGTA2Gz)8OQcC2EmbO>OGUq~f;*ahKZJ0)?Z_Eb;qUp?BSGNm;#p-bP`379rZP zmb~6_ixZ8X2T;A9wtiVwji=q8mVf}?M7z$$x^98{-;~yzjxAg69rPHrJhNnr9}#>X z2us;OwTmy1t78;BEWW{o^i6$zTQulFgWo-h4k+;B<$~HRMvN&gav?Htg6^OvH>nyp znf-!%2Bo0(Tzpb{NroRAWV@aBRMzW^?-aj0H&|G$dYcjotcE>fDLa6lW z8_f+d3Fz+(;B}-q>yya_1^thPZuZ4Cj^1Y=`oU=>(lcK2E|N2{78FDo_|JZ5B;6JC#| zon-ZZfO-2@?n5CZKxZ zk95lCKbt~#&>OHEePL)uZyQ~LZ12A8WY3z3=(vE30<8B|7d=!fKTs_j*I z_)cG<4eEn|g=i)G2Gen>ohdv%LuR@q>q1^Q-a@~tdR{#)kI_QswuvjNjGE$%etOi* zXatoA2i2bNekiPb8^k2V#2=qT1jh>x!%1)v3B($FS5A#m!%STL5U`Wc@~a%4h(%JqA-?Gt>M2|uPTmD%X9`VUv}6wL>o?|n@}$=Raqq5BuIif#xM zD;sc81qtbMLxhJ-jpVNc3V=_jrpKCVXQ$bVc71NZ2pyWmi6y&gsiLk*#Z#}c@@?SF zhh9x3^n$Mnu`dFAS<9?Ev-2|)1{p?bV~SpXe(bfDuNbtVbPLkL1cyO=PU)Rm$$dfi zF~LN=65~|l!-zr8zrR^GV#yRU|H}6l2NFGlYrlu_r8Q+eUvU2%l`Eel1?z)cE_j+1 z5wG(pK-{q7?S-|SwPBf;UAA_ou{y3F3kQ$5o6PnIUmMxKpUw_N)@@uhUGzOaxKNvG z$X@g5V9?GCD?*mm82g|^Xj5ZwQAMj?n7FCHFs<24x(cWYYj!V@0SoDL3U88~ubxmW z)k*qM-<@Lb0N$U@sOmmHG3qIL5E@1MGa~ShwV&ss4^fTUwi0q6wwF%r8jFFGCA&R` zXKNewqg!Pu$V-eEdr)0*^!)MF)r{`bwfnCB9ABD#el)HQsNc9c<#X9a-eycaLtRx} zEx>zoH=kPmLjA5(jV7QftZubRypS^v1MuFIGVc0isv{gLUH7}U%@VBZ{(Qa&4lA}9 zKH+t}m+ok`=PTZc+mTA(qa-)Eutq(wy?oZR<$SiWIc}EFXi(vMnG?Fck|6Tm^8>}@ zYXA2ju*LwCNm7>u_e6U|bN*+m^?xX?e#dw$0nRK$H4b2s76Ld{-s_$UV6{6rOwu(5 w08r}(07(8rNBRGs=IS?{$4lq7icTCZQEAIwr$&1$F^FMe1?d`8$zyALH`}z3^1b!XMOiox{oQ;u(#|3=%-x<=20{|Sv$_)_-aNAk2Xz$6xPOW~iH!g4Z@B zuM%@N2L=)!@(2kbr@~uaH%tT9ToIXmk;SjJ)RwL!&U{SI(`AiCkX@#uk zpK##otrw2!VTfaGiOFH4B;z#Xa_EEIi)zM^=(6B&=O(94NKdoK`;cN0skeyN6wJMSt?^a+^-P}In?pbxk17}B*@82Pp~!81u*FKh*!CVod>MsU%k9Uo&<#=qeDcw1fWd0(U8 z{6pE1Cr86Ju=~-iJ>wG1tNl4mNxxQ}p)i7;g1-Nw+kd?)fNEWspEC6}oq;h`J-o`y ze8}meOPkW zOWR+ny>%AP4cyQw=@v$DGx3zT%T9+aoipZ7l&RAwzP$T}9O*@OU&qC2k8k5odOqz(eG(A<7{oczB5D0X*0|NJ-Z-6Vn4&cUq z+pf#?mc|kQuq}eljl9gjv*_#!H7}}amxvrlT6%CL1VP5u3{5Z*T6qu~#%soE0lR{8 z6dW8Hn1-T|LKA3(clynaAR=X)?R4mR&eS_jMK?L_#(r8Hr!c|n=V%3qlX#}09mDi5 zDLBYdNY6XD9 zRbwjzY&kP)K$c+GtdndGo%?2GI=D#tx}3g1aI3mVMY#}pOobQe#?VTGOH6nF)J{KA z=g{4qs%{9^TeY#9GR&T>hc8~ZyPSC)B924`-8M;L2hd#X@kkrL9PbRN z|B)Hxc^szzZ317-2!e~Ka_S$mP@|Bc6SV(B)I46fz2OOwTl$+GLA^hAEET$<4-xzh zK}4{TOyhBbmXsvaNQ(m>jGt2-zKMUyCA}91Hg0~^5lS~lmajl*1jdm@YIcPJNk?A( z&d!64gIqv3!-96(3O*Fii;19Qy*%RQ-in<(771yo_-C2l>A<_Pn`0N~dUkn#^So*biR$|~nb-XM@m90K34Ejl3$8N`#a&!HQGl$mmhd#{4*Oa~ZTiqR< zDveAIfG>@FWNBefA#>}pP&ZM=QHx<@W#(-GXjsvc#G_iV1s>(R&RLR_t{$1{(o^i5 zt5;{NR=Y8uGONyr_uAY(`Bb)W~BV?)wN(n9{R_f&J3JG zn&50jKM2R!YKt?@D)T%+<>}=-0=k%vI(Rj5v?G2`UdB2hvhsd3vY(DSeQM!{Qsezw ztk9$C2T$CsOb{;ZH!~h0#0mN2thN~4XzE_o3-iRNsV6v=P zF(_2g)Ey&8S{1EA0^bMCHbJ0|64l?C%#7Fup{>610^)2Q?dzs*Qo{h_lP}^FX7wbb zC|lzYCegcKIh<(OM{fuzMXgot4^x*?mMdM@ZlFbzC~W4b&3IuLPa`2DL#cB@OLI`^ ztL3`X)~t;7)1S?#%c3#mk;+i;vgFbv+eKGILKJjtT8&$7tm=47y}F0rVn?i!eTb2r zoNQ6y6UX$S5|c!UNJ)f6DBo9vp6a9utnuZhv`S@y8MDzLe&nmV?QzfrbM0H_$A#S4r;e+%w{d>b-);U_#qH|C?n|)T2YxpE^8LUA?i5_~G<h>7JL#d1BL)EN1|P*xJLsB0LOx`MWNAF?J@2r9kgzj4mgrDGcc{Zow*u6UH?}p4+kTx^= zz<#jW?Xr}-%7>Z8`@&J(hX6WG@ep1&wwVV=M>A*RSmkoon@s~6gCaH{qJ{k-z z>I%k=R=vl(3H4!PTT09&3fh=mzUzcOC5a3@X#KT5EUkhgo6?%+WqOK2xh4ZIt^t}o zU!puLoQ5HFB(8iFWHiw>P1b-K6^|9OW9QhFNFj%Tt@L?L^z5CZ1qj^U|C-!iqvZ9y zhl!@Ii5S4By_^(&{>yk5+bQQ2NzN-X!DJ+7CI$dtaKWln08p(5uM zX#Ujl`t4M?jY0OUDnZ+MCSFW4jmE*(SC(Nd#@RblElo3f@rm%UVhj<>Y6d9&K(OI< zNztTpN@0{<_@K2`qfzU#6>b~^y!wiGav0rEtm|y5$H~y$x0gx1ay+kR3ktENs zkxoo+rOuZ2u}*%Tt^=oZWURysB8QqMb?vDBp`*KhYwMsP(Xnv&(``5OC$6E+RgfA* zQ|(j#ap(Lq(_r9opveeyr*;gJyPmY&!qb_tCPz&hunc$&eD8bvp)qPT;rqJsLBy~R z>-ML&erN4(|89=EEshwd90`(>NNzl{hV*jKEj7ew9`iNauyHIaC>IQ?5?eY90tWti zc}I~QS;G~L?mm)!)L^CvIVz%p!jKWWks$k@%gua>XscXWk5Vmb)NFyJX6McJ#dZ16 z7u|NH(7us!b*->;Z+rSF@iCee8VmM(cjoHskDIj%oyO61NVWO#wzY>Jck*iK7L?u- z`%dcgYfp;;ZXH^2-;yCqEw@?~md#tC$m2037NNe??Dz<+M3K0ejAQzd+hKA06`NL; zvw9H?jVh~)@X00n$$}04I&MZy0@Cbk`R!M33+{XB>hI>T+&2Oeq4(X9nGpXxdc;;c zmA~C-ZZ8>@bO5VQSLon3O!x#&+wiE2CNd1f z%!3E!KPf4@Q}kUV!G(;|%VfdE)gzG!U<<9} z>^wdObV^AreOg(F_D_1KONz9LJ(WFy7VkY72Xq5(T>b%Ne{cVGmC0=j1;VSWkjgm? z(pP1PSnlE+mjor|It*ef1xv~{BZF5$OeJDIN#*WW)IuIEZ22GCpHme#p(n{d)TY`;hi#-&f&5M zJ{>EG28$J%UXgnJ!lf`T)?>gl@CNv7T7Yq^_TIl-)Cro()AH~tb||RiB6)Uoq{06h z-?j>}43e<%`W6ZM#90eq?>KmMIVQnRlMw;56OiSzQ=81 z3Z0xYbD(8I0+<*5&3Xu<^oqK)eENbtzYkba#Zt4Az*t3)$3C-?pwv?shpwBnQQ%yw zUBF5)&+a;^@K)$-oT#CL%WY@u@U={A-bGE3t8$3JI8#-|-)|7$(>7`6;TCDdkjbO* znyDW1TAjG4$(AP&RfAbP)TzW(;zWsbxQ+UjN~lUM!Rlg6d{nDxeXgaD?yAF%sAD`k zCaNH@qGIQ+S0o2~FEslV2<7Up<|{|&MGy!*`&IK3(p<=1_u)vT29h#=Ij+7e^Q>4S zlI|@6BVg{;d_Hj`s`ITFKq5!#6{6;UiP&p{kbf%veS-Q!aq~*>`|@M0^A8z}t=-wK zFkM_}_PAKN<2fWTqv$~&8Q)T{(iNdeY&7ps-dA=A2<|C0GoDZ^n`zL6d`P#A#~6CJ z;V0#O4DD6>kbwoazc%!XR%J)T8$`+_7pMkW*ayuC5FQtxxNV3Uitzm`lsJtY7Tgx= zg>9^o>g2JZ1?YxrHNH$GjNF{CO(!nyOvqVdC3qX^}G! z2rfSTQ~dctX>HcB$n#9J5yqq=a`?g5Oq`k`HGRs;jCc*$eSTtl(`FU=7S+<*Y&Kk! zDHwdFzO;2g3E%Gh?NogFI|Kxzs!JZr-bbg&X;1L{bsvYMhUnU@Ypsg`Fse4_jg|jZ8)%SWT$EDd3J2jq3^`*M1ukkQ=0Bvxo*l42n$zpA`)3s7`Z8m31iP(T zNd_&NaUar9$2FNSuW1%{6M zT5yJ*nd`+RN<3+0YI3g>9mssF$Ek@kY<&wOTzy5CG35Kx$4L|GEEDFK?(P60;3e=5 zxc$~g_zApzru#5Rt*)HPj%4R15lfa2L8O3GgRdOB#|;WE9=D}z263GmOI;(Js4{P; zf|i?>6lk1%um0s;5l8sORVG5N(b6tRc{0R#A+}TE zls7x6LM1UB1e?t_5xvH)8G~!5f;R!i_hMhzzQEXQE&4qyXCp+Xi$A4Q-%q0Zu`h_T zM`698fJK_}Z;pKs%8YspB6?>bseb}TdQ&0jis!_OOG2sLgh+8Lyv;#&nZAMNx!O2 zvDJJ=BjQG-Ky1-qbX-HRp;6i3&(S88=I=#k&nuG`0waK*DspjMT#S;foLL4u{ju(I zY@(#S4&?D^s~Qk&t|1*cVns*G4;RD})uIuLN(mohLvEFFJ8 zOnTDEz!lxB!rPes=bj4y6q3vQI}?W!!@+;~6-N=r9DhQfcOa?L7jYBr9>91_w>kU$ z-Zk%Z0?NO;+bjt?+C$+Ehk`S4DCV!p&Vp{xuolw=O#u<+2ZbXv^eQoppW zMKDDbJ$E*T-I@x@WXecSAvFFVB%tcC8qnaWD(qT_+MVh+*d>r0OXuqCS<6Dyi;m&e z%wBe~m~dBRn{1KNf=s`niiP0rwhgVE>8PcM#1Z;l!gIJa_x9PQ6HkJZk;x~y`q49) zvW%M3J5$?~E1z|U=O}+u&m4kJ;?i>NYGP%A3?r9IMJc1yHfdEUq-O(Hvai5lRff)N zvc{laO;5_HdB}MOk>^&?Zv%K8zLZ*X#nshFpGcE2uA|F1j8AJzzACZRKEEXg06z@h z1ixtME&!_9R(Mr~YMxIewMK4aFc1G}2jY&*LTko|G zmW8O3U*m;T|Lxf*xkJl9DKo#vH=!UgyKZ_kD+*^&lXdgtLnq!tJfsg!XFH&y9=q-nMSPoqD6cj#acZqjmwNr&F7 zt5_z?DUV(K=bl9XWVY4ZJCoc!%YT_R-f0Qb>|xYkbD#b!MEg2n7}8-|m&43c1~(X_04O(}W_QzH6mk+xL-^8W!1N zbiiL+z_sa01Y>0h5X+zN%aE;3Ms4v=vDa5I4f>b!?p7~1Z$RMJ<0as0f|d6~_f)CM z=#cOv1hWZA;TlbhvfCxw&7(nyX_d1Fr5S)K(0dIRFcT-r1)D6u5g%}Yli%Q9{#tGR z7D0|KEftL_7S^bqeY;CrtB+A#(VjFquj`cbn8nDKwKea(SW)fvO_4Mq*x4x6T;hl+ zv#larxg0<3uC+K3yE`AQP3YhQ0tWEV-0HwP0-e{50XHu0luWVV3Ojl-HSLjR`*4n^ zU^9&ylKj+yHr@C0jnUT7c~XT_k9(kwpIgk%hlPrP$Gn+r(4 zTay!FQLUijIq#>ZzZ2}@0|q17wBTd9aH*W|Hr zQE~ZH%Wi_%uhiC@FLMZJP$z1x7O@1SPk0Czkfqc zQbt`O{^y?CK*$HH*>^?L12QA*tglQPx2lBUx-Twp4M1}L1-1f^x)YH8vHd1 zQ@GN@j+^&&2(!>-zONOQr3&Ejz~`O+6!6ERn!|wRWtLA@h8XrHNmYELP-SCPAnh@; zS{KPY0?Z-|^66ROv@W(wU|~2pZHVw-F_WmWUXq7f*}Y1`5DVKMQFj4ib{}Lc9z0PgI@!!%BZQ{~3%%jXbsG((jj6T|%D)u7pTmF(Nhju} zvXo)2ESmJ@csMk>s?RFlGOh6c$ z<#dlMA9JtJke@l`whIsUX_RWEizD#+k^3TpRQoWsYTpFl2;-Sv(=eG3$l^JQh~7GO zvH^LR|3|`hAmonKjIW{vF_94TSI-XwZ>osuhCgAj^gs8o&=Ex@x2ASCJA-)CNMGe! zKsC@`p_g#lci2kg$n0+pTrv%4*eJo6h)Ly&C{plOsqb1_63*cG|8*67W9|5-6ChCX zV*vQLSdR16$u5E8VWkD07-7v4FjDM=sj1>i`)Tk9zn&ePU}&* zvQ#lR7t|j=C`YoFxiTP(^Bot?Jajj5o>O8nJ~2HZUR45I9u}^Mm_h)Ppa7p9Su*$? zibm8uh{njv?qm)H6Hnh>ivCqQZ$>V|0^9-wb`(y%)s{N+Eo?3PytfTh-XB+m&(i9l zrac~e?{^L8`|k`Z4E$6$xVRK1JrC{ZUwT8%uxO!{PM5B8VW?+@&YiW#aa0<)AGfAk z2C_bPCdZfwKg>1Dt@n7#gt$-`zvWqx-vaW?NF1K2@QqX&_|*rh+W&ke{JH~v4t%9_ z!1_9kH?*thyjm}JjU@=4SkqxL3s4wTP_(1%7$>K-2ugOb{FO8;8r=|Zxxknp(%)DN z1!rYT;`1M^?KW!o@GFmPWOlV>pFT!bHk2cHA?Fzzt_dKO=kj&}^pcdO(|{;R9+Mt& zULz)_-fcT>3clwkI>%fIyNJcSqS4E+X#*aq0LhH}_yrE*^Zq**H1Myxx6sy%-7 z)VkRAn!n92T}m>N%q>W-r7o&Bl)-C|6rV93ZB^;~x}0lWTMt|ic!e~OniV4^q*5xu z9#Zx&^t6G{Cncf0N<6JExGU2icpm^>z55dZD@uUH1+U6c>RsiP=^~uc#9i`H@#B!b zqLE=_V$ZkKohz*aCWcUuk>QmkQ&rQ@Ol|3VxD@ckXZYeYCq$HPKeMZj>(S+p!JW@_PgD2k_T(!1lXf&C7ehd1Y=@m?(Lov}`=400Xw z)kY{!>L;Xj62cWqNgE3RT!>U%yg4G~(dVVc2#ZPpj|l(b7$}JaxkS0`zzVJh>~NQ! z3+FO@Tx{BK5@LXzMGdEZ^7zTEI~iNb22?%b9z8c%i8LFOvxRfg6Wcg;gU#v^-DP9< zE^hrhpW^8PmvgD-CCp}#MCpsysRlOQD2*wHAu{m>b8or}IFqflx-fb#BvB`^fV)cB zKleNUAeF7Ae3|5om=B=6zYxQH$e_42Ka3pxkGM$F9DZ4zIM~G}JU-4(>X)}}>m=QQ ze?s}J_663|EQdu$Wm$=lOCd7JgUk5REG0H$iLtqst{O`taeU{eTq-0E+Uhu2e%8OHpds$5WDgAN9f40F!_$bnA6wRKC|rf<1#7w4CYx zOA`!+3&$OZ_6tn^`OeoP*N&Np=!dC!Q(z^L#+GHHvdLpIVF!58@NcdS=u@EGU0(z}x$|srqgwHSc6q+3Y zAZslreHG0PSc$2<;lJEd7D05~=pDHSFuwoFfFU6(2f_TPsG>+4EhGivf*(0oXwu{+ z!Jx**q+toL6}Aw00* z+H_Oy1Dahi)NmEpK=GzqsU))n7?t5j0`^|pDx}Q3iqYtRDN{gWk2k@SfbGGq+wIU-rRZ+C>-qkK}LW3 zAmWhq7eA2n%c_v(t`t?7aj^-EfL2=(_18P#;_DM9JB!rGsVBL)_E(CaYV+zegWli%djA#Tu$9y=CIZU4~|LDwTp^O;uvb7Xp2t42ji{-*%;M9WxgY4RP>-u zYmde1Bc`ucO!^Fg)8S)tp_um`tJI{u1#d<0i0x2>k7bC^x)p`(7U{W_m~iGx&Ear8 zOO`|v7`+Rs*WwdUn=MX}DWJ%<`uo9}){C0d?wog$U?N=dUeh%phK*R%-To-}7lq~n zAvp{tzZz;L+<^Z%0b5^_=(;Z{a5a$R{7VtPH8Wti{M%;k^Q(+;izA9vG>lo#HTth) zRpbzd@7FB!gnzBJBJLegCj-HP*+$l`9;a)CuHYm!qiK9oS`y(O)U*^d!Lq-F zcon;ejdRhJc16Zv=7Wi$*g)MyJi6k>o{una;Ca?F$b@ZpZ}KQdaYG6hEo=LJ(o4ox z1PAKn$`VpC}g4NHzhUx(zbi55k0c`X5RL!_23&rB@g=mHX)-go$hIze9J`hpfTdO!ltO@x&!|97$^E=)V>o@(7d z$+%YoD)h#}392+jD$AO=LLAGAOVgtrR}sGxgp9UbC6BFX zmDsi@+*N*0Vf9-7+4Gdmn2$LXbk=G5+xC4R@b&f%xI5WUA0Y@_aeS;pVnG}a9j2kd zNg@^a)+IGB(zTC*e8Z`PD<+1Mc`5H`PVom70WJ5Y@eKJ`)8G%Pn3K|nQ00rbD5^D= z>r7lTK0>8ae>u2kC>f@re2`Yc3ZDt@7>Mxiua>tMSr!=`0d`V!Wf5s(J%o8niigd^ zWq#qW3--bhrYKo^1N#<;)~aRGGg1~qgmj`Ja;?`^BWtq?h4Cie^sA>E^QKJWjf;#D zj{Fbv^U>k5WM+EAKrJ;}1iWvRR>+>flF#<{w}rbu+44l*6Ns#YxU9~ztx1-*E;u|k z(@jl^?R|odpZRV7@`k%J+K6z?FcC~xip~Uu#Jy>P(`%vrbg;s+eP;Eb**Lm>4s;`Q)d%&a}2vUEMR$# zy3B)wl-e6>tP#f1Gz_@f+p$d6uyByf*)&y3v5jsN9E$nw`&HusVk7*Qg8#5Ai15Z8>=|_;-6}wnHDk?uP69tYP15UC-5T z?XtV$#(PweV2jHn^U}Ren z#ny*gRxb6Xv$7`)VY4Z~%>nJY*wZ+&43RP=vC*<<{)8S1f#G%h-;+ALS)(SYk&r@N zE=asyA_@;pqR5ETuriMP5klBw_wS7^NYWY-pgN3NKnYTc^m?TfjIK#Zb_)nMkS@?C z)TEO#Q4<_Z1O;ER{k5E~K&Jt(C`Oo!=&3>lZg@Ex`0 z131_&X5Tpeh^6>N!V<(Xx4}U@op$%laLr^sXl^_~E8k!sI2m_dlilpiF9uz`~g1$vkVU(Lii89IhG&J!IGQuOdX>fL&SCziWkY&Er@41mTl#0Pni6HRn#>=kGIi) zZWiZPUllEErdgF^+0oO@+0%vVsAnmlZX#SfeC-UubHLC9i6F^_fraOA76z>z3k>nr zWIp?`B&Rz2JN)*eAVcsX=MPra#C7J0mKJovHSnt9GjYehU0!C8vvSl5mU%cy9;UF4 zfcksX+6#r}oa6makp>JbPaMuif#U9s<(nYTaAzO*w!d#*qSUNvh5tAbh##B_n?64z zid%?|X_JgCl~^RK;s#5b2^xe-W6+p(UAiIzdI#+@C6i2xdgGEVRsnaS0ST`N3ecH0 z9pkp=s8(DPwY_AP#wX)3aLZ)iwrVsxH)!X#esnA~SjiM-RS+n*#42a1`erayS^!}= zwgP^V-XN<`v#a&joy=f!__dD@c~0xBYGH+iP;-0QQ#hvS7&LGy$u%K6Fs!{_mjb$O z#p!SJwR)7w0&iqq8bh6@@VG53>}c}jKN7Y85VK}u?~3^MY=fJA05VW)eHN73z9c{^ zfVA~1I$TPpE_&s^34J!3LX+A^@t>O`Al6@SUqtkkJ$-M#U+@lnkH7C)8oQj+9iWJOe1R$MD_= zXn*%>WblV$O~B2*m79PJMjMQ@S4u;`Pc$z-EI|V9??b(e>=^inRPCf}qeb;<_ip$$@hCMU5b9LPaEH|9}RAxe6tbvd_i1xA+=!w5|wj913B#UVgEDvesh1}hZx+HCVEOCS@7tO zeZf}*$xUy8i~HR2-O;T~uuIuh|yEp}`quh}qmsQ^v&4!*d;R zt~@v>$=*lw6UZ6ZAYr%GKrf|3)1t*xrO2wDmr9H7zIFdjRl~)E8;2`~nm&y78IO5G zP2mMj$k={$o-l=@Z;LCQ3Xp#NX!4^99$KTR%JLb-qn0eCh-N5WX_gdOs<+vy8lX}9 zHz)N%3#SPB_BaBak&1dq7#sYFbYAVc@H{J{K0@5QptUemwwh@W)YG=MxTY*unLK*U zSmrh%{UYR`9)4{mrGnBQ|*UtS+NR1%C4E5g@Z~#_bh5qI0?B(Gj#^W_Mf$(agV391yp#X2o z5NY9FwX5VSM3&dZby%eO(Z!|uSQQ|-y)Mx zUAhuEqC;ne3ke5GCCmze!4s;pou*zip6N2asv|?)?P4um#aJzSv`t-Ild|2t{b*z0 z^1`&%VetZ#?6)KgbSKkVN3_r+NfzoaJP>B+c1?XmR6q0hR*)}52q zz3bjJK^9l&4h;y0h6aFurf@vtIVC~E*QF9KXH%O*?Aw~Kz{pjpvJ&58$!7~vDStXr z6wQ7oN8%bkbd)BHJKc4uQK=?(^u$HCs?y|&?l@fyW7Q9O=L2!4MkK3y%W}H48P3Bj z(U58#3=?p&bu@KVQPgA?fK^)>&Y)D%lE%qalPHHW)65hGML!*nO0JGfF}WGMFDQMl z_@nib8pH36#IzQFu6Y)6^L^RmXZIOI*{RX&V^puF88Bo2#I^HzjAwViXL*u*E;piZRS^`qZGE2!LkN@(!i8Gm8AIYe*wRlD+=p>(J z3fo(<|M}H_|AnqX^1|?4Fz~Zrr9a`O3(sI$T^0c(SgQq$ zzVhqF0&Vl+2IGpQU1c*nuU(1}TAw1jZ0o;XS@6NA`$EeVQ9XlEs~cMAuDf9}}o1wu~52rg>A0 z5#0h`1qaZ}SSe$h_Y;`5u-qqO6`73uyD^(?`b{0y zyE@>#`3_U88$#P-bbW%tH=Jdoa-qRMXcQ$0S^9ivB{2~kC!2;eY5`Bg09PovB)eO0 zK?Teqa%eF#bV&$qp_SHad*4?hLbCn%&DBt`=WoJ~_dWvZ_Xo{BF56{~Y}u0fQIH}V zOlg^5rg1{+3lSIi2@PK?J5~)6nF_l$5(ACSzg4l#fL+$g*?n6lH%9YkyN9V54MXX# zrEDobH3HQo-!bCngHS_SW)E%*NoDfF(2J7F0PjnaH{QuaQ67e5Ep8RJ&bffj%+EXH zR4yiWefxUL4E;?F88RgiA~7*xXeO`8uzDscUnvU_NW-(5MpKY#bXdR%j*;QVvXMG&N%ljxNkfr+fClr=bo0ycvxQf;F* z^j6BT8%h*@*M1eC_^v-$+k{w~))?mK5r!AyBtFj}p!Wpk|&@}%w z6f&2vJ-MCBRQwcwfK!vtu1jjg9$6ea7Z!8~0AIvjztZ0`C0@vIuf^_f%^n|%-J(Js z$^Jwf!&U|cx-Np>o2dx~2MhM#?PTO!Y5~@|)Nhc7Jpdu9qZG{?D$t~hCkvow9=eyqD-CeG(6{2!A z)BSjx+2!01B~8~+#;>#r-c4w|;j(?q|+WKyNwxyXAE*)GUB9C?`D^|Uel#F_~5Iz1)%c+W# z%Ss&u<@6?~2U~`DX){&Sc1$bGAoDlu!241^EQxSQI<%0*gZplEFWd$kXezReKSNHB z;J5w9kR&|lo&=%IY(FWCXA#rHu6E6$tf(=pAK$MBvx0+eG8pLYI@{bchPUmN_rvTF z6QJwMCFI1m*>>fWS*&oTKc;|!<7@nTl`<-dH(Dyh zL@dx~)8IeVmgfvZ{!EV*!eO2PqpJNT~QYRicUc z-)?RuhbI<#XhR0eiceQ^>qzN*yUmEPS!SD6aT@)@{A`U@Hs-NO=suyiS%*(d440^p z)Kf<#vR=tF#k!e~9jY-A72pNy6y^Eb>>lw5HhNMZpX)~#W0rizG-yHhclA`eKuN6? z!3+!Er6I)Gi-AUAu4DB6WH?J{Znqm!RHc}HB@GdErp1{G;!to*kKX*K9V0Q{B&=OU z3T^DHaY}b*b}4oV_2DD*oGk2^bJH<425#$U`VPsq41HOongI1Z>GIEv>z`il7dz5@ z*_B2fS2h{)9{t;GNrhGqhige|;Rb<18JJ05yNfB&voGscv_RQvC;F866l5stH{tuH zf-gq1)HG0R+<&|8TFoE+alJrp$caD_ZLCslZ`$3kz=<6H{Y$VrSfCYNmMlmM2bJnIj?P&(O^JNPJyC*w)7msnx&C?@MNJlQ<`7V zZfnXG@9>!o2^y@Yg{xs`JINm{^zLY%KR-pUCcyEIZ>P!)@~@?;9qo4V<+czktzFc2 zV>#gquZ045p>AOneZ=g>r4&-A*jV>nnFR_5+fy7AFc-ndh{uN(B|S zEiWl#wHg4lYxqe>F%89S*-#1JKo;9j+TbMkRf;DbXCePAK$uX_R;$T{wJ@ zDQ<6J*Nzu{*HwJ((LFQExlm(>w$9FP;Z!d3Ke@Rl>}1wRI#8yeVdC{hQ%y@7qDw1q z#+1p)h;HHWxh}aCAIEw!#aw6@(9w}Sd_+Qb#oq*{t|=p&UZV5W3AvH$ly8cJW!EVL zTU{2Jw4O@qAU{iloBfm~GmF?w>J@kuu{FM2C-kgQpdl0%C3Ba@kH&;qeAml;wxvtL z5V1YBj4E}JgUBaTenPAx_+=xr^#0EN*aX$v9-G_Z@;{4YlW*-EHX;0aSpzX z8YOC7zEUt*X%w2M7xU7@Sx+uM;I&%W#!AQqQ&`YKpduMvu2xV((S`2SFPK-Ki|dpa z89wS$sAnlHBcwOusj@%{(%ELLOdg+VlB7%*Yhif_+pjHp)LyB*v&N+?VcCS}J$ief zOQJXOwOjbnCDJ>DB%daFeJ;@CaxtysM?GxIRGZiu*3ab}u-!9X{HNPn!w>s4s)DQ% zls~^7JbK*pLP$SSOc=TmE^E7=AN=PQcN{o(UH(P8D*z<4is%&+yOWIgxeqv)5q6dG zS8ca6C6add%p5=2o`e|gORH&f?fWyAY92*qP#i)dOO6XXNuZUp2sANY8}aU!yeb#C zBe$4Of%jM%R?U{!Vh&6KQA0u#ujYrsUQECTmoN3ZpzIti=L|#pg;^XiMk~J8U@SZ% z=t+#w4L1n{K~x6iA7t4%WL&*%s_?=Jf(=W#{Fe;SWZqt)vxC!~o9!$#rEs&Cpf~<1 z?!jcEhd%*%v@l+75NcQE|{H)R5gQ7b<(%Tk9c$kf_e7oBM?p*KValj+~ zRKl11Ta$TP*8X#H2Bm7!Gd)Esyl*ApbChp;i=P%xjyMVOB15fR$qE;SS=%xN^gVYDn zr{L=^H;>i2^liKLDO90Hzc?dnm_TJ*#~CcpZ(yqS$o}$JGL~(p_v~zvDnIC*%ZJsT z(y%NNbYmFGlli${rXuv)|76RQ<84qTTkM-+lQd5 zNGgx^uvkYD>&ZkYq?=01nSReypI+eP2Ui`VQ~NCb7wzT%kcy`N+_S6%j%^P zgiu@RD{PK-Xhj@XINIIhBC|uWsQ}v~SD$^U#v`zHI(|`8KUzBc1E%dABa8mGH(6FX zJGElli~n58YC^mEheG>b`#O<`%ZJBsUr`A`);f5v6rbACrmTrIg>}8A>%QkM)D}4q$q@p@roI5@@NbSxk++HxCeP8 zue_2FA}WXfnRC~=>wdoH-j8>${b{eY_u6Z(z4qE`|JHBc@YSEQ=7~!0T(z<^^`FAg zE)@TSYM(!-U%-52>`VQHn}PD}D_5H>EQD~nqt_nTv%3%_r_#DD>Q|Z=h7JY}wx{iT zC{GfmcyDyO)p`ic&lfEmiPYg=^=ciPzK0C9NRrS;-sU@^ca%>0vp<|%=Od>gV8hC3Vtr}MVpDa0+R zDx5kja?wQAZ1!!h__$pSw!FF#(;D&ukL@Rr-1>OM=?Z7B?GA2zsnn@^&zNUpTRuw@ z$R4=Xh36w&y1osMQWO)#fe#5gMY3b>XBo>ONL9}ZDnCz9S43)%(ZEOZ!5Wue=Nq@< zKnuy}&M`u)-a!q#fKq~2ptL;NAKQgCC{h@+ga!w%*2*#c`?b)DAvSklN%k8_<%B*> z$c?UPJaG5e?NHdjnodh?82Vj%r;&2Ene zz86UvzjhrBd_;>1oQ}^Sr~TP+Lx9i;$3Huc;vp#F0)^Pg?7G9NA4l#dW)*6Q!vXA& z+94i7h;BK5dw=-x!AV8MMZYl3_&n&EiTtIOrtS~y+9Be(CF&W^iXZlOBnrZ9w{Rg- ztyAEc?bHY{(K2u^4xWgq8^aLv^c1I&By-s!qN%_EC>cW+tG0{qM&~|z8hRifO>v>L zdl?28of>5$ke6;Qxq6BtG^WbW)r`FI&|L4}K=!~-W$rB?NOc5hnPdF%AC!#p3pncH z*n*cl+{ZkMq@*6w7!50|_!X-3rIhqR4tiWC(!)rqxh1eZBEyG*DO1?5A~=w072+Oo znd%LEOO#EoEVHtEck3w|&opPk+JBy17)Vik;2qE*$gN-aM~9Eu+2^dc7h)1@mI{l*uCq!!4{GEKz1Wu8hDmQveI>bF6MC~c(gV4mJeM0FYuZG5wtW3%#+4z}>q_J5 z>B@7X16=)&1x=5LJa3;DqT}-OOoIp(6-Y%f7*YrGPl*q_caXq7R7O}_WUw83N3grQ zV=;SXd{ij0xNhP~Bd>oSPgJIX3I22-5$zmOgj4M4Ka_Qa7Fs)zlo3*wz&|*(v z=^Q!RmTz`Mm@~dcG+Q4(j$pVY(a;&wJ~>7*wISr1Qgl#O70tnm-mP-)FgbZ%V-17Q41L)4=h8 z!Se8q;gwO#AH$iSR|C&W?`>2m=BDc_aq1!W)bI}^*pImZHZ>|KX0LklN>v&v?4VfWYX|Qo zt;Quyq$d8##@+5b%Q}%p?V>bYbPi!T9fqQR;bxtGt-QPbKk;Y2AU+ry*jX6(J?-|?~y!r@4w6zARZ%T3TzwcQeuaIx< zHSrc{?DbcRRk(ED%hoy&>8-kC;5`(i<*t0f(j`APY;=jG1&9-s5&=ldAUIeY|ITq< zRCRx~>4>#P#(6ncF&hLT?L znsjcNZox%Byz8D8Npx<_)@a65hPrF4c_=w%!8L;eY%nusr zkFeJHcv>o-aVI%Rez~On)0!%#JQ)g6p-8;kUoGQc+7!#0!vVm*9uR40SN>-b|8Gx+ z|I1&i0Jwwm*%0^=e5id%UB(m2lELwba5p=o1cj44JpsU^4FI5jE%JZw1@4IZOp2`u e1E#S60OP;L;`0;)_*%@rhNA#Li*Nm(;eJ;l9CDv3YwalhK7a~78VW;4({&m{{A5$A+fQssi~>i+1Vu}CDql{O-)^0T>}FH z6B842b8~BJYrDIMICBe%Fv4(kKVX9>VerF{bc)XO)A{6*!$W@2J&8^H z4vK_8^gd%`z<&#cyfuDCxKu$P85$JBH~@^TEA9TA6`H9QO5<9lNCCizk7Le9b4o@B zyO@n;LZ4s~mXYX?EPUV?gQ`#p)A&I+XpTP&+orXwb5b8fV{03_DZ_S{5^kF@UK?B~ z&b%Z>v%XH+E@#P~*0p8i9!Hupv*BNdtEu1dEfywfv-g%AfyiJWYZe)5J89c3C)UKD zA;$+=>{7QXO#LoH-n>zo2ffVqbMSL;p`iYD-XDCor@3ib8rLZ3!wK;nea)|lTcHjk z?yZe;%Hqv`+^GDfulr_n&YV@{%wp&s8bGq#x443o!zs1(l+N{4*7mx=b~WE(Wsf*T z`AOH+Ulq#k(&=b)P8)16>)cbD{E$Ccrm*{&y=FHNf|o7OwqlkPZ4Wuwky|@gEX=jt zHC`5-{QlS&rkoq%_;;8)O*ZszR)JkdGb9&|nc(S~ta~mP!wn|7v)g!Cy1HA3gTZo_ zNPJg+2LS;1e%ou3441syM+Z5 zJ+&(hPP@{7Kb~;vg>*x4Ko>dTO@>q9FloHVvjU4^4O>&vqsILC+a1pxLSoqfX z5GW4=ZLMzj@S>;5gJnNC7p(`CXkm#%f=v>Gu53yGgAQ26k+!}0Ez-nRR6LsQLF+0 zba@Xfk*MVl<(#t=PUjQs8aNR$db_L~Grw9qX{D_$%rvbF&BBdJJ_-xlNe%pDGOSP^ zxGCDv&CgDKQZL9oF*vRyaRrqNaxAWSa4TGM{~Vq1@}g~e#5pWbX$U;(OR$)W2t}>* zdN$j~S2U>DPPVzQ%EA9~NKXyAvwtNI+&jtc;d-sz%?=kfkjGL&F~e|? zaM2oCq?K#t$zHbQKm?hqP|!2s$RV+`l(Mh^H2h$*Etb>I|BTsOOcT+vT%yBv=qt-z zj-5^7F%4G8Ey)+qhw-}li+YSbQF;17SN@ueUhZrxOHCo{nae7F*mbY8y& zOiF=vlK}_D8V_DOi?#y^#tHZQa`#Un7mT;+mE8ef4AgIi?P3d<;q>J{ZLHf*hmrTI zkZdB-eW}%vFxA_DH9yZROqLgPf=aXFr3Tr-tpAw6TbpS*0hE)!^pMof9Yt$IX^G24AKQf~TS`Z3L*#t1^?eMEJNRAozB4e)ov za(0DI&3w@?jH00Lu9>;aOSaD7znDyA717d$smS#CbMP8=2xyVT73SZ2Jv$B#E)G7! zs*`2t@F+|ZYJ7MI3oT+=v*X(@!e}1S`t^mcQ>IS{Q4jmN%Xybkx{_k!4>}mpj+6U{gXi-H1%qTRh{^~!(9R$JK1?c)K@whRH5#+)E0F>GM+E?uSa%BK> z7YqQv@dwTHRLR&{3Y?{%Ux3jrV|a){F=fDsm|6{WxeRO{{K0fMS=h5>C|+Thp;c)I zM$J;>&J`$BJw-0v1TOVSb!H0beGbYEV+6xHe^0f^&e z-VDqf)NcHc*rr;X6;r>Qn1co?-pb3tyOqYpv<%q}e@`Bjiz7C;2NiGZ_ex_ zH(rNVeYO$2)_pvkj{mcI__KRmTEkHA4}snIihngcVPCZ2-0;#dZXJ=av=a%-m0#bN zZ;U_M>>*AcU%fNxXOEny6`<$j-08X2%1AZbQ?STU(qYhG*`#s6(GjRVW1+gz^K9Z< zCFo!tu6x$sK%LJ9mL5_51NO&0R^2VrcHDYb#2Se`5wrMev#^D~(u^4C)L>RK67VuR z`^&`_NvLz{KERi(egMOxG0~M(EiHFO*YF$4flSHPoSCA>(z~1+^E-oEwYHePNUo;k zTVyxkOA>u{JO4&D{zze^T8G zRzz&8FlEoE>XlFQZqyikG4aS7xhcqz;Duno7KmPh`I1v=-4QSAND-vGv-51uc2>+q z(%DSHzTAgEUp`*>1>Qp-3T^&@kn?HK+dO2(OK)EqOJa^7s<^7x49u{uA5OqY5v!7$ zbOig^L(9Np*|8DRe$TcSDUzWmNisT7_Aq_TF*%Jb5!%J0FuUy6(HA0djG0Jm6}>aQ z$=u(k2q6aQkKq?gL(i16wO=;H)IYj_pQf6IQ-^UgRG5Zl#GBOJa8(m#(r^{j2BW|d z%TR^uQd0WSTr$BS_=-R3(#8u&C$Xu@HnS6?xlT+l97(v8a#yX`C9Tpr>6d9HeXb+| z_<_-02q=fj>2n(E#%!Y4YEjw&LZEo1W{$+UyJ~*^_A=d`*4F$Q#PvC)v3LTCsNeEJ z%f67jYNI6)a&JwF168IuWLH__sxy9x+UhNQ!AeC7o~0F=GL7Zv%lGryfIyaizU2)- zUP<>}d|4cp6hdU82{2iCr)NJ3ssk-5e;?XXKdzWdD zUREpxkhty|%OfKCO|+=Uw*{#PW?b5f^q=W-8O^ObR6&M0ca`Dkowby3`B0){@Q3Sg z+GzPExRH{;QNF(0a2re9BsiKo8W_P{@uw?Q$BLCioT4hrqodvU9vYf@oOn`~e>_ zd>ig~W5Po?=H~9EODt{Y5`T zy)gF1Wpk0hNI{i=kTHDtMiv>sLoo52hBfmuv=!^NI@xDngeVznEAJ4%bpIS zZS>LSskY%$@xylAHz(TFcK4d#iZM1=WnRc{fQ1oY?F_o~R)v0ira@$m+bdrC9tVlO zEy&tG%jWs#%G%TA=@_V&w}f2s_rFVaU1}MY|DdqxqYokYnd-<`Uwlh=`?N>O4Xk zR+p5GQ5Pj^K`zXcUmRO|j9>!y%5s&@;+80%2|dOL4!f`f`3$rXJY}#zLo`L@xh}hc ziw~;UA{YAf(P2>fh3wi%QZ3|V(DDQT{}!wD!lZOSKZsEK4l!CUVflB&4fX?o)bCrw zNYgl!VsA4tq+=jP0bXmJ6}XE~tJ@j}jS+Ea(<6=_0eMI)$pb$dH8Pk<%4Kpb1DuLW z98ZJA!>FPxH68rjTM)6fEyZWq#V?x)d+Zq80!-37JA~ElWZoj*W{HT!IDsnTPDxdb{+a`AFRnvoY230aA)vV!zlBI#;X^| z%_?Xgh%I>~6gc-UI@2=mLyH7z`8kgl@JCO%OX7x`J(oJ-ty=0ECP%(tX|SKndUTC4 zAt+cVV4mBmu#+~fwngmCk-Dj6(ox0P$hmsZBDlh7F*YGADG|Wle?%>zV_#JyN~?F4 zU%eT0Tk5;mKuEW+{L&CM>zVNo$DW^DLV{qgEmL6W$iEilYQ{MqzP=Qf44&4`g3Vug zPJnh3{G+m_|EF@5S;`HogdJ6vWv!;{!KTAw zwA&Y|YaAH`ABPree{EmVe0A0(`(TXzWKV{shr+&Uity!7%(E^2p+S>H$2 znizB)wBSSI5J&Qg}G6mGTXOzBvVl59Jtm8Q<+r&nB!8(60 zSF8fk$Emnl0P5VQu>TF?U_eE%U4C0a>C2u#VpL=)|6<2C0{+c<%~;d~&)k>rY&SfSar z;_70I4KJ5G;@~C?2Wch>DQ$)#jcM43Jj>U9W~&vf9<=5guk4_vL=*chqc69oI6p!l4^HpLcK_(n@NB`nk8lY9Nb-;Wpk?=(jgSf^6tg$SjT4(& zMqb8I1_TdM(!docUcr&7D!R}-h*D;=zUamE+9uTNV!+9`AvL?;0j!}Hv-i?lfB^)f zTNv#{bB=U&)FA~i-)#%&yA&I1es?>u!gG-OYBM2MRMc9Pxwe)#sB&ZBqL|UF0GByt zRq^T4*j^PxW~MQo#=sp-|Db&YfWM2=@@L{X;1(nBeXoURV#K9q`_cy6f`DxANH4*y zsgYGHF{zQMnN-VBV}Rr0$Ax_~XO18G^R|8S>+Z*|(u89xIuDZ2LMe!9l!O+X6n6T7 zWA*g@4^r37Z52N@F@bQ*wMoi5TrwESU%7&q6FnjxzBVe;L0|WmQ;}6Cr0l8cir{p} zMiG*6$SRgdEK8|ETc>_X$E@8`n3wKYaC6J4G~ek2AC@hVYJ#1`S067=?{lEqjZo{D zLa!CmPs48yX}2io`SG8#iGCH;-UA>SU}5+SeJuUk1_X$3I=r+Pey z0)&CinTc>m#C90`?I?6fDKnYz`*8#pw5a4YMHnMV`cT|hg@E(#d29La0Iaws{%YEp zoaf#Atx6tB%r8p_NoF;Kj}hkCk=l9k)*;anb_|w+V5XRHk>0XT!njJH2aWS^m2bcu zAqJ9VFrOi@2G+PX*@yVQ4Cv>TCdH)ceF~E*bAOfyi=|no!!&XD5^RoWm*R0RE*K4m`xXzaYlr0H-a(tBsNgOx(Cm5BmE^!QLSa4s8>ugDU(G++6D4b+< zxd9q&PXx*Imm{jkC;|2A(xwklN1~0F{c^iz$4AtJ`J88$jf%0PMucfjs8s|LyJ=OP z<(4}ucFhDmLZe#Gq0)80yP|qw5f-?Z1Z%FIVHwuCgbC^$p^K!{#vD@N zG!tRwXQ+Qfzx(nh?|v+~$oVIM{{$oAB&fTqT5B+x62$#0^ED`C=Y%t(Y61U2+pb65 z|AUdV_j)cdt;}}n=o)vl>&=UjKB^O6jn))-1#Mhwv|1W+>N#sNA@GlxiErZY+U0oS zH62Txw$I6qtjWWHEMc$GZ3CFJ+Oz3+%K|%FSoTVxhaY-V0AvynGrH=h^l{-BHtB52;HM0q#UJz zMdVeypzezL5Z8hJ&Vq)d63Igz>B zL93jktZW14xoacTU=D?T_9uQyelsD*VufSfkI3knMus^iM>IO}p8MsbDzr~O_=Zlw z&=O8idzxKf;6zNKj=bul?sL+5*N-pL0nf|BS#rCKGprERN3EkCOsOH>N+p0hLE&f^ zTPaE_B{Y=;hD4B*-q;8BkkL3mOf!#M_E>G8<^1FiG7cfi$7l2iEhJsCg8bMX%s-{5 z4m=9i9O^|O(x291b@l#{>25IMN|NfWsHcm|o);XqS8hVE%fnXD`&(>W0!UEwSp{D~t@Y)^D1(EUJvkE(cZ-?NI?Dij=Ac!ud^Vv*InLZjn{*x~L5*Sb$&%gr zT5W1{dE>@gcl~1^WH~4Bh3VDLz6PSoQU6l2Wi5FL_<$_M!ZkF3^##^htZz?tCX_6E{p)5@^K)cw7zmS8`WO^Kgz!aq6ud3|E2l!6{13B2m=Y&(`-gUyi>W-7K(gaoZyETWB zizb7Qib%K6^CvUPswFo0zD(Y+x$ygiRTj(UDZ6(3Mos~*YD$rK{&h!WuGZ+4lW*nA zyxL9SvRe{@(to{iudhAw7Nu?WRl;b*o>Ems@$QtEUQa654)PKR$t1@Uq~e!athDUirfnjthpMOz1mx6ltox$ zQOmzSq@hBn{-Tb8*Szmw7QQAY{XNZZ`33C@9yv&>+0Z$rk2!vQ`xiLc4!eI44+i&Z zy(@0x0TM{o>+{(}BBP%~@8pAYAlNzcfQ#zRl~+5yD`%Wr^pSIcILoA-aNeoy^PaU+ ztmZCHfwvdzkBu>>k_a2mQh!2wAcNpU@>f%U^u@yre?$5+GnIko*~K?CIL&)aiffoo zy|sEpBP)xK$_i>-(F)#RTSDBbk3EX+tbtRn?_%}&-KXjK{fTl{(-VMNKF6$V4lpEY zAjeBt&xxdk|3xb&g%uQU2VEkP>of);$VnVi`{@&CvQZIsrF$RJ?X36s@`WN zndBShbgl4#e~6n0zz6uLzbKJwFc$vjV3E~BNzV4MN3{n1*B6SE2yy9zF@*j;>2!e6 zvXL^qDCEb@)_D+t#&u~_j0LQ=o1;6qLNkmIJ(w9F|TF| zTIEY=D>-dT5Jmqn2h}G>9n>;kTLEJzGKmXyjVWcpo76&6-z$X3&;ECqAwB9eU)24>49g_IT&+wOVFX@Fbtwd+%a z+r8>tZEn$!Z;?QUFpRRp6kT&|YZasQV_?T{r%@Gp)7LIp$X#KgK%; z$QW5dA5TXhMD_hVOGHkJaplxL&^nGRu&GXIG$uJ>gN%GB8%6r%le&v3<6x#ktS~t- zaJ@LT6rjGXqcxbZ#rja3Q7Z1L%Def|4c)t-!20uSRP5S*=?-bg!qDL+Jv!y_W3HNoS8Z;}M z2&G>J`K9~LzJK{~;9uM^!`_(p1}%BeKftP``S>#?5-d>7Fk&;vosCFN%-BnBbqWrk z(I?sI?ux5Ag9$mp>7`4joC0{;jyESYb?#Wjk#8M@Eh~tD3w|*tWlp-~-^ZbiyLGc4 z`|wePC4ggU38MX*__hofB0eO~azHu4~_4BaNqy%+kbQqCvJ!N;|z%OX>lj=_^G(iMh zSfdrRRmSwwXbc8fcXv8GHPU}yKE|wB88pePzM47CIBJrygEvAV?dH&;zT?y|348*b z!7H&~r1D9UFp8LR(g=D?J!z*j$<*Yf8Ls$cV{MoFJkiqhY4sPW%_t6;3b$~dZ|9Ht zU;mcX<=Gqz-Elh?US$82H+ac*XqGCtg3@+M=EAZZNf0=E3|5v0Zk2C+nYDrIf~xFh z%CKVivUe|^)tz&YtETTL8{&RR4MO1$q1w|cV1oxP}T#ve@defJ*^6t~Kd%+;TV z{K&-iVKk+kBJ|~Eo#<+-_T?^T0Mi;aTnK zW-*oF1O=*U5(k2Fn~>9c*ceO!w%SS~obz=F>-otoK?QP)D}rY{-QuMYHF^y$VrnobjqicedN5ki9R>3hRCuKEBq5k`k+pwc2%HrVRIbq^nSsb!4cV z!VDX=tOZ`?V4k1*oM2FuAbnMrgBq(Q1EV>&)0CjdP9*7;Ti9SwXbCh zQ@P#}VgLYF1WyQPkV@VgdWa2HP!Sa7M^6VLO$k62pKo1-iQ|XT>?y{iWM(L5TDPSZ zybD1j^JdI6&??&^?4#ElS!bMxgS+gS^d_>XCJU06_a-N{KeEn6WdGIsm5^efGwIo6Im&9r0&9-8brb0Ic!D~0k$Nweu}a*H|x zOT$DZkGYLGnFoO_-J9u}-RtFnlah5T6hQ)hx9$17Kg9lV6vT<=3NTzdj(f)u3BnSi zC5z_{N`ZddOOV~`z@CjCF`uudNFi_ee=<7Rp@nbeDqWy&YmG@!I63{8raD0Y5&?7R zOiqfy6BM_cCS6MmJgCf48L!61^UbRmJUo<)5S6la#?5jPg5NAOhCf&369%E#;ziQU z4Y^U%5E$)U6uyRoQW#F5Y^YLAR3<%3=$;qsl(z|IJ%qZFYby^?oIqn7l4co0nM5-3 z8WKo4tJGb&(KpYc@TRTfqL+LH{8^P!R>hgCsFabULZ3?W(h3Xt59X`%HMmirA0GZ8 z?kp5O&sW8r)!2pp`+rS#8UtSTIbm{yo*=VdrT_pP?wH=~m$^JiaAwM_N2M=Xvf_D> z+vSMZD<_XDKj{48(>atGR*iVvrFAMp}M4_cKB zM=Rtwn2QBJaI$DJ0SnD6=-JCY#1e=pvR7rQt#oHpGTvpeNhE38ETI#y?%!dBsgeNN zcMN?07}_Tw(8XKS7AKCeV`7IUb~q1M zU{=syv1%M<+>}K$F8?+6tKMp|6X*F6-|Ah|twZQU(CXjR>O;q4JtuP5sWjy%!@PiC zjVj?Sr@k&q&{s}#*arK70JO%O@k3<1Hb8*e`nY4u1KS?S2hZz1blE^S9VzFK_Y&NI|xFIPRUnf|SZ;5vh$iqi8$sQ8^TUOZTAN# zVK<70fS{Ch15{j%4MstybHdXXn`UZOnTntoE^-?B9h|YQEtvZ|o3YI8@7H@A&-6tj z!5ZO@?YZ2%Xc$=oe5Jc5Ys;Ee70eP0ols82nh|IDCSyNT`F2qSs46ycG?%Gl{vmD+ z8bQ}r=~k8OI|%SUj?*uBM_lgz-+&70p#{S{@rEr+H|7?Oe{ZJAA|N3|u{<+2Kx$k$|^N$NJG9+x1LMs$N(o$42j zfIU7WI)v+m5hrS&#V`I{5(^&SoR@{^7X+PFu8y%Tbx_D5eZaC6qW)xLpb_Bl!tyn# z5voO3sS)C^L?`)4^J|EmG_qFU$8Q0OOn@AY)0&^&hXb~r{cBCZ$~yspSMS!bc3riT zhd2NL1+@u4>8+qUQI=^hI?blegvVC$>a~ixE>kySaYo&tTEC^a@{o3 z-H|U$+mni3-?FN0zub_R4VJBzj6HJ{`_LKsD=bkV~oDAl$-RUjG>2n%i_H62NGS`LWMnLRTtX(+IN@>mT zJ#Nw{P2)mQix#|I{(eGmB*anrWjY=&Z7E6lW7SKH>8MOn>NY}H?mxje3qTMEoV{gL zX#`Oa)V({5`r=8v8R&@OCCPg%!iM!u7{U>5QsWdX`wmz{<9V?V@Z=|lpOGP(nxx@L)R;-@9zGw zgqhH60hVPLwv^-TFHTaKa&NX$_$|dyhcKoKKl6{!)z`4V+S~5=z_f2+D?3|V%Oyy> zhMX3UY>WHrdusX|X^4hJ9lX_rPwZGSaP+o^vB>bb`}Iq}4X-MvZ|7#jc4Iit+-rA? z5AFye4O=x3$Xi-}hMyJi9f5Rw7KoXgV^LE5Si z8V%>5F7WjZK%1_rM%Rq9kmK-HO&3&|`djQTSjW z?+(s$>aPVMI1i`QjvgcADdN#yW_?`S$;c{AthM*;^@3yN81VybQ;{&g=GlGANdw0< zqr;|Q-I}V)d49-e5Do|p-JPVIv>(r|~hkEK5Qt)qS_rzKQzLR-iaaEbd9!&aN=};-=y? zx-U~4#RSEM2{WPJAo!D3rIG^qBT}SwY-o^XZQg22vG%Ms2hDF+-LzQS$UgKvhZuE6 z<}r4(qtlo>J<>`L8TLFu!~)5aXHUJ$gpuG>1GE1Qks@A;!y3*%GW`>b;2JRNuBu|n z7xbUsLwf(jJKJb1Hub++X!0Jc-7!O`up2`rIKxP6)evmyYKgke4OsmBF+mB3{y0ap zsUao%R>5dJNia%^j&Set$|4fTLL$DP7mN*nXY(Ie(%2NtI>ChFghFcl)dxrR-r3Zy z{-yeHtHXx$8^qkXqbei$S=4Rd9fRzG8|I|nRtvtSeRKRAfdzPX$hBvmf6=>XEXwD| z+05oPLzjuoiBZO7dH=1Y;2Um?8pcX?qvuOFkEC1{U9E^(K_J#NJZZZLl7~5_FIVFP zjbf0%wOT9-$*2eM!784X-6INCSkhD{b;~gm!*6>`8uMjIPcbFgqOIJj?h?{4RKblD z=B~J;Dn*wB{gzWu6zuB^6F$d~U&wVZ>JvVl+_;aUT> ztgQ^M?GQq{si0n5pn29*fHM6`IeL*ezlYrnd_}IoS>`IQEn|sb_X8E0#_Y$%G>ftV*`+R7#2SU?0sUa_3GQ}n9{sq5r~J41th1~>Yz=># zQ=8)=DyJ@Be0vT&jlXoYz7$2%3=5LT`la)i{!{+FpF0g+FT6*?qWw!CyVm{y<*!}I zgel{T>WxV*NYL7mYy=37K~!g%Tm*pVp#*6CMh0$*YB5adzhx@W-~qzJ!bX%5YB)8- z1g{MQ+tk`LyzMq|H^y;j@jdF~G%dqLIe$jPUz_D&J)+He>c}WEG78eObev9NnT4&* z&Aea56a=VOc<0kC6kY8ITuJ8R9EX~li6*G{Fbt|N^?xn?SE77CSWS9Q-xn^ z8E2i!+^kKn9=oXc2rIS*w996k`#sJgr>#xq2KdS79IGv88g|*e&elhV&orQo_>uA} zXOz^e*VUwN^z5rMcL-f;0t-wcP0Ha{cy91+DTZNVww->jmPnr=Y0#GyNzawCl-Gdf z3_l-lFl*Wy*$b*Ef7yXtLrglmzeUA|zt>U#zUcX|TMWJ3Vx~f4(;2}2Xt5G>C`Hmt zBr*XTlmcqmGw4H9>v=jh!@6#gVF8rT(h2Qf?U-v6SDbOEBuS2LnKro^WXwMmO^n`FibaJX4fMtDT>fFBh5#k8OFp~C+qZd2ZCo? zw}mf2a60l942VZ0vs;zb#b1}(k7|Qq`EfA+A49VQ zC~dQdXIDU!=-gP^X9o|0F~ea$5)n21BsjKG&s)0w^Lqe@u8Fhn?HU&b)Bj2olDQq( zE1{Laq5pB5A%igS$g5nnxtX1-&x+lnN^X{c7utjowiik%CU1r z-1cvda=Yp_>h?M9T9AZwkrsV!%OPt9Ow>yEi)e^H^HaUHt6{P@EVv0tdHK8`}>qTM%g#o*)- z2QGT7`s1;Qd2FNXt)g;oW3JY3(zyKjeN!9Cyu3B_O!?m+KOr3@?=40AM~}7F+3BuG zWdmp0`0p(eO6$q-BrU~9a~L6Z$1cMY8;wR&Q5g6*LDbR_P;z9Jh3>0!T_so9+Q+$H zB&%0e=egj15+K?D5lw%!qmyq=ZIJ1aC0ks@8ShJ-AwCtNMg|eU7nLKiUZ9 zXE*lFn|63PwyGc7{UJ7Hj^-){>ErJ0^=~`MK@@WLY!v&aww#^aY9j099Ln8Bj1n8M z9%|5fv7T6vk0Pr!@K-yyvk6)5Xb9D5Aq$HG{;iMR%dZ+UO}FnT>nV+uYKD z&v;G6M8~B-9CEo@@=2YOx8TSF@8})07@@`3K%lj?1W6nPB?u@2c)}sDV<2jaJ{XO~ zl?ox*mCFLsY-$V8h`81{gPQBsxrWWNfN@{LFr~`t}OYH|LKE+3$ z0bSkG9yO*PbGydd8-A~qnDV8#5p0L3lOlxegpTyFQNb-QJ$V;m*}jf{xEGNL#rY-pS#Syc}I+Cf~A6ROfWH`O;PS)jQ{~sOpJ0y zd<{a`vO%#}O67rPmtMkNLBmCrJ-dO9I8vunO^r74XK^xRxr(2-KP7Qx*7K{j`^bI{ z^qdo~Rh>Z~YpRgfj}V>oNWExlAXvw2BdD3^0zrmLQQ%c*iX9eK0mWwnfrWBfk53Z8 z)5&2>LNlq4Wko<+`-P~vKb%_akq16P{a2LE<#+(bMRZ{hc~AZVB^F=928W1TrQyE# zCoO4(wi5D^X5hGuAt#QHGgHvH0y=@+0ZnMFMF7%yLmmTs zhD7V8w7L{q^mhC_<@ImLRhaax9lOC^%yFFFE%~T8q_8nn&+Ke$N*HDSUsZ}jb+uC} z9C00>kH<&X+;2A3oz-Ug4ws!t9ySJk`MampW>U$;Ax(DopO~Vb4U_G2elU9)G#hPP zKrVLD_rCcvK?eS%f%`Ro|12*{>LeOoiRiJYVEjxzYXro66P<$dZ?BR&Q}StmpIQDd#_ancT0luSca?xHPv$3=b7uaMv<&! z#t}<+7LJ2RxUr17^$Kh;HQz03ElJ6QO>EzUS^}Hx5GZaa_BmKO)^07QoUEc{EuJZa zmV7;{%Rm{G9xincsvcMC8N*puqjv%8iR-zHMgd+IS#+nd`ZS<>iZ#q1&oex=1-P1- z9NMm}8_rzSMV{?dD5w%v4$*?U-H@w$7$=CwbVEBoP530OQ+-70HfYs+#;60oWwQ<4 z8PYcU?BCk3HnaZiXH6E>iZ0|;;ho@>hb2cPlX0MxyZL&}mLy8xXb~pEk!OYU2y`sN z3Jb-8zEez6>%r)lid&_U0epsmC^ENPa%T-P;rO4qw#4QKGP1#Pps9K6~1^w5!Bi<^Zy6Q^~n)x61#Hy0< z`G#MK^@hIHEb)2zqz~Y+OpP1KgN3-gE3ceQ?3^x>o?u!{x?p_NNuN1-=o&MC?P9ru zXU2Q-dY~1b6h@xWmrt)`;yX2C5wUj(sKKz60fYRi#VdBO>xba}Q5OkfPZS+bvsF6;f+Ju~A}(`OwD=O3B40 zB_TnxG@G*Rc<5q>$)!1+R8vOxrVeHkxkj-@8%TLns)*6Z{<@D1Mh&hL4DqCdb$FsG z_-R5puBAA=T0)ji^v85p#n!E3FZ_FRezN!q z=8mQA7H!j#SI(#_tq%JQulU{71G7a+o{Zm97<;Jx90iq>W#XeqE%GkE#B6kn*D`+8 zdY>2FPaLKOR`rW-D~(;}jRQ~Zg+;Ez!e7c+ogro8Yw=}@ihxEg1pptJ?M+?p_nHDT z@{aAqDu~4N&b`IkfOF!ztF(0ABB|BJK#4$oRL-V$ixqxQggkFw9MTJl?$%LY+khfs z!68d(FvGHeidtZh5_c16bO%L9Z@xmC+2QL>Tb{9Nb@hy)mHQ>w2zS`|nv@A_IHN2s zAy^vjct(YO$upve9rbXRvZd=hbZ|3|X`ow3H%MQmcQzMF!#Z2bP|%}#9aH)K4L8Gn zB4&zd^LuqyIdPP?Y+EPDRS zWqnTtOv;PmrUN79ZNpBNb)+zue^ z!V0UF+&!9pW+Du~@ZHJGs4^&P|jxPgijQGRh@f zo3~9Hshl@do1ZPT2t~X|<&3=-$d}t&+RA*>cAE*R3$l!>ar2{i z`VFKyNn?@-#g~#;MWu2(UMMfDB0{XgxNJ?9lCLfSTTdnn-y{=fmo1gj%LA;_Ls9d@ zBWkChzzc1fT9Kd{*=M%;eH~n_S#!x~BH!(=I`t{>MllKgLBS#sum z-Aie+*ez4BJXMskr~RX9)n;Y&+r4s`QKB^uKXdV%HMlD`C#T902ea000v?&1)H9M5}(_ z0hcV5yF<;7W35^8;XD%qC_^n3U>>G;(ET;RxRRO3<5v$~OiniJ$Acxf|hD1tfXRJOI)m@oCxD zH#3YAs7E8OJf!uR%K^ngq6!p*-g3X$Op!L;<)TGm2B>zFKA zvvF+L2RGQ_c1p#Hcz7uu#?~>4sEK9nvN-5J9u-U20@|z-YNH~(?^|x(sbX= zr^dZqu9lI)YJISU%03P|I`mA&*%vvUpJXf?_39Wd+urQ#@uIaJ9yLo<>1?TS*rF!8 zxo_(7>6xHr>4oLV7wbgDZ(GNG788yYatx*Rp|+Ta3p9w($(P7Nwv#O=0XBW zy;%D}ULb)DD|R27-w1)3sA3@okxJgziuZytH9HWoTgJOh@N+izw_|6CXP(8dc4JP_ za>!e`mt3?KM_5>D67`LZ+U&&O;9|d6?F!!ywy5Trq$Coy1XJv@!qzo_L}WI_xfwxJ zX_hw!S_xiq5(7}E>*!FYU9A(eTKv`F1Q|3!@Y83qtP}?<=hR@6^;-kTz~YAbBMyef zN-vPUwJKWc6lVV}zZ9F6tcs~xs%Y%!_n9N|^852&Wv*+NGE3{MW)iq+N!Nvc4x&@? zC|P*plJaC6bo=lFi%!3mZnrcWr)Y3vWbvXH&*Ze)`l3h+YUEjU?c!d1X$?Rv%)Fj+ zf-P*GdlX!GQ2)n0KLKzHw&VV)O21eN349O$0HUoD{P)L~2Veg8Y{0WxeAkJ*mX}WI zIZ5NzatX+gNU3rp9qAdjr~e+yajCp) z6?gXNYodQnKzicr)I;x(?mm53hAs|W`2V$YT~SRi+d7ocrG(xgR7t>4f*`$jg%Dc& zk&Xlif>NYuXwpIpBoGCpibPO)J0eYrz)wd61e793l_H7=xp>aKFZb=9bsq0L&RR2j z*8aY=XRmMe>>0bSt;u<~@XemO%Eo;ib$DpN^)-ZZbk5o|&|Fj{M_apo2n+$Ji~SAc z{#YW=mYv*ZAufzn!B6I9U)K(Nv{eB?kt;SII~uJy4r}q-e~5LiXSbJrmB6aw`9+sC zl^G@0XWUFZHJ;>d2IPeD@y&?Y5)IPf3LJ8hc{Y)QXw_8Rn!Sj;6vX%NN2|ymD%0s5 z1^Ads37fYQjFSBJRK4avE0*Wxw9uIC;;Smy-b@ta4xTHLK*3Cvzb>e+-t>GpTeqdK z;ov@D5czOV)l5=`zek1onm2$yXHd6OOJs^xQ%U zKvbV!s#q+6KYijiT()bixZb||QEHJcZ6bR%M@q6>KTsxO%vp$)E`jl1c@I6{_S-GX zt1#70zJdz@OW@=wXSHOc?)1NIAr_{``gpVe%2N`&G3lQefT^Pw&<(J7?Ygm7m zLu1xzJ3uGF$1dTMe|5r3;~89q>t-J~q117D))rM>)awf$vF&a4yOqfHtJP2(>!e3x z&}*G&c}+$jpl26D=@mYI4e?!~a8n35V^bqd{?6MMc{Anc#^#Z!lkdI^)9R69YNh{rjQ)%tKPNC0rAI6Y#* zTSteI;#KgqxD50e-gRF`cdm|ORtK2J3yHb%@@H(E-JvIe4G3f-ig8c0$Lk(YX|JGJ z$b@8TkXmuAy{bJqZws-2|1vNJr}^L^5<3w1K}?!jmi@Q9(v`&RrJt4i$+eMMzv?>{ z{G6+Um^;?34Q@n3sFnO^V#MCXv+;0Q4?-T_xx;ZKx^1V2UZhc@x6P@`>K{LgmoT~wWFZE$q@h@G!t_N=pIXw*!)a)7A`NOz%EWNO2&k9sz!U)TU zzF?eC`{AW(*n@ZSg>K(q$!Z&`)*rftogfa16wAn_LDqP-lv%gDpa$eoueSaGnV1q> zEIig?j))qWnA-ZSte_Yt1=A`0M|3dhP4ciJc|WZQY*uYEK=mGioCLmzRp(BGjJ#u(;I}O?WLHT~( zzFFs7l_ZxPL<$yG?@3pSWp?AHUbYkuM)R_X@=say%)G+G-ZWnxt}s4qcyp4{gr{KVT16%rl&`y=I8?8~d#kciAGk5iSe2I6Il zB@e^CJS4QENwo;gWyuXA?wL@_oQm%YrcyIw$kv4Ib@8Ds8J2^C@Je06j$fowuMlQakW8G(o)}r1AZaGs<{laHzER?l1Ee zN>_M>9+goNT{QK0ate!-5XV_Ehd>y+Yf)#vG0P=0xom+dY=aH5TEqerH7j6m4o5XN zq1NyT0cK#P_^j`+1JpGrAH9S|SHIkKyXzt#OCM=s;;OMls(iBzsJ4){e0i3y2=PFP z%bvyBVHs{1z-Ed@m{Pc3tN2|B^ODg4seZijY zp^>+69-cHjA?B|(_r9Nd!Q4zRuNDW)rTTHu&qFmT@^FIVY`NSMgF1T7V~m(-!~+C)>`W?VMfH+L3wdD>kW6AT#^UOjdbnq-}z7X!EUHD zAI0>)VADsY{>;r^D;RdoRvbwN9`S`iE*OWJ9krdc> zT?cuu#2;6u-;d3nqi$yrWiw3g`1SNs!b&U**FC%^rH z;s z`hK3a;z#^HNsdVg_yKB>E9$YzZmHzu_*qua=Xam^f+e~EFND6YaNYNe9rqlR6Acy$ z4rp|#5CqYG`!M_{!bvkd!FVvRoe7!D(&7FEGB#}S^u_p}7ti-ekHgGOZkUNjh_WQ` zUOFrVNy3x5g$C;HW((dpQ?By1>L0{Ia?5f~--0EuNgw-BmxkueiPP8VIP9oQljit5 z8TgpDjhaA=#VVtTx1JX7M5iR;suW5wA)RqukEnXnOU~vErR+Hx=$7JECfS(2|3A`P;ls^AF5vQf{*0%4it4%}S>3ug$qc zCyA@BazeWrFY&3JzP2HAU9aH8#kZl8%Ln7i(g{!e0QC-@fvmvTqNL$x1*DfI*YJhR zwe&p`c{_0CLoJk^B<^j+3MeTc*0IZtd;*Lg0GgJiv5IY2;gLqN36@m#p0Ww%L}VN6 z9VnRt?3x*limLF_LJESU_8W>yeUJgiqc&VX+-#tXwZN#y>D}DD0K%!v!OAxKT%f~r z#(`H8crl`>0h4Lz+soX4{x+R0{knJpr%*N~)S-3#oEY|yAre&@hgs!khT0b@DfW+3 z*62C2UQ)-XTcg|!Qb?8M+v<8ekq!oR>6-(c72=g`BdOuD`i}8-_nu9Z zgWaGuPIH|Wxm@bvC5~PlQgQwAs66?BKxUK+_s^ZKKa6{iee~wGz6V;g1g_uWODmzx zpJu>Vttjx01}nCD5%LzDT5B9$xEzJ~>uZrQ;!^qR!g!l7$Km^$bM05Xp4^=w(U4Zq z0liw4+#Qvsehd!|GqHy|22RJ4_Z2x)p(edhKaq0UPAX|hTC=l_vndWHLS{V3=)AG}o97$CMAWwl zL!oA4cdEIsfu#DB)xpx5$+Xn!2U2p~S*`8kO^W=ErtbvHx` z7mK(@J^OlK{FgVbw42J)uFYU19{BXxe%gnOga5h9m3MEJ!WN(YYA{~G zs7v8hlHe{-Kt{;P~?b&w=YYOcJ4zP)av zmQ1eFv65zP&y$VI$N_1shRD8Ar7#N&M*7OD0ktC)?Aokr>sWgz&`{0O04tBFwR`&}DPS9(*O14LiRi zl@~Yw1nHV=T5En8F2=p2j#|6ljNJU}^R_dKNEcM#AUWMqf^x3d94RCE_{SN1>X>_2uE gGA@vOhy?&HM4NwtdVy=%g&nbrTJ($A{|Ko61qOeXjQ{`u diff --git a/dist/audio/hihat_open2.mp3 b/dist/audio/hihat_open2.mp3 deleted file mode 100644 index 1c46a695b925d7ba52b53727a28c9c0364dd5cdb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26562 zcmdpdRZtvV7wzEg?(VL^-Q5OE!UmXwrKRn^zGwzl^43=9m6 zj!sW6EG(?9Zf))D?fv?7d3kwz`{&Q!zklD}AdvTGS*l2?%JQ%a3cA5=|Fe+Q1pwfq zq=lJN1wh^XvttA+%KzVu|F0M1W$t~0pc(;dudx4qD8_XW0E$sf()=ke2yhexvVjHw zHfnurt@tmFVfBkB32n`c#r{$t?EVq^69cTu_R!2-29 zi94q{oW&vTbv3=8$iS!E+hSG)bvT=a!P_b)%{fMtZ1Oz8uMABZ3(Q(eR~*~p7A04p zza-8_7--eP^Ba*GC`+EUQIRgrpRT*(&V%b3wRB)#j*cbVZi$<7$!BAw-TIPlu*9Wq zKhycR+!ZeRS?A$GUcBR^i|d08QuOPPZk+{B=k(4#R*up`8@h3e*VZgAuyNENe0@FI zD%<#eT^H}yZOPQ{!B_FkS$T|)5yv%;PkeM;&Lez&S#C2qj@K;?B$=!;TEOzbcI|fN zpIY~Lek`l*+vhLcZ9t8zR7^?$06KhssU_sHwWw{naiP#xEF$~)+*>X@@EP)Am?%4= z6)4N@iEJ1!`)%{b<{^0X@Z_qeuGU(f#x{s7xF$-6udU`I7C>?m1R6ju7rM_ZVoIT_ z_J@-l#N-~RvXqfh;GCEs9EOFBcFr>v5|YVK;Ex6=V_^#7ahn;JD2s^EIZDD-WsB&W z?rr;85@9qX7T`PmN^nh~Qsst~n$5o@SPb9?vAq7-KRONIKkfcoPV!oZe;+8~5#9PC zb}PPofl{N@znS%eH^>k>T)3utm}OB<%DX%b@)h#!;TUOhYqA4d20=r{mljoF0?<|q zEu~zYj;FoUI8q^QT^9KI@fq^&;izE%04f(vauH(PaG-)Y-5&0~Vob5hTB!z{;73eb zZVeU92ozYaWyKfG2WV!zyzVB(i+d#3lP6V@B6ZKTOXJ9TB~t`+1Tc9r&!gHRl|lMW z+tEVu$!|MgiEbXFuiVCqPTa_8I1!9ivoFaAQ{n`bhEd2{w@#DX=vQ`w(4!@<;A=u$ zao%o{HkzWVrq-p%#~Y&6L?Auwj=Lw7tyI0MCN*gV zzc4aA4x_^tflcU~XjxMninE6v(_qT++9~$ko+jX-7zkeRkt3_a?GaiS=zd&Z3hi!zE-5exI>ZR z(uVBlMj6YljdMA>!;Ybj5yNdLf8`pqg3m(mh~-qWO`1Y0fuXF!!dNcw;z6lnITAVV z0<0&$r^;nK{lVG_VSsd{+#K68DpICk`or2%VvMs6)Nzg-TnQW%h8Xcxq-C0wN@xm~ z@AxGPNcdQ@N*~BEh|ZRh->S-TWutcR<)JH{pnHgZs68~I&bn3R%scSu%tvW!mRvru zojB5ss!EQQho6|uMoo8py5pdRyfj+=3_=P^&~f+mxuG>fe29ph)Wpz^|W-^K@0}9O+_)oYtsSeFQj!G)*JJ21ToU>?F@dIaA zRKWbAU|mnPr+UaLVHXR;_CDjy+yLVb|0MF2r65a)B8?MeXeTm_>XPazvFZv&rP1bg zt<=cd=o=dZa(?P<2-)b$v=Ahgz%`t&E3&pJrzeqT9*wiEwL|serMq>!i=xq!G_C?z zSyoa8e*qI&pJES2hK2zp67hnAzSS(EFRT6$iuN-gtN3H!=TS}jDXlCdki{g2dnn=F zfBy_GaRdZ>I)rABpok=F}+xuG5&N=%Sgj=%vv|dL{P8YHH^&Xr0ztaT(zfEo3lsp zK4Vfki4j~^@^$b`mXlri=AwPwt25e~Tg6nvP`vo=@kc=J-}cARnn20?(>5#Ua&)^f zA_vpQW*((!;*x^~H=&QL|n}A0)-TVNn+8+BAEciV#=^y&~(EE3RGs|ofwVy*bl0gP)mV!3U$BBP1;rcxSVfz zBp2$&ZHy)3ml%kLWD=Hg<*F#u{vmD&fMD;o^1@-^#v4TF`z}k!>3--<_oYY0186(| z0NB5^0xMgb!4|(04muR^#~DGr*WHhOQi}Lzo zy*Oe5m1K3dqs>2aC%1jAex~-`IVLmW1*@4gC@sxC%ye)SIC%B(d`KAj9&Wc_7*OSZ z0r~E%?Zeh-?v%nC1T`bn)YARHKP+oFVD&SES9gl{eV%zZ zEp)1{{*`M;gEiMzNT)cwCe5**L!#vh3{3KvD~NW@8Q_w#NvrXzqL-K`?*^>W#Q9aq zwTKs$JJsNa21}v$tG-X!|Nf)&tHhv=vzn6`mkRWWkeW6-Y1vOFdYOnKhr#$VB$-{n zz-vvg+v=L!f4SK#)V*~!FA*Uc&DC{XHe)42v@I{pOKHJm+a^Eg=1k%EM!QR?52fq- zV0YrcN8=cHM!&8#XgF{i~QD(lsAi1&)b_JAS`)x z1~vc&-(d$%XW)h@%lstjqgI{Mw7*iI&HD07Amrh5{hR6C2Ym1kn?>@ z6h}pHHC4?3GEgQ{JMC-n3D-HVaouW%Q|#=Po`NJhm+FH>+(!4D>1yCOzOR;mSQ6Ou*gYOBxc?7vKY|bq?#nSbH@CK8JW=Z3d#>b| zm#+i{9-@@Q$ezmaSMXEoEs|n>b)Ws12gm1vdg$AMmPk31!VrPw4I~TcIb|x2LoB!c zg*n_y@YXjiMRAB+hZ8tOzz`rf$Rwsxb~pNpqD5}suomu5yi>rH{lKIGWQO$kMp+9@ z$Y3IUMiN_kOa z!n!>Fha%;8m8s7WgB zEmIefw^F(ACGW=Ld-!c6bXZP2tTpK{!t!GB@xb6IlaV^3T60ue=GMp{l`UN=R|`LE zY3FcW-T=2XYlO!-@jbjk&LNN&@Ezp!ui;gsZ<-dg1T=HKdya#gMU}CHoEbodE1iVA zcNYc$O4B@al$82=Qar37Zb}pWMMTX@RRMZ%nhq*!W`s7ozGTEpyg~GuU*E%W0)>Cjq z*zS=S1#7%UTuph@*-W>bWVr#L571t`;f#YxwoX^R`H2!LqNFH7ZxO2P$QqvM$KYm1s@cu~dz0ArbAPHXj-oQP!& z*&R{JgP6p|1jjK+2hW!%C-ni~fZ0X+)xIZPo=m^yPl97j>P4IW?v7fz(@2wUsjhUw zaB)5&>v|?yq``w4+R|VCe<{io01?|w`&P)0n%<1C4i*4Kmm{b;-IqO{7)1SE?*J&A zmIjD0ZRk02sxqpaN3G!D?1d8-d%517`3+*$S-CKxEFb}+EXNy3tEKrpaaN%@quhw< zO`fO9c>83+b5tsIYH*l@H%Ma?BA@G#+rYD*@ULrG4W)vrra=( zjk*Ab^^Khvpd``#rGt)YEwe*p*aln{XqtAP*f8XaSw~?r!aBW_&{vbF$&p*TTxxCv zRiY<#j+^h0_sn@jOub0R1novOa#u*g8)nKzhY0t3^+F_R6Xi)=Daj+1>u`(=8~Yv? zgkL@?8w99l#Pi-!F9)t)JTpUj!JVP1Mov}H=zJ^qanPGI!nGd);GoeYgsB=s(OCgN zHhPLN*l$(_yeu=f^XNjLM$DvA#o1}SS`8CR#d3g3r2ek*| zBGL+#tDN=1I!beX0kRRluPDMWPPV2X2DQl8PRocs*miNIsLnaYxSU(^TlNpr{JOMb zi7~3WqhA6x!^#hNS4Vf9coD>Tt<3rMgFNcI8+<`DN5%1_`+HKw)v4*_-ipH+m2+C5 z$jSz7b>yC8xNp-a)S(uT(%Oc2$&~H9Q*$6`HQnrQTZeGuG!E{_ z1Ssiq+Qk0vJq?D9CAT&1k1e)*SLVMnWa^pLjizUFZLqsTcn`Ll6uP$~@_O-Bn9=u! zjcCQ5M)z4bTfs3Qy!n8+f6zV&LMZUj`^;f+&GkRQ$Zjes{hob~rvX47?_}DqrW7rx zGD}~IKF;VwDknFfs!RLPdj^iY+&~hhLzh3**<_hEUmXvF@Yg0)&6Z#m8o(`)8`jCm za!@V)-qtLv8c~}Bxyg}HO2Dde8kL*BaB#=2i(>CXZxdXwJ+Q9cfhOYgp3qy9RM?K%S7U7Ah7Vbbzyna`Xz$w{^JBkL*I=N0w(+n)THyY>f7ELC9eUyY1 z1I0<1bY0JKPu$H~Al%XlhHdBxrHM${myK^z->1z)=`(R4*C|>NvyLdb;V`%H*p+q5 zbIxsA{v$jTeLrH?Em(gZFSOUuV${x#hzzA4Kl&wJ7Jsxk^IJe<6NH^LamXguW8O9% zPv2{>A$dT4Q0t($*MT)bCddXXW5*e^Gh(_c^E7V~l$^G4-PJD2J*Yt-&X7-#jz`E_ z?0L<1i257wj;FYi*fv9{xSA5Wg%D7UAhw4Uf3)gbQbp`GaG}8{E5bK8BNXGmW~WLn z)ixP7iOzoUh_ab6hp8OFN|ONuGwx zdw-B~-mrXe%4nU_)#HRM<>)sNy;>lu_de^==#*xmW;2b| zns?ZEa;qzDwW*C=HPt_za0EbT4$-;gu+-u*`!5$FV_P&h@8jw35Bg6h1SIj{{9ZB) zCO-NAPk=`#B2Wr{pcNk9<)&ekN1>9SoHO5|SYy7ZNy=S$$<^i!3E0oNZ{EfeTIt{a z;YLqB@1vsg@x(sd%TfYfXCWz|wq)?Qx&jti?V?=MHJ9b?wQc)yY3JJ`1hV-0)*%0* z1@bIReaC#+JskyNwoXa9phAP&xNCA6k+$WkWT%T|OXZ;xv-vCiN{wwAaA3o>#j zdl&sBS#I2!a>7TO9hm zNK#^>e-*yt)91AYB)LR)mG9Uwg3CB)V+(@4HIhk9AKI+F^tHL@e_Wa9zn%&~Jbf)( ztH(@rkCWEj#qQe|sykhg8Lgdzh#c3=?@>@p)YELc; zBPyIs6PduCt2hZ8PqE?B_s~nZI^mr-Y51g_Sfuu3C_EGMbtuiR@GVBj*J6-Zu&+0h zgiXq?WgpmP%sZt0L)14oU)0x4wsk@Rzco8XJ?& z-x2zHZC2am9nS&6pV5wlB8}7^JJLWaGcPJr%$zRqRAE(Hh#-J&a0wKxz3#ppB{`3f zf%n&u>93u=5H`M=W;F1}`QxjD)275_RZmFfmv9hN7{EiaK3)bhGJ45OFN-=fWSBm_ z$%5PkH_g%qDTomTfOT4_>ww0cb=5X+tvn@UM z#9NSv3Z?_dEZcvng5D|~7xl?N}~x5?66?dkvgw_h56mDBU5YUt(2GhTf{`FA)3`a&JUcK>ZZ zyW@XJ&E3bI+@d4^fYWmH6YSQ9_G|;{Tj-=&&U%Xw=)5!(N^C0$Mn0i4EbCvNH}Ed-?a65(Btd1Mq14m_-AQeU{9u z({RRcreSM5TOha1E$uJ~YuCJgjYb+uRuec z6vi3D#hX*H)B1Xp*34t<(#Tka9Hzbb474XJH7#G}?g1s}b3YpX3Lvxx1D*9J=XMO% z=;9n{Tp7Y;m4D&;FBHOksP?V8iW_|pVfH)XSRy3F{}s^h+K%TM%{Z~0Ou z*=nA{x^;=G(5A^Y#ud9_5uKJEz^&j>xtw@B8%JY`@lxM?9uLN6M}r>wVs!fy9IYD1 z0lk)y`pdw^uJ8N8?ycT!-+kjp`W)!asT)jWp^_3d>gu9a0KUuZ(5wc*kv{H^_g}!E zldrb9jC!v1-;cywATQ#Oo=5xF=<-4tIT?v}ui>_s-q;o5;Z6$^Oa$di>qrf+8u0S* z$}J*R(;_BjL^YPfW$6$Hjh*~b7>P&BRszvTxco(bX>BYr#Jv-xwMb4YwYcPY#Nhh{ z)uJ@Oq=V#k!5-%0{{tvzLBxHsD8cIWKh1R3E-Gn$8i8c1uO1(md^CgC%IOS%$^WUI~UkIs5aAoRjo#t56E zYOpx2>mTTXf6#snLiv=Weyjiangu`@{SIwPF(mB^E(*lG|Mi9JTH|FKN9^j!XH>^Z zZnJT8qv15-9R@)Hix^hc1f;249?E(NrryaC_2bZsueJ0xn{t>7J8c8gkF{k%VPEyM zZM&*s6zuQ~t$LO27*E3_3?_xwN*(!(`tw?)u+@~RL9UfcQh{IMo<@_KuE>gbkorg> zE~rHWZ3J9LCZuIG?aF>l1{dT+$d9bpn3X2rpFy(`; zfZa13T)Up+56#hVRPQ8lvWj6)JT~$*Q)=@yv)QBM?0Ea^-m?R8`Re!W$H!OZtEea+ zcU%Azm$a&;w5dq45PwQ3DKQG7WiV1%p z+#HE0Ca0ix=TMo;RRL1Uv8WiWg2QBC$T+3YDVvLuu=!;YGgFZwOgwxf=)gu@HjOYF z<;dcxX=jZQ>=la6MT2iCN!ZX}bD#z5k{Xk?J)Xf%|4u+Y0&eUn?4M~aqbN|dVWbQ< z^)_W-?Q->gCi?vJ2TgG`aTBUjK8fc~&Spk63+Cm}+j4rB@@L`eY^=zHX z$EEybJO6aT6#!8uTI*I_&V{B3aps-kXsp@fXGDp{XM##NDFFcLLD}pp>M@5ezC1iw z-;WaEu~T^U4P$3zrH?wE9i|o(JX=I|+K`O10|qL*XPWej`|KmA0iWWpO^GXD zp01OFC?wH8(>IfMuD;jAcd5j`(Ph2AQQPgP^e$r0)E@)AAKuRp*{huRtWaD4G^ceO z@LDqke-t*m*w_}DIB2L^VKgtWz}) zs?sQ{FZ;4LFsHsrnZo{3g@w3hZfcg|6ZT|_(2$TjKN!PqLsmnLmYY>of&r`9pkJUiJn*#RsGvkeOo9Z`kR|_S-t~zrbhMg0&1vv{7mc@p1)BSxRQK<~P*FLfGqW?y86} zK1`f2SakKMi;%yuEZb#fLMP}^#7U$8@#I$v6ftCsqZS1sM?;oBHAu1W@>}3Hq2npl z@KZpwc@p_IJ60HlO$ zSn&r z+5Uy^g-|53IE`C%n?a^s!tM8(DPx4B6BRbH;34nrNG6Sr;YXu{x^$KAk2vHVNc5M%6nT!8vMOAy@2l>O zSw!l3@j1f&E)KDLsbEWi(R>X-ZcLsr`zBcz=$f&vLrYAN#my0TqT>%p21cq0DF=6y ze9jHT%+^)VAIx`lT9=OMYI*r#5goRvaMv1?CT23_5K*n%4R&f@a<&q;?wLht5=|4G z9=QY^w|s-lL$Z7_%~XQ{xN@Ytk0|_}#3%K(mKcE4PyloetmH>TS02gm5I&C!EMm`% zh5V$@nvJi9Mzq$&@)e$8rcmQ@OUc>THK7JU1dIfUDnR$qR3hk#Qg@L#!<5YC6a}=T zxrZ0j)C8Y+C5E~So98CEwbw-CU!P@&Ed}j({b!;JS`Qw9(y{DhT+)J6JJiJE&Fgge zj2D{7To3G^vM}g|X2vMmld}syW`#AEs7fDLG6{7S8bYiPKS6hlW=cdsH;T@x{s_a~ z8_j~eT;e`s&1%Ch;joI|5tf9ap5YN!ge}3;sWQ;XLhzRy5?Gz=tx5CKCVcwM7en-| zG=kgH*|mY?g^HDNO-{AC1gXpk3GkSMu)E?;c@f->JZA zR5<~9X{My|>fK@x@7&Nmd87JbB!`f31a#U?SjA@~C3_URK57cYa%q{##HtalFJfhE z6}>YWQ*@sZbviZc8NX5eN_N{6-RtCcqK>zhwy_dO8`0wWrj+}kK05>CzG4~FR#RHP z=5S$=o*zw9CX6lhF;Pi3M{cB|W)-QcR=b#MZ)8&z?WCWV8njG_@_|0*cPv`{0P2P= zVujRncJdOGrFNp&3h1CdPAB2{ceN7VAtXg+30PMX+);OiQdPQWPaRptQ5I4W(|m?o zW~!0$as?!-h&@_q|KK?*d)4D``rvg5Ik|5x>rU)=eEah{xlIe<+MAV12PG zAyhR+SQpYI!JtpQyOW@{%92y-_-M_{6n@Ts8=d#7fajdIBr7fYZm0AJYOggZ@@KuO zCrUo~=nnPp)?>l#w@}Pi_nAT`x4?4!lXk**S!|O^;pOXCw)Qdt!uz-{eVIV#DeX1g za1nu?pviJdG*?ioY&vY7Z4DFJs*-`##;I0OO?-6F3QmUmpQ%=sdLUMq0#!~P<1OyN z!O|}dp6wco`SWx8fXhON`r~_n_1}{JtKA|LO$p!%4zW$k(i`R=_6ZKEUUbC8!^D=z zdhtpMRr*FbPq(VBi-I38#X3#skc~RP{vvC|QHO^YJxOxU9cpBwoKRZdvsquYNfs=n z0OK+lRHEG`YYjw+zN;x=y$Z*QgDBzj{}3lyqR+aB>2`M2@N6fTiGjVz$J}xIrxR9! z5NU%o-8tA@7%BgQHf8p@?2Jg)cqgEQ_Pw3})NV(jrnbPAr@j5f^eYC;!FixjSG?vD zUG5m|z|%~C*Htl1J^#*xG{*mbo zeD_fR`}`2q?8F>3j!GciXbJsdm`TV2v0ytKd86t;D4DwQAxBNXiqvP_P^J+6X59#t zNs8=nIQR}C>eSwEsTb<+vkaS4*a|I82-W(;wBrl2A1^X!m}~}*V*0?PYKDj%+_#wU z<^;JO1I`!b(iEMZ%}lwi+gl8MoW<)AWAI9bC~>#!UZ}avRpeL*!h2)R8X{_L)PK8N zc-Gw+Og5}h&?OU4DPn%n(n(_Ve-1ZTL{DT}q2(e_@+-}Kowj}icOblumY^Jj# zH5@uNq+!F)3rj~%mERUoWLJP9IdtNAp|O{kU5+(2`Uk~1?V3l~Zs9!80aoBZw|Nopb@4V?QlC*27p7*cH4~a5;omEFChcoHiB!=3t%4`kSTF?Eb=b z0r7fVu8u_PI-F8yuV{%Wwu6px9YdLO+9-8mJ>BOu{^CaTi{;1m?NaF-5BG?I_4j+b z3#Y z70R#e%Qe!x2$6Z|eB=11Mo7#j%HUJEoD4k6YvPr;mHG#kA5xXV>uXhM-5mSC+w`WWTIE&WF2p#~+_D`kjC~YXwZ3sr z0HFXCM$}_zhfw0mqN-U2=pR(d%lBpTF^`wOOshtp?*0(B4ECT(>Zj$BG5=~A|6S{^ zc_n(69bfkBBcBcoSma)5ICfa}P%byQGvG#iF($&PK6de!h}q@WM|e7&_GOL5*4|d$ z%?(jgxkbkYw+#`y!&)mEQJIlh^A&!Ik(|KTr}8qVZzJHd-*IEMVh`0Jq?w;E`}SFu z7}NM_wHN*Lz9u1jd#FAug+LCIwKqyi_${~J6-cT7$;os-fRbm(G|Yi2x~NhbSxvcA z0C(1i*F0`s8$Yfp2~ienAs}o7s=(VMP1{Y`dB#x)4(8WtD-YaMOIoGmvp-GxUYUC?pQc3?z95iW1emeI>j&HRn$}s<*9(jgFE=rua z)%SN{>Hm+kshFO`XG9G8OaGVLStE9_2V^OIKOg-SOE^ukU?jZ}sG?wQE05T|MpuUtAZHflu+j zn0tHCRD1MTw-SBVTnL*T{G~iarCS@a)A|z{mXEhPS+Al>49ykZ?$dbrcAEoP!tSV+ zx3uv#+#mB2-H9o!*E4|JCc0M-jVlfk6Z?W}lOC^RN$05Jk2BqNRm!Ent7nt?u?}gm zUXa%JEWUrqGk~)>lwXLmiRz#Tz!^i@j}zA^k%gNTHyIQHjVJ{tO_ZC(4co+%F3so~ z&7}}0qJT@NgNthZY2P(WbqsezLG+A`ZM_7&$yVqSH-ZYLTptOHceMmZnf5rzJ z8dGRF*Eb3YdRPLzm$RDO1yk!>3I6z*-`ezX6Mp=+yG#_L<=i02`@HlGToXJc%#y@( z^U<7X89a74I@9KHtdL6cEtXP_uLCh6!LgrZ4kwT^5T97Wf&L(E)68nYyq)q@JU)XT z1L?YuAr`#qtN=Ifti?GxLQ+tvmN^mTY$x<&-+rmO5HPO(TY*VsWvPH8`NEtH(m?F= zYB9o-umrZ&Lu|^OYp*0)QLEilK*o(xuE`=p5#XLuiGP;W)uKL;W9=?lr<@_{eWvvS~ipkK<1$jRtG+-XaBDA z_*R|Zt}yk9m6Ot~7Bxu+19?Djp9Wth`pI74UR=jb=T#yR^vwwuk71+To_^_9wvRE$ zt-5rcyD91fo->jRl@XMVfxFn-L{4ST(65kHwECq^J{#_mks#qiHRcxbA$OnDY+!0D z%%Ub5L-M3BCNaWf^wV%jE66a`UAKwok^>79&$d&Y1h4t0B>g`<@;3yr?enbrCysuu ze!@6d0DxiuEIcEc(|`CssZBU(kwvM)*2Gjok13;DpW$D;fa`jTQ2({bJ?RcnI@?bA z_qrRRp&>dN7=byYs7oS72kT?Cs<1~kgJ$#6!Q@Qc^lazh>Z_WZcSn<3-e*0^q6fkh zf^wS~Zb2+OYn@R;O<%+MRr)LESn&tlj-@vK`;)d(zXy!*i z9}W>TcP=R&Ov7|fLdD{VJujvjq(b48_Jm8OewG~9ndi{t&2PBLEdGoepOj2Ir}@p! zA-PTxqj?OZ5RnsX-u@Fa)Ra)hFvb*wO1Ss~F$8hV@F}P6`%;rfd3UNyR-Q8*vn5)V zD;o1Yt*4cfv%mi&Y2^ySXV&IwX%25%S3+4k+$Oq0pSCPMkNW%PDJ$``<~vt#bzK43 zx32ctH{PyeZvERuILu7%~#8b(+3 zSMS)Ygn7`8Ax7L?!Wb&0Txd?B=!#lWl`uD5}p0jV$#vmUd^S@`f|rA=NA92FYZpHpu3haI5j+Gpd|BX6DtT>qVNT`e`<0E#Zu zA*S||wm<$)PW9~Ln=pp=`z|ITlW#NMzr?M~u|k`P{?cQKp3~=GO_Og8_g*H5R5#7n zWMeZEG*%Ys{2;{}G7>pz8*?O^w0nNc`j%lf3%9*B*4up6!m86IApK%J|oX(5yq`k3Asz-HbEzbWHxFdXUyave zjd7O0Jl22n)#br_-yzw?mei=YwT}kyWSy*uo{STT0;_8sJ_YSLf2oM>IJ^{NV3(a(SJtzVn*OE zfzp}hfCSS-z|V<`i#fUelak1fyK+-4akr!{nZ=m;PrJ9tVkS@K-XceuOxh*u>j(bb z<^0yy_9D(EXWS5o?s;K;qVX*MN*%njOp~21z<#7_1lWO(p@0a~fQp zlqMJ+97A(xNl&!NxEB@C5bdWlgEVn|D=3aG5lYmQxk&xn)& zstqjB8Bvm`vG?ST5&)&c~GgidG~$Xf%+#C?X8 z#h+s#&7li?}7>In9i7K6#g^R!w zx{(TTcNs1t#E0txK!()4Qd0O{nkgMHIo zCV+N6IQT5ANgeSpPhvtpY4Dn`tr5m0?YH=a%#Mf4od2|c^^gRfi{1&*rp~G%S2_B& z6iLMw39?M_imS>gS$d|_3m4N^Z4`{)J zNY5}zxiBQbiHCApvcN1pBB)SBEWp zvXeF>(o^J*XG`^n&gz}eaWUE31=^)@dK<_6*o@KX{o5p@7V_|l{^{h6`9i40885B> zJ>10!Vd=@`K{XNUU|Vb@r*IWP0pbD4hfTbRm=RD2&g#3(J$ETfZ2=2VkM*2LrkFUk z0&1-&De188KUO2?RE7wJ5F)^_u@vr9U5jA63s$hyS;G_Vb;{MYK3qc3~+qw7th6caHfBg+g z&ne-561WFIP5Vw*KDA-}59A9eEa(**JdB2T%zC<-96WqApsI!SQA>p(t<58$;Ar0J zsWVgEDrRj%?@LWCGNIZw+Sc@#jYAV4SXjR&(7&TLa^fdB{W?!=DLA8B_>3Gkkp?^% z_R9^`tLhJ!9GTs*H_Lq47GFg5L4*sS>#wZdMlDbqM};DDY4$!c>2cEZnIi4a+nz~R z-IdLzJmkk_?JIHLrud@?9uK$p3+>uvK?xrk&d-RmAy!=j6*DcDy^K=L>up)sUNOI8{rmos~A$%CCHOfl*A3L*@s#9`WwkL7*$p37g_|l(pTb8{Ye^Y z&~pwClJ5F^8$Pu)lftldi$I{0Xi7)wgxXbLeR)+Vs=(6;)*xnI$74R$3g{cjH?yq> zX-fl^MGHRm(vNJ5&?}jWF;!lXA+_{Kx4sw-nwZXJl zHXnBCA{D=s#t;q|XB?WXeexX>uSQnFGugd#Jrpo|itamaMP;+4bAm+XA8^tA? z^mJcpe^wCn`#-G!589+G$OhP(jtroKYU#WYy6h}7aS;#|7Y&V$VtB+u<0X))aZPhF zYx-RIbam2Rpu)`8Yp+_MK1*Ls3fPG|U(~5PZr^Ne?>wK3IKPxP;#ehQYyyx@@2l&N z0=G#m#AGH;<1Mf7;gU58ay53N)p`;CaCH}0$xi@tZX3t6GE|wf3&!m7&_vUWnw60qdR?=7m$4?X2 zs)$pADf2Jk<-OcvcdJU@A#d7dw-xvYzcq$PyK<5xz_2^AZC}gLZ$%G9w#>gMM3g_<*|gO=6=PYoUH86G8-A|XBTNL1U*5lliLT~V3P9ZI=Y*5?#dch?77J^82o$Zvbm7s|vqveVyQe(;a{fQpw!D&rqh)k#K%xNJ+}fD zuXV0xC&T2@Bt)G)X6LpY3JX<%O3$)FFj-IGq_Z6%=Ym0ksm9cjV-0a}wf;KFUOvR0 z$~T&@U5qlwVtQ*6Elcc9(?K;vkQ31=jF!Uuo6-#*XTWPPOKtK832Y=BwiI;uB3-G1 zbsI_8FCjRE|I^)DM8(m?-=d96Ai*uT(-5?ANN|^?p^?Vj3GN!a(clo=8X9*965I(A zoDdlkfE!K}jh^JK~(*s(`$md&20s!$qU$ z{uMj?KiTRL0M9!{&qs^VlPB^&*(&p`xcZ#n#$?_91k(z$tcM9cDj`-@MNilBob4C9 zYsC_Q!VOH7aUQO4HBS0M~XnY=Zwjqmj}-)V%HUYp)iKcHI#)b*Jq>h}0# zU~bCMI77R-L{R`NZH52mwa#M$C*go}Nz(ejLxmR*wa3;m2{mPM`&-6K20R(tZbb6> z;*L<#j{$Fm1OGA?qj%V=;7?+#J#$)uDXB|HwN(sZVK#$*^g^3&B-~gE7pW%hoan8jIMtwN(p2K2d+ZG?$>~EgMSjL%3HJ z!<=KOJIzstrePuTBO!B#Kj!aFB&@svg{fj&+IXTk*E~Pc{hDk#er??7G=<5|8lmie zK0<9(Tmdi5*HI>Nb9TqcpAu5NDEH-YFz8&O=%|jK;v->~=Nif-0&iU#9UUafPN@tA zEwd3(fvxH8WR#=j>QRRhFOmnXMhW1*Bi#srAiRQ1%n)l#?u-t=N&-Y|iuJ&d9gciT ztK`eA6j?+dBbfWRRAy+%1j~`s)k%-C49pmLOcFHAqQONbZZkQhc<7DAzN+-P)pj{y z?_c^pj>Ml!F}O3a_GV?q??*>ZW-?j**%sl1j{sJ5(*@x3_U1;?>|S&Y!UgnAM6vC& z#$e{&`Wf+1sk@}=*L^%mZ1y#ib?htZH0Jm@`oJiMG1vCTgpik2_EUvsAl4v}MWGbZ z{(Vog*UBbuIC3d<7V=~qWc&0w?fH@&2k_cHeYE9+4UZ7#)46qkeX9nk1!=TynRf{N zIPXX`f+xy^+xxTHp+?RYRlnt8Lm0$j=ijFW9K1V3x2@*4E)O5Kwn@JjK{?sO{DrQ{FS#OaK~auuV1OtAtw{?su@AAV6)j zi`iHbX^x0k<&_jwjwUt6ate$$wdjI1CwCMY%f{I2^|rVOQh*KGOZGWA ziY4rI5;J9fUfB^Ts%?R5pOpv1w+)Fco^e(tb_)VF-GNAE>8U3!(N2VWwdMD26&0J~ zs|C=v^IM0g?XL`$ z6@S;EEiQ*5cL>WL*C8hJ#hSjrS^SExK~*L-To<=Rk|d*$j>r0Z z12TCfPy&s@<_$BdmE<|S&)jB=a^jP~*u)@$j~DsbOLL?$`~0L7M9n58ZL0ZF1@`Wt z{}6{J#C!{Z-U(>kvRKjlOW%yCwAyDfE0euwaRB-;rdNTvsoRCkC!?C<%Or}dweLFS zfp@LbMyR);%D^OR^JD&Kqn?Q{Dk;dx(0YKP08bC zR5HDPj9n`{xqH+7VBP}E;qq||ZeLH;=Uq9&yI3JpUC=R@U384x>o8F1ogz?6X#b| zWw~6B%=0%8P9!5_|5hldq)<=PBO+%;4_JCD7zseUs?ws-r{f-fC1jN^-MAhXHF9*m zo(+f0GX8n`JXwm8@9dB zhdh$_aBO@Jfr$vO&SLjlHJf*&Xk%P;PbM^!sKX@*8avuU$?lFM7*l&0QeqnF8@=1z&!=ySMZLsC4ctvj7L}3 zdLs|}Pl87+P9|*dD#a$bCHHAJyN$^)j&&nr8wY1Yy=RgJ3m`Z+E@spHMv1Nv9S~*uJ9Luly@HX`6Ra~ zISxfVF$p0J{uhA4=sVY*blI75_A2b5)?e4}P4XHYI`ZcbTavaG`SveqDIg;*(fCEJ z^@}nM3Y2c@KS8sit~S2kp~d^)FD|-`5E1$%6*C5)ldgd(R)@w)iJT5kM!E^B`w?bP zp>u>6)BJ7*)oEiYTXZdH)y{;M|HSL=%z26xWV)Bg3rA)V*Z|&Ksw3QXm!0FktokVu z57TKD%~Lt&`|@8?OrKpM^shx3|DWM`=7A$!``tFmj3#Bc{ z-M0LE_d>t-_uXv3qN?MzVH%?8@SZR~a3;=xL!MJoMFl4wgdrv9Nuv1M ze)hZfE+FELr++T2t~UJsnfvY1JNJms=n}SFc@Bt-1Uw=R7I4n;z^t0s$UFTh=!yvV83cmYm{OSDG&Y!N+t(!;rcmu{GVtA8SD@}n?XDtme|XLK zXo-3P<^JRBGkPJo{%z(X0BAWdnw527mF~vQ*V&_z17r&p0b6X5y$dA7vrYSPi`A0! zI*?Yt!fU7!A=GL&Rm)ZFC=Lw}bwBVg(IO^`+FR>dD2z^A!D;_r%NqhK31fU|n z8Aq6(HP{@vS53m*98-$kaigHY$HqxX2I#8CTm%-14NTFeVdU0xTi+C=f zAD8HzSa&@}JFWad2INw!)&v#Z$X@N&wV^0 z6^5Hzrli0n#W1OUnT@0x%Fk~*Q=Oq{j2l52Gde6@$3nF++#GhC!QuV$Hrh=0iHGw% zPIguHu)Q@d_cl|;1_ee-8HHGP%g@?sep&PU4s%LJGqaqT@q+Ao!~_x+lDywLOlhVS zVwUoiu#`UFF0Jt#+VYT`2CxBq{dz_zR;rIrdmf)UMKxU;g@1mT^7$ow_7U{q-HLPZ z?&g_xaQ%;RhiasW8dNE(LSmo79b1)#rKa8;hvv%x0gX~7N&8SVV}h2<5EXcb#NCVz zqqqTWaol}DoY>WV5X=VHC2p& zxtNOtNZp;gz(#5nRgkl>T4IyPZ%;OQjOPgQ{Rn4M^Po0;XR+-6vfYPBJUS;0A6>h1 z>B#?VLFkDqc+O-+2FoLD&{P^gbS&PJjf-_Aow)5jUnRKumc*3uS9;FOWMsD5#jDa= zEpvD-8xZ#!T<);)m49tHLE}tl9J;LC8PNZd4!%KkQF`6>apS;J z*0S?Da*(w91Dq4=eNSaOru-jRug|vbC?e=QA0}xCsg&b-r|WDC#6}%l<%F9XdbV9ydpbU*W+(Jc{t3;@Pt{5! z__BU|i|eMjx5vW#SC+r1nIrKZr*>!M8K()xvnn;XCJaLSc(us;n9J(x{%0^Tx)y6e)5_U{o{NCynC-`d4cThtz@Bt329Tja}sitIM z5wJL6l?TqW9GJpP6yGh-XK=sq;#}lOlN#Q2Q>K=5YnbsGLm`&7Tot#8l-tAjBG3jD zh~5*C*3~irKXUlA%@Q_(rM6N~i3c!*XRDG&lfaWkWd9`J2VgT|1o;~Ss1Z*Y!3WX| z20-GEmbs>V)o;t_RMAWk!sOj7K~0-8Q<5oW^>Hk7SgUvI^pmPiQKEd?S2aqlV#Dwo zBe*bf(m7-KvogO;TPwRr(1(@o1{;oQUIG#Zp+Vp40A_N{^E~Q`7ZYg~@AzTe`DU>2 zxilz{En}5SEuBeXtUb!Bx(mA{cNYA=%Z2@Xhx=o-sn30l zdCw>l#bF!O?c-}jtz7vx_#U$!&`QK)u=4>w0{iKTAVrL{@W$m_P=m1}A?FnAa%t$- z!mlM9?{(Ni)0%=SCo|m(h4{BQmqgqvzZ(d9BFf&`6^x6MHk?NJkxG3+sR*sI#86ou zZIkNN$g6*_aRTG(k!Dj-dDDl&YKJJSA*3XpvysY;7O%)O7Xy;8TzLIJYh-)g47)+{ zdS8x(t5R=xPv;$N`P}(l7Gp$Sds9E|PX24mLXV+$?i)FfLT$u?#xm1CriTW*%39rE4D zdevl&!4OI2K~I>rUfTVBm6JD^9U_oA+~iFV2$S{`v7FRC3UtpY!*OpYVKnAni~ zkYXbSCLlLqyj&=r$^h_Ia~YYkO{)e#`XA4hBuZh$W3(FgGG;imT95gJZZOut?SWq# zA79;Yrm=qE{-##wt(nDtAOuB;Z`R~^*4>HQ zsgZ!99@a&L(*3f{m_uH&vN_G>auhNql@r&05|DC4zW*LjieH#GWwET=fgqUg(P>Z* z&6YLSZG5Ne(i_ouCXQANp^(V8IX3oRQ}A;LJZ!_&ov@PW_0)Xn3MnAQoEUV~L%6fF zRg}V|vvU4Fh)4mU#^xgFebl$-Z>{2BN_Up2o5RiPNcA3J@kO)qm$PLFGue{H>NzG~ z)pkBU*h_ENxy1Pj)e?y#_x&c+fF;`*_6k9@!yqOjCVNE(+s2$M!V6Di^S-jp52~f_ zgfFFOC#PJ<6E&(>q46~e_8{Pq@RvEgP> zdgoQWP@H^#9EHF8dhx@dp`}jNs{Ryt7zK)A>j;wyXrJ?r>kwn9{E2=(5_%Q zL)Sg;|7U(Rj>9N~10G|CAQ|)>R`*gJfQX3BmC|h3^S9YObtkuVw;(hD_@N1fxYKTrF9kqAw)4zT{(6&oT}Tns==`um&f?UDMs+zG@9PHK{pT_0ilh;4(28Y& z8M^?Vkr!J}R?H+3hNCG=dg~wg8hqGPo?|V42c%@KH-uAkFED$%?n&0TUZnE<^{8)lo z(SM=Zmfx#CP=X4mvi`cULZru>$w6{KCFM#_zsg<4LNY3u<4d(}5@~Sqg<;5entnP` ziF>sBoYr1$)m1ffx4mlb523fHCWI`@&Pd|9s+=KZBk2MNn8TOT zB+EHEL^zwkg}N-GdcX3EQD=7FD0>uJ8jlfWOCPku%}h50kSZNY1IIPgK$wrN*|Of# z2-M#V7f_UoH7@QG^62%FcF-ZvU7iCxD=pkl@u&4mWzge%dCFVHK3JO=)*^4VeN^N;Dadf`4a?D3mxsWXm zN4l`ZOqAs%5Ks7y$+@Y~QG0Job3U<^SJ@AKUQ|RCy+m0QuvHEv(0k?sSDc!BZadMG zxRwyk0M4-?*T)LDIxZ{Ddj}s+P&mI>f?++P6#@kjU2;FEFz^fyPQTcjA#W7^8IYez zWTa+~+jqh%I-T7EoK|(RRMl*L^%u`WVCrWz_KEH1{b%{=TgoCDmc0lY?<_jkYqaQC zRw?4g>Xth5jm6a&rHG;d*k;Ei_XKsi|$N*FKR%a5}lcW(z z`Vx7}5P41IF6-msV^WEa8ME!8EDd`42xt8(=**Qz;M79a)^{;U1}Qss#_@Nh8k&B& zIVPLzJiJ~X#xyfo7!a1KCxouzv5jrhj~DfP*zFs`=rZHUMTql*r#Y;*9(lQDIV2jb zN;9aA8RUXP3!cySzWYR%*hQ9KkOM_i?YP6lM=$G|ow1agxQU=Lx8GLvKcHCZLb z;DSsr5lwi1JVUTq7oTU_``5;(LDL_RrKZ^oy|sY`jTQx$I!jpwE{dL^T_89gDfFRhWTOqx*Q`{HG^8XfAlc$KtbYsA(^?vCRdhlPUv&zFoYhBo zzZGGUl^jc#x~4x4D;y8{?emgIK+HQagx5-s?>OdD`rc&Cac;g{Tf{rLw+z-f2e7JA z+-Qxb_47c6RhS^EOB;2l;fX!$QkH{O;OgDFcy!nVD?ZWt?q1kL z$?KI~w(`iR0@aK9m%++3AAdg_x0&oZNItUDKCe*F0_I_V9KjKa(IWGV9_O2irULnq zU_{HQs>o4U^}5{@ym&_0QJUR&^jjGEl8e>DxYN2e6eep(^vXkIcyV(XIr}OAqve&8 zX62;DlwqG_d6=G+5}nSZQp=va@82fkR2}dZiRMf0SC<_c*P`fn1BUQYlN6b4l3E>^ zEZ!aGAf53e$n3rfnM1Q3`vt11{>7e60Pc;W@|~`oCuop6nFt+wj!MYU`*w0aBCRXY zNC-PhwC>VYXUlk|sMFxkr1~R$BC*&|Q3wml;h3ZtQ4ogkZUwl<^`k!A}~<0_~7`^QH*Mw0!HzS+YicO4n`UZ*%_z=GOrAdzp>#+;EPEz zY_%gPvyIIlBCQfmAL4$K7170T5cE6vrA)KW&)rG75dnX*yyJ2k7Caz-!%W>HO6plk z6;-v{YU+AXbHC_UEiA^TCcF$8qM_2UyKtud;)o!+8ku(A#f3}a(7#{3;LD5RggFhq zdU|$Qa%(-zeacGSrPRikUum##89e?Di9xf>Gz;AMF4^-bOVWsbX=PIV+yD;GEsLxo z5O%8k1fk0`9A-CKvL9!YKJ7_~ zHC+z8db%P${r#;_t$mX!*4EpTWl9VX|siPdqC zbvLVHwfbeU^@f}%={PfVnwxkfS>(BMjE~l4?~Ck2|9Y)2Yg@WKu&qyh-P{BqvG>K! zb`A3ObnM!dPKvmzCc<`64(S#%7xq*|W0(4d&Ixl*)N8pYz82Yh>X_7b^ck=E#_9iK zS%8WCO_5Fj)em_8iTlW#4t)8n|LUHjNZbgg(Gxx~If+vI(0>*1SlW~1exbpS02Vv+ zBYe)yXt?>r7z7gtrjRQ~$`yk5LtNEK9mRSfvFRj~0)l>~2~8W-Ut~)Z!gn`^p9f51Xj2 z%f;Ilq62dcpMQJ@Fh?575#2xk>3{cYFKhmKvkkv??b=Njh1y0tYizeYtVJ9rcCe=} z_cNPgMCQ!KCM>Tp7OpP-;g#ky2C12gqpenl!_R6n0a@>sk{Y!bv@~!PH@K_2Z}#wZ zhbC3&4U4j30@6~{7NjcYMFWrX zG;R`vvgc9O(FLLbbg(-3%zINGs zvQ~##>=&kkZfQQSX41~KxPMt_F%s7Ss_@O&+M8Vt-vs^Zsm=8Xk_DlI4Jpj)Bn0Wc z+2*uVfY<_lfNeT}0oAxkjriNfFqG0TO}4?N@Ew8jjyOi$g+Fvf+!r_Lx<3y=&E5f9 zl}=j&%*vv<@z_{cH}C8r)vtrbVh59E2Lw*y_IR5eSqa&_DQTZ?R)YX*tWSP=qkU>X z%ju?!qb}hdnY$cP<-$8`^d@PdA)y?mY*KlM@K3`!^&Vx2r0c866YZ%?VvYuW3VKe! zbRlq>ZTkFby{=E*l@DIq*rmKDW(sy*RKbtg@h0X7ta3=;#$%5vYtvIw7d>5MMP5JR z=b+YKcGnw@r$@2hn$z91rr4q*E~?E{YGkyqGADTJq-}c}bsGfzd+hK3$8PcXUiQ1f ziNf34n$910?GakqZBLbXvz`P4)OwroOMOokS3GzqV;Z8lmb@qTUqeUQ*NSnJ`Cl;R z#B)31Rh}d;`}yIqY%MOf;K;^POuWa9g=D9?L|}H*z0r{45__dZuL?8p(G*`IK-$v-Oi;I26^a|ZhBqb+Q2U0V7TqVieirc)=Rzktam z^Ml_+h%z-ro%7@$mxcP1VV9t)7-WxR!}KOIMyTmiO?XSmP-8K7{btd})&ZeU@y}TG zT%sBc9^;f#iMc7TdimOpq0ncRtViC2NDtdS(L8@9hfjt^0!7CYoaE-kK>*+d`o>-- zSxUi(>I`NV&@lSs+&;!$9ks)H+w`H^O**Q~#eN^5LJG(j@f{~>gpZHQ=C^RHrP0J0~;LMk< z#{GBY|2?XNUljVkb&+H=!T!H@kpGums5>jWmB=ezk)g$-r|5p<3HrvsJ&byUC>>({ se}2&aWuN^2{~XjEiQVV4a|VnTQOp2zi}v3lpx5C6fF_>&A6$h01$9Hy_5c6? diff --git a/dist/audio/hihat_open3.mp3 b/dist/audio/hihat_open3.mp3 deleted file mode 100644 index d73cae1c232135885907d745ac9e3a835ab7b023..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 53361 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 mYxe(%a0h!Lg!!B`As`BX0`LI+0 diff --git a/dist/audio/kick1.mp3 b/dist/audio/kick1.mp3 deleted file mode 100644 index bf47ddecbc9406b6c35ab911fbe358111fe5cf63..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 17165 zcmdsfWl)>Z_hujgf(LgR++7M3N`T<*?(Xgdg1fsr#S0WD(&8?~y_7g0mH}83#=g50*koRdefd9=haCEbOx&;5}#Q*@v-~w=Ph=_=& zsi_$l7&tgM1Ox;`MMb5g|9TG>;+U+#t(Uzmhzvar^KU-B?-&xpR)es{`kbkqk#YFJ0ng0eyHn#O? z-GH~vRfT5n8q3#nHu&swY$c}4#dm59Twu_P@A z+3H(#1dk=u$xg5s?R$E&ef6tFKK*?IJP3-0$5&|>GZ`35mm22ta=jI#Q7&pAM3q!N zbvI?ShQ}9c4}0V9sp^o4+QJ!7m+oP7@Lnz3d&y9^0avi-K(Jtb_0wba+st7@{_?f$ z<^(RN6k}%bCXmICE!mSR ztGEnPEOkl!q`|~7+aEM82mMOrtbqyfA3@e=fgV&?niKR~5ta6t#l@*d%=YY4Rzq9+ zpo-Vz95l2%W+E+KwO#>8t#Zkr;%$p^WyF2#sPxjI(sx6bJJLFXq)iSAOBx@SY6Dv| zQX$dRtAw6sk~g&#zDF5NM(J9FM9nlxz4EF@Uqll=opb-9(vy8%jF;joH#Xv_sY1}>nWTr6h?h3#XLVz8=00872na`VT zBabQ(^o&oSup&Muw?{iAC8ljG!wi>< zq_9SNy{a})y%3ip2#6{}ZF?=ZG|R4&)SaQ@G;Te(>$}2gU1_Vp@tw(4Q*nZ_$rKfa}&BbZ~Xhc56bXL{BIS^_3 z{P!tm8#%~_es?4id5=WuK086)oV=-`SXo%4Fu&Ul75b>H86_C$jZMa11<|g{z(7Sw zTIRxD(~L%70i$KZ%f5&}DNvWm? z2WT-V$-K~OUhELnFS!_VeI-zt@lzTMDMa44*h~Y^eXVBi11;~^pyYv|CkN5#3Y~x8 zsvQGZ?n3~8)1!3m{0~e_oZFGGR|YPK0>v$k6Ckk|>HFtBWXgNUt4F>PR-GDv6Bem+ z){1}Q44 z8LQlaRGQsQX+%T6TD3}ZI3;zGG&Gjs#M_rU06UT=*v4|&^p4aNrLdld++tW_eN`i=t7$SYq-3f>IpPzlT8TfD?1YCUZ&-6SgGcRElUCuKPeL+-hUw2ngYFaRLtZq&0Y(7E4Qj=m=IkmrsI3MN+HTQ zD*Q{?%d3*CakhZBlftjSXuy4gX>gAj78;?84>&u&m(o0n3nfEfC zTNnK?9cpAeykGcO7z_n6Jv~=gz2q_x3}65U&DrLemohJykiu)*-_p2v<+B@I^xSIz zIx1xoCHiQqH^8LN;N=Tt$hV`3(FQ`rN>CF?#)u>)+G}-unT0>ra#|Acr>V3t4OmCX znK`;W*%d>#<;tIWC<4x|xoqEUd3(&hb30S8U5VD==Kd*!l6l+q*s=B{g3T>`oC;UC zd!}wgoxJbhy@laccg`6HM`kY&MpaVUOe2noxVFq-hU|4mw$KfMsjB~QfOk-TfbHh z^3QkFb?)2wi+cfPg;`d>RqSxMZLHA=wQxcB6j;DXa!+F%2peX)arKDB#U4>09$)^9 zk?WD~d|3Gz#i>>1pi_#9k~D!0E80kz&wFh-8hl0>+c%ifSeZm*dU@rT(kE1SaKUew zS$MPUs@0kFdWH^JVl4~)nKUm0JPECo2v<%#k7-GplQQ9lJf@)yTym{T6I{}5))Btj zzTR@`bX*Qf+ZqpUQ#8gO>aSJLzOGC(a%px}nucU_!SEc1&NAQzcl7Nhqk#=X8Wqj& zI&DXFW3`vD33xoYsE~c_)UroDd}TP;Y~)?#8GrTUz1L%k)~g1}_6AUN%7SK;5^uk%!R`g_$v+*jskrPS-S;cg5Ggl(Rh` zya5=)qlrqz_&Ra=udW)WIG^}<=PS-0G1I>*Wt5Qd(RrW}fz@KukuTfWHqHTLlYbPl zx}Md0v+x?}-~YsFc_i}s!K?rn@DB-F2()(X>3_k2&I0`Kln#@W%W$2y1hV!atQeoD znpfjz?0>hO(tI>LrjqwT5tlWQ0Yeb11VOa|GGht%%SMNfF%xpOOe8@--vvnhd4dpm<)Q*ide2+0=aXTje@nGB0c6+f?3;}p$o!9NZ7g3{>p+f}Ra{wYW;f-&)I49+My~XCFXqf7@ z_hmruyr4spW?j*{kWwUa6S@6H{}_3E69o8dN296R@I5{9{Q}?8fHy@%6gk8&iIEaw zSd5(?U{D(XfX+rJ?;A;52_NEs;@;S2!*Vl*CNA-WG9c&46LCbt6mqGFU>*8ewj0f&Js0nbCL+no-BK-EvNJ|OoQ>24(nDP&-ZukXuktFTync|jGFRbC=JfA zLp?*fZx!ROJ7`Fcb=B)Tn);Df$cu%Q>x%`?2H)c=Q{>70(d9!i38-$uPhRVLzaAc~ zMY+msWMni7?!W?28N#<9gGDa*PqZ%qXx*Aq!7jpG0#I<^lL(O12{4_%UpRWwgsP{H zUt|a{d4DpFlY?pLC{P3SNahlI*|4gNuP~gClsZlv9wLR~ORQg0>#{Q~czH+lXJZMv zmFWn(`6y8hNg3F<*!lScwX3rfWv?4-gO7E}M~a*oCzsjNAS6tollpHYlhs=~Nxh9c zBbPQ*=DQA&-P9Voe|uMRs4a6&WCwa)isq(~h1V_{+aLf3>61dsQJ<4OFzhlm z3bId?&S&8GN}tN0n~hh|?0K1PaPHibKUd-#^d^uZKuPRlV7*Wngf79lzPRA}hAW2S zN+DWNMxVoNdAzA2N-Az=&GvzlS}0e-ztxVV$0%jo^7UOl2{oEy zw1$1?W!~9w{Ok;F_@i>a$)o?r4~T<7sm44H;LktzI1bR~Js!j^IkkO9%hN&dHAX@h z6dM%@k6z7Pf+Zr68_3G1yy}Un9|35*@{0HFHeCz@|Dh@|(=(PQ(LP!RSP4E+^-dBw zkC_|ir>pOOCy0-sFsYu5lJ{wNMzei5ZbbH2!+LPc4BcYf;T1ogHA1}?M1tx?Wxw(K znC#@xN`Ot+*AU!RbsjY2DW}_=%fvnvLf>+fB`>_f?Ubb~NIuV5qS=g__s7F8w5amf zlqucKFX}-2M@Iei@j2>K&*yaGQz9LP?Py;1&+B2P zMDQkQy*y@%uj;0fY%~-lIr-0sNT>0sNx_W2ep(zQ(Q}ynkqBfO7Ldi7S7wa(94z!C z&|#15h6ZKG{)evcO2PM4yv;J+pQdF>96l>hVu-oW(}P~7RiZK%C=mj10!RuCLZjCV zJNrU}Fyxp}05)I~5FnWN>a6NjJmD33d{CgS^UWP2eh429YzbB^z=aN^MX3rOKO|-? zis7de6OSJ%JCCPZ+l%@~)t>+~18s$1cj{Y73$Wu8H;JP~8JH|7a{#D2LRxB6qg^de>p zhnse@CO+Gn7+95`BguF3pex z6;b_p0RiJ8^Z!1hadpxSvi{7(0YFXxzO&CiBHjQU++cqUP)AUbX;(~P(a6+hcz13 z(z55E)M~+%A$NqlVFxjqcysNHI!6QI+<62lABfTA)J43y^~>4cJ7dM31q;haH0AsE z7kP^pWb`h)U8bSfH4dDz@f&8yc=ytfu>Ka12~30e&10}9cw?b zjSVCLXjHdr`G9AqgVd_{)76^!tJ$e8-gnMkH4%DLqN5YrSTRT8*baW3MQ66N+_Q|7 z(t_3^z&fLYNl=tvD4@53m-xAjB5RA9_v1J51@gVufs_ln)JR^8K}#99SYmku&ote8 z6ic6%v6w9XsCowgwY{7OR-rKx`9dD@lxY*&O3|G2`a??*)=#1hqDwfX{z}d8wRS=h z8+%+?!?4QE$XPju-^>`>GObkfWBcRUY{ZXzYFBys@}l1!)`9OH4wO8|XtTr}ui1a4 z(JS$#r|9>*`ja3`EdypOLx!>OZB0OH5kN;r@D;a^0iy!Ii1)rPmtfp5jxB5H zMdWLWS2?(GEf~yYLAWU?YBCz8*vr+JuyeifH(+Lfk1v)fb55$d&rzuLh^BZjH&v=^ z`9zV8mkC!?9abu*iH}|59o^yCdtxJ~B{w>D+@)8VNKIctb8w7DP}{wIXv(}YP$1; z;{M9V^P{I)rp)FPfUaRN?(8mW#9Kzb{X|tg$7f9Eylc=w1l|6Vv_3>2kIvpU1f5{{ z`S}YQzw4+#|5MRQ85v;GF=o<5jM?B~6H&kygJXyQH!%XIv-YE9F(|!j3T^vZPJUJN zg%}FH+`kSL)yQjNmp_r{!3}wB4zG5v-5{wy`Wgia)Yiqadq6kR;Tm)90 zkipXrEH$+p(o6Rubst?D%DH$#k5+kSp(bchXVe#waCF?_D>QtlVKsv@=}5c?0}%+$ zyok#ClZ##BEa%Opa5=TrptZLG0x;CbG9dFNKRat&eev>ldP+olGG03oweB<|FHWoN zm|&eWV+o_$z|TIgbEN`rOVh&MkV1fgQ-_#(q8Ocp(5ik+r$Psl5`zRsyq;SVtcl4A z&?l+&_(#?6;h?pb`NMS^x<~tL@gBdo+fTxDeq5%b zDv-01xlm#lMi)pqjUd%+*F=15y{(~-=jPmxA&X1GxZ&$7X|U@kHx$s#Wv`MJbp{8u zk{kl{-Wx&ub$N#kIlTYw_Vt0QEa#-PKY;doqgza!{)53YeIHz`iK&?MX&(jZWLW|n zc^NaCRfl1)ptgV)ANB-08;mW9o-?m)gEZg1UY@v@RS8o{1IvY-8Gpzi1scDe8r-=bn@gVk%*?Ro z(Tk^W{LBou8M%|UDi}#@Z5$uY;;iFL12g@mbpba=`X;V+5Phh<(w5gpcF>IhGxQnK z0GKdBBj%VUgvKV=;Kyz96j7r^mJtoHoGq-P5ELI7!6y*K_7?dRosh`Kr{)v#F&Ztv z{~uM?0cb3;j=`A9)i~MVOh%!ff4`BH$1Dgk{8c_iOhrPk`rC9ILdV0MBZrdwzhhinT zmhQy$+naeRLbVbqNUaVAI~GdTr20&<5fhE&ABP;~9|29LZG!PsAV?&d&EFoScQ1{9 ziDi|ifT<`6yor5u;O%Ko4~a53!!KsL++U~na+ zu?duZcj7qLA0(&yzOA~z;TQ?&2yI-2I6O)c4(b5jVFnEldXjw3yrtn&%lWZi9$8b0 ze8_rz*A7$>hrj4U%KZKL46h*V@Cyg}rDql^4D8feK@Xq#U{g+72mJ!BxCJKG9tV;V zXpie>zHo81OWq0G7#>%+ko1`5XOu$+%tPt$ch|wcz?U}SBid{vLhLAe%kFUsY{r&U3j#z- zp;C=%(~p(%zl!D8(SM+EdH1;NdgTii+C2B&6z}ZKjHADtX|T)f?HSPeay^MU<%EQz z$@4!qMOk90a;#~zHn^gBd$>k|9-klUAM%(E!8ghC@cA);#>X3l+vN!cngOWEr-<%uPn2U|xt1CN5%G8E{8JtMUCCUCp)q$)^K?shlv_&|YVhT16g9jSD4YTZ(Nf~KL zV_bteb(v>8V2ukR&(0{D;UsXNWq{Y-Jz$oDhejW5QZ&^EQ+ML+~blRH{$>{r0N&R=38@$B!?~seu=jni>d7Kv66aq(#jU^=TJ`*d|)u z$HXm^kc+Uz}2T%(z)8$gt`ZFnrEk%JP^|o#l&!NYG{xm&|TDNup zL2jY*XL`S-GsjcN`OyS-kP3`5DkCr4KZvOUamceAQ?MXdVyFcU>ZmdNL`qPfmPvxL zXzVRpVkLM)Wf&H)9X;*KoCJXg?&ri-c1IV>lHt_L>KNH-l^)13?@xr)AQmNXQbxK} zDqW18FU^6JmqxDk>)}Eap-5pSgDgpD<6yEBSQ%Q8z2d;vMu&;w)4S-CV@VF+ATK*7Dc6v^4*|_k{5eIKyNa0NQJE(Ov?JG%``NX-N%~`LO0U_s^(&kZt z4B{8Pg#|Z@p$$DuM1fCV(PQ8({2N(e5t~MLK>I$6Z@^7 zN)?osj0$9_#`|;Gw!$7T`L5%WJ$9ML3yXQS%)ao$L*v$&bKegqKaYAJ-#pk7;LLxY z4Z9l)@6iHdU_~Ilpb7HvRk9HB5>Q<8i8WRiaDq`$`tB=&RX5R)Nzic2$O36;tpVOXiN5rFzk}g_R=b-^Ky8alO}x2iOwS;plj7I&{D!Akn|G^0TYOW#D@}+-M)iQ2u(c zsl9GoRf6-xAG}J!D%%BX%EqiRDiXR5YH!SlE%BYLHn0hX^n{w>iYbrqmzal29N63a zM%K)*)(^8fbp6oj>f+8si#*3?9r`-oF~>Fwm$Gl@N6z;@JfL8!zb1kMdX^oR3gFmc`_{q9|t`p=ijj$uRuQ+XB`LSM086$xA`+tPIEFRu})>zy(wabJDF$W|yG&2tqn91NFZr5;%%gD|Pkvw!&_2Sq^3 z?Z_NiZCU02XyYgu==`o)qy}56QC;tkfE8o;NN}%!{PIw2MU0=^qKw3uKt67?sze@w zj|H>~8Obr@cW({f-lnRl=>-j@NmCS)!&vexEPTEQfz^K1(H&x*g{G@SB@VXCGozzI zjn<<)@_M+ux3ufzw{25BGlo4o8$CN=;7LP2oeVUBz1PT5B75ZBZ)C;ACJ_NH-pu_21(XI`3W4MK%USMe zUL>!r5@(brZKPf!kS&~;p1*Zry{BAS#urAi)Gp&d2LW4V-7aZD*A0hMh8+2LSY|Lr z6(y{s7xm+^^ja!u=gpYOvNW5AH$Eh@r6xugipJoa=0o#Q$Q zHIL5v=E2=YJ<9_6uZdKKb}6XgumKF(xQ=Q?d)^xb2IQZMjd$hD>*3wZ$rWg9oqFa5 z{rMf!m30+;zxMM;M4)~iofV^=L$eMF2EiCi%|wZ!ksmWt3~WL3BdeXTe@OTY0DY2@ zyH}x6fLkksfPfI@Ba*kEs`T?BKY7SUcA~ z2L#SF&On4>$_$tnuCzE4Kn;FL4l?9LK)os+`7|{lIDF*h$L0)j=uAp;7Jex)7{l4t z^sqgawAIqoqh@dN7Qgz4Zo!hT!?xH)9NZpWd}h)tm@i!?JuoH%M7bn0`p>}M? zZQ*X2pQWfqI}u!Ku5!724lIZe)arcfbbH@&-~=mcr^$d;*5RtR@u< zerzPq_qE4n$Q(Xi1643cJF*x{(|@reht$C$JPw_hlayWrN=-mHAf4ND8crz?x4xO$ zx3(#>+M>D`-p9D-8}ULtN7+_8a!?(SQG(`{JZv?M*Vpn>1&2nw?l5UCS9n>`IAr+s z!NfPyIK!Tnf}W!}ax6$uC#ts$O;vbn4N41w2ZNNA1}tKcmw}27XygYFJG*{dZkESxctR6Cls zy5dsy@5jo+tM5EHUeOW~1*J8U)qMuwVpUaxk6n%fHa2lXNoL2fx{`i{NVv4S!5$Kl|^FCbUOB79K zt+iv&=R*S5US`BVt9Bw|Yz{GPW&)ek6{WtuO#cIs$m<8;zNy)(jxgi;&J@wyFp~tS z5}MuJ9rsEokRmWGGnEgnoCFrPBu06ct2#&yfS58!qhqkxxK6IP&4io3z&Z5Xc5yAp z-VI~=rQr1fMc7bmSh7p9v!u|oJ%tw?#RF)S$%W2%<)P)Y?l8@|P-9{e_eW=$Pxi#_ zo3ik`#07$GCbu6eKv=Zd2~-6dF_qCKhQ)uIbRgKSy}W3cX=jO%tu>v6mQswKRT&>k zLaS2|L4?tS^fd}z`942q;UUGG8ShTba zl%HA)s+>Xud$}iIHCi3?_4wS05=pp*OmAq_Kk;#x{Qk9$h$EKa1vBB)O2=UYV9?W3 zVMk@L!xXN|l;Cq`Z*2m?A=Nh z-k`k1&?u9JnJQx7s}+OGW!TnlLH*DepN6)c{_$WQRUPEpMSQ}ayg%;Ut)S%7n2YuX ziP-Cy9`({62f;G~;Z^9DA3?g#iJDA1l<93uZFz(ul{mCKhPSar-`Z#`G0Cvw=ci1^ zK2Fl={}7R6iQjXa3}^q&iO>CKV^`}y>!*lk!#vT*nMax=bxXs~xcT6--*a!?YVz48 z4J-ehT&u%x8V5`Hq24^@eYKPP z$*9KKr7p%=6Q0eU>_UgMj82Zq8wIYieGf1Jf z+Cp`nU|lg_w<qXd&+fmiwz?oiK zY%v8=5FI9}5Pwus!GV9w3ltS7s7i-p^MH+*x0n**B{GCJ{-mY%-#9zEm|yIjmk^AN zW}&J@a5$55d!BpIh<8v@u1at^?p~UnqK1FyHTSUr+_wiD8jk9HJXjOtV2g;vg4Dvt zCRKmP%W}WpnWk5nM zO5H|?sG|TV6$fzJkxS-~M~yNXu9*OEQ0Dq%h5y&J`d^uU0|4zjmH7ddKVV;Pi^0t5 z#Fz|EW&YxqYof1DWq#6N!jK(|$WV@|5Lm;se^^Zpw zDY4k!WBz#7yXr{FfaonIa4Qml#7PjPJ(`h33mFX8siZMfw#WzuB7@gDgjir1z>x>5 zOQcHqUp*2qeFq9l|PJ zU7(jqHAw->oyZt-*6$8u;GG4#*VxIuL1~~Y5WD7%W$2PpKg1avlIF+76j@B$c47f| z!iGN5lF8dIh3UF~PU#3}0izMBy`Y2wIX>-(p=8Ybqv}&fu1@+%v}s^3QERtB47en% zx+G^+LFFQ3mhBAqfR*5$nTZv!l$A@;#XLIeFol$!&4o!^-1_C8vggu)I5mMeumNqm z;_J=P%U|ZNk!$CbpFfz}KYpm|+3B3~!f^15u~Y9~6vPQt`Khv>1WOkegLxtLi9sWV z3as>kahZhiH`P2*b$vbc*j&DCPC*o8$tm-+&tNcVeYl^ohaX+M9tQ?|foc`CM%F6e zs3lLE72oDp`pKh7Xw_wg5>xJKS5zRT%KM}q%+8|3Ij<$I<~rwsrI{)%Hhc_f&biD2 zO~2|39y;cwLe;yzRA4?afl!lGUbvyT3In}TyX$6_>aQ2ZpSLsg=#JGxq%~bKoCO^a zq?YIdL%!84jLUKODpsx)qBU&rFED!(J{<^(*?Opb{Nz#KpRkQv#iV=9KggD%kj|~? z>s7(#rV z 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 HwDaEp2o5cR diff --git a/dist/audio/kick2.mp3 b/dist/audio/kick2.mp3 deleted file mode 100644 index 20bc0d9ca50d67da6f447fec7dae819f6c52fec3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20555 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 diff --git a/dist/audio/kick3.mp3 b/dist/audio/kick3.mp3 deleted file mode 100644 index eecfe74d26fda6946ae76a8e5cc37ebf9caceea7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26609 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 diff --git a/dist/audio/rim1.mp3 b/dist/audio/rim1.mp3 deleted file mode 100644 index 1022da1272e72fbb82d4e28a277cc07149015df4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26113 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

b7bfAlr`GZ^ZC^%MDghg_-4Y4PB#Jm|c_W;o} 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 diff --git a/dist/audio/snare2.mp3 b/dist/audio/snare2.mp3 deleted file mode 100644 index 5cd3e44fd7b1a71d27e248eee014961b7fe1ed7e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29323 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 diff --git a/dist/audio/snare3.mp3 b/dist/audio/snare3.mp3 deleted file mode 100644 index be2f489ec203dda686f5e074ec99cb7dc976b646..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 27055 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 ZBtWBr)G_~`w - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/dist/index.html b/dist/index.html deleted file mode 100644 index fc2ff57..0000000 --- a/dist/index.html +++ /dev/null @@ -1,32 +0,0 @@ - - - - - - -

- -
- - - diff --git a/dist/slang.app.js b/dist/slang.app.js deleted file mode 100644 index 2f4f509..0000000 --- a/dist/slang.app.js +++ /dev/null @@ -1,47832 +0,0 @@ -/******/ (function(modules) { // webpackBootstrap -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) { -/******/ return installedModules[moduleId].exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ i: moduleId, -/******/ l: false, -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ -/******/ // Flag the module as loaded -/******/ module.l = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ // expose the modules object (__webpack_modules__) -/******/ __webpack_require__.m = modules; -/******/ -/******/ // expose the module cache -/******/ __webpack_require__.c = installedModules; -/******/ -/******/ // define getter function for harmony exports -/******/ __webpack_require__.d = function(exports, name, getter) { -/******/ if(!__webpack_require__.o(exports, name)) { -/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); -/******/ } -/******/ }; -/******/ -/******/ // define __esModule on exports -/******/ __webpack_require__.r = function(exports) { -/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { -/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); -/******/ } -/******/ Object.defineProperty(exports, '__esModule', { value: true }); -/******/ }; -/******/ -/******/ // create a fake namespace object -/******/ // mode & 1: value is a module id, require it -/******/ // mode & 2: merge all properties of value into the ns -/******/ // mode & 4: return value when already ns object -/******/ // mode & 8|1: behave like require -/******/ __webpack_require__.t = function(value, mode) { -/******/ if(mode & 1) value = __webpack_require__(value); -/******/ if(mode & 8) return value; -/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; -/******/ var ns = Object.create(null); -/******/ __webpack_require__.r(ns); -/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); -/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); -/******/ return ns; -/******/ }; -/******/ -/******/ // getDefaultExport function for compatibility with non-harmony modules -/******/ __webpack_require__.n = function(module) { -/******/ var getter = module && module.__esModule ? -/******/ function getDefault() { return module['default']; } : -/******/ function getModuleExports() { return module; }; -/******/ __webpack_require__.d(getter, 'a', getter); -/******/ return getter; -/******/ }; -/******/ -/******/ // Object.prototype.hasOwnProperty.call -/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; -/******/ -/******/ // __webpack_public_path__ -/******/ __webpack_require__.p = "/"; -/******/ -/******/ -/******/ // Load entry module and return exports -/******/ return __webpack_require__(__webpack_require__.s = "./src/editor.js"); -/******/ }) -/************************************************************************/ -/******/ ({ - -/***/ "./node_modules/adsr-envelope/index.js": -/***/ (function(module, exports, __webpack_require__) { - -module.exports = __webpack_require__("./node_modules/adsr-envelope/lib/index.js"); - - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/ADSREnvelope.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })(); - -var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var _ADSRParams = __webpack_require__("./node_modules/adsr-envelope/lib/ADSRParams.js"); - -var _ADSRParams2 = _interopRequireDefault(_ADSRParams); - -var ADSREnvelope = (function () { - function ADSREnvelope(opts) { - _classCallCheck(this, ADSREnvelope); - - this._ = new _ADSRParams2["default"](opts); - } - - _createClass(ADSREnvelope, [{ - key: "valueAt", - value: function valueAt() { - var time = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; - - return this._.valueAt(time); - } - }, { - key: "applyTo", - value: function applyTo(audioParam, playbackTime) { - this.getWebAudioAPIMethods(playbackTime).forEach(function (_ref) { - var _ref2 = _slicedToArray(_ref, 3); - - var method = _ref2[0]; - var value = _ref2[1]; - var time = _ref2[2]; - - audioParam[method](value, time); - }); - - return this; - } - }, { - key: "getWebAudioAPIMethods", - value: function getWebAudioAPIMethods() { - var playbackTime = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; - - return this._.methods(playbackTime); - } - }, { - key: "clone", - value: function clone() { - return new ADSREnvelope({ - attackTime: this._.attackTime, - decayTime: this._.decayTime, - sustainLevel: this._.sustainLevel, - releaseTime: this._.releaseTime, - gateTime: this._.gateTime, - peakLevel: this._.peakLevel, - epsilon: this._.epsilon, - attackCurve: this._.attackCurve, - decayCurve: this._.decayCurve, - releaseCurve: this._.releaseCurve - }); - } - }, { - key: "duration", - set: function set(value) { - this._.setDuration(value); - }, - get: function get() { - return this._.duration; - } - }, { - key: "attackTime", - set: function set(value) { - this._.setAttackTime(value); - }, - get: function get() { - return this._.attackTime; - } - }, { - key: "decayTime", - set: function set(value) { - this._.setDecayTime(value); - }, - get: function get() { - return this._.decayTime; - } - }, { - key: "sustainTime", - set: function set(value) { - this._.setSustainTime(value); - }, - get: function get() { - return this._.sustainTime; - } - }, { - key: "sustainLevel", - set: function set(value) { - this._.setSustainLevel(value); - }, - get: function get() { - return this._.sustainLevel; - } - }, { - key: "releaseTime", - set: function set(value) { - this._.setReleaseTime(value); - }, - get: function get() { - return this._.releaseTime; - } - }, { - key: "gateTime", - set: function set(value) { - this._.setGateTime(value); - }, - get: function get() { - return this._.gateTime; - } - }, { - key: "peakLevel", - set: function set(value) { - this._.setPeakLevel(value); - }, - get: function get() { - return this._.peakLevel; - } - }, { - key: "epsilon", - set: function set(value) { - this._.setEpsilon(value); - }, - get: function get() { - return this._.epsilon; - } - }, { - key: "attackCurve", - set: function set(value) { - this._.setAttackCurve(value); - }, - get: function get() { - return this._.attackCurve; - } - }, { - key: "decayCurve", - set: function set(value) { - this._.setDecayCurve(value); - }, - get: function get() { - return this._.decayCurve; - } - }, { - key: "releaseCurve", - set: function set(value) { - this._.setReleaseCurve(value); - }, - get: function get() { - return this._.releaseCurve; - } - }]); - - return ADSREnvelope; -})(); - -exports["default"] = ADSREnvelope; -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/ADSRParams.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })(); - -var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var _EnvelopeBuilder = __webpack_require__("./node_modules/adsr-envelope/lib/EnvelopeBuilder.js"); - -var _EnvelopeBuilder2 = _interopRequireDefault(_EnvelopeBuilder); - -var _EnvelopeValue = __webpack_require__("./node_modules/adsr-envelope/lib/EnvelopeValue.js"); - -var _EnvelopeValue2 = _interopRequireDefault(_EnvelopeValue); - -var _defaultValues = __webpack_require__("./node_modules/adsr-envelope/lib/defaultValues.js"); - -var _defaultValues2 = _interopRequireDefault(_defaultValues); - -var _utilsDefaults = __webpack_require__("./node_modules/adsr-envelope/lib/utils/defaults.js"); - -var _utilsDefaults2 = _interopRequireDefault(_utilsDefaults); - -var _utilsConstrain = __webpack_require__("./node_modules/adsr-envelope/lib/utils/constrain.js"); - -var _utilsConstrain2 = _interopRequireDefault(_utilsConstrain); - -var _utilsIsFiniteNumber = __webpack_require__("./node_modules/adsr-envelope/lib/utils/isFiniteNumber.js"); - -var _utilsIsFiniteNumber2 = _interopRequireDefault(_utilsIsFiniteNumber); - -var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); - -var EPSILON = 2.220446049250313e-16; - -var ADSRParams = (function () { - function ADSRParams() { - var opts = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; - - _classCallCheck(this, ADSRParams); - - this.attackTime = time((0, _utilsDefaults2["default"])(opts.attackTime, _defaultValues2["default"].attackTime)); - this.decayTime = time((0, _utilsDefaults2["default"])(opts.decayTime, _defaultValues2["default"].decayTime)); - this.sustainLevel = level((0, _utilsDefaults2["default"])(opts.sustainLevel, _defaultValues2["default"].sustainLevel)); - this.releaseTime = time((0, _utilsDefaults2["default"])(opts.releaseTime, _defaultValues2["default"].releaseTime)); - this.peakLevel = time((0, _utilsDefaults2["default"])(opts.peakLevel, _defaultValues2["default"].peakLevel)); - this.epsilon = epsilon((0, _utilsDefaults2["default"])(opts.epsilon, _defaultValues2["default"].epsilon)); - this.attackCurve = curve((0, _utilsDefaults2["default"])(opts.attackCurve, _defaultValues2["default"].attackCurve)); - this.decayCurve = curve((0, _utilsDefaults2["default"])(opts.decayCurve, _defaultValues2["default"].decayCurve)); - this.releaseCurve = curve((0, _utilsDefaults2["default"])(opts.releaseCurve, _defaultValues2["default"].releaseCurve)); - this.gateTime = _defaultValues2["default"].gateTime; - - if ((0, _utilsIsFiniteNumber2["default"])(opts.sustainTime)) { - this.setSustainTime(opts.sustainTime); - } - if ((0, _utilsIsFiniteNumber2["default"])(opts.gateTime)) { - this.setGateTime(opts.gateTime); - } - if ((0, _utilsIsFiniteNumber2["default"])(opts.duration)) { - this.setDuration(opts.duration); - } - - this.update(); - } - - _createClass(ADSRParams, [{ - key: "valueAt", - value: function valueAt(time) { - return _EnvelopeValue2["default"].at(this.envelope, time); - } - }, { - key: "methods", - value: function methods(playbackTime) { - return this.envelope.map(function (_ref) { - var _ref2 = _slicedToArray(_ref, 3); - - var type = _ref2[0]; - var value = _ref2[1]; - var time = _ref2[2]; - - return [method(type), value, playbackTime + time]; - }); - } - }, { - key: "setDuration", - value: function setDuration(value) { - var duration = time(value); - - this.setGateTime(duration - this.releaseTime); - } - }, { - key: "setAttackTime", - value: function setAttackTime(value) { - this.attackTime = time(value); - this.update(); - } - }, { - key: "setDecayTime", - value: function setDecayTime(value) { - this.decayTime = time(value); - this.update(); - } - }, { - key: "setSustainTime", - value: function setSustainTime(value) { - var sustainTime = time(value); - - this.setGateTime(this.attackTime + this.decayTime + sustainTime); - } - }, { - key: "setSustainLevel", - value: function setSustainLevel(value) { - this.sustainLevel = level(value); - this.update(); - } - }, { - key: "setReleaseTime", - value: function setReleaseTime(value) { - this.releaseTime = time(value); - this.update(); - } - }, { - key: "setGateTime", - value: function setGateTime(value) { - this.gateTime = time(value); - this.update(); - } - }, { - key: "setPeakLevel", - value: function setPeakLevel(value) { - this.peakLevel = time(value); - this.update(); - } - }, { - key: "setEpsilon", - value: function setEpsilon(value) { - this.epsilon = epsilon(value); - this.update(); - } - }, { - key: "setAttackCurve", - value: function setAttackCurve(value) { - this.attackCurve = curve(value); - this.update(); - } - }, { - key: "setDecayCurve", - value: function setDecayCurve(value) { - this.decayCurve = curve(value); - this.update(); - } - }, { - key: "setReleaseCurve", - value: function setReleaseCurve(value) { - this.releaseCurve = curve(value); - this.update(); - } - }, { - key: "update", - value: function update() { - this.sustainTime = Math.max(0, this.gateTime - this.attackTime - this.decayTime); - this.duration = this.gateTime + this.releaseTime; - this.envelope = _EnvelopeBuilder2["default"].build(this); - } - }]); - - return ADSRParams; -})(); - -exports["default"] = ADSRParams; - -function time(value) { - return Math.max(0, value) || 0; -} - -function level(value) { - return (0, _utilsConstrain2["default"])(+value, 0, 1) || 0; -} - -function epsilon(value) { - return (0, _utilsConstrain2["default"])(+value, EPSILON, 1e-2) || 1e-3; -} - -function curve(type) { - return type === "exp" ? "exp" : "lin"; -} - -function method(type) { - switch (type) { - case _constants.SET: - return "setValueAtTime"; - case _constants.LIN: - return "linearRampToValueAtTime"; - case _constants.EXP: - return "exponentialRampToValueAtTime"; - default: - // do nothing - } -} -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/EnvelopeBuilder.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - -var _EnvelopeReducer = __webpack_require__("./node_modules/adsr-envelope/lib/EnvelopeReducer.js"); - -var _EnvelopeReducer2 = _interopRequireDefault(_EnvelopeReducer); - -var _utilsLinlin = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linlin.js"); - -var _utilsLinlin2 = _interopRequireDefault(_utilsLinlin); - -var _utilsLinexp = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linexp.js"); - -var _utilsLinexp2 = _interopRequireDefault(_utilsLinexp); - -var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); - -function build(params) { - var envelope = buildEnvelope(params); - - envelope = _EnvelopeReducer2["default"].reduce(envelope); - - return envelope; -} - -function getCurveItems(curveType, epsilon) { - if (curveType === "exp") { - return { zero: epsilon, calc: _utilsLinexp2["default"], type: _constants.EXP }; - } - return { zero: 0, calc: _utilsLinlin2["default"], type: _constants.LIN }; -} - -function buildEnvelope(params) { - var attackTime = params.attackTime; - var decayTime = params.decayTime; - var gateTime = params.gateTime; - var releaseTime = params.releaseTime; - - var envType = 0; - - envType += 0 < attackTime ? 4 : 0; - envType += 0 < decayTime ? 2 : 0; - envType += 0 < releaseTime ? 1 : 0; - - switch (envType) { - case 0: - return buildSustainEnvelope(params); - case 1: - return buildSustainReleaseEnvelope(params); - case 2: - if (gateTime <= decayTime) { - return buildDecayEnvelope(params); - } - return buildDecaySustainEnvelope(params); - case 3: - if (gateTime <= decayTime) { - return buildDecayReleaseEnvelope(params); - } - return buildDecaySustainReleaseEnvelope(params); - case 4: - if (gateTime <= attackTime) { - return buildAttackEnvelope(params); - } - return buildAttackSustainEnvelope(params); - case 5: - if (gateTime <= attackTime) { - return buildAttackReleaseEnvelope(params); - } - return buildAttackSustainReleaseEnvelope(params); - case 6: - if (gateTime <= attackTime) { - return buildAttackEnvelope(params); - } - if (gateTime <= attackTime + decayTime) { - return buildAttackDecayEnvelope(params); - } - return buildAttackDecaySustainEnvelope(params); - case 7: - if (gateTime <= attackTime) { - return buildAttackReleaseEnvelope(params); - } - if (gateTime <= attackTime + decayTime) { - return buildAttackDecayReleaseEnvelope(params); - } - return buildAttackDecaySustainReleaseEnvelope(params); - default: - // do nothing - } -} - -function buildSustainEnvelope(params) { - // - // - // ----------* - // | - // +--------- - // 0 12 - // - var result = []; - var t0 = 0; - var t1 = params.gateTime; - var t2 = params.gateTime; - var v0 = params.sustainLevel * params.peakLevel; - var v1 = params.sustainLevel * params.peakLevel; - var v2 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([_constants.SET, v1, t1]); - result.push([_constants.SET, v2, t2]); - - return result; -} - -function buildSustainReleaseEnvelope(params) { - // - // - // ----------* - // \ - // +------- - // 0 1 2 - var result = []; - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.gateTime; - var t2 = params.gateTime + params.releaseTime; - var v0 = Math.max(r.zero, params.sustainLevel * params.peakLevel); - var v1 = Math.max(r.zero, params.sustainLevel * params.peakLevel); - var v2 = r.zero; - - result.push([_constants.SET, v0, t0]); - result.push([_constants.SET, v1, t1]); - result.push([r.type, v2, t2]); - - return result; -} - -function buildDecaySustainEnvelope(params) { - // + - // \ - // +-------* - // | - // +--------- - // 0 1 23 - var result = []; - var d = getCurveItems(params.decayCurve, params.epsilon); - var t0 = 0; - var t1 = params.decayTime; - var t2 = params.gateTime; - var t3 = params.gateTime; - var v0 = Math.max(d.zero, params.peakLevel); - var v1 = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v2 = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v3 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([d.type, v1, t1]); - result.push([_constants.SET, v2, t2]); - result.push([_constants.SET, v3, t3]); - - return result; -} - -function buildDecayEnvelope(params) { - // + - // \ - // * - // | - // +----------------- - // 0 12 - var result = []; - var d = getCurveItems(params.decayCurve, params.epsilon); - var t0 = 0; - var t1 = params.gateTime; - var t2 = params.gateTime; - var v0 = Math.max(d.zero, params.peakLevel); - var vx = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v1 = d.calc(t1, 0, params.decayTime, v0, vx); - var v2 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([d.type, v1, t1]); - result.push([_constants.SET, v2, t2]); - - return result; -} - -function buildDecaySustainReleaseEnvelope(params) { - // + - // \ - // +-------* - // \ - // +------- - // 0 1 2 3 - var result = []; - var d = getCurveItems(params.decayCurve, params.epsilon); - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.decayTime; - var t2 = params.gateTime; - var t3 = params.gateTime + params.releaseTime; - var v0 = Math.max(d.zero, r.zero, params.peakLevel); - var v1 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); - var v2 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); - var v3 = r.zero; - - result.push([_constants.SET, v0, t0]); - result.push([d.type, v1, t1]); - result.push([_constants.SET, v2, t2]); - result.push([r.type, v3, t3]); - - return result; -} - -function buildDecayReleaseEnvelope(params) { - // + - // \ - // * - // \ - // +--------------- - // 0 1 2 - var result = []; - var d = getCurveItems(params.decayCurve, params.epsilon); - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.gateTime; - var t2 = params.gateTime + params.releaseTime; - var v0 = Math.max(d.zero, r.zero, params.peakLevel); - var vx = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); - var v1 = d.calc(t1, 0, params.decayTime, v0, vx); - var v2 = Math.max(d.zero, r.zero); - - result.push([_constants.SET, v0, t0]); - result.push([d.type, v1, t1]); - result.push([r.type, v2, t2]); - - return result; -} - -function buildAttackSustainEnvelope(params) { - // + - // /| - // / +-----* - // / | - // + +--------- - // 0 12 34 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var t0 = 0; - var t1 = params.attackTime; - var t2 = params.attackTime; - var t3 = params.gateTime; - var t4 = params.gateTime; - var v0 = a.zero; - var v1 = Math.max(a.zero, params.peakLevel); - var v2 = params.sustainLevel * params.peakLevel; - var v3 = params.sustainLevel * params.peakLevel; - var v4 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([_constants.SET, v2, t2]); - result.push([_constants.SET, v3, t3]); - result.push([_constants.SET, v4, t4]); - - return result; -} - -function buildAttackEnvelope(params) { - // - // - // * - // /| - // + +----------------- - // 0 12 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var t0 = 0; - var t1 = params.gateTime; - var t2 = params.gateTime; - var v0 = a.zero; - var vx = Math.max(a.zero, params.peakLevel); - var v1 = a.calc(t1, 0, params.attackTime, v0, vx); - var v2 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([_constants.SET, v2, t2]); - - return result; -} - -function buildAttackSustainReleaseEnvelope(params) { - // + - // /| - // / +-----* - // / \ - // + +------- - // 0 12 3 4 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.attackTime; - var t2 = params.attackTime; - var t3 = params.gateTime; - var t4 = params.gateTime + params.releaseTime; - var v0 = a.zero; - var v1 = Math.max(a.zero, params.peakLevel); - var v2 = Math.max(r.zero, params.sustainLevel * params.peakLevel); - var v3 = Math.max(r.zero, params.sustainLevel * params.peakLevel); - var v4 = r.zero; - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([_constants.SET, v2, t2]); - result.push([_constants.SET, v3, t3]); - result.push([r.type, v4, t4]); - - return result; -} - -function buildAttackReleaseEnvelope(params) { - // - // - // * - // / \ - // + +--------------- - // 0 1 2 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.gateTime; - var t2 = params.gateTime + params.releaseTime; - var v0 = a.zero; - var vx = Math.max(a.zero, params.peakLevel); - var v1 = a.calc(t1, 0, params.attackTime, v0, vx); - var v2 = r.zero; - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([r.type, v2, t2]); - - return result; -} - -function buildAttackDecaySustainEnvelope(params) { - // + - // / \ - // / +---* - // / | - // + +--------- - // 0 1 2 34 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var d = getCurveItems(params.decayCurve, params.epsilon); - var t0 = 0; - var t1 = params.attackTime; - var t2 = params.attackTime + params.decayTime; - var t3 = params.gateTime; - var t4 = params.gateTime; - var v0 = a.zero; - var v1 = Math.max(a.zero, d.zero, params.peakLevel); - var v2 = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v3 = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v4 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([d.type, v2, t2]); - result.push([_constants.SET, v3, t3]); - result.push([_constants.SET, v4, t4]); - - return result; -} - -function buildAttackDecayEnvelope(params) { - // + - // / \ - // / * - // / | - // + +------------- - // 0 1 23 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var d = getCurveItems(params.decayCurve, params.epsilon); - var t0 = 0; - var t1 = params.attackTime; - var t2 = params.gateTime; - var t3 = params.gateTime; - var v0 = a.zero; - var v1 = Math.max(a.zero, d.zero, params.peakLevel); - var vx = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v2 = d.calc(t2, params.attackTime, params.attackTime + params.decayTime, v1, vx); - var v3 = 0; - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([d.type, v2, t2]); - result.push([_constants.SET, v3, t3]); - - return result; -} - -function buildAttackDecaySustainReleaseEnvelope(params) { - // + - // / \ - // / +---* - // / \ - // + +------- - // 0 1 2 3 4 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var d = getCurveItems(params.decayCurve, params.epsilon); - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.attackTime; - var t2 = params.attackTime + params.decayTime; - var t3 = params.gateTime; - var t4 = params.gateTime + params.releaseTime; - var v0 = a.zero; - var v1 = Math.max(a.zero, d.zero, params.peakLevel); - var v2 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); - var v3 = Math.max(d.zero, r.zero, params.sustainLevel * params.peakLevel); - var v4 = Math.max(d.zero, r.zero); - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([d.type, v2, t2]); - result.push([_constants.SET, v3, t3]); - result.push([r.type, v4, t4]); - - return result; -} - -function buildAttackDecayReleaseEnvelope(params) { - // + - // / \ - // / * - // / \ - // + +----------- - // 0 1 2 3 - var result = []; - var a = getCurveItems(params.attackCurve, params.epsilon); - var d = getCurveItems(params.decayCurve, params.epsilon); - var r = getCurveItems(params.releaseCurve, params.epsilon); - var t0 = 0; - var t1 = params.attackTime; - var t2 = params.gateTime; - var t3 = params.gateTime + params.releaseTime; - var v0 = a.zero; - var v1 = Math.max(a.zero, d.zero, params.peakLevel); - var vx = Math.max(d.zero, params.sustainLevel * params.peakLevel); - var v2 = d.calc(t2, params.attackTime, params.attackTime + params.decayTime, v1, vx); - var v3 = Math.max(d.zero, r.zero); - - result.push([_constants.SET, v0, t0]); - result.push([a.type, v1, t1]); - result.push([d.type, v2, t2]); - result.push([r.type, v3, t3]); - - return result; -} - -exports["default"] = { build: build }; -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/EnvelopeReducer.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); - -function reduce(envelope) { - envelope = envelope.filter(function (items) { - return isFinite(items[_constants.TIME]); - }); - - var changed = undefined; - - do { - changed = false; - - if (2 <= envelope.length) { - var a = envelope[envelope.length - 2]; - var b = envelope[envelope.length - 1]; - - if (a[_constants.VALUE] === b[_constants.VALUE]) { - envelope.pop(); - } - } - - for (var i = envelope.length - 2; i >= 0; i--) { - var a = envelope[i]; - var b = envelope[i + 1]; - - if (a[_constants.TYPE] === _constants.SET) { - if (b[_constants.TYPE] !== _constants.SET) { - if (a[_constants.VALUE] === b[_constants.VALUE] || a[_constants.TIME] === b[_constants.TIME]) { - b[_constants.TYPE] = _constants.SET; - changed = true; - } - } else if (a[_constants.TIME] === b[_constants.TIME]) { - envelope.splice(i, 1); - changed = true; - } - } - } - } while (changed && envelope.length); - - return envelope; -} - -exports["default"] = { reduce: reduce }; -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/EnvelopeValue.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - -var _utilsLinlin = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linlin.js"); - -var _utilsLinlin2 = _interopRequireDefault(_utilsLinlin); - -var _utilsLinexp = __webpack_require__("./node_modules/adsr-envelope/lib/utils/linexp.js"); - -var _utilsLinexp2 = _interopRequireDefault(_utilsLinexp); - -var _constants = __webpack_require__("./node_modules/adsr-envelope/lib/constants.js"); - -function at(envelope, time) { - for (var i = 0, imax = envelope.length - 1; i < imax; i++) { - var e0 = envelope[i]; - var e1 = envelope[i + 1]; - - if (e0[_constants.TIME] <= time && time < e1[_constants.TIME]) { - switch (e1[_constants.TYPE]) { - case _constants.LIN: - return (0, _utilsLinlin2["default"])(time, e0[_constants.TIME], e1[_constants.TIME], e0[_constants.VALUE], e1[_constants.VALUE]); - case _constants.EXP: - return (0, _utilsLinexp2["default"])(time, e0[_constants.TIME], e1[_constants.TIME], e0[_constants.VALUE], e1[_constants.VALUE]); - default: - return e0[_constants.VALUE]; - } - } - } - - return envelope.length ? envelope[envelope.length - 1][_constants.VALUE] : 0; -} - -exports["default"] = { at: at }; -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/constants.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -var SET = 0; -exports.SET = SET; -var LIN = 1; -exports.LIN = LIN; -var EXP = 2; - -exports.EXP = EXP; -var TYPE = 0; -exports.TYPE = TYPE; -var VALUE = 1; -exports.VALUE = VALUE; -var TIME = 2; -exports.TIME = TIME; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/defaultValues.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports["default"] = { - attackTime: 0.01, - decayTime: 0.3, - sustainLevel: 0.5, - releaseTime: 1, - gateTime: Infinity, - peakLevel: 1, - epsilon: 1e-3, - attackCurve: "lin", - decayCurve: "lin", - releaseCurve: "lin" -}; -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/index.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } - -var _ADSREnvelope = __webpack_require__("./node_modules/adsr-envelope/lib/ADSREnvelope.js"); - -var _ADSREnvelope2 = _interopRequireDefault(_ADSREnvelope); - -exports["default"] = _ADSREnvelope2["default"]; -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/utils/constrain.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports["default"] = constrain; - -function constrain(value, minValue, maxValue) { - return Math.max(minValue, Math.min(value, maxValue)); -} - -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/utils/defaults.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports["default"] = defaults; - -function defaults(value, defaultValue) { - return typeof value !== "undefined" ? value : defaultValue; -} - -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/utils/isFiniteNumber.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports["default"] = isFiniteNumber; - -function isFiniteNumber(value) { - return typeof value === "number" && isFinite(value); -} - -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/utils/linexp.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports["default"] = linexp; - -function linexp(value, inMin, inMax, outMin, outMax) { - return Math.pow(outMax / outMin, (value - inMin) / (inMax - inMin)) * outMin; -} - -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/adsr-envelope/lib/utils/linlin.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports["default"] = linlin; - -function linlin(value, inMin, inMax, outMin, outMax) { - return (value - inMin) / (inMax - inMin) * (outMax - outMin) + outMin; -} - -module.exports = exports["default"]; - -/***/ }), - -/***/ "./node_modules/base-audio-context/index.js": -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(global) {var AudioContext = global.AudioContext || global.webkitAudioContext; -var OfflineAudioContext = global.OfflineAudioContext || global.webkitOfflineAudioContext; -var BaseAudioContext = global.BaseAudioContext || (OfflineAudioContext && Object.getPrototypeOf(OfflineAudioContext)); - -module.exports = (typeof BaseAudioContext === "function" && BaseAudioContext.prototype) ? BaseAudioContext : AudioContext; - -/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/global.js"))) - -/***/ }), - -/***/ "./node_modules/codemirror/addon/mode/simple.js": -/***/ (function(module, exports, __webpack_require__) { - -// CodeMirror, copyright (c) by Marijn Haverbeke and others -// Distributed under an MIT license: http://codemirror.net/LICENSE - -(function(mod) { - if (true) // CommonJS - mod(__webpack_require__("./node_modules/codemirror/lib/codemirror.js")); - else {} -})(function(CodeMirror) { - "use strict"; - - CodeMirror.defineSimpleMode = function(name, states) { - CodeMirror.defineMode(name, function(config) { - return CodeMirror.simpleMode(config, states); - }); - }; - - CodeMirror.simpleMode = function(config, states) { - ensureState(states, "start"); - var states_ = {}, meta = states.meta || {}, hasIndentation = false; - for (var state in states) if (state != meta && states.hasOwnProperty(state)) { - var list = states_[state] = [], orig = states[state]; - for (var i = 0; i < orig.length; i++) { - var data = orig[i]; - list.push(new Rule(data, states)); - if (data.indent || data.dedent) hasIndentation = true; - } - } - var mode = { - startState: function() { - return {state: "start", pending: null, - local: null, localState: null, - indent: hasIndentation ? [] : null}; - }, - copyState: function(state) { - var s = {state: state.state, pending: state.pending, - local: state.local, localState: null, - indent: state.indent && state.indent.slice(0)}; - if (state.localState) - s.localState = CodeMirror.copyState(state.local.mode, state.localState); - if (state.stack) - s.stack = state.stack.slice(0); - for (var pers = state.persistentStates; pers; pers = pers.next) - s.persistentStates = {mode: pers.mode, - spec: pers.spec, - state: pers.state == state.localState ? s.localState : CodeMirror.copyState(pers.mode, pers.state), - next: s.persistentStates}; - return s; - }, - token: tokenFunction(states_, config), - innerMode: function(state) { return state.local && {mode: state.local.mode, state: state.localState}; }, - indent: indentFunction(states_, meta) - }; - if (meta) for (var prop in meta) if (meta.hasOwnProperty(prop)) - mode[prop] = meta[prop]; - return mode; - }; - - function ensureState(states, name) { - if (!states.hasOwnProperty(name)) - throw new Error("Undefined state " + name + " in simple mode"); - } - - function toRegex(val, caret) { - if (!val) return /(?:)/; - var flags = ""; - if (val instanceof RegExp) { - if (val.ignoreCase) flags = "i"; - val = val.source; - } else { - val = String(val); - } - return new RegExp((caret === false ? "" : "^") + "(?:" + val + ")", flags); - } - - function asToken(val) { - if (!val) return null; - if (val.apply) return val - if (typeof val == "string") return val.replace(/\./g, " "); - var result = []; - for (var i = 0; i < val.length; i++) - result.push(val[i] && val[i].replace(/\./g, " ")); - return result; - } - - function Rule(data, states) { - if (data.next || data.push) ensureState(states, data.next || data.push); - this.regex = toRegex(data.regex); - this.token = asToken(data.token); - this.data = data; - } - - function tokenFunction(states, config) { - return function(stream, state) { - if (state.pending) { - var pend = state.pending.shift(); - if (state.pending.length == 0) state.pending = null; - stream.pos += pend.text.length; - return pend.token; - } - - if (state.local) { - if (state.local.end && stream.match(state.local.end)) { - var tok = state.local.endToken || null; - state.local = state.localState = null; - return tok; - } else { - var tok = state.local.mode.token(stream, state.localState), m; - if (state.local.endScan && (m = state.local.endScan.exec(stream.current()))) - stream.pos = stream.start + m.index; - return tok; - } - } - - var curState = states[state.state]; - for (var i = 0; i < curState.length; i++) { - var rule = curState[i]; - var matches = (!rule.data.sol || stream.sol()) && stream.match(rule.regex); - if (matches) { - if (rule.data.next) { - state.state = rule.data.next; - } else if (rule.data.push) { - (state.stack || (state.stack = [])).push(state.state); - state.state = rule.data.push; - } else if (rule.data.pop && state.stack && state.stack.length) { - state.state = state.stack.pop(); - } - - if (rule.data.mode) - enterLocalMode(config, state, rule.data.mode, rule.token); - if (rule.data.indent) - state.indent.push(stream.indentation() + config.indentUnit); - if (rule.data.dedent) - state.indent.pop(); - var token = rule.token - if (token && token.apply) token = token(matches) - if (matches.length > 2 && rule.token && typeof rule.token != "string") { - state.pending = []; - for (var j = 2; j < matches.length; j++) - if (matches[j]) - state.pending.push({text: matches[j], token: rule.token[j - 1]}); - stream.backUp(matches[0].length - (matches[1] ? matches[1].length : 0)); - return token[0]; - } else if (token && token.join) { - return token[0]; - } else { - return token; - } - } - } - stream.next(); - return null; - }; - } - - function cmp(a, b) { - if (a === b) return true; - if (!a || typeof a != "object" || !b || typeof b != "object") return false; - var props = 0; - for (var prop in a) if (a.hasOwnProperty(prop)) { - if (!b.hasOwnProperty(prop) || !cmp(a[prop], b[prop])) return false; - props++; - } - for (var prop in b) if (b.hasOwnProperty(prop)) props--; - return props == 0; - } - - function enterLocalMode(config, state, spec, token) { - var pers; - if (spec.persistent) for (var p = state.persistentStates; p && !pers; p = p.next) - if (spec.spec ? cmp(spec.spec, p.spec) : spec.mode == p.mode) pers = p; - var mode = pers ? pers.mode : spec.mode || CodeMirror.getMode(config, spec.spec); - var lState = pers ? pers.state : CodeMirror.startState(mode); - if (spec.persistent && !pers) - state.persistentStates = {mode: mode, spec: spec.spec, state: lState, next: state.persistentStates}; - - state.localState = lState; - state.local = {mode: mode, - end: spec.end && toRegex(spec.end), - endScan: spec.end && spec.forceEnd !== false && toRegex(spec.end, false), - endToken: token && token.join ? token[token.length - 1] : token}; - } - - function indexOf(val, arr) { - for (var i = 0; i < arr.length; i++) if (arr[i] === val) return true; - } - - function indentFunction(states, meta) { - return function(state, textAfter, line) { - if (state.local && state.local.mode.indent) - return state.local.mode.indent(state.localState, textAfter, line); - if (state.indent == null || state.local || meta.dontIndentStates && indexOf(state.state, meta.dontIndentStates) > -1) - return CodeMirror.Pass; - - var pos = state.indent.length - 1, rules = states[state.state]; - scan: for (;;) { - for (var i = 0; i < rules.length; i++) { - var rule = rules[i]; - if (rule.data.dedent && rule.data.dedentIfLineStart !== false) { - var m = rule.regex.exec(textAfter); - if (m && m[0]) { - pos--; - if (rule.next || rule.push) rules = states[rule.next || rule.push]; - textAfter = textAfter.slice(m[0].length); - continue scan; - } - } - } - break; - } - return pos < 0 ? 0 : state.indent[pos]; - }; - } -}); - - -/***/ }), - -/***/ "./node_modules/codemirror/lib/codemirror.css": -/***/ (function(module, exports, __webpack_require__) { - -// extracted by mini-css-extract-plugin - -/***/ }), - -/***/ "./node_modules/codemirror/lib/codemirror.js": -/***/ (function(module, exports, __webpack_require__) { - -// CodeMirror, copyright (c) by Marijn Haverbeke and others -// Distributed under an MIT license: http://codemirror.net/LICENSE - -// This is CodeMirror (http://codemirror.net), a code editor -// implemented in JavaScript on top of the browser's DOM. -// -// You can find some technical background for some of the code below -// at http://marijnhaverbeke.nl/blog/#cm-internals . - -(function (global, factory) { - true ? module.exports = factory() : - undefined; -}(this, (function () { 'use strict'; - -// Kludges for bugs and behavior differences that can't be feature -// detected are enabled based on userAgent etc sniffing. -var userAgent = navigator.userAgent; -var platform = navigator.platform; - -var gecko = /gecko\/\d/i.test(userAgent); -var ie_upto10 = /MSIE \d/.test(userAgent); -var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent); -var edge = /Edge\/(\d+)/.exec(userAgent); -var ie = ie_upto10 || ie_11up || edge; -var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]); -var webkit = !edge && /WebKit\//.test(userAgent); -var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent); -var chrome = !edge && /Chrome\//.test(userAgent); -var presto = /Opera\//.test(userAgent); -var safari = /Apple Computer/.test(navigator.vendor); -var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent); -var phantom = /PhantomJS/.test(userAgent); - -var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent); -var android = /Android/.test(userAgent); -// This is woefully incomplete. Suggestions for alternative methods welcome. -var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent); -var mac = ios || /Mac/.test(platform); -var chromeOS = /\bCrOS\b/.test(userAgent); -var windows = /win/i.test(platform); - -var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/); -if (presto_version) { presto_version = Number(presto_version[1]); } -if (presto_version && presto_version >= 15) { presto = false; webkit = true; } -// Some browsers use the wrong event properties to signal cmd/ctrl on OS X -var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11)); -var captureRightClick = gecko || (ie && ie_version >= 9); - -function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") } - -var rmClass = function(node, cls) { - var current = node.className; - var match = classTest(cls).exec(current); - if (match) { - var after = current.slice(match.index + match[0].length); - node.className = current.slice(0, match.index) + (after ? match[1] + after : ""); - } -}; - -function removeChildren(e) { - for (var count = e.childNodes.length; count > 0; --count) - { e.removeChild(e.firstChild); } - return e -} - -function removeChildrenAndAdd(parent, e) { - return removeChildren(parent).appendChild(e) -} - -function elt(tag, content, className, style) { - var e = document.createElement(tag); - if (className) { e.className = className; } - if (style) { e.style.cssText = style; } - if (typeof content == "string") { e.appendChild(document.createTextNode(content)); } - else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]); } } - return e -} -// wrapper for elt, which removes the elt from the accessibility tree -function eltP(tag, content, className, style) { - var e = elt(tag, content, className, style); - e.setAttribute("role", "presentation"); - return e -} - -var range; -if (document.createRange) { range = function(node, start, end, endNode) { - var r = document.createRange(); - r.setEnd(endNode || node, end); - r.setStart(node, start); - return r -}; } -else { range = function(node, start, end) { - var r = document.body.createTextRange(); - try { r.moveToElementText(node.parentNode); } - catch(e) { return r } - r.collapse(true); - r.moveEnd("character", end); - r.moveStart("character", start); - return r -}; } - -function contains(parent, child) { - if (child.nodeType == 3) // Android browser always returns false when child is a textnode - { child = child.parentNode; } - if (parent.contains) - { return parent.contains(child) } - do { - if (child.nodeType == 11) { child = child.host; } - if (child == parent) { return true } - } while (child = child.parentNode) -} - -function activeElt() { - // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement. - // IE < 10 will throw when accessed while the page is loading or in an iframe. - // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable. - var activeElement; - try { - activeElement = document.activeElement; - } catch(e) { - activeElement = document.body || null; - } - while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement) - { activeElement = activeElement.shadowRoot.activeElement; } - return activeElement -} - -function addClass(node, cls) { - var current = node.className; - if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls; } -} -function joinClasses(a, b) { - var as = a.split(" "); - for (var i = 0; i < as.length; i++) - { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i]; } } - return b -} - -var selectInput = function(node) { node.select(); }; -if (ios) // Mobile Safari apparently has a bug where select() is broken. - { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; }; } -else if (ie) // Suppress mysterious IE10 errors - { selectInput = function(node) { try { node.select(); } catch(_e) {} }; } - -function bind(f) { - var args = Array.prototype.slice.call(arguments, 1); - return function(){return f.apply(null, args)} -} - -function copyObj(obj, target, overwrite) { - if (!target) { target = {}; } - for (var prop in obj) - { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop))) - { target[prop] = obj[prop]; } } - return target -} - -// Counts the column offset in a string, taking tabs into account. -// Used mostly to find indentation. -function countColumn(string, end, tabSize, startIndex, startValue) { - if (end == null) { - end = string.search(/[^\s\u00a0]/); - if (end == -1) { end = string.length; } - } - for (var i = startIndex || 0, n = startValue || 0;;) { - var nextTab = string.indexOf("\t", i); - if (nextTab < 0 || nextTab >= end) - { return n + (end - i) } - n += nextTab - i; - n += tabSize - (n % tabSize); - i = nextTab + 1; - } -} - -var Delayed = function() {this.id = null;}; -Delayed.prototype.set = function (ms, f) { - clearTimeout(this.id); - this.id = setTimeout(f, ms); -}; - -function indexOf(array, elt) { - for (var i = 0; i < array.length; ++i) - { if (array[i] == elt) { return i } } - return -1 -} - -// Number of pixels added to scroller and sizer to hide scrollbar -var scrollerGap = 30; - -// Returned or thrown by various protocols to signal 'I'm not -// handling this'. -var Pass = {toString: function(){return "CodeMirror.Pass"}}; - -// Reused option objects for setSelection & friends -var sel_dontScroll = {scroll: false}; -var sel_mouse = {origin: "*mouse"}; -var sel_move = {origin: "+move"}; - -// The inverse of countColumn -- find the offset that corresponds to -// a particular column. -function findColumn(string, goal, tabSize) { - for (var pos = 0, col = 0;;) { - var nextTab = string.indexOf("\t", pos); - if (nextTab == -1) { nextTab = string.length; } - var skipped = nextTab - pos; - if (nextTab == string.length || col + skipped >= goal) - { return pos + Math.min(skipped, goal - col) } - col += nextTab - pos; - col += tabSize - (col % tabSize); - pos = nextTab + 1; - if (col >= goal) { return pos } - } -} - -var spaceStrs = [""]; -function spaceStr(n) { - while (spaceStrs.length <= n) - { spaceStrs.push(lst(spaceStrs) + " "); } - return spaceStrs[n] -} - -function lst(arr) { return arr[arr.length-1] } - -function map(array, f) { - var out = []; - for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i); } - return out -} - -function insertSorted(array, value, score) { - var pos = 0, priority = score(value); - while (pos < array.length && score(array[pos]) <= priority) { pos++; } - array.splice(pos, 0, value); -} - -function nothing() {} - -function createObj(base, props) { - var inst; - if (Object.create) { - inst = Object.create(base); - } else { - nothing.prototype = base; - inst = new nothing(); - } - if (props) { copyObj(props, inst); } - return inst -} - -var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/; -function isWordCharBasic(ch) { - return /\w/.test(ch) || ch > "\x80" && - (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch)) -} -function isWordChar(ch, helper) { - if (!helper) { return isWordCharBasic(ch) } - if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true } - return helper.test(ch) -} - -function isEmpty(obj) { - for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } } - return true -} - -// Extending unicode characters. A series of a non-extending char + -// any number of extending chars is treated as a single unit as far -// as editing and measuring is concerned. This is not fully correct, -// since some scripts/fonts/browsers also treat other configurations -// of code points as a group. -var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/; -function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) } - -// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range. -function skipExtendingChars(str, pos, dir) { - while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir; } - return pos -} - -// Returns the value from the range [`from`; `to`] that satisfies -// `pred` and is closest to `from`. Assumes that at least `to` -// satisfies `pred`. Supports `from` being greater than `to`. -function findFirst(pred, from, to) { - // At any point we are certain `to` satisfies `pred`, don't know - // whether `from` does. - var dir = from > to ? -1 : 1; - for (;;) { - if (from == to) { return from } - var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF); - if (mid == from) { return pred(mid) ? from : to } - if (pred(mid)) { to = mid; } - else { from = mid + dir; } - } -} - -// The display handles the DOM integration, both for input reading -// and content drawing. It holds references to DOM nodes and -// display-related state. - -function Display(place, doc, input) { - var d = this; - this.input = input; - - // Covers bottom-right square when both scrollbars are present. - d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler"); - d.scrollbarFiller.setAttribute("cm-not-content", "true"); - // Covers bottom of gutter when coverGutterNextToScrollbar is on - // and h scrollbar is present. - d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler"); - d.gutterFiller.setAttribute("cm-not-content", "true"); - // Will contain the actual code, positioned to cover the viewport. - d.lineDiv = eltP("div", null, "CodeMirror-code"); - // Elements are added to these to represent selection and cursors. - d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1"); - d.cursorDiv = elt("div", null, "CodeMirror-cursors"); - // A visibility: hidden element used to find the size of things. - d.measure = elt("div", null, "CodeMirror-measure"); - // When lines outside of the viewport are measured, they are drawn in this. - d.lineMeasure = elt("div", null, "CodeMirror-measure"); - // Wraps everything that needs to exist inside the vertically-padded coordinate system - d.lineSpace = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv], - null, "position: relative; outline: none"); - var lines = eltP("div", [d.lineSpace], "CodeMirror-lines"); - // Moved around its parent to cover visible view. - d.mover = elt("div", [lines], null, "position: relative"); - // Set to the height of the document, allowing scrolling. - d.sizer = elt("div", [d.mover], "CodeMirror-sizer"); - d.sizerWidth = null; - // Behavior of elts with overflow: auto and padding is - // inconsistent across browsers. This is used to ensure the - // scrollable area is big enough. - d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;"); - // Will contain the gutters, if any. - d.gutters = elt("div", null, "CodeMirror-gutters"); - d.lineGutter = null; - // Actual scrollable element. - d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll"); - d.scroller.setAttribute("tabIndex", "-1"); - // The element in which the editor lives. - d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror"); - - // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported) - if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; } - if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true; } - - if (place) { - if (place.appendChild) { place.appendChild(d.wrapper); } - else { place(d.wrapper); } - } - - // Current rendered range (may be bigger than the view window). - d.viewFrom = d.viewTo = doc.first; - d.reportedViewFrom = d.reportedViewTo = doc.first; - // Information about the rendered lines. - d.view = []; - d.renderedView = null; - // Holds info about a single rendered line when it was rendered - // for measurement, while not in view. - d.externalMeasured = null; - // Empty space (in pixels) above the view - d.viewOffset = 0; - d.lastWrapHeight = d.lastWrapWidth = 0; - d.updateLineNumbers = null; - - d.nativeBarWidth = d.barHeight = d.barWidth = 0; - d.scrollbarsClipped = false; - - // Used to only resize the line number gutter when necessary (when - // the amount of lines crosses a boundary that makes its width change) - d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null; - // Set to true when a non-horizontal-scrolling line widget is - // added. As an optimization, line widget aligning is skipped when - // this is false. - d.alignWidgets = false; - - d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null; - - // Tracks the maximum line length so that the horizontal scrollbar - // can be kept static when scrolling. - d.maxLine = null; - d.maxLineLength = 0; - d.maxLineChanged = false; - - // Used for measuring wheel scrolling granularity - d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null; - - // True when shift is held down. - d.shift = false; - - // Used to track whether anything happened since the context menu - // was opened. - d.selForContextMenu = null; - - d.activeTouch = null; - - input.init(d); -} - -// Find the line object corresponding to the given line number. -function getLine(doc, n) { - n -= doc.first; - if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") } - var chunk = doc; - while (!chunk.lines) { - for (var i = 0;; ++i) { - var child = chunk.children[i], sz = child.chunkSize(); - if (n < sz) { chunk = child; break } - n -= sz; - } - } - return chunk.lines[n] -} - -// Get the part of a document between two positions, as an array of -// strings. -function getBetween(doc, start, end) { - var out = [], n = start.line; - doc.iter(start.line, end.line + 1, function (line) { - var text = line.text; - if (n == end.line) { text = text.slice(0, end.ch); } - if (n == start.line) { text = text.slice(start.ch); } - out.push(text); - ++n; - }); - return out -} -// Get the lines between from and to, as array of strings. -function getLines(doc, from, to) { - var out = []; - doc.iter(from, to, function (line) { out.push(line.text); }); // iter aborts when callback returns truthy value - return out -} - -// Update the height of a line, propagating the height change -// upwards to parent nodes. -function updateLineHeight(line, height) { - var diff = height - line.height; - if (diff) { for (var n = line; n; n = n.parent) { n.height += diff; } } -} - -// Given a line object, find its line number by walking up through -// its parent links. -function lineNo(line) { - if (line.parent == null) { return null } - var cur = line.parent, no = indexOf(cur.lines, line); - for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) { - for (var i = 0;; ++i) { - if (chunk.children[i] == cur) { break } - no += chunk.children[i].chunkSize(); - } - } - return no + cur.first -} - -// Find the line at the given vertical position, using the height -// information in the document tree. -function lineAtHeight(chunk, h) { - var n = chunk.first; - outer: do { - for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) { - var child = chunk.children[i$1], ch = child.height; - if (h < ch) { chunk = child; continue outer } - h -= ch; - n += child.chunkSize(); - } - return n - } while (!chunk.lines) - var i = 0; - for (; i < chunk.lines.length; ++i) { - var line = chunk.lines[i], lh = line.height; - if (h < lh) { break } - h -= lh; - } - return n + i -} - -function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size} - -function lineNumberFor(options, i) { - return String(options.lineNumberFormatter(i + options.firstLineNumber)) -} - -// A Pos instance represents a position within the text. -function Pos(line, ch, sticky) { - if ( sticky === void 0 ) sticky = null; - - if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) } - this.line = line; - this.ch = ch; - this.sticky = sticky; -} - -// Compare two positions, return 0 if they are the same, a negative -// number when a is less, and a positive number otherwise. -function cmp(a, b) { return a.line - b.line || a.ch - b.ch } - -function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 } - -function copyPos(x) {return Pos(x.line, x.ch)} -function maxPos(a, b) { return cmp(a, b) < 0 ? b : a } -function minPos(a, b) { return cmp(a, b) < 0 ? a : b } - -// Most of the external API clips given positions to make sure they -// actually exist within the document. -function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))} -function clipPos(doc, pos) { - if (pos.line < doc.first) { return Pos(doc.first, 0) } - var last = doc.first + doc.size - 1; - if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) } - return clipToLen(pos, getLine(doc, pos.line).text.length) -} -function clipToLen(pos, linelen) { - var ch = pos.ch; - if (ch == null || ch > linelen) { return Pos(pos.line, linelen) } - else if (ch < 0) { return Pos(pos.line, 0) } - else { return pos } -} -function clipPosArray(doc, array) { - var out = []; - for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]); } - return out -} - -// Optimize some code when these features are not used. -var sawReadOnlySpans = false; -var sawCollapsedSpans = false; - -function seeReadOnlySpans() { - sawReadOnlySpans = true; -} - -function seeCollapsedSpans() { - sawCollapsedSpans = true; -} - -// TEXTMARKER SPANS - -function MarkedSpan(marker, from, to) { - this.marker = marker; - this.from = from; this.to = to; -} - -// Search an array of spans for a span matching the given marker. -function getMarkedSpanFor(spans, marker) { - if (spans) { for (var i = 0; i < spans.length; ++i) { - var span = spans[i]; - if (span.marker == marker) { return span } - } } -} -// Remove a span from an array, returning undefined if no spans are -// left (we don't store arrays for lines without spans). -function removeMarkedSpan(spans, span) { - var r; - for (var i = 0; i < spans.length; ++i) - { if (spans[i] != span) { (r || (r = [])).push(spans[i]); } } - return r -} -// Add a span to a line. -function addMarkedSpan(line, span) { - line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]; - span.marker.attachLine(line); -} - -// Used for the algorithm that adjusts markers for a change in the -// document. These functions cut an array of spans at a given -// character position, returning an array of remaining chunks (or -// undefined if nothing remains). -function markedSpansBefore(old, startCh, isInsert) { - var nw; - if (old) { for (var i = 0; i < old.length; ++i) { - var span = old[i], marker = span.marker; - var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh); - if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) { - var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh);(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to)); - } - } } - return nw -} -function markedSpansAfter(old, endCh, isInsert) { - var nw; - if (old) { for (var i = 0; i < old.length; ++i) { - var span = old[i], marker = span.marker; - var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh); - if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) { - var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh, - span.to == null ? null : span.to - endCh)); - } - } } - return nw -} - -// Given a change object, compute the new set of marker spans that -// cover the line in which the change took place. Removes spans -// entirely within the change, reconnects spans belonging to the -// same marker that appear on both sides of the change, and cuts off -// spans partially within the change. Returns an array of span -// arrays with one element for each line in (after) the change. -function stretchSpansOverChange(doc, change) { - if (change.full) { return null } - var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans; - var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans; - if (!oldFirst && !oldLast) { return null } - - var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0; - // Get the spans that 'stick out' on both sides - var first = markedSpansBefore(oldFirst, startCh, isInsert); - var last = markedSpansAfter(oldLast, endCh, isInsert); - - // Next, merge those two ends - var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0); - if (first) { - // Fix up .to properties of first - for (var i = 0; i < first.length; ++i) { - var span = first[i]; - if (span.to == null) { - var found = getMarkedSpanFor(last, span.marker); - if (!found) { span.to = startCh; } - else if (sameLine) { span.to = found.to == null ? null : found.to + offset; } - } - } - } - if (last) { - // Fix up .from in last (or move them into first in case of sameLine) - for (var i$1 = 0; i$1 < last.length; ++i$1) { - var span$1 = last[i$1]; - if (span$1.to != null) { span$1.to += offset; } - if (span$1.from == null) { - var found$1 = getMarkedSpanFor(first, span$1.marker); - if (!found$1) { - span$1.from = offset; - if (sameLine) { (first || (first = [])).push(span$1); } - } - } else { - span$1.from += offset; - if (sameLine) { (first || (first = [])).push(span$1); } - } - } - } - // Make sure we didn't create any zero-length spans - if (first) { first = clearEmptySpans(first); } - if (last && last != first) { last = clearEmptySpans(last); } - - var newMarkers = [first]; - if (!sameLine) { - // Fill gap with whole-line-spans - var gap = change.text.length - 2, gapMarkers; - if (gap > 0 && first) - { for (var i$2 = 0; i$2 < first.length; ++i$2) - { if (first[i$2].to == null) - { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)); } } } - for (var i$3 = 0; i$3 < gap; ++i$3) - { newMarkers.push(gapMarkers); } - newMarkers.push(last); - } - return newMarkers -} - -// Remove spans that are empty and don't have a clearWhenEmpty -// option of false. -function clearEmptySpans(spans) { - for (var i = 0; i < spans.length; ++i) { - var span = spans[i]; - if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false) - { spans.splice(i--, 1); } - } - if (!spans.length) { return null } - return spans -} - -// Used to 'clip' out readOnly ranges when making a change. -function removeReadOnlyRanges(doc, from, to) { - var markers = null; - doc.iter(from.line, to.line + 1, function (line) { - if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) { - var mark = line.markedSpans[i].marker; - if (mark.readOnly && (!markers || indexOf(markers, mark) == -1)) - { (markers || (markers = [])).push(mark); } - } } - }); - if (!markers) { return null } - var parts = [{from: from, to: to}]; - for (var i = 0; i < markers.length; ++i) { - var mk = markers[i], m = mk.find(0); - for (var j = 0; j < parts.length; ++j) { - var p = parts[j]; - if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue } - var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to); - if (dfrom < 0 || !mk.inclusiveLeft && !dfrom) - { newParts.push({from: p.from, to: m.from}); } - if (dto > 0 || !mk.inclusiveRight && !dto) - { newParts.push({from: m.to, to: p.to}); } - parts.splice.apply(parts, newParts); - j += newParts.length - 3; - } - } - return parts -} - -// Connect or disconnect spans from a line. -function detachMarkedSpans(line) { - var spans = line.markedSpans; - if (!spans) { return } - for (var i = 0; i < spans.length; ++i) - { spans[i].marker.detachLine(line); } - line.markedSpans = null; -} -function attachMarkedSpans(line, spans) { - if (!spans) { return } - for (var i = 0; i < spans.length; ++i) - { spans[i].marker.attachLine(line); } - line.markedSpans = spans; -} - -// Helpers used when computing which overlapping collapsed span -// counts as the larger one. -function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 } -function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 } - -// Returns a number indicating which of two overlapping collapsed -// spans is larger (and thus includes the other). Falls back to -// comparing ids when the spans cover exactly the same range. -function compareCollapsedMarkers(a, b) { - var lenDiff = a.lines.length - b.lines.length; - if (lenDiff != 0) { return lenDiff } - var aPos = a.find(), bPos = b.find(); - var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b); - if (fromCmp) { return -fromCmp } - var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b); - if (toCmp) { return toCmp } - return b.id - a.id -} - -// Find out whether a line ends or starts in a collapsed span. If -// so, return the marker for that span. -function collapsedSpanAtSide(line, start) { - var sps = sawCollapsedSpans && line.markedSpans, found; - if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) { - sp = sps[i]; - if (sp.marker.collapsed && (start ? sp.from : sp.to) == null && - (!found || compareCollapsedMarkers(found, sp.marker) < 0)) - { found = sp.marker; } - } } - return found -} -function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) } -function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) } - -function collapsedSpanAround(line, ch) { - var sps = sawCollapsedSpans && line.markedSpans, found; - if (sps) { for (var i = 0; i < sps.length; ++i) { - var sp = sps[i]; - if (sp.marker.collapsed && (sp.from == null || sp.from < ch) && (sp.to == null || sp.to > ch) && - (!found || compareCollapsedMarkers(found, sp.marker) < 0)) { found = sp.marker; } - } } - return found -} - -// Test whether there exists a collapsed span that partially -// overlaps (covers the start or end, but not both) of a new span. -// Such overlap is not allowed. -function conflictingCollapsedRange(doc, lineNo$$1, from, to, marker) { - var line = getLine(doc, lineNo$$1); - var sps = sawCollapsedSpans && line.markedSpans; - if (sps) { for (var i = 0; i < sps.length; ++i) { - var sp = sps[i]; - if (!sp.marker.collapsed) { continue } - var found = sp.marker.find(0); - var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker); - var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker); - if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue } - if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) || - fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0)) - { return true } - } } -} - -// A visual line is a line as drawn on the screen. Folding, for -// example, can cause multiple logical lines to appear on the same -// visual line. This finds the start of the visual line that the -// given line is part of (usually that is the line itself). -function visualLine(line) { - var merged; - while (merged = collapsedSpanAtStart(line)) - { line = merged.find(-1, true).line; } - return line -} - -function visualLineEnd(line) { - var merged; - while (merged = collapsedSpanAtEnd(line)) - { line = merged.find(1, true).line; } - return line -} - -// Returns an array of logical lines that continue the visual line -// started by the argument, or undefined if there are no such lines. -function visualLineContinued(line) { - var merged, lines; - while (merged = collapsedSpanAtEnd(line)) { - line = merged.find(1, true).line - ;(lines || (lines = [])).push(line); - } - return lines -} - -// Get the line number of the start of the visual line that the -// given line number is part of. -function visualLineNo(doc, lineN) { - var line = getLine(doc, lineN), vis = visualLine(line); - if (line == vis) { return lineN } - return lineNo(vis) -} - -// Get the line number of the start of the next visual line after -// the given line. -function visualLineEndNo(doc, lineN) { - if (lineN > doc.lastLine()) { return lineN } - var line = getLine(doc, lineN), merged; - if (!lineIsHidden(doc, line)) { return lineN } - while (merged = collapsedSpanAtEnd(line)) - { line = merged.find(1, true).line; } - return lineNo(line) + 1 -} - -// Compute whether a line is hidden. Lines count as hidden when they -// are part of a visual line that starts with another line, or when -// they are entirely covered by collapsed, non-widget span. -function lineIsHidden(doc, line) { - var sps = sawCollapsedSpans && line.markedSpans; - if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) { - sp = sps[i]; - if (!sp.marker.collapsed) { continue } - if (sp.from == null) { return true } - if (sp.marker.widgetNode) { continue } - if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp)) - { return true } - } } -} -function lineIsHiddenInner(doc, line, span) { - if (span.to == null) { - var end = span.marker.find(1, true); - return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker)) - } - if (span.marker.inclusiveRight && span.to == line.text.length) - { return true } - for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) { - sp = line.markedSpans[i]; - if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to && - (sp.to == null || sp.to != span.from) && - (sp.marker.inclusiveLeft || span.marker.inclusiveRight) && - lineIsHiddenInner(doc, line, sp)) { return true } - } -} - -// Find the height above the given line. -function heightAtLine(lineObj) { - lineObj = visualLine(lineObj); - - var h = 0, chunk = lineObj.parent; - for (var i = 0; i < chunk.lines.length; ++i) { - var line = chunk.lines[i]; - if (line == lineObj) { break } - else { h += line.height; } - } - for (var p = chunk.parent; p; chunk = p, p = chunk.parent) { - for (var i$1 = 0; i$1 < p.children.length; ++i$1) { - var cur = p.children[i$1]; - if (cur == chunk) { break } - else { h += cur.height; } - } - } - return h -} - -// Compute the character length of a line, taking into account -// collapsed ranges (see markText) that might hide parts, and join -// other lines onto it. -function lineLength(line) { - if (line.height == 0) { return 0 } - var len = line.text.length, merged, cur = line; - while (merged = collapsedSpanAtStart(cur)) { - var found = merged.find(0, true); - cur = found.from.line; - len += found.from.ch - found.to.ch; - } - cur = line; - while (merged = collapsedSpanAtEnd(cur)) { - var found$1 = merged.find(0, true); - len -= cur.text.length - found$1.from.ch; - cur = found$1.to.line; - len += cur.text.length - found$1.to.ch; - } - return len -} - -// Find the longest line in the document. -function findMaxLine(cm) { - var d = cm.display, doc = cm.doc; - d.maxLine = getLine(doc, doc.first); - d.maxLineLength = lineLength(d.maxLine); - d.maxLineChanged = true; - doc.iter(function (line) { - var len = lineLength(line); - if (len > d.maxLineLength) { - d.maxLineLength = len; - d.maxLine = line; - } - }); -} - -// BIDI HELPERS - -function iterateBidiSections(order, from, to, f) { - if (!order) { return f(from, to, "ltr", 0) } - var found = false; - for (var i = 0; i < order.length; ++i) { - var part = order[i]; - if (part.from < to && part.to > from || from == to && part.to == from) { - f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr", i); - found = true; - } - } - if (!found) { f(from, to, "ltr"); } -} - -var bidiOther = null; -function getBidiPartAt(order, ch, sticky) { - var found; - bidiOther = null; - for (var i = 0; i < order.length; ++i) { - var cur = order[i]; - if (cur.from < ch && cur.to > ch) { return i } - if (cur.to == ch) { - if (cur.from != cur.to && sticky == "before") { found = i; } - else { bidiOther = i; } - } - if (cur.from == ch) { - if (cur.from != cur.to && sticky != "before") { found = i; } - else { bidiOther = i; } - } - } - return found != null ? found : bidiOther -} - -// Bidirectional ordering algorithm -// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm -// that this (partially) implements. - -// One-char codes used for character types: -// L (L): Left-to-Right -// R (R): Right-to-Left -// r (AL): Right-to-Left Arabic -// 1 (EN): European Number -// + (ES): European Number Separator -// % (ET): European Number Terminator -// n (AN): Arabic Number -// , (CS): Common Number Separator -// m (NSM): Non-Spacing Mark -// b (BN): Boundary Neutral -// s (B): Paragraph Separator -// t (S): Segment Separator -// w (WS): Whitespace -// N (ON): Other Neutrals - -// Returns null if characters are ordered as they appear -// (left-to-right), or an array of sections ({from, to, level} -// objects) in the order in which they occur visually. -var bidiOrdering = (function() { - // Character types for codepoints 0 to 0xff - var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN"; - // Character types for codepoints 0x600 to 0x6f9 - var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111"; - function charType(code) { - if (code <= 0xf7) { return lowTypes.charAt(code) } - else if (0x590 <= code && code <= 0x5f4) { return "R" } - else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) } - else if (0x6ee <= code && code <= 0x8ac) { return "r" } - else if (0x2000 <= code && code <= 0x200b) { return "w" } - else if (code == 0x200c) { return "b" } - else { return "L" } - } - - var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/; - var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/; - - function BidiSpan(level, from, to) { - this.level = level; - this.from = from; this.to = to; - } - - return function(str, direction) { - var outerType = direction == "ltr" ? "L" : "R"; - - if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false } - var len = str.length, types = []; - for (var i = 0; i < len; ++i) - { types.push(charType(str.charCodeAt(i))); } - - // W1. Examine each non-spacing mark (NSM) in the level run, and - // change the type of the NSM to the type of the previous - // character. If the NSM is at the start of the level run, it will - // get the type of sor. - for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) { - var type = types[i$1]; - if (type == "m") { types[i$1] = prev; } - else { prev = type; } - } - - // W2. Search backwards from each instance of a European number - // until the first strong type (R, L, AL, or sor) is found. If an - // AL is found, change the type of the European number to Arabic - // number. - // W3. Change all ALs to R. - for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) { - var type$1 = types[i$2]; - if (type$1 == "1" && cur == "r") { types[i$2] = "n"; } - else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R"; } } - } - - // W4. A single European separator between two European numbers - // changes to a European number. A single common separator between - // two numbers of the same type changes to that type. - for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) { - var type$2 = types[i$3]; - if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1"; } - else if (type$2 == "," && prev$1 == types[i$3+1] && - (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1; } - prev$1 = type$2; - } - - // W5. A sequence of European terminators adjacent to European - // numbers changes to all European numbers. - // W6. Otherwise, separators and terminators change to Other - // Neutral. - for (var i$4 = 0; i$4 < len; ++i$4) { - var type$3 = types[i$4]; - if (type$3 == ",") { types[i$4] = "N"; } - else if (type$3 == "%") { - var end = (void 0); - for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {} - var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N"; - for (var j = i$4; j < end; ++j) { types[j] = replace; } - i$4 = end - 1; - } - } - - // W7. Search backwards from each instance of a European number - // until the first strong type (R, L, or sor) is found. If an L is - // found, then change the type of the European number to L. - for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) { - var type$4 = types[i$5]; - if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L"; } - else if (isStrong.test(type$4)) { cur$1 = type$4; } - } - - // N1. A sequence of neutrals takes the direction of the - // surrounding strong text if the text on both sides has the same - // direction. European and Arabic numbers act as if they were R in - // terms of their influence on neutrals. Start-of-level-run (sor) - // and end-of-level-run (eor) are used at level run boundaries. - // N2. Any remaining neutrals take the embedding direction. - for (var i$6 = 0; i$6 < len; ++i$6) { - if (isNeutral.test(types[i$6])) { - var end$1 = (void 0); - for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {} - var before = (i$6 ? types[i$6-1] : outerType) == "L"; - var after = (end$1 < len ? types[end$1] : outerType) == "L"; - var replace$1 = before == after ? (before ? "L" : "R") : outerType; - for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; } - i$6 = end$1 - 1; - } - } - - // Here we depart from the documented algorithm, in order to avoid - // building up an actual levels array. Since there are only three - // levels (0, 1, 2) in an implementation that doesn't take - // explicit embedding into account, we can build up the order on - // the fly, without following the level-based algorithm. - var order = [], m; - for (var i$7 = 0; i$7 < len;) { - if (countsAsLeft.test(types[i$7])) { - var start = i$7; - for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {} - order.push(new BidiSpan(0, start, i$7)); - } else { - var pos = i$7, at = order.length; - for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {} - for (var j$2 = pos; j$2 < i$7;) { - if (countsAsNum.test(types[j$2])) { - if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); } - var nstart = j$2; - for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {} - order.splice(at, 0, new BidiSpan(2, nstart, j$2)); - pos = j$2; - } else { ++j$2; } - } - if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); } - } - } - if (direction == "ltr") { - if (order[0].level == 1 && (m = str.match(/^\s+/))) { - order[0].from = m[0].length; - order.unshift(new BidiSpan(0, 0, m[0].length)); - } - if (lst(order).level == 1 && (m = str.match(/\s+$/))) { - lst(order).to -= m[0].length; - order.push(new BidiSpan(0, len - m[0].length, len)); - } - } - - return direction == "rtl" ? order.reverse() : order - } -})(); - -// Get the bidi ordering for the given line (and cache it). Returns -// false for lines that are fully left-to-right, and an array of -// BidiSpan objects otherwise. -function getOrder(line, direction) { - var order = line.order; - if (order == null) { order = line.order = bidiOrdering(line.text, direction); } - return order -} - -// EVENT HANDLING - -// Lightweight event framework. on/off also work on DOM nodes, -// registering native DOM handlers. - -var noHandlers = []; - -var on = function(emitter, type, f) { - if (emitter.addEventListener) { - emitter.addEventListener(type, f, false); - } else if (emitter.attachEvent) { - emitter.attachEvent("on" + type, f); - } else { - var map$$1 = emitter._handlers || (emitter._handlers = {}); - map$$1[type] = (map$$1[type] || noHandlers).concat(f); - } -}; - -function getHandlers(emitter, type) { - return emitter._handlers && emitter._handlers[type] || noHandlers -} - -function off(emitter, type, f) { - if (emitter.removeEventListener) { - emitter.removeEventListener(type, f, false); - } else if (emitter.detachEvent) { - emitter.detachEvent("on" + type, f); - } else { - var map$$1 = emitter._handlers, arr = map$$1 && map$$1[type]; - if (arr) { - var index = indexOf(arr, f); - if (index > -1) - { map$$1[type] = arr.slice(0, index).concat(arr.slice(index + 1)); } - } - } -} - -function signal(emitter, type /*, values...*/) { - var handlers = getHandlers(emitter, type); - if (!handlers.length) { return } - var args = Array.prototype.slice.call(arguments, 2); - for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args); } -} - -// The DOM events that CodeMirror handles can be overridden by -// registering a (non-DOM) handler on the editor for the event name, -// and preventDefault-ing the event in that handler. -function signalDOMEvent(cm, e, override) { - if (typeof e == "string") - { e = {type: e, preventDefault: function() { this.defaultPrevented = true; }}; } - signal(cm, override || e.type, cm, e); - return e_defaultPrevented(e) || e.codemirrorIgnore -} - -function signalCursorActivity(cm) { - var arr = cm._handlers && cm._handlers.cursorActivity; - if (!arr) { return } - var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []); - for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1) - { set.push(arr[i]); } } -} - -function hasHandler(emitter, type) { - return getHandlers(emitter, type).length > 0 -} - -// Add on and off methods to a constructor's prototype, to make -// registering events on such objects more convenient. -function eventMixin(ctor) { - ctor.prototype.on = function(type, f) {on(this, type, f);}; - ctor.prototype.off = function(type, f) {off(this, type, f);}; -} - -// Due to the fact that we still support jurassic IE versions, some -// compatibility wrappers are needed. - -function e_preventDefault(e) { - if (e.preventDefault) { e.preventDefault(); } - else { e.returnValue = false; } -} -function e_stopPropagation(e) { - if (e.stopPropagation) { e.stopPropagation(); } - else { e.cancelBubble = true; } -} -function e_defaultPrevented(e) { - return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false -} -function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);} - -function e_target(e) {return e.target || e.srcElement} -function e_button(e) { - var b = e.which; - if (b == null) { - if (e.button & 1) { b = 1; } - else if (e.button & 2) { b = 3; } - else if (e.button & 4) { b = 2; } - } - if (mac && e.ctrlKey && b == 1) { b = 3; } - return b -} - -// Detect drag-and-drop -var dragAndDrop = function() { - // There is *some* kind of drag-and-drop support in IE6-8, but I - // couldn't get it to work yet. - if (ie && ie_version < 9) { return false } - var div = elt('div'); - return "draggable" in div || "dragDrop" in div -}(); - -var zwspSupported; -function zeroWidthElement(measure) { - if (zwspSupported == null) { - var test = elt("span", "\u200b"); - removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")])); - if (measure.firstChild.offsetHeight != 0) - { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8); } - } - var node = zwspSupported ? elt("span", "\u200b") : - elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px"); - node.setAttribute("cm-text", ""); - return node -} - -// Feature-detect IE's crummy client rect reporting for bidi text -var badBidiRects; -function hasBadBidiRects(measure) { - if (badBidiRects != null) { return badBidiRects } - var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA")); - var r0 = range(txt, 0, 1).getBoundingClientRect(); - var r1 = range(txt, 1, 2).getBoundingClientRect(); - removeChildren(measure); - if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780) - return badBidiRects = (r1.right - r0.right < 3) -} - -// See if "".split is the broken IE version, if so, provide an -// alternative way to split lines. -var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) { - var pos = 0, result = [], l = string.length; - while (pos <= l) { - var nl = string.indexOf("\n", pos); - if (nl == -1) { nl = string.length; } - var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl); - var rt = line.indexOf("\r"); - if (rt != -1) { - result.push(line.slice(0, rt)); - pos += rt + 1; - } else { - result.push(line); - pos = nl + 1; - } - } - return result -} : function (string) { return string.split(/\r\n?|\n/); }; - -var hasSelection = window.getSelection ? function (te) { - try { return te.selectionStart != te.selectionEnd } - catch(e) { return false } -} : function (te) { - var range$$1; - try {range$$1 = te.ownerDocument.selection.createRange();} - catch(e) {} - if (!range$$1 || range$$1.parentElement() != te) { return false } - return range$$1.compareEndPoints("StartToEnd", range$$1) != 0 -}; - -var hasCopyEvent = (function () { - var e = elt("div"); - if ("oncopy" in e) { return true } - e.setAttribute("oncopy", "return;"); - return typeof e.oncopy == "function" -})(); - -var badZoomedRects = null; -function hasBadZoomedRects(measure) { - if (badZoomedRects != null) { return badZoomedRects } - var node = removeChildrenAndAdd(measure, elt("span", "x")); - var normal = node.getBoundingClientRect(); - var fromRange = range(node, 0, 1).getBoundingClientRect(); - return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1 -} - -// Known modes, by name and by MIME -var modes = {}; -var mimeModes = {}; - -// Extra arguments are stored as the mode's dependencies, which is -// used by (legacy) mechanisms like loadmode.js to automatically -// load a mode. (Preferred mechanism is the require/define calls.) -function defineMode(name, mode) { - if (arguments.length > 2) - { mode.dependencies = Array.prototype.slice.call(arguments, 2); } - modes[name] = mode; -} - -function defineMIME(mime, spec) { - mimeModes[mime] = spec; -} - -// Given a MIME type, a {name, ...options} config object, or a name -// string, return a mode config object. -function resolveMode(spec) { - if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) { - spec = mimeModes[spec]; - } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) { - var found = mimeModes[spec.name]; - if (typeof found == "string") { found = {name: found}; } - spec = createObj(found, spec); - spec.name = found.name; - } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) { - return resolveMode("application/xml") - } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) { - return resolveMode("application/json") - } - if (typeof spec == "string") { return {name: spec} } - else { return spec || {name: "null"} } -} - -// Given a mode spec (anything that resolveMode accepts), find and -// initialize an actual mode object. -function getMode(options, spec) { - spec = resolveMode(spec); - var mfactory = modes[spec.name]; - if (!mfactory) { return getMode(options, "text/plain") } - var modeObj = mfactory(options, spec); - if (modeExtensions.hasOwnProperty(spec.name)) { - var exts = modeExtensions[spec.name]; - for (var prop in exts) { - if (!exts.hasOwnProperty(prop)) { continue } - if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop]; } - modeObj[prop] = exts[prop]; - } - } - modeObj.name = spec.name; - if (spec.helperType) { modeObj.helperType = spec.helperType; } - if (spec.modeProps) { for (var prop$1 in spec.modeProps) - { modeObj[prop$1] = spec.modeProps[prop$1]; } } - - return modeObj -} - -// This can be used to attach properties to mode objects from -// outside the actual mode definition. -var modeExtensions = {}; -function extendMode(mode, properties) { - var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {}); - copyObj(properties, exts); -} - -function copyState(mode, state) { - if (state === true) { return state } - if (mode.copyState) { return mode.copyState(state) } - var nstate = {}; - for (var n in state) { - var val = state[n]; - if (val instanceof Array) { val = val.concat([]); } - nstate[n] = val; - } - return nstate -} - -// Given a mode and a state (for that mode), find the inner mode and -// state at the position that the state refers to. -function innerMode(mode, state) { - var info; - while (mode.innerMode) { - info = mode.innerMode(state); - if (!info || info.mode == mode) { break } - state = info.state; - mode = info.mode; - } - return info || {mode: mode, state: state} -} - -function startState(mode, a1, a2) { - return mode.startState ? mode.startState(a1, a2) : true -} - -// STRING STREAM - -// Fed to the mode parsers, provides helper functions to make -// parsers more succinct. - -var StringStream = function(string, tabSize, lineOracle) { - this.pos = this.start = 0; - this.string = string; - this.tabSize = tabSize || 8; - this.lastColumnPos = this.lastColumnValue = 0; - this.lineStart = 0; - this.lineOracle = lineOracle; -}; - -StringStream.prototype.eol = function () {return this.pos >= this.string.length}; -StringStream.prototype.sol = function () {return this.pos == this.lineStart}; -StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined}; -StringStream.prototype.next = function () { - if (this.pos < this.string.length) - { return this.string.charAt(this.pos++) } -}; -StringStream.prototype.eat = function (match) { - var ch = this.string.charAt(this.pos); - var ok; - if (typeof match == "string") { ok = ch == match; } - else { ok = ch && (match.test ? match.test(ch) : match(ch)); } - if (ok) {++this.pos; return ch} -}; -StringStream.prototype.eatWhile = function (match) { - var start = this.pos; - while (this.eat(match)){} - return this.pos > start -}; -StringStream.prototype.eatSpace = function () { - var this$1 = this; - - var start = this.pos; - while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos; } - return this.pos > start -}; -StringStream.prototype.skipToEnd = function () {this.pos = this.string.length;}; -StringStream.prototype.skipTo = function (ch) { - var found = this.string.indexOf(ch, this.pos); - if (found > -1) {this.pos = found; return true} -}; -StringStream.prototype.backUp = function (n) {this.pos -= n;}; -StringStream.prototype.column = function () { - if (this.lastColumnPos < this.start) { - this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue); - this.lastColumnPos = this.start; - } - return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0) -}; -StringStream.prototype.indentation = function () { - return countColumn(this.string, null, this.tabSize) - - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0) -}; -StringStream.prototype.match = function (pattern, consume, caseInsensitive) { - if (typeof pattern == "string") { - var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }; - var substr = this.string.substr(this.pos, pattern.length); - if (cased(substr) == cased(pattern)) { - if (consume !== false) { this.pos += pattern.length; } - return true - } - } else { - var match = this.string.slice(this.pos).match(pattern); - if (match && match.index > 0) { return null } - if (match && consume !== false) { this.pos += match[0].length; } - return match - } -}; -StringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)}; -StringStream.prototype.hideFirstChars = function (n, inner) { - this.lineStart += n; - try { return inner() } - finally { this.lineStart -= n; } -}; -StringStream.prototype.lookAhead = function (n) { - var oracle = this.lineOracle; - return oracle && oracle.lookAhead(n) -}; -StringStream.prototype.baseToken = function () { - var oracle = this.lineOracle; - return oracle && oracle.baseToken(this.pos) -}; - -var SavedContext = function(state, lookAhead) { - this.state = state; - this.lookAhead = lookAhead; -}; - -var Context = function(doc, state, line, lookAhead) { - this.state = state; - this.doc = doc; - this.line = line; - this.maxLookAhead = lookAhead || 0; - this.baseTokens = null; - this.baseTokenPos = 1; -}; - -Context.prototype.lookAhead = function (n) { - var line = this.doc.getLine(this.line + n); - if (line != null && n > this.maxLookAhead) { this.maxLookAhead = n; } - return line -}; - -Context.prototype.baseToken = function (n) { - var this$1 = this; - - if (!this.baseTokens) { return null } - while (this.baseTokens[this.baseTokenPos] <= n) - { this$1.baseTokenPos += 2; } - var type = this.baseTokens[this.baseTokenPos + 1]; - return {type: type && type.replace(/( |^)overlay .*/, ""), - size: this.baseTokens[this.baseTokenPos] - n} -}; - -Context.prototype.nextLine = function () { - this.line++; - if (this.maxLookAhead > 0) { this.maxLookAhead--; } -}; - -Context.fromSaved = function (doc, saved, line) { - if (saved instanceof SavedContext) - { return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead) } - else - { return new Context(doc, copyState(doc.mode, saved), line) } -}; - -Context.prototype.save = function (copy) { - var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state; - return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state -}; - - -// Compute a style array (an array starting with a mode generation -// -- for invalidation -- followed by pairs of end positions and -// style strings), which is used to highlight the tokens on the -// line. -function highlightLine(cm, line, context, forceToEnd) { - // A styles array always starts with a number identifying the - // mode/overlays that it is based on (for easy invalidation). - var st = [cm.state.modeGen], lineClasses = {}; - // Compute the base array of styles - runMode(cm, line.text, cm.doc.mode, context, function (end, style) { return st.push(end, style); }, - lineClasses, forceToEnd); - var state = context.state; - - // Run overlays, adjust style array. - var loop = function ( o ) { - context.baseTokens = st; - var overlay = cm.state.overlays[o], i = 1, at = 0; - context.state = true; - runMode(cm, line.text, overlay.mode, context, function (end, style) { - var start = i; - // Ensure there's a token end at the current position, and that i points at it - while (at < end) { - var i_end = st[i]; - if (i_end > end) - { st.splice(i, 1, end, st[i+1], i_end); } - i += 2; - at = Math.min(end, i_end); - } - if (!style) { return } - if (overlay.opaque) { - st.splice(start, i - start, end, "overlay " + style); - i = start + 2; - } else { - for (; start < i; start += 2) { - var cur = st[start+1]; - st[start+1] = (cur ? cur + " " : "") + "overlay " + style; - } - } - }, lineClasses); - context.state = state; - context.baseTokens = null; - context.baseTokenPos = 1; - }; - - for (var o = 0; o < cm.state.overlays.length; ++o) loop( o ); - - return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null} -} - -function getLineStyles(cm, line, updateFrontier) { - if (!line.styles || line.styles[0] != cm.state.modeGen) { - var context = getContextBefore(cm, lineNo(line)); - var resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state); - var result = highlightLine(cm, line, context); - if (resetState) { context.state = resetState; } - line.stateAfter = context.save(!resetState); - line.styles = result.styles; - if (result.classes) { line.styleClasses = result.classes; } - else if (line.styleClasses) { line.styleClasses = null; } - if (updateFrontier === cm.doc.highlightFrontier) - { cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier); } - } - return line.styles -} - -function getContextBefore(cm, n, precise) { - var doc = cm.doc, display = cm.display; - if (!doc.mode.startState) { return new Context(doc, true, n) } - var start = findStartLine(cm, n, precise); - var saved = start > doc.first && getLine(doc, start - 1).stateAfter; - var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start); - - doc.iter(start, n, function (line) { - processLine(cm, line.text, context); - var pos = context.line; - line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null; - context.nextLine(); - }); - if (precise) { doc.modeFrontier = context.line; } - return context -} - -// Lightweight form of highlight -- proceed over this line and -// update state, but don't save a style array. Used for lines that -// aren't currently visible. -function processLine(cm, text, context, startAt) { - var mode = cm.doc.mode; - var stream = new StringStream(text, cm.options.tabSize, context); - stream.start = stream.pos = startAt || 0; - if (text == "") { callBlankLine(mode, context.state); } - while (!stream.eol()) { - readToken(mode, stream, context.state); - stream.start = stream.pos; - } -} - -function callBlankLine(mode, state) { - if (mode.blankLine) { return mode.blankLine(state) } - if (!mode.innerMode) { return } - var inner = innerMode(mode, state); - if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) } -} - -function readToken(mode, stream, state, inner) { - for (var i = 0; i < 10; i++) { - if (inner) { inner[0] = innerMode(mode, state).mode; } - var style = mode.token(stream, state); - if (stream.pos > stream.start) { return style } - } - throw new Error("Mode " + mode.name + " failed to advance stream.") -} - -var Token = function(stream, type, state) { - this.start = stream.start; this.end = stream.pos; - this.string = stream.current(); - this.type = type || null; - this.state = state; -}; - -// Utility for getTokenAt and getLineTokens -function takeToken(cm, pos, precise, asArray) { - var doc = cm.doc, mode = doc.mode, style; - pos = clipPos(doc, pos); - var line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise); - var stream = new StringStream(line.text, cm.options.tabSize, context), tokens; - if (asArray) { tokens = []; } - while ((asArray || stream.pos < pos.ch) && !stream.eol()) { - stream.start = stream.pos; - style = readToken(mode, stream, context.state); - if (asArray) { tokens.push(new Token(stream, style, copyState(doc.mode, context.state))); } - } - return asArray ? tokens : new Token(stream, style, context.state) -} - -function extractLineClasses(type, output) { - if (type) { for (;;) { - var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/); - if (!lineClass) { break } - type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length); - var prop = lineClass[1] ? "bgClass" : "textClass"; - if (output[prop] == null) - { output[prop] = lineClass[2]; } - else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop])) - { output[prop] += " " + lineClass[2]; } - } } - return type -} - -// Run the given mode's parser over a line, calling f for each token. -function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) { - var flattenSpans = mode.flattenSpans; - if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans; } - var curStart = 0, curStyle = null; - var stream = new StringStream(text, cm.options.tabSize, context), style; - var inner = cm.options.addModeClass && [null]; - if (text == "") { extractLineClasses(callBlankLine(mode, context.state), lineClasses); } - while (!stream.eol()) { - if (stream.pos > cm.options.maxHighlightLength) { - flattenSpans = false; - if (forceToEnd) { processLine(cm, text, context, stream.pos); } - stream.pos = text.length; - style = null; - } else { - style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses); - } - if (inner) { - var mName = inner[0].name; - if (mName) { style = "m-" + (style ? mName + " " + style : mName); } - } - if (!flattenSpans || curStyle != style) { - while (curStart < stream.start) { - curStart = Math.min(stream.start, curStart + 5000); - f(curStart, curStyle); - } - curStyle = style; - } - stream.start = stream.pos; - } - while (curStart < stream.pos) { - // Webkit seems to refuse to render text nodes longer than 57444 - // characters, and returns inaccurate measurements in nodes - // starting around 5000 chars. - var pos = Math.min(stream.pos, curStart + 5000); - f(pos, curStyle); - curStart = pos; - } -} - -// Finds the line to start with when starting a parse. Tries to -// find a line with a stateAfter, so that it can start with a -// valid state. If that fails, it returns the line with the -// smallest indentation, which tends to need the least context to -// parse correctly. -function findStartLine(cm, n, precise) { - var minindent, minline, doc = cm.doc; - var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100); - for (var search = n; search > lim; --search) { - if (search <= doc.first) { return doc.first } - var line = getLine(doc, search - 1), after = line.stateAfter; - if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier)) - { return search } - var indented = countColumn(line.text, null, cm.options.tabSize); - if (minline == null || minindent > indented) { - minline = search - 1; - minindent = indented; - } - } - return minline -} - -function retreatFrontier(doc, n) { - doc.modeFrontier = Math.min(doc.modeFrontier, n); - if (doc.highlightFrontier < n - 10) { return } - var start = doc.first; - for (var line = n - 1; line > start; line--) { - var saved = getLine(doc, line).stateAfter; - // change is on 3 - // state on line 1 looked ahead 2 -- so saw 3 - // test 1 + 2 < 3 should cover this - if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) { - start = line + 1; - break - } - } - doc.highlightFrontier = Math.min(doc.highlightFrontier, start); -} - -// LINE DATA STRUCTURE - -// Line objects. These hold state related to a line, including -// highlighting info (the styles array). -var Line = function(text, markedSpans, estimateHeight) { - this.text = text; - attachMarkedSpans(this, markedSpans); - this.height = estimateHeight ? estimateHeight(this) : 1; -}; - -Line.prototype.lineNo = function () { return lineNo(this) }; -eventMixin(Line); - -// Change the content (text, markers) of a line. Automatically -// invalidates cached information and tries to re-estimate the -// line's height. -function updateLine(line, text, markedSpans, estimateHeight) { - line.text = text; - if (line.stateAfter) { line.stateAfter = null; } - if (line.styles) { line.styles = null; } - if (line.order != null) { line.order = null; } - detachMarkedSpans(line); - attachMarkedSpans(line, markedSpans); - var estHeight = estimateHeight ? estimateHeight(line) : 1; - if (estHeight != line.height) { updateLineHeight(line, estHeight); } -} - -// Detach a line from the document tree and its markers. -function cleanUpLine(line) { - line.parent = null; - detachMarkedSpans(line); -} - -// Convert a style as returned by a mode (either null, or a string -// containing one or more styles) to a CSS style. This is cached, -// and also looks for line-wide styles. -var styleToClassCache = {}; -var styleToClassCacheWithMode = {}; -function interpretTokenStyle(style, options) { - if (!style || /^\s*$/.test(style)) { return null } - var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache; - return cache[style] || - (cache[style] = style.replace(/\S+/g, "cm-$&")) -} - -// Render the DOM representation of the text of a line. Also builds -// up a 'line map', which points at the DOM nodes that represent -// specific stretches of text, and is used by the measuring code. -// The returned object contains the DOM node, this map, and -// information about line-wide styles that were set by the mode. -function buildLineContent(cm, lineView) { - // The padding-right forces the element to have a 'border', which - // is needed on Webkit to be able to get line-level bounding - // rectangles for it (in measureChar). - var content = eltP("span", null, null, webkit ? "padding-right: .1px" : null); - var builder = {pre: eltP("pre", [content], "CodeMirror-line"), content: content, - col: 0, pos: 0, cm: cm, - trailingSpace: false, - splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")}; - lineView.measure = {}; - - // Iterate over the logical lines that make up this visual line. - for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) { - var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0); - builder.pos = 0; - builder.addToken = buildToken; - // Optionally wire in some hacks into the token-rendering - // algorithm, to deal with browser quirks. - if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction))) - { builder.addToken = buildTokenBadBidi(builder.addToken, order); } - builder.map = []; - var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line); - insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate)); - if (line.styleClasses) { - if (line.styleClasses.bgClass) - { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || ""); } - if (line.styleClasses.textClass) - { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || ""); } - } - - // Ensure at least a single node is present, for measuring. - if (builder.map.length == 0) - { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))); } - - // Store the map and a cache object for the current logical line - if (i == 0) { - lineView.measure.map = builder.map; - lineView.measure.cache = {}; - } else { - (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map) - ;(lineView.measure.caches || (lineView.measure.caches = [])).push({}); - } - } - - // See issue #2901 - if (webkit) { - var last = builder.content.lastChild; - if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab"))) - { builder.content.className = "cm-tab-wrap-hack"; } - } - - signal(cm, "renderLine", cm, lineView.line, builder.pre); - if (builder.pre.className) - { builder.textClass = joinClasses(builder.pre.className, builder.textClass || ""); } - - return builder -} - -function defaultSpecialCharPlaceholder(ch) { - var token = elt("span", "\u2022", "cm-invalidchar"); - token.title = "\\u" + ch.charCodeAt(0).toString(16); - token.setAttribute("aria-label", token.title); - return token -} - -// Build up the DOM representation for a single token, and add it to -// the line map. Takes care to render special characters separately. -function buildToken(builder, text, style, startStyle, endStyle, title, css) { - if (!text) { return } - var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text; - var special = builder.cm.state.specialChars, mustWrap = false; - var content; - if (!special.test(text)) { - builder.col += text.length; - content = document.createTextNode(displayText); - builder.map.push(builder.pos, builder.pos + text.length, content); - if (ie && ie_version < 9) { mustWrap = true; } - builder.pos += text.length; - } else { - content = document.createDocumentFragment(); - var pos = 0; - while (true) { - special.lastIndex = pos; - var m = special.exec(text); - var skipped = m ? m.index - pos : text.length - pos; - if (skipped) { - var txt = document.createTextNode(displayText.slice(pos, pos + skipped)); - if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])); } - else { content.appendChild(txt); } - builder.map.push(builder.pos, builder.pos + skipped, txt); - builder.col += skipped; - builder.pos += skipped; - } - if (!m) { break } - pos += skipped + 1; - var txt$1 = (void 0); - if (m[0] == "\t") { - var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize; - txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab")); - txt$1.setAttribute("role", "presentation"); - txt$1.setAttribute("cm-text", "\t"); - builder.col += tabWidth; - } else if (m[0] == "\r" || m[0] == "\n") { - txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar")); - txt$1.setAttribute("cm-text", m[0]); - builder.col += 1; - } else { - txt$1 = builder.cm.options.specialCharPlaceholder(m[0]); - txt$1.setAttribute("cm-text", m[0]); - if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])); } - else { content.appendChild(txt$1); } - builder.col += 1; - } - builder.map.push(builder.pos, builder.pos + 1, txt$1); - builder.pos++; - } - } - builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32; - if (style || startStyle || endStyle || mustWrap || css) { - var fullStyle = style || ""; - if (startStyle) { fullStyle += startStyle; } - if (endStyle) { fullStyle += endStyle; } - var token = elt("span", [content], fullStyle, css); - if (title) { token.title = title; } - return builder.content.appendChild(token) - } - builder.content.appendChild(content); -} - -function splitSpaces(text, trailingBefore) { - if (text.length > 1 && !/ /.test(text)) { return text } - var spaceBefore = trailingBefore, result = ""; - for (var i = 0; i < text.length; i++) { - var ch = text.charAt(i); - if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32)) - { ch = "\u00a0"; } - result += ch; - spaceBefore = ch == " "; - } - return result -} - -// Work around nonsense dimensions being reported for stretches of -// right-to-left text. -function buildTokenBadBidi(inner, order) { - return function (builder, text, style, startStyle, endStyle, title, css) { - style = style ? style + " cm-force-border" : "cm-force-border"; - var start = builder.pos, end = start + text.length; - for (;;) { - // Find the part that overlaps with the start of this text - var part = (void 0); - for (var i = 0; i < order.length; i++) { - part = order[i]; - if (part.to > start && part.from <= start) { break } - } - if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) } - inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css); - startStyle = null; - text = text.slice(part.to - start); - start = part.to; - } - } -} - -function buildCollapsedSpan(builder, size, marker, ignoreWidget) { - var widget = !ignoreWidget && marker.widgetNode; - if (widget) { builder.map.push(builder.pos, builder.pos + size, widget); } - if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) { - if (!widget) - { widget = builder.content.appendChild(document.createElement("span")); } - widget.setAttribute("cm-marker", marker.id); - } - if (widget) { - builder.cm.display.input.setUneditable(widget); - builder.content.appendChild(widget); - } - builder.pos += size; - builder.trailingSpace = false; -} - -// Outputs a number of spans to make up a line, taking highlighting -// and marked text into account. -function insertLineContent(line, builder, styles) { - var spans = line.markedSpans, allText = line.text, at = 0; - if (!spans) { - for (var i$1 = 1; i$1 < styles.length; i$1+=2) - { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)); } - return - } - - var len = allText.length, pos = 0, i = 1, text = "", style, css; - var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed; - for (;;) { - if (nextChange == pos) { // Update current marker set - spanStyle = spanEndStyle = spanStartStyle = title = css = ""; - collapsed = null; nextChange = Infinity; - var foundBookmarks = [], endStyles = (void 0); - for (var j = 0; j < spans.length; ++j) { - var sp = spans[j], m = sp.marker; - if (m.type == "bookmark" && sp.from == pos && m.widgetNode) { - foundBookmarks.push(m); - } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) { - if (sp.to != null && sp.to != pos && nextChange > sp.to) { - nextChange = sp.to; - spanEndStyle = ""; - } - if (m.className) { spanStyle += " " + m.className; } - if (m.css) { css = (css ? css + ";" : "") + m.css; } - if (m.startStyle && sp.from == pos) { spanStartStyle += " " + m.startStyle; } - if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to); } - if (m.title && !title) { title = m.title; } - if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0)) - { collapsed = sp; } - } else if (sp.from > pos && nextChange > sp.from) { - nextChange = sp.from; - } - } - if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2) - { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += " " + endStyles[j$1]; } } } - - if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2) - { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]); } } - if (collapsed && (collapsed.from || 0) == pos) { - buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos, - collapsed.marker, collapsed.from == null); - if (collapsed.to == null) { return } - if (collapsed.to == pos) { collapsed = false; } - } - } - if (pos >= len) { break } - - var upto = Math.min(len, nextChange); - while (true) { - if (text) { - var end = pos + text.length; - if (!collapsed) { - var tokenText = end > upto ? text.slice(0, upto - pos) : text; - builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle, - spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css); - } - if (end >= upto) {text = text.slice(upto - pos); pos = upto; break} - pos = end; - spanStartStyle = ""; - } - text = allText.slice(at, at = styles[i++]); - style = interpretTokenStyle(styles[i++], builder.cm.options); - } - } -} - - -// These objects are used to represent the visible (currently drawn) -// part of the document. A LineView may correspond to multiple -// logical lines, if those are connected by collapsed ranges. -function LineView(doc, line, lineN) { - // The starting line - this.line = line; - // Continuing lines, if any - this.rest = visualLineContinued(line); - // Number of logical lines in this visual line - this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1; - this.node = this.text = null; - this.hidden = lineIsHidden(doc, line); -} - -// Create a range of LineView objects for the given lines. -function buildViewArray(cm, from, to) { - var array = [], nextPos; - for (var pos = from; pos < to; pos = nextPos) { - var view = new LineView(cm.doc, getLine(cm.doc, pos), pos); - nextPos = pos + view.size; - array.push(view); - } - return array -} - -var operationGroup = null; - -function pushOperation(op) { - if (operationGroup) { - operationGroup.ops.push(op); - } else { - op.ownsGroup = operationGroup = { - ops: [op], - delayedCallbacks: [] - }; - } -} - -function fireCallbacksForOps(group) { - // Calls delayed callbacks and cursorActivity handlers until no - // new ones appear - var callbacks = group.delayedCallbacks, i = 0; - do { - for (; i < callbacks.length; i++) - { callbacks[i].call(null); } - for (var j = 0; j < group.ops.length; j++) { - var op = group.ops[j]; - if (op.cursorActivityHandlers) - { while (op.cursorActivityCalled < op.cursorActivityHandlers.length) - { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm); } } - } - } while (i < callbacks.length) -} - -function finishOperation(op, endCb) { - var group = op.ownsGroup; - if (!group) { return } - - try { fireCallbacksForOps(group); } - finally { - operationGroup = null; - endCb(group); - } -} - -var orphanDelayedCallbacks = null; - -// Often, we want to signal events at a point where we are in the -// middle of some work, but don't want the handler to start calling -// other methods on the editor, which might be in an inconsistent -// state or simply not expect any other events to happen. -// signalLater looks whether there are any handlers, and schedules -// them to be executed when the last operation ends, or, if no -// operation is active, when a timeout fires. -function signalLater(emitter, type /*, values...*/) { - var arr = getHandlers(emitter, type); - if (!arr.length) { return } - var args = Array.prototype.slice.call(arguments, 2), list; - if (operationGroup) { - list = operationGroup.delayedCallbacks; - } else if (orphanDelayedCallbacks) { - list = orphanDelayedCallbacks; - } else { - list = orphanDelayedCallbacks = []; - setTimeout(fireOrphanDelayed, 0); - } - var loop = function ( i ) { - list.push(function () { return arr[i].apply(null, args); }); - }; - - for (var i = 0; i < arr.length; ++i) - loop( i ); -} - -function fireOrphanDelayed() { - var delayed = orphanDelayedCallbacks; - orphanDelayedCallbacks = null; - for (var i = 0; i < delayed.length; ++i) { delayed[i](); } -} - -// When an aspect of a line changes, a string is added to -// lineView.changes. This updates the relevant part of the line's -// DOM structure. -function updateLineForChanges(cm, lineView, lineN, dims) { - for (var j = 0; j < lineView.changes.length; j++) { - var type = lineView.changes[j]; - if (type == "text") { updateLineText(cm, lineView); } - else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims); } - else if (type == "class") { updateLineClasses(cm, lineView); } - else if (type == "widget") { updateLineWidgets(cm, lineView, dims); } - } - lineView.changes = null; -} - -// Lines with gutter elements, widgets or a background class need to -// be wrapped, and have the extra elements added to the wrapper div -function ensureLineWrapped(lineView) { - if (lineView.node == lineView.text) { - lineView.node = elt("div", null, null, "position: relative"); - if (lineView.text.parentNode) - { lineView.text.parentNode.replaceChild(lineView.node, lineView.text); } - lineView.node.appendChild(lineView.text); - if (ie && ie_version < 8) { lineView.node.style.zIndex = 2; } - } - return lineView.node -} - -function updateLineBackground(cm, lineView) { - var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass; - if (cls) { cls += " CodeMirror-linebackground"; } - if (lineView.background) { - if (cls) { lineView.background.className = cls; } - else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; } - } else if (cls) { - var wrap = ensureLineWrapped(lineView); - lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild); - cm.display.input.setUneditable(lineView.background); - } -} - -// Wrapper around buildLineContent which will reuse the structure -// in display.externalMeasured when possible. -function getLineContent(cm, lineView) { - var ext = cm.display.externalMeasured; - if (ext && ext.line == lineView.line) { - cm.display.externalMeasured = null; - lineView.measure = ext.measure; - return ext.built - } - return buildLineContent(cm, lineView) -} - -// Redraw the line's text. Interacts with the background and text -// classes because the mode may output tokens that influence these -// classes. -function updateLineText(cm, lineView) { - var cls = lineView.text.className; - var built = getLineContent(cm, lineView); - if (lineView.text == lineView.node) { lineView.node = built.pre; } - lineView.text.parentNode.replaceChild(built.pre, lineView.text); - lineView.text = built.pre; - if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) { - lineView.bgClass = built.bgClass; - lineView.textClass = built.textClass; - updateLineClasses(cm, lineView); - } else if (cls) { - lineView.text.className = cls; - } -} - -function updateLineClasses(cm, lineView) { - updateLineBackground(cm, lineView); - if (lineView.line.wrapClass) - { ensureLineWrapped(lineView).className = lineView.line.wrapClass; } - else if (lineView.node != lineView.text) - { lineView.node.className = ""; } - var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass; - lineView.text.className = textClass || ""; -} - -function updateLineGutter(cm, lineView, lineN, dims) { - if (lineView.gutter) { - lineView.node.removeChild(lineView.gutter); - lineView.gutter = null; - } - if (lineView.gutterBackground) { - lineView.node.removeChild(lineView.gutterBackground); - lineView.gutterBackground = null; - } - if (lineView.line.gutterClass) { - var wrap = ensureLineWrapped(lineView); - lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass, - ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px; width: " + (dims.gutterTotalWidth) + "px")); - cm.display.input.setUneditable(lineView.gutterBackground); - wrap.insertBefore(lineView.gutterBackground, lineView.text); - } - var markers = lineView.line.gutterMarkers; - if (cm.options.lineNumbers || markers) { - var wrap$1 = ensureLineWrapped(lineView); - var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px")); - cm.display.input.setUneditable(gutterWrap); - wrap$1.insertBefore(gutterWrap, lineView.text); - if (lineView.line.gutterClass) - { gutterWrap.className += " " + lineView.line.gutterClass; } - if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"])) - { lineView.lineNumber = gutterWrap.appendChild( - elt("div", lineNumberFor(cm.options, lineN), - "CodeMirror-linenumber CodeMirror-gutter-elt", - ("left: " + (dims.gutterLeft["CodeMirror-linenumbers"]) + "px; width: " + (cm.display.lineNumInnerWidth) + "px"))); } - if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) { - var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]; - if (found) - { gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt", - ("left: " + (dims.gutterLeft[id]) + "px; width: " + (dims.gutterWidth[id]) + "px"))); } - } } - } -} - -function updateLineWidgets(cm, lineView, dims) { - if (lineView.alignable) { lineView.alignable = null; } - for (var node = lineView.node.firstChild, next = (void 0); node; node = next) { - next = node.nextSibling; - if (node.className == "CodeMirror-linewidget") - { lineView.node.removeChild(node); } - } - insertLineWidgets(cm, lineView, dims); -} - -// Build a line's DOM representation from scratch -function buildLineElement(cm, lineView, lineN, dims) { - var built = getLineContent(cm, lineView); - lineView.text = lineView.node = built.pre; - if (built.bgClass) { lineView.bgClass = built.bgClass; } - if (built.textClass) { lineView.textClass = built.textClass; } - - updateLineClasses(cm, lineView); - updateLineGutter(cm, lineView, lineN, dims); - insertLineWidgets(cm, lineView, dims); - return lineView.node -} - -// A lineView may contain multiple logical lines (when merged by -// collapsed spans). The widgets for all of them need to be drawn. -function insertLineWidgets(cm, lineView, dims) { - insertLineWidgetsFor(cm, lineView.line, lineView, dims, true); - if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++) - { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false); } } -} - -function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) { - if (!line.widgets) { return } - var wrap = ensureLineWrapped(lineView); - for (var i = 0, ws = line.widgets; i < ws.length; ++i) { - var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget"); - if (!widget.handleMouseEvents) { node.setAttribute("cm-ignore-events", "true"); } - positionLineWidget(widget, node, lineView, dims); - cm.display.input.setUneditable(node); - if (allowAbove && widget.above) - { wrap.insertBefore(node, lineView.gutter || lineView.text); } - else - { wrap.appendChild(node); } - signalLater(widget, "redraw"); - } -} - -function positionLineWidget(widget, node, lineView, dims) { - if (widget.noHScroll) { - (lineView.alignable || (lineView.alignable = [])).push(node); - var width = dims.wrapperWidth; - node.style.left = dims.fixedPos + "px"; - if (!widget.coverGutter) { - width -= dims.gutterTotalWidth; - node.style.paddingLeft = dims.gutterTotalWidth + "px"; - } - node.style.width = width + "px"; - } - if (widget.coverGutter) { - node.style.zIndex = 5; - node.style.position = "relative"; - if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + "px"; } - } -} - -function widgetHeight(widget) { - if (widget.height != null) { return widget.height } - var cm = widget.doc.cm; - if (!cm) { return 0 } - if (!contains(document.body, widget.node)) { - var parentStyle = "position: relative;"; - if (widget.coverGutter) - { parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;"; } - if (widget.noHScroll) - { parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;"; } - removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle)); - } - return widget.height = widget.node.parentNode.offsetHeight -} - -// Return true when the given mouse event happened in a widget -function eventInWidget(display, e) { - for (var n = e_target(e); n != display.wrapper; n = n.parentNode) { - if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") || - (n.parentNode == display.sizer && n != display.mover)) - { return true } - } -} - -// POSITION MEASUREMENT - -function paddingTop(display) {return display.lineSpace.offsetTop} -function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight} -function paddingH(display) { - if (display.cachedPaddingH) { return display.cachedPaddingH } - var e = removeChildrenAndAdd(display.measure, elt("pre", "x")); - var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle; - var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}; - if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data; } - return data -} - -function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth } -function displayWidth(cm) { - return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth -} -function displayHeight(cm) { - return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight -} - -// Ensure the lineView.wrapping.heights array is populated. This is -// an array of bottom offsets for the lines that make up a drawn -// line. When lineWrapping is on, there might be more than one -// height. -function ensureLineHeights(cm, lineView, rect) { - var wrapping = cm.options.lineWrapping; - var curWidth = wrapping && displayWidth(cm); - if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) { - var heights = lineView.measure.heights = []; - if (wrapping) { - lineView.measure.width = curWidth; - var rects = lineView.text.firstChild.getClientRects(); - for (var i = 0; i < rects.length - 1; i++) { - var cur = rects[i], next = rects[i + 1]; - if (Math.abs(cur.bottom - next.bottom) > 2) - { heights.push((cur.bottom + next.top) / 2 - rect.top); } - } - } - heights.push(rect.bottom - rect.top); - } -} - -// Find a line map (mapping character offsets to text nodes) and a -// measurement cache for the given line number. (A line view might -// contain multiple lines when collapsed ranges are present.) -function mapFromLineView(lineView, line, lineN) { - if (lineView.line == line) - { return {map: lineView.measure.map, cache: lineView.measure.cache} } - for (var i = 0; i < lineView.rest.length; i++) - { if (lineView.rest[i] == line) - { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } } - for (var i$1 = 0; i$1 < lineView.rest.length; i$1++) - { if (lineNo(lineView.rest[i$1]) > lineN) - { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } } -} - -// Render a line into the hidden node display.externalMeasured. Used -// when measurement is needed for a line that's not in the viewport. -function updateExternalMeasurement(cm, line) { - line = visualLine(line); - var lineN = lineNo(line); - var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN); - view.lineN = lineN; - var built = view.built = buildLineContent(cm, view); - view.text = built.pre; - removeChildrenAndAdd(cm.display.lineMeasure, built.pre); - return view -} - -// Get a {top, bottom, left, right} box (in line-local coordinates) -// for a given character. -function measureChar(cm, line, ch, bias) { - return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias) -} - -// Find a line view that corresponds to the given line number. -function findViewForLine(cm, lineN) { - if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo) - { return cm.display.view[findViewIndex(cm, lineN)] } - var ext = cm.display.externalMeasured; - if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size) - { return ext } -} - -// Measurement can be split in two steps, the set-up work that -// applies to the whole line, and the measurement of the actual -// character. Functions like coordsChar, that need to do a lot of -// measurements in a row, can thus ensure that the set-up work is -// only done once. -function prepareMeasureForLine(cm, line) { - var lineN = lineNo(line); - var view = findViewForLine(cm, lineN); - if (view && !view.text) { - view = null; - } else if (view && view.changes) { - updateLineForChanges(cm, view, lineN, getDimensions(cm)); - cm.curOp.forceUpdate = true; - } - if (!view) - { view = updateExternalMeasurement(cm, line); } - - var info = mapFromLineView(view, line, lineN); - return { - line: line, view: view, rect: null, - map: info.map, cache: info.cache, before: info.before, - hasHeights: false - } -} - -// Given a prepared measurement object, measures the position of an -// actual character (or fetches it from the cache). -function measureCharPrepared(cm, prepared, ch, bias, varHeight) { - if (prepared.before) { ch = -1; } - var key = ch + (bias || ""), found; - if (prepared.cache.hasOwnProperty(key)) { - found = prepared.cache[key]; - } else { - if (!prepared.rect) - { prepared.rect = prepared.view.text.getBoundingClientRect(); } - if (!prepared.hasHeights) { - ensureLineHeights(cm, prepared.view, prepared.rect); - prepared.hasHeights = true; - } - found = measureCharInner(cm, prepared, ch, bias); - if (!found.bogus) { prepared.cache[key] = found; } - } - return {left: found.left, right: found.right, - top: varHeight ? found.rtop : found.top, - bottom: varHeight ? found.rbottom : found.bottom} -} - -var nullRect = {left: 0, right: 0, top: 0, bottom: 0}; - -function nodeAndOffsetInLineMap(map$$1, ch, bias) { - var node, start, end, collapse, mStart, mEnd; - // First, search the line map for the text node corresponding to, - // or closest to, the target character. - for (var i = 0; i < map$$1.length; i += 3) { - mStart = map$$1[i]; - mEnd = map$$1[i + 1]; - if (ch < mStart) { - start = 0; end = 1; - collapse = "left"; - } else if (ch < mEnd) { - start = ch - mStart; - end = start + 1; - } else if (i == map$$1.length - 3 || ch == mEnd && map$$1[i + 3] > ch) { - end = mEnd - mStart; - start = end - 1; - if (ch >= mEnd) { collapse = "right"; } - } - if (start != null) { - node = map$$1[i + 2]; - if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right")) - { collapse = bias; } - if (bias == "left" && start == 0) - { while (i && map$$1[i - 2] == map$$1[i - 3] && map$$1[i - 1].insertLeft) { - node = map$$1[(i -= 3) + 2]; - collapse = "left"; - } } - if (bias == "right" && start == mEnd - mStart) - { while (i < map$$1.length - 3 && map$$1[i + 3] == map$$1[i + 4] && !map$$1[i + 5].insertLeft) { - node = map$$1[(i += 3) + 2]; - collapse = "right"; - } } - break - } - } - return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd} -} - -function getUsefulRect(rects, bias) { - var rect = nullRect; - if (bias == "left") { for (var i = 0; i < rects.length; i++) { - if ((rect = rects[i]).left != rect.right) { break } - } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) { - if ((rect = rects[i$1]).left != rect.right) { break } - } } - return rect -} - -function measureCharInner(cm, prepared, ch, bias) { - var place = nodeAndOffsetInLineMap(prepared.map, ch, bias); - var node = place.node, start = place.start, end = place.end, collapse = place.collapse; - - var rect; - if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates. - for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned - while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start; } - while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end; } - if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart) - { rect = node.parentNode.getBoundingClientRect(); } - else - { rect = getUsefulRect(range(node, start, end).getClientRects(), bias); } - if (rect.left || rect.right || start == 0) { break } - end = start; - start = start - 1; - collapse = "right"; - } - if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect); } - } else { // If it is a widget, simply get the box for the whole widget. - if (start > 0) { collapse = bias = "right"; } - var rects; - if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1) - { rect = rects[bias == "right" ? rects.length - 1 : 0]; } - else - { rect = node.getBoundingClientRect(); } - } - if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) { - var rSpan = node.parentNode.getClientRects()[0]; - if (rSpan) - { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom}; } - else - { rect = nullRect; } - } - - var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top; - var mid = (rtop + rbot) / 2; - var heights = prepared.view.measure.heights; - var i = 0; - for (; i < heights.length - 1; i++) - { if (mid < heights[i]) { break } } - var top = i ? heights[i - 1] : 0, bot = heights[i]; - var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left, - right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left, - top: top, bottom: bot}; - if (!rect.left && !rect.right) { result.bogus = true; } - if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; } - - return result -} - -// Work around problem with bounding client rects on ranges being -// returned incorrectly when zoomed on IE10 and below. -function maybeUpdateRectForZooming(measure, rect) { - if (!window.screen || screen.logicalXDPI == null || - screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure)) - { return rect } - var scaleX = screen.logicalXDPI / screen.deviceXDPI; - var scaleY = screen.logicalYDPI / screen.deviceYDPI; - return {left: rect.left * scaleX, right: rect.right * scaleX, - top: rect.top * scaleY, bottom: rect.bottom * scaleY} -} - -function clearLineMeasurementCacheFor(lineView) { - if (lineView.measure) { - lineView.measure.cache = {}; - lineView.measure.heights = null; - if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++) - { lineView.measure.caches[i] = {}; } } - } -} - -function clearLineMeasurementCache(cm) { - cm.display.externalMeasure = null; - removeChildren(cm.display.lineMeasure); - for (var i = 0; i < cm.display.view.length; i++) - { clearLineMeasurementCacheFor(cm.display.view[i]); } -} - -function clearCaches(cm) { - clearLineMeasurementCache(cm); - cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null; - if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true; } - cm.display.lineNumChars = null; -} - -function pageScrollX() { - // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206 - // which causes page_Offset and bounding client rects to use - // different reference viewports and invalidate our calculations. - if (chrome && android) { return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft)) } - return window.pageXOffset || (document.documentElement || document.body).scrollLeft -} -function pageScrollY() { - if (chrome && android) { return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop)) } - return window.pageYOffset || (document.documentElement || document.body).scrollTop -} - -function widgetTopHeight(lineObj) { - var height = 0; - if (lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) - { height += widgetHeight(lineObj.widgets[i]); } } } - return height -} - -// Converts a {top, bottom, left, right} box from line-local -// coordinates into another coordinate system. Context may be one of -// "line", "div" (display.lineDiv), "local"./null (editor), "window", -// or "page". -function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) { - if (!includeWidgets) { - var height = widgetTopHeight(lineObj); - rect.top += height; rect.bottom += height; - } - if (context == "line") { return rect } - if (!context) { context = "local"; } - var yOff = heightAtLine(lineObj); - if (context == "local") { yOff += paddingTop(cm.display); } - else { yOff -= cm.display.viewOffset; } - if (context == "page" || context == "window") { - var lOff = cm.display.lineSpace.getBoundingClientRect(); - yOff += lOff.top + (context == "window" ? 0 : pageScrollY()); - var xOff = lOff.left + (context == "window" ? 0 : pageScrollX()); - rect.left += xOff; rect.right += xOff; - } - rect.top += yOff; rect.bottom += yOff; - return rect -} - -// Coverts a box from "div" coords to another coordinate system. -// Context may be "window", "page", "div", or "local"./null. -function fromCoordSystem(cm, coords, context) { - if (context == "div") { return coords } - var left = coords.left, top = coords.top; - // First move into "page" coordinate system - if (context == "page") { - left -= pageScrollX(); - top -= pageScrollY(); - } else if (context == "local" || !context) { - var localBox = cm.display.sizer.getBoundingClientRect(); - left += localBox.left; - top += localBox.top; - } - - var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect(); - return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top} -} - -function charCoords(cm, pos, context, lineObj, bias) { - if (!lineObj) { lineObj = getLine(cm.doc, pos.line); } - return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context) -} - -// Returns a box for a given cursor position, which may have an -// 'other' property containing the position of the secondary cursor -// on a bidi boundary. -// A cursor Pos(line, char, "before") is on the same visual line as `char - 1` -// and after `char - 1` in writing order of `char - 1` -// A cursor Pos(line, char, "after") is on the same visual line as `char` -// and before `char` in writing order of `char` -// Examples (upper-case letters are RTL, lower-case are LTR): -// Pos(0, 1, ...) -// before after -// ab a|b a|b -// aB a|B aB| -// Ab |Ab A|b -// AB B|A B|A -// Every position after the last character on a line is considered to stick -// to the last character on the line. -function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) { - lineObj = lineObj || getLine(cm.doc, pos.line); - if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); } - function get(ch, right) { - var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight); - if (right) { m.left = m.right; } else { m.right = m.left; } - return intoCoordSystem(cm, lineObj, m, context) - } - var order = getOrder(lineObj, cm.doc.direction), ch = pos.ch, sticky = pos.sticky; - if (ch >= lineObj.text.length) { - ch = lineObj.text.length; - sticky = "before"; - } else if (ch <= 0) { - ch = 0; - sticky = "after"; - } - if (!order) { return get(sticky == "before" ? ch - 1 : ch, sticky == "before") } - - function getBidi(ch, partPos, invert) { - var part = order[partPos], right = part.level == 1; - return get(invert ? ch - 1 : ch, right != invert) - } - var partPos = getBidiPartAt(order, ch, sticky); - var other = bidiOther; - var val = getBidi(ch, partPos, sticky == "before"); - if (other != null) { val.other = getBidi(ch, other, sticky != "before"); } - return val -} - -// Used to cheaply estimate the coordinates for a position. Used for -// intermediate scroll updates. -function estimateCoords(cm, pos) { - var left = 0; - pos = clipPos(cm.doc, pos); - if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch; } - var lineObj = getLine(cm.doc, pos.line); - var top = heightAtLine(lineObj) + paddingTop(cm.display); - return {left: left, right: left, top: top, bottom: top + lineObj.height} -} - -// Positions returned by coordsChar contain some extra information. -// xRel is the relative x position of the input coordinates compared -// to the found position (so xRel > 0 means the coordinates are to -// the right of the character position, for example). When outside -// is true, that means the coordinates lie outside the line's -// vertical range. -function PosWithInfo(line, ch, sticky, outside, xRel) { - var pos = Pos(line, ch, sticky); - pos.xRel = xRel; - if (outside) { pos.outside = true; } - return pos -} - -// Compute the character position closest to the given coordinates. -// Input must be lineSpace-local ("div" coordinate system). -function coordsChar(cm, x, y) { - var doc = cm.doc; - y += cm.display.viewOffset; - if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) } - var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1; - if (lineN > last) - { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) } - if (x < 0) { x = 0; } - - var lineObj = getLine(doc, lineN); - for (;;) { - var found = coordsCharInner(cm, lineObj, lineN, x, y); - var collapsed = collapsedSpanAround(lineObj, found.ch + (found.xRel > 0 ? 1 : 0)); - if (!collapsed) { return found } - var rangeEnd = collapsed.find(1); - if (rangeEnd.line == lineN) { return rangeEnd } - lineObj = getLine(doc, lineN = rangeEnd.line); - } -} - -function wrappedLineExtent(cm, lineObj, preparedMeasure, y) { - y -= widgetTopHeight(lineObj); - var end = lineObj.text.length; - var begin = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch - 1).bottom <= y; }, end, 0); - end = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch).top > y; }, begin, end); - return {begin: begin, end: end} -} - -function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) { - if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); } - var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), "line").top; - return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop) -} - -// Returns true if the given side of a box is after the given -// coordinates, in top-to-bottom, left-to-right order. -function boxIsAfter(box, x, y, left) { - return box.bottom <= y ? false : box.top > y ? true : (left ? box.left : box.right) > x -} - -function coordsCharInner(cm, lineObj, lineNo$$1, x, y) { - // Move y into line-local coordinate space - y -= heightAtLine(lineObj); - var preparedMeasure = prepareMeasureForLine(cm, lineObj); - // When directly calling `measureCharPrepared`, we have to adjust - // for the widgets at this line. - var widgetHeight$$1 = widgetTopHeight(lineObj); - var begin = 0, end = lineObj.text.length, ltr = true; - - var order = getOrder(lineObj, cm.doc.direction); - // If the line isn't plain left-to-right text, first figure out - // which bidi section the coordinates fall into. - if (order) { - var part = (cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart) - (cm, lineObj, lineNo$$1, preparedMeasure, order, x, y); - ltr = part.level != 1; - // The awkward -1 offsets are needed because findFirst (called - // on these below) will treat its first bound as inclusive, - // second as exclusive, but we want to actually address the - // characters in the part's range - begin = ltr ? part.from : part.to - 1; - end = ltr ? part.to : part.from - 1; - } - - // A binary search to find the first character whose bounding box - // starts after the coordinates. If we run across any whose box wrap - // the coordinates, store that. - var chAround = null, boxAround = null; - var ch = findFirst(function (ch) { - var box = measureCharPrepared(cm, preparedMeasure, ch); - box.top += widgetHeight$$1; box.bottom += widgetHeight$$1; - if (!boxIsAfter(box, x, y, false)) { return false } - if (box.top <= y && box.left <= x) { - chAround = ch; - boxAround = box; - } - return true - }, begin, end); - - var baseX, sticky, outside = false; - // If a box around the coordinates was found, use that - if (boxAround) { - // Distinguish coordinates nearer to the left or right side of the box - var atLeft = x - boxAround.left < boxAround.right - x, atStart = atLeft == ltr; - ch = chAround + (atStart ? 0 : 1); - sticky = atStart ? "after" : "before"; - baseX = atLeft ? boxAround.left : boxAround.right; - } else { - // (Adjust for extended bound, if necessary.) - if (!ltr && (ch == end || ch == begin)) { ch++; } - // To determine which side to associate with, get the box to the - // left of the character and compare it's vertical position to the - // coordinates - sticky = ch == 0 ? "after" : ch == lineObj.text.length ? "before" : - (measureCharPrepared(cm, preparedMeasure, ch - (ltr ? 1 : 0)).bottom + widgetHeight$$1 <= y) == ltr ? - "after" : "before"; - // Now get accurate coordinates for this place, in order to get a - // base X position - var coords = cursorCoords(cm, Pos(lineNo$$1, ch, sticky), "line", lineObj, preparedMeasure); - baseX = coords.left; - outside = y < coords.top || y >= coords.bottom; - } - - ch = skipExtendingChars(lineObj.text, ch, 1); - return PosWithInfo(lineNo$$1, ch, sticky, outside, x - baseX) -} - -function coordsBidiPart(cm, lineObj, lineNo$$1, preparedMeasure, order, x, y) { - // Bidi parts are sorted left-to-right, and in a non-line-wrapping - // situation, we can take this ordering to correspond to the visual - // ordering. This finds the first part whose end is after the given - // coordinates. - var index = findFirst(function (i) { - var part = order[i], ltr = part.level != 1; - return boxIsAfter(cursorCoords(cm, Pos(lineNo$$1, ltr ? part.to : part.from, ltr ? "before" : "after"), - "line", lineObj, preparedMeasure), x, y, true) - }, 0, order.length - 1); - var part = order[index]; - // If this isn't the first part, the part's start is also after - // the coordinates, and the coordinates aren't on the same line as - // that start, move one part back. - if (index > 0) { - var ltr = part.level != 1; - var start = cursorCoords(cm, Pos(lineNo$$1, ltr ? part.from : part.to, ltr ? "after" : "before"), - "line", lineObj, preparedMeasure); - if (boxIsAfter(start, x, y, true) && start.top > y) - { part = order[index - 1]; } - } - return part -} - -function coordsBidiPartWrapped(cm, lineObj, _lineNo, preparedMeasure, order, x, y) { - // In a wrapped line, rtl text on wrapping boundaries can do things - // that don't correspond to the ordering in our `order` array at - // all, so a binary search doesn't work, and we want to return a - // part that only spans one line so that the binary search in - // coordsCharInner is safe. As such, we first find the extent of the - // wrapped line, and then do a flat search in which we discard any - // spans that aren't on the line. - var ref = wrappedLineExtent(cm, lineObj, preparedMeasure, y); - var begin = ref.begin; - var end = ref.end; - if (/\s/.test(lineObj.text.charAt(end - 1))) { end--; } - var part = null, closestDist = null; - for (var i = 0; i < order.length; i++) { - var p = order[i]; - if (p.from >= end || p.to <= begin) { continue } - var ltr = p.level != 1; - var endX = measureCharPrepared(cm, preparedMeasure, ltr ? Math.min(end, p.to) - 1 : Math.max(begin, p.from)).right; - // Weigh against spans ending before this, so that they are only - // picked if nothing ends after - var dist = endX < x ? x - endX + 1e9 : endX - x; - if (!part || closestDist > dist) { - part = p; - closestDist = dist; - } - } - if (!part) { part = order[order.length - 1]; } - // Clip the part to the wrapped line. - if (part.from < begin) { part = {from: begin, to: part.to, level: part.level}; } - if (part.to > end) { part = {from: part.from, to: end, level: part.level}; } - return part -} - -var measureText; -// Compute the default text height. -function textHeight(display) { - if (display.cachedTextHeight != null) { return display.cachedTextHeight } - if (measureText == null) { - measureText = elt("pre"); - // Measure a bunch of lines, for browsers that compute - // fractional heights. - for (var i = 0; i < 49; ++i) { - measureText.appendChild(document.createTextNode("x")); - measureText.appendChild(elt("br")); - } - measureText.appendChild(document.createTextNode("x")); - } - removeChildrenAndAdd(display.measure, measureText); - var height = measureText.offsetHeight / 50; - if (height > 3) { display.cachedTextHeight = height; } - removeChildren(display.measure); - return height || 1 -} - -// Compute the default character width. -function charWidth(display) { - if (display.cachedCharWidth != null) { return display.cachedCharWidth } - var anchor = elt("span", "xxxxxxxxxx"); - var pre = elt("pre", [anchor]); - removeChildrenAndAdd(display.measure, pre); - var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10; - if (width > 2) { display.cachedCharWidth = width; } - return width || 10 -} - -// Do a bulk-read of the DOM positions and sizes needed to draw the -// view, so that we don't interleave reading and writing to the DOM. -function getDimensions(cm) { - var d = cm.display, left = {}, width = {}; - var gutterLeft = d.gutters.clientLeft; - for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) { - left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft; - width[cm.options.gutters[i]] = n.clientWidth; - } - return {fixedPos: compensateForHScroll(d), - gutterTotalWidth: d.gutters.offsetWidth, - gutterLeft: left, - gutterWidth: width, - wrapperWidth: d.wrapper.clientWidth} -} - -// Computes display.scroller.scrollLeft + display.gutters.offsetWidth, -// but using getBoundingClientRect to get a sub-pixel-accurate -// result. -function compensateForHScroll(display) { - return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left -} - -// Returns a function that estimates the height of a line, to use as -// first approximation until the line becomes visible (and is thus -// properly measurable). -function estimateHeight(cm) { - var th = textHeight(cm.display), wrapping = cm.options.lineWrapping; - var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3); - return function (line) { - if (lineIsHidden(cm.doc, line)) { return 0 } - - var widgetsHeight = 0; - if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) { - if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height; } - } } - - if (wrapping) - { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th } - else - { return widgetsHeight + th } - } -} - -function estimateLineHeights(cm) { - var doc = cm.doc, est = estimateHeight(cm); - doc.iter(function (line) { - var estHeight = est(line); - if (estHeight != line.height) { updateLineHeight(line, estHeight); } - }); -} - -// Given a mouse event, find the corresponding position. If liberal -// is false, it checks whether a gutter or scrollbar was clicked, -// and returns null if it was. forRect is used by rectangular -// selections, and tries to estimate a character position even for -// coordinates beyond the right of the text. -function posFromMouse(cm, e, liberal, forRect) { - var display = cm.display; - if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") { return null } - - var x, y, space = display.lineSpace.getBoundingClientRect(); - // Fails unpredictably on IE[67] when mouse is dragged around quickly. - try { x = e.clientX - space.left; y = e.clientY - space.top; } - catch (e) { return null } - var coords = coordsChar(cm, x, y), line; - if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) { - var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length; - coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff)); - } - return coords -} - -// Find the view element corresponding to a given line. Return null -// when the line isn't visible. -function findViewIndex(cm, n) { - if (n >= cm.display.viewTo) { return null } - n -= cm.display.viewFrom; - if (n < 0) { return null } - var view = cm.display.view; - for (var i = 0; i < view.length; i++) { - n -= view[i].size; - if (n < 0) { return i } - } -} - -function updateSelection(cm) { - cm.display.input.showSelection(cm.display.input.prepareSelection()); -} - -function prepareSelection(cm, primary) { - if ( primary === void 0 ) primary = true; - - var doc = cm.doc, result = {}; - var curFragment = result.cursors = document.createDocumentFragment(); - var selFragment = result.selection = document.createDocumentFragment(); - - for (var i = 0; i < doc.sel.ranges.length; i++) { - if (!primary && i == doc.sel.primIndex) { continue } - var range$$1 = doc.sel.ranges[i]; - if (range$$1.from().line >= cm.display.viewTo || range$$1.to().line < cm.display.viewFrom) { continue } - var collapsed = range$$1.empty(); - if (collapsed || cm.options.showCursorWhenSelecting) - { drawSelectionCursor(cm, range$$1.head, curFragment); } - if (!collapsed) - { drawSelectionRange(cm, range$$1, selFragment); } - } - return result -} - -// Draws a cursor for the given range -function drawSelectionCursor(cm, head, output) { - var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine); - - var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor")); - cursor.style.left = pos.left + "px"; - cursor.style.top = pos.top + "px"; - cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"; - - if (pos.other) { - // Secondary cursor, shown when on a 'jump' in bi-directional text - var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor")); - otherCursor.style.display = ""; - otherCursor.style.left = pos.other.left + "px"; - otherCursor.style.top = pos.other.top + "px"; - otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px"; - } -} - -function cmpCoords(a, b) { return a.top - b.top || a.left - b.left } - -// Draws the given range as a highlighted selection -function drawSelectionRange(cm, range$$1, output) { - var display = cm.display, doc = cm.doc; - var fragment = document.createDocumentFragment(); - var padding = paddingH(cm.display), leftSide = padding.left; - var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right; - var docLTR = doc.direction == "ltr"; - - function add(left, top, width, bottom) { - if (top < 0) { top = 0; } - top = Math.round(top); - bottom = Math.round(bottom); - fragment.appendChild(elt("div", null, "CodeMirror-selected", ("position: absolute; left: " + left + "px;\n top: " + top + "px; width: " + (width == null ? rightSide - left : width) + "px;\n height: " + (bottom - top) + "px"))); - } - - function drawForLine(line, fromArg, toArg) { - var lineObj = getLine(doc, line); - var lineLen = lineObj.text.length; - var start, end; - function coords(ch, bias) { - return charCoords(cm, Pos(line, ch), "div", lineObj, bias) - } - - function wrapX(pos, dir, side) { - var extent = wrappedLineExtentChar(cm, lineObj, null, pos); - var prop = (dir == "ltr") == (side == "after") ? "left" : "right"; - var ch = side == "after" ? extent.begin : extent.end - (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1); - return coords(ch, prop)[prop] - } - - var order = getOrder(lineObj, doc.direction); - iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir, i) { - var ltr = dir == "ltr"; - var fromPos = coords(from, ltr ? "left" : "right"); - var toPos = coords(to - 1, ltr ? "right" : "left"); - - var openStart = fromArg == null && from == 0, openEnd = toArg == null && to == lineLen; - var first = i == 0, last = !order || i == order.length - 1; - if (toPos.top - fromPos.top <= 3) { // Single line - var openLeft = (docLTR ? openStart : openEnd) && first; - var openRight = (docLTR ? openEnd : openStart) && last; - var left = openLeft ? leftSide : (ltr ? fromPos : toPos).left; - var right = openRight ? rightSide : (ltr ? toPos : fromPos).right; - add(left, fromPos.top, right - left, fromPos.bottom); - } else { // Multiple lines - var topLeft, topRight, botLeft, botRight; - if (ltr) { - topLeft = docLTR && openStart && first ? leftSide : fromPos.left; - topRight = docLTR ? rightSide : wrapX(from, dir, "before"); - botLeft = docLTR ? leftSide : wrapX(to, dir, "after"); - botRight = docLTR && openEnd && last ? rightSide : toPos.right; - } else { - topLeft = !docLTR ? leftSide : wrapX(from, dir, "before"); - topRight = !docLTR && openStart && first ? rightSide : fromPos.right; - botLeft = !docLTR && openEnd && last ? leftSide : toPos.left; - botRight = !docLTR ? rightSide : wrapX(to, dir, "after"); - } - add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom); - if (fromPos.bottom < toPos.top) { add(leftSide, fromPos.bottom, null, toPos.top); } - add(botLeft, toPos.top, botRight - botLeft, toPos.bottom); - } - - if (!start || cmpCoords(fromPos, start) < 0) { start = fromPos; } - if (cmpCoords(toPos, start) < 0) { start = toPos; } - if (!end || cmpCoords(fromPos, end) < 0) { end = fromPos; } - if (cmpCoords(toPos, end) < 0) { end = toPos; } - }); - return {start: start, end: end} - } - - var sFrom = range$$1.from(), sTo = range$$1.to(); - if (sFrom.line == sTo.line) { - drawForLine(sFrom.line, sFrom.ch, sTo.ch); - } else { - var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line); - var singleVLine = visualLine(fromLine) == visualLine(toLine); - var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end; - var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start; - if (singleVLine) { - if (leftEnd.top < rightStart.top - 2) { - add(leftEnd.right, leftEnd.top, null, leftEnd.bottom); - add(leftSide, rightStart.top, rightStart.left, rightStart.bottom); - } else { - add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom); - } - } - if (leftEnd.bottom < rightStart.top) - { add(leftSide, leftEnd.bottom, null, rightStart.top); } - } - - output.appendChild(fragment); -} - -// Cursor-blinking -function restartBlink(cm) { - if (!cm.state.focused) { return } - var display = cm.display; - clearInterval(display.blinker); - var on = true; - display.cursorDiv.style.visibility = ""; - if (cm.options.cursorBlinkRate > 0) - { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"; }, - cm.options.cursorBlinkRate); } - else if (cm.options.cursorBlinkRate < 0) - { display.cursorDiv.style.visibility = "hidden"; } -} - -function ensureFocus(cm) { - if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); } -} - -function delayBlurEvent(cm) { - cm.state.delayingBlurEvent = true; - setTimeout(function () { if (cm.state.delayingBlurEvent) { - cm.state.delayingBlurEvent = false; - onBlur(cm); - } }, 100); -} - -function onFocus(cm, e) { - if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false; } - - if (cm.options.readOnly == "nocursor") { return } - if (!cm.state.focused) { - signal(cm, "focus", cm, e); - cm.state.focused = true; - addClass(cm.display.wrapper, "CodeMirror-focused"); - // This test prevents this from firing when a context - // menu is closed (since the input reset would kill the - // select-all detection hack) - if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) { - cm.display.input.reset(); - if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20); } // Issue #1730 - } - cm.display.input.receivedFocus(); - } - restartBlink(cm); -} -function onBlur(cm, e) { - if (cm.state.delayingBlurEvent) { return } - - if (cm.state.focused) { - signal(cm, "blur", cm, e); - cm.state.focused = false; - rmClass(cm.display.wrapper, "CodeMirror-focused"); - } - clearInterval(cm.display.blinker); - setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false; } }, 150); -} - -// Read the actual heights of the rendered lines, and update their -// stored heights to match. -function updateHeightsInViewport(cm) { - var display = cm.display; - var prevBottom = display.lineDiv.offsetTop; - for (var i = 0; i < display.view.length; i++) { - var cur = display.view[i], height = (void 0); - if (cur.hidden) { continue } - if (ie && ie_version < 8) { - var bot = cur.node.offsetTop + cur.node.offsetHeight; - height = bot - prevBottom; - prevBottom = bot; - } else { - var box = cur.node.getBoundingClientRect(); - height = box.bottom - box.top; - } - var diff = cur.line.height - height; - if (height < 2) { height = textHeight(display); } - if (diff > .005 || diff < -.005) { - updateLineHeight(cur.line, height); - updateWidgetHeight(cur.line); - if (cur.rest) { for (var j = 0; j < cur.rest.length; j++) - { updateWidgetHeight(cur.rest[j]); } } - } - } -} - -// Read and store the height of line widgets associated with the -// given line. -function updateWidgetHeight(line) { - if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i) { - var w = line.widgets[i], parent = w.node.parentNode; - if (parent) { w.height = parent.offsetHeight; } - } } -} - -// Compute the lines that are visible in a given viewport (defaults -// the the current scroll position). viewport may contain top, -// height, and ensure (see op.scrollToPos) properties. -function visibleLines(display, doc, viewport) { - var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop; - top = Math.floor(top - paddingTop(display)); - var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight; - - var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom); - // Ensure is a {from: {line, ch}, to: {line, ch}} object, and - // forces those lines into the viewport (if possible). - if (viewport && viewport.ensure) { - var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line; - if (ensureFrom < from) { - from = ensureFrom; - to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight); - } else if (Math.min(ensureTo, doc.lastLine()) >= to) { - from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight); - to = ensureTo; - } - } - return {from: from, to: Math.max(to, from + 1)} -} - -// Re-align line numbers and gutter marks to compensate for -// horizontal scrolling. -function alignHorizontally(cm) { - var display = cm.display, view = display.view; - if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return } - var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft; - var gutterW = display.gutters.offsetWidth, left = comp + "px"; - for (var i = 0; i < view.length; i++) { if (!view[i].hidden) { - if (cm.options.fixedGutter) { - if (view[i].gutter) - { view[i].gutter.style.left = left; } - if (view[i].gutterBackground) - { view[i].gutterBackground.style.left = left; } - } - var align = view[i].alignable; - if (align) { for (var j = 0; j < align.length; j++) - { align[j].style.left = left; } } - } } - if (cm.options.fixedGutter) - { display.gutters.style.left = (comp + gutterW) + "px"; } -} - -// Used to ensure that the line number gutter is still the right -// size for the current document size. Returns true when an update -// is needed. -function maybeUpdateLineNumberWidth(cm) { - if (!cm.options.lineNumbers) { return false } - var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display; - if (last.length != display.lineNumChars) { - var test = display.measure.appendChild(elt("div", [elt("div", last)], - "CodeMirror-linenumber CodeMirror-gutter-elt")); - var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW; - display.lineGutter.style.width = ""; - display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1; - display.lineNumWidth = display.lineNumInnerWidth + padding; - display.lineNumChars = display.lineNumInnerWidth ? last.length : -1; - display.lineGutter.style.width = display.lineNumWidth + "px"; - updateGutterSpace(cm); - return true - } - return false -} - -// SCROLLING THINGS INTO VIEW - -// If an editor sits on the top or bottom of the window, partially -// scrolled out of view, this ensures that the cursor is visible. -function maybeScrollWindow(cm, rect) { - if (signalDOMEvent(cm, "scrollCursorIntoView")) { return } - - var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null; - if (rect.top + box.top < 0) { doScroll = true; } - else if (rect.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false; } - if (doScroll != null && !phantom) { - var scrollNode = elt("div", "\u200b", null, ("position: absolute;\n top: " + (rect.top - display.viewOffset - paddingTop(cm.display)) + "px;\n height: " + (rect.bottom - rect.top + scrollGap(cm) + display.barHeight) + "px;\n left: " + (rect.left) + "px; width: " + (Math.max(2, rect.right - rect.left)) + "px;")); - cm.display.lineSpace.appendChild(scrollNode); - scrollNode.scrollIntoView(doScroll); - cm.display.lineSpace.removeChild(scrollNode); - } -} - -// Scroll a given position into view (immediately), verifying that -// it actually became visible (as line heights are accurately -// measured, the position of something may 'drift' during drawing). -function scrollPosIntoView(cm, pos, end, margin) { - if (margin == null) { margin = 0; } - var rect; - if (!cm.options.lineWrapping && pos == end) { - // Set pos and end to the cursor positions around the character pos sticks to - // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch - // If pos == Pos(_, 0, "before"), pos and end are unchanged - pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos; - end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos; - } - for (var limit = 0; limit < 5; limit++) { - var changed = false; - var coords = cursorCoords(cm, pos); - var endCoords = !end || end == pos ? coords : cursorCoords(cm, end); - rect = {left: Math.min(coords.left, endCoords.left), - top: Math.min(coords.top, endCoords.top) - margin, - right: Math.max(coords.left, endCoords.left), - bottom: Math.max(coords.bottom, endCoords.bottom) + margin}; - var scrollPos = calculateScrollPos(cm, rect); - var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft; - if (scrollPos.scrollTop != null) { - updateScrollTop(cm, scrollPos.scrollTop); - if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true; } - } - if (scrollPos.scrollLeft != null) { - setScrollLeft(cm, scrollPos.scrollLeft); - if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true; } - } - if (!changed) { break } - } - return rect -} - -// Scroll a given set of coordinates into view (immediately). -function scrollIntoView(cm, rect) { - var scrollPos = calculateScrollPos(cm, rect); - if (scrollPos.scrollTop != null) { updateScrollTop(cm, scrollPos.scrollTop); } - if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft); } -} - -// Calculate a new scroll position needed to scroll the given -// rectangle into view. Returns an object with scrollTop and -// scrollLeft properties. When these are undefined, the -// vertical/horizontal position does not need to be adjusted. -function calculateScrollPos(cm, rect) { - var display = cm.display, snapMargin = textHeight(cm.display); - if (rect.top < 0) { rect.top = 0; } - var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop; - var screen = displayHeight(cm), result = {}; - if (rect.bottom - rect.top > screen) { rect.bottom = rect.top + screen; } - var docBottom = cm.doc.height + paddingVert(display); - var atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin; - if (rect.top < screentop) { - result.scrollTop = atTop ? 0 : rect.top; - } else if (rect.bottom > screentop + screen) { - var newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen); - if (newTop != screentop) { result.scrollTop = newTop; } - } - - var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft; - var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0); - var tooWide = rect.right - rect.left > screenw; - if (tooWide) { rect.right = rect.left + screenw; } - if (rect.left < 10) - { result.scrollLeft = 0; } - else if (rect.left < screenleft) - { result.scrollLeft = Math.max(0, rect.left - (tooWide ? 0 : 10)); } - else if (rect.right > screenw + screenleft - 3) - { result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw; } - return result -} - -// Store a relative adjustment to the scroll position in the current -// operation (to be applied when the operation finishes). -function addToScrollTop(cm, top) { - if (top == null) { return } - resolveScrollToPos(cm); - cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top; -} - -// Make sure that at the end of the operation the current cursor is -// shown. -function ensureCursorVisible(cm) { - resolveScrollToPos(cm); - var cur = cm.getCursor(); - cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin}; -} - -function scrollToCoords(cm, x, y) { - if (x != null || y != null) { resolveScrollToPos(cm); } - if (x != null) { cm.curOp.scrollLeft = x; } - if (y != null) { cm.curOp.scrollTop = y; } -} - -function scrollToRange(cm, range$$1) { - resolveScrollToPos(cm); - cm.curOp.scrollToPos = range$$1; -} - -// When an operation has its scrollToPos property set, and another -// scroll action is applied before the end of the operation, this -// 'simulates' scrolling that position into view in a cheap way, so -// that the effect of intermediate scroll commands is not ignored. -function resolveScrollToPos(cm) { - var range$$1 = cm.curOp.scrollToPos; - if (range$$1) { - cm.curOp.scrollToPos = null; - var from = estimateCoords(cm, range$$1.from), to = estimateCoords(cm, range$$1.to); - scrollToCoordsRange(cm, from, to, range$$1.margin); - } -} - -function scrollToCoordsRange(cm, from, to, margin) { - var sPos = calculateScrollPos(cm, { - left: Math.min(from.left, to.left), - top: Math.min(from.top, to.top) - margin, - right: Math.max(from.right, to.right), - bottom: Math.max(from.bottom, to.bottom) + margin - }); - scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop); -} - -// Sync the scrollable area and scrollbars, ensure the viewport -// covers the visible area. -function updateScrollTop(cm, val) { - if (Math.abs(cm.doc.scrollTop - val) < 2) { return } - if (!gecko) { updateDisplaySimple(cm, {top: val}); } - setScrollTop(cm, val, true); - if (gecko) { updateDisplaySimple(cm); } - startWorker(cm, 100); -} - -function setScrollTop(cm, val, forceScroll) { - val = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val); - if (cm.display.scroller.scrollTop == val && !forceScroll) { return } - cm.doc.scrollTop = val; - cm.display.scrollbars.setScrollTop(val); - if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val; } -} - -// Sync scroller and scrollbar, ensure the gutter elements are -// aligned. -function setScrollLeft(cm, val, isScroller, forceScroll) { - val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth); - if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) { return } - cm.doc.scrollLeft = val; - alignHorizontally(cm); - if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val; } - cm.display.scrollbars.setScrollLeft(val); -} - -// SCROLLBARS - -// Prepare DOM reads needed to update the scrollbars. Done in one -// shot to minimize update/measure roundtrips. -function measureForScrollbars(cm) { - var d = cm.display, gutterW = d.gutters.offsetWidth; - var docH = Math.round(cm.doc.height + paddingVert(cm.display)); - return { - clientHeight: d.scroller.clientHeight, - viewHeight: d.wrapper.clientHeight, - scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth, - viewWidth: d.wrapper.clientWidth, - barLeft: cm.options.fixedGutter ? gutterW : 0, - docHeight: docH, - scrollHeight: docH + scrollGap(cm) + d.barHeight, - nativeBarWidth: d.nativeBarWidth, - gutterWidth: gutterW - } -} - -var NativeScrollbars = function(place, scroll, cm) { - this.cm = cm; - var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar"); - var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar"); - vert.tabIndex = horiz.tabIndex = -1; - place(vert); place(horiz); - - on(vert, "scroll", function () { - if (vert.clientHeight) { scroll(vert.scrollTop, "vertical"); } - }); - on(horiz, "scroll", function () { - if (horiz.clientWidth) { scroll(horiz.scrollLeft, "horizontal"); } - }); - - this.checkedZeroWidth = false; - // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8). - if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = "18px"; } -}; - -NativeScrollbars.prototype.update = function (measure) { - var needsH = measure.scrollWidth > measure.clientWidth + 1; - var needsV = measure.scrollHeight > measure.clientHeight + 1; - var sWidth = measure.nativeBarWidth; - - if (needsV) { - this.vert.style.display = "block"; - this.vert.style.bottom = needsH ? sWidth + "px" : "0"; - var totalHeight = measure.viewHeight - (needsH ? sWidth : 0); - // A bug in IE8 can cause this value to be negative, so guard it. - this.vert.firstChild.style.height = - Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px"; - } else { - this.vert.style.display = ""; - this.vert.firstChild.style.height = "0"; - } - - if (needsH) { - this.horiz.style.display = "block"; - this.horiz.style.right = needsV ? sWidth + "px" : "0"; - this.horiz.style.left = measure.barLeft + "px"; - var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0); - this.horiz.firstChild.style.width = - Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + "px"; - } else { - this.horiz.style.display = ""; - this.horiz.firstChild.style.width = "0"; - } - - if (!this.checkedZeroWidth && measure.clientHeight > 0) { - if (sWidth == 0) { this.zeroWidthHack(); } - this.checkedZeroWidth = true; - } - - return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0} -}; - -NativeScrollbars.prototype.setScrollLeft = function (pos) { - if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos; } - if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz"); } -}; - -NativeScrollbars.prototype.setScrollTop = function (pos) { - if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos; } - if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert, "vert"); } -}; - -NativeScrollbars.prototype.zeroWidthHack = function () { - var w = mac && !mac_geMountainLion ? "12px" : "18px"; - this.horiz.style.height = this.vert.style.width = w; - this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none"; - this.disableHoriz = new Delayed; - this.disableVert = new Delayed; -}; - -NativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay, type) { - bar.style.pointerEvents = "auto"; - function maybeDisable() { - // To find out whether the scrollbar is still visible, we - // check whether the element under the pixel in the bottom - // right corner of the scrollbar box is the scrollbar box - // itself (when the bar is still visible) or its filler child - // (when the bar is hidden). If it is still visible, we keep - // it enabled, if it's hidden, we disable pointer events. - var box = bar.getBoundingClientRect(); - var elt$$1 = type == "vert" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2) - : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1); - if (elt$$1 != bar) { bar.style.pointerEvents = "none"; } - else { delay.set(1000, maybeDisable); } - } - delay.set(1000, maybeDisable); -}; - -NativeScrollbars.prototype.clear = function () { - var parent = this.horiz.parentNode; - parent.removeChild(this.horiz); - parent.removeChild(this.vert); -}; - -var NullScrollbars = function () {}; - -NullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} }; -NullScrollbars.prototype.setScrollLeft = function () {}; -NullScrollbars.prototype.setScrollTop = function () {}; -NullScrollbars.prototype.clear = function () {}; - -function updateScrollbars(cm, measure) { - if (!measure) { measure = measureForScrollbars(cm); } - var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight; - updateScrollbarsInner(cm, measure); - for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) { - if (startWidth != cm.display.barWidth && cm.options.lineWrapping) - { updateHeightsInViewport(cm); } - updateScrollbarsInner(cm, measureForScrollbars(cm)); - startWidth = cm.display.barWidth; startHeight = cm.display.barHeight; - } -} - -// Re-synchronize the fake scrollbars with the actual size of the -// content. -function updateScrollbarsInner(cm, measure) { - var d = cm.display; - var sizes = d.scrollbars.update(measure); - - d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px"; - d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px"; - d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"; - - if (sizes.right && sizes.bottom) { - d.scrollbarFiller.style.display = "block"; - d.scrollbarFiller.style.height = sizes.bottom + "px"; - d.scrollbarFiller.style.width = sizes.right + "px"; - } else { d.scrollbarFiller.style.display = ""; } - if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) { - d.gutterFiller.style.display = "block"; - d.gutterFiller.style.height = sizes.bottom + "px"; - d.gutterFiller.style.width = measure.gutterWidth + "px"; - } else { d.gutterFiller.style.display = ""; } -} - -var scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars}; - -function initScrollbars(cm) { - if (cm.display.scrollbars) { - cm.display.scrollbars.clear(); - if (cm.display.scrollbars.addClass) - { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass); } - } - - cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) { - cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller); - // Prevent clicks in the scrollbars from killing focus - on(node, "mousedown", function () { - if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0); } - }); - node.setAttribute("cm-not-content", "true"); - }, function (pos, axis) { - if (axis == "horizontal") { setScrollLeft(cm, pos); } - else { updateScrollTop(cm, pos); } - }, cm); - if (cm.display.scrollbars.addClass) - { addClass(cm.display.wrapper, cm.display.scrollbars.addClass); } -} - -// Operations are used to wrap a series of changes to the editor -// state in such a way that each change won't have to update the -// cursor and display (which would be awkward, slow, and -// error-prone). Instead, display updates are batched and then all -// combined and executed at once. - -var nextOpId = 0; -// Start a new operation. -function startOperation(cm) { - cm.curOp = { - cm: cm, - viewChanged: false, // Flag that indicates that lines might need to be redrawn - startHeight: cm.doc.height, // Used to detect need to update scrollbar - forceUpdate: false, // Used to force a redraw - updateInput: null, // Whether to reset the input textarea - typing: false, // Whether this reset should be careful to leave existing text (for compositing) - changeObjs: null, // Accumulated changes, for firing change events - cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on - cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already - selectionChanged: false, // Whether the selection needs to be redrawn - updateMaxLine: false, // Set when the widest line needs to be determined anew - scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet - scrollToPos: null, // Used to scroll to a specific position - focus: false, - id: ++nextOpId // Unique ID - }; - pushOperation(cm.curOp); -} - -// Finish an operation, updating the display and signalling delayed events -function endOperation(cm) { - var op = cm.curOp; - finishOperation(op, function (group) { - for (var i = 0; i < group.ops.length; i++) - { group.ops[i].cm.curOp = null; } - endOperations(group); - }); -} - -// The DOM updates done when an operation finishes are batched so -// that the minimum number of relayouts are required. -function endOperations(group) { - var ops = group.ops; - for (var i = 0; i < ops.length; i++) // Read DOM - { endOperation_R1(ops[i]); } - for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe) - { endOperation_W1(ops[i$1]); } - for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM - { endOperation_R2(ops[i$2]); } - for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe) - { endOperation_W2(ops[i$3]); } - for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM - { endOperation_finish(ops[i$4]); } -} - -function endOperation_R1(op) { - var cm = op.cm, display = cm.display; - maybeClipScrollbars(cm); - if (op.updateMaxLine) { findMaxLine(cm); } - - op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null || - op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom || - op.scrollToPos.to.line >= display.viewTo) || - display.maxLineChanged && cm.options.lineWrapping; - op.update = op.mustUpdate && - new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate); -} - -function endOperation_W1(op) { - op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update); -} - -function endOperation_R2(op) { - var cm = op.cm, display = cm.display; - if (op.updatedDisplay) { updateHeightsInViewport(cm); } - - op.barMeasure = measureForScrollbars(cm); - - // If the max line changed since it was last measured, measure it, - // and ensure the document's width matches it. - // updateDisplay_W2 will use these properties to do the actual resizing - if (display.maxLineChanged && !cm.options.lineWrapping) { - op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3; - cm.display.sizerWidth = op.adjustWidthTo; - op.barMeasure.scrollWidth = - Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth); - op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm)); - } - - if (op.updatedDisplay || op.selectionChanged) - { op.preparedSelection = display.input.prepareSelection(); } -} - -function endOperation_W2(op) { - var cm = op.cm; - - if (op.adjustWidthTo != null) { - cm.display.sizer.style.minWidth = op.adjustWidthTo + "px"; - if (op.maxScrollLeft < cm.doc.scrollLeft) - { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true); } - cm.display.maxLineChanged = false; - } - - var takeFocus = op.focus && op.focus == activeElt(); - if (op.preparedSelection) - { cm.display.input.showSelection(op.preparedSelection, takeFocus); } - if (op.updatedDisplay || op.startHeight != cm.doc.height) - { updateScrollbars(cm, op.barMeasure); } - if (op.updatedDisplay) - { setDocumentHeight(cm, op.barMeasure); } - - if (op.selectionChanged) { restartBlink(cm); } - - if (cm.state.focused && op.updateInput) - { cm.display.input.reset(op.typing); } - if (takeFocus) { ensureFocus(op.cm); } -} - -function endOperation_finish(op) { - var cm = op.cm, display = cm.display, doc = cm.doc; - - if (op.updatedDisplay) { postUpdateDisplay(cm, op.update); } - - // Abort mouse wheel delta measurement, when scrolling explicitly - if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos)) - { display.wheelStartX = display.wheelStartY = null; } - - // Propagate the scroll position to the actual DOM scroller - if (op.scrollTop != null) { setScrollTop(cm, op.scrollTop, op.forceScroll); } - - if (op.scrollLeft != null) { setScrollLeft(cm, op.scrollLeft, true, true); } - // If we need to scroll a specific position into view, do so. - if (op.scrollToPos) { - var rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from), - clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin); - maybeScrollWindow(cm, rect); - } - - // Fire events for markers that are hidden/unidden by editing or - // undoing - var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers; - if (hidden) { for (var i = 0; i < hidden.length; ++i) - { if (!hidden[i].lines.length) { signal(hidden[i], "hide"); } } } - if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1) - { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], "unhide"); } } } - - if (display.wrapper.offsetHeight) - { doc.scrollTop = cm.display.scroller.scrollTop; } - - // Fire change events, and delayed event handlers - if (op.changeObjs) - { signal(cm, "changes", cm, op.changeObjs); } - if (op.update) - { op.update.finish(); } -} - -// Run the given function in an operation -function runInOp(cm, f) { - if (cm.curOp) { return f() } - startOperation(cm); - try { return f() } - finally { endOperation(cm); } -} -// Wraps a function in an operation. Returns the wrapped function. -function operation(cm, f) { - return function() { - if (cm.curOp) { return f.apply(cm, arguments) } - startOperation(cm); - try { return f.apply(cm, arguments) } - finally { endOperation(cm); } - } -} -// Used to add methods to editor and doc instances, wrapping them in -// operations. -function methodOp(f) { - return function() { - if (this.curOp) { return f.apply(this, arguments) } - startOperation(this); - try { return f.apply(this, arguments) } - finally { endOperation(this); } - } -} -function docMethodOp(f) { - return function() { - var cm = this.cm; - if (!cm || cm.curOp) { return f.apply(this, arguments) } - startOperation(cm); - try { return f.apply(this, arguments) } - finally { endOperation(cm); } - } -} - -// Updates the display.view data structure for a given change to the -// document. From and to are in pre-change coordinates. Lendiff is -// the amount of lines added or subtracted by the change. This is -// used for changes that span multiple lines, or change the way -// lines are divided into visual lines. regLineChange (below) -// registers single-line changes. -function regChange(cm, from, to, lendiff) { - if (from == null) { from = cm.doc.first; } - if (to == null) { to = cm.doc.first + cm.doc.size; } - if (!lendiff) { lendiff = 0; } - - var display = cm.display; - if (lendiff && to < display.viewTo && - (display.updateLineNumbers == null || display.updateLineNumbers > from)) - { display.updateLineNumbers = from; } - - cm.curOp.viewChanged = true; - - if (from >= display.viewTo) { // Change after - if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo) - { resetView(cm); } - } else if (to <= display.viewFrom) { // Change before - if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) { - resetView(cm); - } else { - display.viewFrom += lendiff; - display.viewTo += lendiff; - } - } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap - resetView(cm); - } else if (from <= display.viewFrom) { // Top overlap - var cut = viewCuttingPoint(cm, to, to + lendiff, 1); - if (cut) { - display.view = display.view.slice(cut.index); - display.viewFrom = cut.lineN; - display.viewTo += lendiff; - } else { - resetView(cm); - } - } else if (to >= display.viewTo) { // Bottom overlap - var cut$1 = viewCuttingPoint(cm, from, from, -1); - if (cut$1) { - display.view = display.view.slice(0, cut$1.index); - display.viewTo = cut$1.lineN; - } else { - resetView(cm); - } - } else { // Gap in the middle - var cutTop = viewCuttingPoint(cm, from, from, -1); - var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1); - if (cutTop && cutBot) { - display.view = display.view.slice(0, cutTop.index) - .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN)) - .concat(display.view.slice(cutBot.index)); - display.viewTo += lendiff; - } else { - resetView(cm); - } - } - - var ext = display.externalMeasured; - if (ext) { - if (to < ext.lineN) - { ext.lineN += lendiff; } - else if (from < ext.lineN + ext.size) - { display.externalMeasured = null; } - } -} - -// Register a change to a single line. Type must be one of "text", -// "gutter", "class", "widget" -function regLineChange(cm, line, type) { - cm.curOp.viewChanged = true; - var display = cm.display, ext = cm.display.externalMeasured; - if (ext && line >= ext.lineN && line < ext.lineN + ext.size) - { display.externalMeasured = null; } - - if (line < display.viewFrom || line >= display.viewTo) { return } - var lineView = display.view[findViewIndex(cm, line)]; - if (lineView.node == null) { return } - var arr = lineView.changes || (lineView.changes = []); - if (indexOf(arr, type) == -1) { arr.push(type); } -} - -// Clear the view. -function resetView(cm) { - cm.display.viewFrom = cm.display.viewTo = cm.doc.first; - cm.display.view = []; - cm.display.viewOffset = 0; -} - -function viewCuttingPoint(cm, oldN, newN, dir) { - var index = findViewIndex(cm, oldN), diff, view = cm.display.view; - if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size) - { return {index: index, lineN: newN} } - var n = cm.display.viewFrom; - for (var i = 0; i < index; i++) - { n += view[i].size; } - if (n != oldN) { - if (dir > 0) { - if (index == view.length - 1) { return null } - diff = (n + view[index].size) - oldN; - index++; - } else { - diff = n - oldN; - } - oldN += diff; newN += diff; - } - while (visualLineNo(cm.doc, newN) != newN) { - if (index == (dir < 0 ? 0 : view.length - 1)) { return null } - newN += dir * view[index - (dir < 0 ? 1 : 0)].size; - index += dir; - } - return {index: index, lineN: newN} -} - -// Force the view to cover a given range, adding empty view element -// or clipping off existing ones as needed. -function adjustView(cm, from, to) { - var display = cm.display, view = display.view; - if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) { - display.view = buildViewArray(cm, from, to); - display.viewFrom = from; - } else { - if (display.viewFrom > from) - { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view); } - else if (display.viewFrom < from) - { display.view = display.view.slice(findViewIndex(cm, from)); } - display.viewFrom = from; - if (display.viewTo < to) - { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)); } - else if (display.viewTo > to) - { display.view = display.view.slice(0, findViewIndex(cm, to)); } - } - display.viewTo = to; -} - -// Count the number of lines in the view whose DOM representation is -// out of date (or nonexistent). -function countDirtyView(cm) { - var view = cm.display.view, dirty = 0; - for (var i = 0; i < view.length; i++) { - var lineView = view[i]; - if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty; } - } - return dirty -} - -// HIGHLIGHT WORKER - -function startWorker(cm, time) { - if (cm.doc.highlightFrontier < cm.display.viewTo) - { cm.state.highlight.set(time, bind(highlightWorker, cm)); } -} - -function highlightWorker(cm) { - var doc = cm.doc; - if (doc.highlightFrontier >= cm.display.viewTo) { return } - var end = +new Date + cm.options.workTime; - var context = getContextBefore(cm, doc.highlightFrontier); - var changedLines = []; - - doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) { - if (context.line >= cm.display.viewFrom) { // Visible - var oldStyles = line.styles; - var resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null; - var highlighted = highlightLine(cm, line, context, true); - if (resetState) { context.state = resetState; } - line.styles = highlighted.styles; - var oldCls = line.styleClasses, newCls = highlighted.classes; - if (newCls) { line.styleClasses = newCls; } - else if (oldCls) { line.styleClasses = null; } - var ischange = !oldStyles || oldStyles.length != line.styles.length || - oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass); - for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i]; } - if (ischange) { changedLines.push(context.line); } - line.stateAfter = context.save(); - context.nextLine(); - } else { - if (line.text.length <= cm.options.maxHighlightLength) - { processLine(cm, line.text, context); } - line.stateAfter = context.line % 5 == 0 ? context.save() : null; - context.nextLine(); - } - if (+new Date > end) { - startWorker(cm, cm.options.workDelay); - return true - } - }); - doc.highlightFrontier = context.line; - doc.modeFrontier = Math.max(doc.modeFrontier, context.line); - if (changedLines.length) { runInOp(cm, function () { - for (var i = 0; i < changedLines.length; i++) - { regLineChange(cm, changedLines[i], "text"); } - }); } -} - -// DISPLAY DRAWING - -var DisplayUpdate = function(cm, viewport, force) { - var display = cm.display; - - this.viewport = viewport; - // Store some values that we'll need later (but don't want to force a relayout for) - this.visible = visibleLines(display, cm.doc, viewport); - this.editorIsHidden = !display.wrapper.offsetWidth; - this.wrapperHeight = display.wrapper.clientHeight; - this.wrapperWidth = display.wrapper.clientWidth; - this.oldDisplayWidth = displayWidth(cm); - this.force = force; - this.dims = getDimensions(cm); - this.events = []; -}; - -DisplayUpdate.prototype.signal = function (emitter, type) { - if (hasHandler(emitter, type)) - { this.events.push(arguments); } -}; -DisplayUpdate.prototype.finish = function () { - var this$1 = this; - - for (var i = 0; i < this.events.length; i++) - { signal.apply(null, this$1.events[i]); } -}; - -function maybeClipScrollbars(cm) { - var display = cm.display; - if (!display.scrollbarsClipped && display.scroller.offsetWidth) { - display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth; - display.heightForcer.style.height = scrollGap(cm) + "px"; - display.sizer.style.marginBottom = -display.nativeBarWidth + "px"; - display.sizer.style.borderRightWidth = scrollGap(cm) + "px"; - display.scrollbarsClipped = true; - } -} - -function selectionSnapshot(cm) { - if (cm.hasFocus()) { return null } - var active = activeElt(); - if (!active || !contains(cm.display.lineDiv, active)) { return null } - var result = {activeElt: active}; - if (window.getSelection) { - var sel = window.getSelection(); - if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) { - result.anchorNode = sel.anchorNode; - result.anchorOffset = sel.anchorOffset; - result.focusNode = sel.focusNode; - result.focusOffset = sel.focusOffset; - } - } - return result -} - -function restoreSelection(snapshot) { - if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt()) { return } - snapshot.activeElt.focus(); - if (snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) { - var sel = window.getSelection(), range$$1 = document.createRange(); - range$$1.setEnd(snapshot.anchorNode, snapshot.anchorOffset); - range$$1.collapse(false); - sel.removeAllRanges(); - sel.addRange(range$$1); - sel.extend(snapshot.focusNode, snapshot.focusOffset); - } -} - -// Does the actual updating of the line display. Bails out -// (returning false) when there is nothing to be done and forced is -// false. -function updateDisplayIfNeeded(cm, update) { - var display = cm.display, doc = cm.doc; - - if (update.editorIsHidden) { - resetView(cm); - return false - } - - // Bail out if the visible area is already rendered and nothing changed. - if (!update.force && - update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo && - (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) && - display.renderedView == display.view && countDirtyView(cm) == 0) - { return false } - - if (maybeUpdateLineNumberWidth(cm)) { - resetView(cm); - update.dims = getDimensions(cm); - } - - // Compute a suitable new viewport (from & to) - var end = doc.first + doc.size; - var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first); - var to = Math.min(end, update.visible.to + cm.options.viewportMargin); - if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom); } - if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo); } - if (sawCollapsedSpans) { - from = visualLineNo(cm.doc, from); - to = visualLineEndNo(cm.doc, to); - } - - var different = from != display.viewFrom || to != display.viewTo || - display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth; - adjustView(cm, from, to); - - display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom)); - // Position the mover div to align with the current scroll position - cm.display.mover.style.top = display.viewOffset + "px"; - - var toUpdate = countDirtyView(cm); - if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view && - (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo)) - { return false } - - // For big changes, we hide the enclosing element during the - // update, since that speeds up the operations on most browsers. - var selSnapshot = selectionSnapshot(cm); - if (toUpdate > 4) { display.lineDiv.style.display = "none"; } - patchDisplay(cm, display.updateLineNumbers, update.dims); - if (toUpdate > 4) { display.lineDiv.style.display = ""; } - display.renderedView = display.view; - // There might have been a widget with a focused element that got - // hidden or updated, if so re-focus it. - restoreSelection(selSnapshot); - - // Prevent selection and cursors from interfering with the scroll - // width and height. - removeChildren(display.cursorDiv); - removeChildren(display.selectionDiv); - display.gutters.style.height = display.sizer.style.minHeight = 0; - - if (different) { - display.lastWrapHeight = update.wrapperHeight; - display.lastWrapWidth = update.wrapperWidth; - startWorker(cm, 400); - } - - display.updateLineNumbers = null; - - return true -} - -function postUpdateDisplay(cm, update) { - var viewport = update.viewport; - - for (var first = true;; first = false) { - if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) { - // Clip forced viewport to actual scrollable area. - if (viewport && viewport.top != null) - { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)}; } - // Updated line heights might result in the drawn area not - // actually covering the viewport. Keep looping until it does. - update.visible = visibleLines(cm.display, cm.doc, viewport); - if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo) - { break } - } - if (!updateDisplayIfNeeded(cm, update)) { break } - updateHeightsInViewport(cm); - var barMeasure = measureForScrollbars(cm); - updateSelection(cm); - updateScrollbars(cm, barMeasure); - setDocumentHeight(cm, barMeasure); - update.force = false; - } - - update.signal(cm, "update", cm); - if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) { - update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo); - cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo; - } -} - -function updateDisplaySimple(cm, viewport) { - var update = new DisplayUpdate(cm, viewport); - if (updateDisplayIfNeeded(cm, update)) { - updateHeightsInViewport(cm); - postUpdateDisplay(cm, update); - var barMeasure = measureForScrollbars(cm); - updateSelection(cm); - updateScrollbars(cm, barMeasure); - setDocumentHeight(cm, barMeasure); - update.finish(); - } -} - -// Sync the actual display DOM structure with display.view, removing -// nodes for lines that are no longer in view, and creating the ones -// that are not there yet, and updating the ones that are out of -// date. -function patchDisplay(cm, updateNumbersFrom, dims) { - var display = cm.display, lineNumbers = cm.options.lineNumbers; - var container = display.lineDiv, cur = container.firstChild; - - function rm(node) { - var next = node.nextSibling; - // Works around a throw-scroll bug in OS X Webkit - if (webkit && mac && cm.display.currentWheelTarget == node) - { node.style.display = "none"; } - else - { node.parentNode.removeChild(node); } - return next - } - - var view = display.view, lineN = display.viewFrom; - // Loop over the elements in the view, syncing cur (the DOM nodes - // in display.lineDiv) with the view as we go. - for (var i = 0; i < view.length; i++) { - var lineView = view[i]; - if (lineView.hidden) { - } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet - var node = buildLineElement(cm, lineView, lineN, dims); - container.insertBefore(node, cur); - } else { // Already drawn - while (cur != lineView.node) { cur = rm(cur); } - var updateNumber = lineNumbers && updateNumbersFrom != null && - updateNumbersFrom <= lineN && lineView.lineNumber; - if (lineView.changes) { - if (indexOf(lineView.changes, "gutter") > -1) { updateNumber = false; } - updateLineForChanges(cm, lineView, lineN, dims); - } - if (updateNumber) { - removeChildren(lineView.lineNumber); - lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN))); - } - cur = lineView.node.nextSibling; - } - lineN += lineView.size; - } - while (cur) { cur = rm(cur); } -} - -function updateGutterSpace(cm) { - var width = cm.display.gutters.offsetWidth; - cm.display.sizer.style.marginLeft = width + "px"; -} - -function setDocumentHeight(cm, measure) { - cm.display.sizer.style.minHeight = measure.docHeight + "px"; - cm.display.heightForcer.style.top = measure.docHeight + "px"; - cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px"; -} - -// Rebuild the gutter elements, ensure the margin to the left of the -// code matches their width. -function updateGutters(cm) { - var gutters = cm.display.gutters, specs = cm.options.gutters; - removeChildren(gutters); - var i = 0; - for (; i < specs.length; ++i) { - var gutterClass = specs[i]; - var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass)); - if (gutterClass == "CodeMirror-linenumbers") { - cm.display.lineGutter = gElt; - gElt.style.width = (cm.display.lineNumWidth || 1) + "px"; - } - } - gutters.style.display = i ? "" : "none"; - updateGutterSpace(cm); -} - -// Make sure the gutters options contains the element -// "CodeMirror-linenumbers" when the lineNumbers option is true. -function setGuttersForLineNumbers(options) { - var found = indexOf(options.gutters, "CodeMirror-linenumbers"); - if (found == -1 && options.lineNumbers) { - options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]); - } else if (found > -1 && !options.lineNumbers) { - options.gutters = options.gutters.slice(0); - options.gutters.splice(found, 1); - } -} - -// Since the delta values reported on mouse wheel events are -// unstandardized between browsers and even browser versions, and -// generally horribly unpredictable, this code starts by measuring -// the scroll effect that the first few mouse wheel events have, -// and, from that, detects the way it can convert deltas to pixel -// offsets afterwards. -// -// The reason we want to know the amount a wheel event will scroll -// is that it gives us a chance to update the display before the -// actual scrolling happens, reducing flickering. - -var wheelSamples = 0; -var wheelPixelsPerUnit = null; -// Fill in a browser-detected starting value on browsers where we -// know one. These don't have to be accurate -- the result of them -// being wrong would just be a slight flicker on the first wheel -// scroll (if it is large enough). -if (ie) { wheelPixelsPerUnit = -.53; } -else if (gecko) { wheelPixelsPerUnit = 15; } -else if (chrome) { wheelPixelsPerUnit = -.7; } -else if (safari) { wheelPixelsPerUnit = -1/3; } - -function wheelEventDelta(e) { - var dx = e.wheelDeltaX, dy = e.wheelDeltaY; - if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail; } - if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail; } - else if (dy == null) { dy = e.wheelDelta; } - return {x: dx, y: dy} -} -function wheelEventPixels(e) { - var delta = wheelEventDelta(e); - delta.x *= wheelPixelsPerUnit; - delta.y *= wheelPixelsPerUnit; - return delta -} - -function onScrollWheel(cm, e) { - var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y; - - var display = cm.display, scroll = display.scroller; - // Quit if there's nothing to scroll here - var canScrollX = scroll.scrollWidth > scroll.clientWidth; - var canScrollY = scroll.scrollHeight > scroll.clientHeight; - if (!(dx && canScrollX || dy && canScrollY)) { return } - - // Webkit browsers on OS X abort momentum scrolls when the target - // of the scroll event is removed from the scrollable element. - // This hack (see related code in patchDisplay) makes sure the - // element is kept around. - if (dy && mac && webkit) { - outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) { - for (var i = 0; i < view.length; i++) { - if (view[i].node == cur) { - cm.display.currentWheelTarget = cur; - break outer - } - } - } - } - - // On some browsers, horizontal scrolling will cause redraws to - // happen before the gutter has been realigned, causing it to - // wriggle around in a most unseemly way. When we have an - // estimated pixels/delta value, we just handle horizontal - // scrolling entirely here. It'll be slightly off from native, but - // better than glitching out. - if (dx && !gecko && !presto && wheelPixelsPerUnit != null) { - if (dy && canScrollY) - { updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit)); } - setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit)); - // Only prevent default scrolling if vertical scrolling is - // actually possible. Otherwise, it causes vertical scroll - // jitter on OSX trackpads when deltaX is small and deltaY - // is large (issue #3579) - if (!dy || (dy && canScrollY)) - { e_preventDefault(e); } - display.wheelStartX = null; // Abort measurement, if in progress - return - } - - // 'Project' the visible viewport to cover the area that is being - // scrolled into view (if we know enough to estimate it). - if (dy && wheelPixelsPerUnit != null) { - var pixels = dy * wheelPixelsPerUnit; - var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight; - if (pixels < 0) { top = Math.max(0, top + pixels - 50); } - else { bot = Math.min(cm.doc.height, bot + pixels + 50); } - updateDisplaySimple(cm, {top: top, bottom: bot}); - } - - if (wheelSamples < 20) { - if (display.wheelStartX == null) { - display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop; - display.wheelDX = dx; display.wheelDY = dy; - setTimeout(function () { - if (display.wheelStartX == null) { return } - var movedX = scroll.scrollLeft - display.wheelStartX; - var movedY = scroll.scrollTop - display.wheelStartY; - var sample = (movedY && display.wheelDY && movedY / display.wheelDY) || - (movedX && display.wheelDX && movedX / display.wheelDX); - display.wheelStartX = display.wheelStartY = null; - if (!sample) { return } - wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1); - ++wheelSamples; - }, 200); - } else { - display.wheelDX += dx; display.wheelDY += dy; - } - } -} - -// Selection objects are immutable. A new one is created every time -// the selection changes. A selection is one or more non-overlapping -// (and non-touching) ranges, sorted, and an integer that indicates -// which one is the primary selection (the one that's scrolled into -// view, that getCursor returns, etc). -var Selection = function(ranges, primIndex) { - this.ranges = ranges; - this.primIndex = primIndex; -}; - -Selection.prototype.primary = function () { return this.ranges[this.primIndex] }; - -Selection.prototype.equals = function (other) { - var this$1 = this; - - if (other == this) { return true } - if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false } - for (var i = 0; i < this.ranges.length; i++) { - var here = this$1.ranges[i], there = other.ranges[i]; - if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false } - } - return true -}; - -Selection.prototype.deepCopy = function () { - var this$1 = this; - - var out = []; - for (var i = 0; i < this.ranges.length; i++) - { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)); } - return new Selection(out, this.primIndex) -}; - -Selection.prototype.somethingSelected = function () { - var this$1 = this; - - for (var i = 0; i < this.ranges.length; i++) - { if (!this$1.ranges[i].empty()) { return true } } - return false -}; - -Selection.prototype.contains = function (pos, end) { - var this$1 = this; - - if (!end) { end = pos; } - for (var i = 0; i < this.ranges.length; i++) { - var range = this$1.ranges[i]; - if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0) - { return i } - } - return -1 -}; - -var Range = function(anchor, head) { - this.anchor = anchor; this.head = head; -}; - -Range.prototype.from = function () { return minPos(this.anchor, this.head) }; -Range.prototype.to = function () { return maxPos(this.anchor, this.head) }; -Range.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch }; - -// Take an unsorted, potentially overlapping set of ranges, and -// build a selection out of it. 'Consumes' ranges array (modifying -// it). -function normalizeSelection(ranges, primIndex) { - var prim = ranges[primIndex]; - ranges.sort(function (a, b) { return cmp(a.from(), b.from()); }); - primIndex = indexOf(ranges, prim); - for (var i = 1; i < ranges.length; i++) { - var cur = ranges[i], prev = ranges[i - 1]; - if (cmp(prev.to(), cur.from()) >= 0) { - var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to()); - var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head; - if (i <= primIndex) { --primIndex; } - ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to)); - } - } - return new Selection(ranges, primIndex) -} - -function simpleSelection(anchor, head) { - return new Selection([new Range(anchor, head || anchor)], 0) -} - -// Compute the position of the end of a change (its 'to' property -// refers to the pre-change end). -function changeEnd(change) { - if (!change.text) { return change.to } - return Pos(change.from.line + change.text.length - 1, - lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0)) -} - -// Adjust a position to refer to the post-change position of the -// same text, or the end of the change if the change covers it. -function adjustForChange(pos, change) { - if (cmp(pos, change.from) < 0) { return pos } - if (cmp(pos, change.to) <= 0) { return changeEnd(change) } - - var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch; - if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch; } - return Pos(line, ch) -} - -function computeSelAfterChange(doc, change) { - var out = []; - for (var i = 0; i < doc.sel.ranges.length; i++) { - var range = doc.sel.ranges[i]; - out.push(new Range(adjustForChange(range.anchor, change), - adjustForChange(range.head, change))); - } - return normalizeSelection(out, doc.sel.primIndex) -} - -function offsetPos(pos, old, nw) { - if (pos.line == old.line) - { return Pos(nw.line, pos.ch - old.ch + nw.ch) } - else - { return Pos(nw.line + (pos.line - old.line), pos.ch) } -} - -// Used by replaceSelections to allow moving the selection to the -// start or around the replaced test. Hint may be "start" or "around". -function computeReplacedSel(doc, changes, hint) { - var out = []; - var oldPrev = Pos(doc.first, 0), newPrev = oldPrev; - for (var i = 0; i < changes.length; i++) { - var change = changes[i]; - var from = offsetPos(change.from, oldPrev, newPrev); - var to = offsetPos(changeEnd(change), oldPrev, newPrev); - oldPrev = change.to; - newPrev = to; - if (hint == "around") { - var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0; - out[i] = new Range(inv ? to : from, inv ? from : to); - } else { - out[i] = new Range(from, from); - } - } - return new Selection(out, doc.sel.primIndex) -} - -// Used to get the editor into a consistent state again when options change. - -function loadMode(cm) { - cm.doc.mode = getMode(cm.options, cm.doc.modeOption); - resetModeState(cm); -} - -function resetModeState(cm) { - cm.doc.iter(function (line) { - if (line.stateAfter) { line.stateAfter = null; } - if (line.styles) { line.styles = null; } - }); - cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first; - startWorker(cm, 100); - cm.state.modeGen++; - if (cm.curOp) { regChange(cm); } -} - -// DOCUMENT DATA STRUCTURE - -// By default, updates that start and end at the beginning of a line -// are treated specially, in order to make the association of line -// widgets and marker elements with the text behave more intuitive. -function isWholeLineUpdate(doc, change) { - return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" && - (!doc.cm || doc.cm.options.wholeLineUpdateBefore) -} - -// Perform a change on the document data structure. -function updateDoc(doc, change, markedSpans, estimateHeight$$1) { - function spansFor(n) {return markedSpans ? markedSpans[n] : null} - function update(line, text, spans) { - updateLine(line, text, spans, estimateHeight$$1); - signalLater(line, "change", line, change); - } - function linesFor(start, end) { - var result = []; - for (var i = start; i < end; ++i) - { result.push(new Line(text[i], spansFor(i), estimateHeight$$1)); } - return result - } - - var from = change.from, to = change.to, text = change.text; - var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line); - var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line; - - // Adjust the line structure - if (change.full) { - doc.insert(0, linesFor(0, text.length)); - doc.remove(text.length, doc.size - text.length); - } else if (isWholeLineUpdate(doc, change)) { - // This is a whole-line replace. Treated specially to make - // sure line objects move the way they are supposed to. - var added = linesFor(0, text.length - 1); - update(lastLine, lastLine.text, lastSpans); - if (nlines) { doc.remove(from.line, nlines); } - if (added.length) { doc.insert(from.line, added); } - } else if (firstLine == lastLine) { - if (text.length == 1) { - update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans); - } else { - var added$1 = linesFor(1, text.length - 1); - added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight$$1)); - update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)); - doc.insert(from.line + 1, added$1); - } - } else if (text.length == 1) { - update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0)); - doc.remove(from.line + 1, nlines); - } else { - update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0)); - update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans); - var added$2 = linesFor(1, text.length - 1); - if (nlines > 1) { doc.remove(from.line + 1, nlines - 1); } - doc.insert(from.line + 1, added$2); - } - - signalLater(doc, "change", doc, change); -} - -// Call f for all linked documents. -function linkedDocs(doc, f, sharedHistOnly) { - function propagate(doc, skip, sharedHist) { - if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) { - var rel = doc.linked[i]; - if (rel.doc == skip) { continue } - var shared = sharedHist && rel.sharedHist; - if (sharedHistOnly && !shared) { continue } - f(rel.doc, shared); - propagate(rel.doc, doc, shared); - } } - } - propagate(doc, null, true); -} - -// Attach a document to an editor. -function attachDoc(cm, doc) { - if (doc.cm) { throw new Error("This document is already in use.") } - cm.doc = doc; - doc.cm = cm; - estimateLineHeights(cm); - loadMode(cm); - setDirectionClass(cm); - if (!cm.options.lineWrapping) { findMaxLine(cm); } - cm.options.mode = doc.modeOption; - regChange(cm); -} - -function setDirectionClass(cm) { - (cm.doc.direction == "rtl" ? addClass : rmClass)(cm.display.lineDiv, "CodeMirror-rtl"); -} - -function directionChanged(cm) { - runInOp(cm, function () { - setDirectionClass(cm); - regChange(cm); - }); -} - -function History(startGen) { - // Arrays of change events and selections. Doing something adds an - // event to done and clears undo. Undoing moves events from done - // to undone, redoing moves them in the other direction. - this.done = []; this.undone = []; - this.undoDepth = Infinity; - // Used to track when changes can be merged into a single undo - // event - this.lastModTime = this.lastSelTime = 0; - this.lastOp = this.lastSelOp = null; - this.lastOrigin = this.lastSelOrigin = null; - // Used by the isClean() method - this.generation = this.maxGeneration = startGen || 1; -} - -// Create a history change event from an updateDoc-style change -// object. -function historyChangeFromChange(doc, change) { - var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}; - attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); - linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true); - return histChange -} - -// Pop all selection events off the end of a history array. Stop at -// a change event. -function clearSelectionEvents(array) { - while (array.length) { - var last = lst(array); - if (last.ranges) { array.pop(); } - else { break } - } -} - -// Find the top change event in the history. Pop off selection -// events that are in the way. -function lastChangeEvent(hist, force) { - if (force) { - clearSelectionEvents(hist.done); - return lst(hist.done) - } else if (hist.done.length && !lst(hist.done).ranges) { - return lst(hist.done) - } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) { - hist.done.pop(); - return lst(hist.done) - } -} - -// Register a change in the history. Merges changes that are within -// a single operation, or are close together with an origin that -// allows merging (starting with "+") into a single event. -function addChangeToHistory(doc, change, selAfter, opId) { - var hist = doc.history; - hist.undone.length = 0; - var time = +new Date, cur; - var last; - - if ((hist.lastOp == opId || - hist.lastOrigin == change.origin && change.origin && - ((change.origin.charAt(0) == "+" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) || - change.origin.charAt(0) == "*")) && - (cur = lastChangeEvent(hist, hist.lastOp == opId))) { - // Merge this change into the last event - last = lst(cur.changes); - if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) { - // Optimized case for simple insertion -- don't want to add - // new changesets for every character typed - last.to = changeEnd(change); - } else { - // Add new sub-event - cur.changes.push(historyChangeFromChange(doc, change)); - } - } else { - // Can not be merged, start a new event. - var before = lst(hist.done); - if (!before || !before.ranges) - { pushSelectionToHistory(doc.sel, hist.done); } - cur = {changes: [historyChangeFromChange(doc, change)], - generation: hist.generation}; - hist.done.push(cur); - while (hist.done.length > hist.undoDepth) { - hist.done.shift(); - if (!hist.done[0].ranges) { hist.done.shift(); } - } - } - hist.done.push(selAfter); - hist.generation = ++hist.maxGeneration; - hist.lastModTime = hist.lastSelTime = time; - hist.lastOp = hist.lastSelOp = opId; - hist.lastOrigin = hist.lastSelOrigin = change.origin; - - if (!last) { signal(doc, "historyAdded"); } -} - -function selectionEventCanBeMerged(doc, origin, prev, sel) { - var ch = origin.charAt(0); - return ch == "*" || - ch == "+" && - prev.ranges.length == sel.ranges.length && - prev.somethingSelected() == sel.somethingSelected() && - new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500) -} - -// Called whenever the selection changes, sets the new selection as -// the pending selection in the history, and pushes the old pending -// selection into the 'done' array when it was significantly -// different (in number of selected ranges, emptiness, or time). -function addSelectionToHistory(doc, sel, opId, options) { - var hist = doc.history, origin = options && options.origin; - - // A new event is started when the previous origin does not match - // the current, or the origins don't allow matching. Origins - // starting with * are always merged, those starting with + are - // merged when similar and close together in time. - if (opId == hist.lastSelOp || - (origin && hist.lastSelOrigin == origin && - (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin || - selectionEventCanBeMerged(doc, origin, lst(hist.done), sel)))) - { hist.done[hist.done.length - 1] = sel; } - else - { pushSelectionToHistory(sel, hist.done); } - - hist.lastSelTime = +new Date; - hist.lastSelOrigin = origin; - hist.lastSelOp = opId; - if (options && options.clearRedo !== false) - { clearSelectionEvents(hist.undone); } -} - -function pushSelectionToHistory(sel, dest) { - var top = lst(dest); - if (!(top && top.ranges && top.equals(sel))) - { dest.push(sel); } -} - -// Used to store marked span information in the history. -function attachLocalSpans(doc, change, from, to) { - var existing = change["spans_" + doc.id], n = 0; - doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) { - if (line.markedSpans) - { (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans; } - ++n; - }); -} - -// When un/re-doing restores text containing marked spans, those -// that have been explicitly cleared should not be restored. -function removeClearedSpans(spans) { - if (!spans) { return null } - var out; - for (var i = 0; i < spans.length; ++i) { - if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i); } } - else if (out) { out.push(spans[i]); } - } - return !out ? spans : out.length ? out : null -} - -// Retrieve and filter the old marked spans stored in a change event. -function getOldSpans(doc, change) { - var found = change["spans_" + doc.id]; - if (!found) { return null } - var nw = []; - for (var i = 0; i < change.text.length; ++i) - { nw.push(removeClearedSpans(found[i])); } - return nw -} - -// Used for un/re-doing changes from the history. Combines the -// result of computing the existing spans with the set of spans that -// existed in the history (so that deleting around a span and then -// undoing brings back the span). -function mergeOldSpans(doc, change) { - var old = getOldSpans(doc, change); - var stretched = stretchSpansOverChange(doc, change); - if (!old) { return stretched } - if (!stretched) { return old } - - for (var i = 0; i < old.length; ++i) { - var oldCur = old[i], stretchCur = stretched[i]; - if (oldCur && stretchCur) { - spans: for (var j = 0; j < stretchCur.length; ++j) { - var span = stretchCur[j]; - for (var k = 0; k < oldCur.length; ++k) - { if (oldCur[k].marker == span.marker) { continue spans } } - oldCur.push(span); - } - } else if (stretchCur) { - old[i] = stretchCur; - } - } - return old -} - -// Used both to provide a JSON-safe object in .getHistory, and, when -// detaching a document, to split the history in two -function copyHistoryArray(events, newGroup, instantiateSel) { - var copy = []; - for (var i = 0; i < events.length; ++i) { - var event = events[i]; - if (event.ranges) { - copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event); - continue - } - var changes = event.changes, newChanges = []; - copy.push({changes: newChanges}); - for (var j = 0; j < changes.length; ++j) { - var change = changes[j], m = (void 0); - newChanges.push({from: change.from, to: change.to, text: change.text}); - if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\d+)$/)) { - if (indexOf(newGroup, Number(m[1])) > -1) { - lst(newChanges)[prop] = change[prop]; - delete change[prop]; - } - } } } - } - } - return copy -} - -// The 'scroll' parameter given to many of these indicated whether -// the new cursor position should be scrolled into view after -// modifying the selection. - -// If shift is held or the extend flag is set, extends a range to -// include a given position (and optionally a second position). -// Otherwise, simply returns the range between the given positions. -// Used for cursor motion and such. -function extendRange(range, head, other, extend) { - if (extend) { - var anchor = range.anchor; - if (other) { - var posBefore = cmp(head, anchor) < 0; - if (posBefore != (cmp(other, anchor) < 0)) { - anchor = head; - head = other; - } else if (posBefore != (cmp(head, other) < 0)) { - head = other; - } - } - return new Range(anchor, head) - } else { - return new Range(other || head, head) - } -} - -// Extend the primary selection range, discard the rest. -function extendSelection(doc, head, other, options, extend) { - if (extend == null) { extend = doc.cm && (doc.cm.display.shift || doc.extend); } - setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options); -} - -// Extend all selections (pos is an array of selections with length -// equal the number of selections) -function extendSelections(doc, heads, options) { - var out = []; - var extend = doc.cm && (doc.cm.display.shift || doc.extend); - for (var i = 0; i < doc.sel.ranges.length; i++) - { out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend); } - var newSel = normalizeSelection(out, doc.sel.primIndex); - setSelection(doc, newSel, options); -} - -// Updates a single range in the selection. -function replaceOneSelection(doc, i, range, options) { - var ranges = doc.sel.ranges.slice(0); - ranges[i] = range; - setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options); -} - -// Reset the selection to a single range. -function setSimpleSelection(doc, anchor, head, options) { - setSelection(doc, simpleSelection(anchor, head), options); -} - -// Give beforeSelectionChange handlers a change to influence a -// selection update. -function filterSelectionChange(doc, sel, options) { - var obj = { - ranges: sel.ranges, - update: function(ranges) { - var this$1 = this; - - this.ranges = []; - for (var i = 0; i < ranges.length; i++) - { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor), - clipPos(doc, ranges[i].head)); } - }, - origin: options && options.origin - }; - signal(doc, "beforeSelectionChange", doc, obj); - if (doc.cm) { signal(doc.cm, "beforeSelectionChange", doc.cm, obj); } - if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) } - else { return sel } -} - -function setSelectionReplaceHistory(doc, sel, options) { - var done = doc.history.done, last = lst(done); - if (last && last.ranges) { - done[done.length - 1] = sel; - setSelectionNoUndo(doc, sel, options); - } else { - setSelection(doc, sel, options); - } -} - -// Set a new selection. -function setSelection(doc, sel, options) { - setSelectionNoUndo(doc, sel, options); - addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options); -} - -function setSelectionNoUndo(doc, sel, options) { - if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange")) - { sel = filterSelectionChange(doc, sel, options); } - - var bias = options && options.bias || - (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1); - setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true)); - - if (!(options && options.scroll === false) && doc.cm) - { ensureCursorVisible(doc.cm); } -} - -function setSelectionInner(doc, sel) { - if (sel.equals(doc.sel)) { return } - - doc.sel = sel; - - if (doc.cm) { - doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true; - signalCursorActivity(doc.cm); - } - signalLater(doc, "cursorActivity", doc); -} - -// Verify that the selection does not partially select any atomic -// marked ranges. -function reCheckSelection(doc) { - setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false)); -} - -// Return a selection that does not partially select any atomic -// ranges. -function skipAtomicInSelection(doc, sel, bias, mayClear) { - var out; - for (var i = 0; i < sel.ranges.length; i++) { - var range = sel.ranges[i]; - var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]; - var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear); - var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear); - if (out || newAnchor != range.anchor || newHead != range.head) { - if (!out) { out = sel.ranges.slice(0, i); } - out[i] = new Range(newAnchor, newHead); - } - } - return out ? normalizeSelection(out, sel.primIndex) : sel -} - -function skipAtomicInner(doc, pos, oldPos, dir, mayClear) { - var line = getLine(doc, pos.line); - if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) { - var sp = line.markedSpans[i], m = sp.marker; - if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) && - (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) { - if (mayClear) { - signal(m, "beforeCursorEnter"); - if (m.explicitlyCleared) { - if (!line.markedSpans) { break } - else {--i; continue} - } - } - if (!m.atomic) { continue } - - if (oldPos) { - var near = m.find(dir < 0 ? 1 : -1), diff = (void 0); - if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft) - { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null); } - if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0)) - { return skipAtomicInner(doc, near, pos, dir, mayClear) } - } - - var far = m.find(dir < 0 ? -1 : 1); - if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight) - { far = movePos(doc, far, dir, far.line == pos.line ? line : null); } - return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null - } - } } - return pos -} - -// Ensure a given position is not inside an atomic range. -function skipAtomic(doc, pos, oldPos, bias, mayClear) { - var dir = bias || 1; - var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) || - (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) || - skipAtomicInner(doc, pos, oldPos, -dir, mayClear) || - (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true)); - if (!found) { - doc.cantEdit = true; - return Pos(doc.first, 0) - } - return found -} - -function movePos(doc, pos, dir, line) { - if (dir < 0 && pos.ch == 0) { - if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) } - else { return null } - } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) { - if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) } - else { return null } - } else { - return new Pos(pos.line, pos.ch + dir) - } -} - -function selectAll(cm) { - cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll); -} - -// UPDATING - -// Allow "beforeChange" event handlers to influence a change -function filterChange(doc, change, update) { - var obj = { - canceled: false, - from: change.from, - to: change.to, - text: change.text, - origin: change.origin, - cancel: function () { return obj.canceled = true; } - }; - if (update) { obj.update = function (from, to, text, origin) { - if (from) { obj.from = clipPos(doc, from); } - if (to) { obj.to = clipPos(doc, to); } - if (text) { obj.text = text; } - if (origin !== undefined) { obj.origin = origin; } - }; } - signal(doc, "beforeChange", doc, obj); - if (doc.cm) { signal(doc.cm, "beforeChange", doc.cm, obj); } - - if (obj.canceled) { return null } - return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin} -} - -// Apply a change to a document, and add it to the document's -// history, and propagating it to all linked documents. -function makeChange(doc, change, ignoreReadOnly) { - if (doc.cm) { - if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) } - if (doc.cm.state.suppressEdits) { return } - } - - if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) { - change = filterChange(doc, change, true); - if (!change) { return } - } - - // Possibly split or suppress the update based on the presence - // of read-only spans in its range. - var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to); - if (split) { - for (var i = split.length - 1; i >= 0; --i) - { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin}); } - } else { - makeChangeInner(doc, change); - } -} - -function makeChangeInner(doc, change) { - if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) { return } - var selAfter = computeSelAfterChange(doc, change); - addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN); - - makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change)); - var rebased = []; - - linkedDocs(doc, function (doc, sharedHist) { - if (!sharedHist && indexOf(rebased, doc.history) == -1) { - rebaseHist(doc.history, change); - rebased.push(doc.history); - } - makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change)); - }); -} - -// Revert a change stored in a document's history. -function makeChangeFromHistory(doc, type, allowSelectionOnly) { - var suppress = doc.cm && doc.cm.state.suppressEdits; - if (suppress && !allowSelectionOnly) { return } - - var hist = doc.history, event, selAfter = doc.sel; - var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done; - - // Verify that there is a useable event (so that ctrl-z won't - // needlessly clear selection events) - var i = 0; - for (; i < source.length; i++) { - event = source[i]; - if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges) - { break } - } - if (i == source.length) { return } - hist.lastOrigin = hist.lastSelOrigin = null; - - for (;;) { - event = source.pop(); - if (event.ranges) { - pushSelectionToHistory(event, dest); - if (allowSelectionOnly && !event.equals(doc.sel)) { - setSelection(doc, event, {clearRedo: false}); - return - } - selAfter = event; - } else if (suppress) { - source.push(event); - return - } else { break } - } - - // Build up a reverse change object to add to the opposite history - // stack (redo when undoing, and vice versa). - var antiChanges = []; - pushSelectionToHistory(selAfter, dest); - dest.push({changes: antiChanges, generation: hist.generation}); - hist.generation = event.generation || ++hist.maxGeneration; - - var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange"); - - var loop = function ( i ) { - var change = event.changes[i]; - change.origin = type; - if (filter && !filterChange(doc, change, false)) { - source.length = 0; - return {} - } - - antiChanges.push(historyChangeFromChange(doc, change)); - - var after = i ? computeSelAfterChange(doc, change) : lst(source); - makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change)); - if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}); } - var rebased = []; - - // Propagate to the linked documents - linkedDocs(doc, function (doc, sharedHist) { - if (!sharedHist && indexOf(rebased, doc.history) == -1) { - rebaseHist(doc.history, change); - rebased.push(doc.history); - } - makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change)); - }); - }; - - for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) { - var returned = loop( i$1 ); - - if ( returned ) return returned.v; - } -} - -// Sub-views need their line numbers shifted when text is added -// above or below them in the parent document. -function shiftDoc(doc, distance) { - if (distance == 0) { return } - doc.first += distance; - doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range( - Pos(range.anchor.line + distance, range.anchor.ch), - Pos(range.head.line + distance, range.head.ch) - ); }), doc.sel.primIndex); - if (doc.cm) { - regChange(doc.cm, doc.first, doc.first - distance, distance); - for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++) - { regLineChange(doc.cm, l, "gutter"); } - } -} - -// More lower-level change function, handling only a single document -// (not linked ones). -function makeChangeSingleDoc(doc, change, selAfter, spans) { - if (doc.cm && !doc.cm.curOp) - { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) } - - if (change.to.line < doc.first) { - shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line)); - return - } - if (change.from.line > doc.lastLine()) { return } - - // Clip the change to the size of this doc - if (change.from.line < doc.first) { - var shift = change.text.length - 1 - (doc.first - change.from.line); - shiftDoc(doc, shift); - change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch), - text: [lst(change.text)], origin: change.origin}; - } - var last = doc.lastLine(); - if (change.to.line > last) { - change = {from: change.from, to: Pos(last, getLine(doc, last).text.length), - text: [change.text[0]], origin: change.origin}; - } - - change.removed = getBetween(doc, change.from, change.to); - - if (!selAfter) { selAfter = computeSelAfterChange(doc, change); } - if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans); } - else { updateDoc(doc, change, spans); } - setSelectionNoUndo(doc, selAfter, sel_dontScroll); -} - -// Handle the interaction of a change to a document with the editor -// that this document is part of. -function makeChangeSingleDocInEditor(cm, change, spans) { - var doc = cm.doc, display = cm.display, from = change.from, to = change.to; - - var recomputeMaxLength = false, checkWidthStart = from.line; - if (!cm.options.lineWrapping) { - checkWidthStart = lineNo(visualLine(getLine(doc, from.line))); - doc.iter(checkWidthStart, to.line + 1, function (line) { - if (line == display.maxLine) { - recomputeMaxLength = true; - return true - } - }); - } - - if (doc.sel.contains(change.from, change.to) > -1) - { signalCursorActivity(cm); } - - updateDoc(doc, change, spans, estimateHeight(cm)); - - if (!cm.options.lineWrapping) { - doc.iter(checkWidthStart, from.line + change.text.length, function (line) { - var len = lineLength(line); - if (len > display.maxLineLength) { - display.maxLine = line; - display.maxLineLength = len; - display.maxLineChanged = true; - recomputeMaxLength = false; - } - }); - if (recomputeMaxLength) { cm.curOp.updateMaxLine = true; } - } - - retreatFrontier(doc, from.line); - startWorker(cm, 400); - - var lendiff = change.text.length - (to.line - from.line) - 1; - // Remember that these lines changed, for updating the display - if (change.full) - { regChange(cm); } - else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change)) - { regLineChange(cm, from.line, "text"); } - else - { regChange(cm, from.line, to.line + 1, lendiff); } - - var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change"); - if (changeHandler || changesHandler) { - var obj = { - from: from, to: to, - text: change.text, - removed: change.removed, - origin: change.origin - }; - if (changeHandler) { signalLater(cm, "change", cm, obj); } - if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj); } - } - cm.display.selForContextMenu = null; -} - -function replaceRange(doc, code, from, to, origin) { - if (!to) { to = from; } - if (cmp(to, from) < 0) { var assign; - (assign = [to, from], from = assign[0], to = assign[1]); } - if (typeof code == "string") { code = doc.splitLines(code); } - makeChange(doc, {from: from, to: to, text: code, origin: origin}); -} - -// Rebasing/resetting history to deal with externally-sourced changes - -function rebaseHistSelSingle(pos, from, to, diff) { - if (to < pos.line) { - pos.line += diff; - } else if (from < pos.line) { - pos.line = from; - pos.ch = 0; - } -} - -// Tries to rebase an array of history events given a change in the -// document. If the change touches the same lines as the event, the -// event, and everything 'behind' it, is discarded. If the change is -// before the event, the event's positions are updated. Uses a -// copy-on-write scheme for the positions, to avoid having to -// reallocate them all on every rebase, but also avoid problems with -// shared position objects being unsafely updated. -function rebaseHistArray(array, from, to, diff) { - for (var i = 0; i < array.length; ++i) { - var sub = array[i], ok = true; - if (sub.ranges) { - if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; } - for (var j = 0; j < sub.ranges.length; j++) { - rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff); - rebaseHistSelSingle(sub.ranges[j].head, from, to, diff); - } - continue - } - for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) { - var cur = sub.changes[j$1]; - if (to < cur.from.line) { - cur.from = Pos(cur.from.line + diff, cur.from.ch); - cur.to = Pos(cur.to.line + diff, cur.to.ch); - } else if (from <= cur.to.line) { - ok = false; - break - } - } - if (!ok) { - array.splice(0, i + 1); - i = 0; - } - } -} - -function rebaseHist(hist, change) { - var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1; - rebaseHistArray(hist.done, from, to, diff); - rebaseHistArray(hist.undone, from, to, diff); -} - -// Utility for applying a change to a line by handle or number, -// returning the number and optionally registering the line as -// changed. -function changeLine(doc, handle, changeType, op) { - var no = handle, line = handle; - if (typeof handle == "number") { line = getLine(doc, clipLine(doc, handle)); } - else { no = lineNo(handle); } - if (no == null) { return null } - if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType); } - return line -} - -// The document is represented as a BTree consisting of leaves, with -// chunk of lines in them, and branches, with up to ten leaves or -// other branch nodes below them. The top node is always a branch -// node, and is the document object itself (meaning it has -// additional methods and properties). -// -// All nodes have parent links. The tree is used both to go from -// line numbers to line objects, and to go from objects to numbers. -// It also indexes by height, and is used to convert between height -// and line object, and to find the total height of the document. -// -// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html - -function LeafChunk(lines) { - var this$1 = this; - - this.lines = lines; - this.parent = null; - var height = 0; - for (var i = 0; i < lines.length; ++i) { - lines[i].parent = this$1; - height += lines[i].height; - } - this.height = height; -} - -LeafChunk.prototype = { - chunkSize: function() { return this.lines.length }, - - // Remove the n lines at offset 'at'. - removeInner: function(at, n) { - var this$1 = this; - - for (var i = at, e = at + n; i < e; ++i) { - var line = this$1.lines[i]; - this$1.height -= line.height; - cleanUpLine(line); - signalLater(line, "delete"); - } - this.lines.splice(at, n); - }, - - // Helper used to collapse a small branch into a single leaf. - collapse: function(lines) { - lines.push.apply(lines, this.lines); - }, - - // Insert the given array of lines at offset 'at', count them as - // having the given height. - insertInner: function(at, lines, height) { - var this$1 = this; - - this.height += height; - this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at)); - for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1; } - }, - - // Used to iterate over a part of the tree. - iterN: function(at, n, op) { - var this$1 = this; - - for (var e = at + n; at < e; ++at) - { if (op(this$1.lines[at])) { return true } } - } -}; - -function BranchChunk(children) { - var this$1 = this; - - this.children = children; - var size = 0, height = 0; - for (var i = 0; i < children.length; ++i) { - var ch = children[i]; - size += ch.chunkSize(); height += ch.height; - ch.parent = this$1; - } - this.size = size; - this.height = height; - this.parent = null; -} - -BranchChunk.prototype = { - chunkSize: function() { return this.size }, - - removeInner: function(at, n) { - var this$1 = this; - - this.size -= n; - for (var i = 0; i < this.children.length; ++i) { - var child = this$1.children[i], sz = child.chunkSize(); - if (at < sz) { - var rm = Math.min(n, sz - at), oldHeight = child.height; - child.removeInner(at, rm); - this$1.height -= oldHeight - child.height; - if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null; } - if ((n -= rm) == 0) { break } - at = 0; - } else { at -= sz; } - } - // If the result is smaller than 25 lines, ensure that it is a - // single leaf node. - if (this.size - n < 25 && - (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) { - var lines = []; - this.collapse(lines); - this.children = [new LeafChunk(lines)]; - this.children[0].parent = this; - } - }, - - collapse: function(lines) { - var this$1 = this; - - for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines); } - }, - - insertInner: function(at, lines, height) { - var this$1 = this; - - this.size += lines.length; - this.height += height; - for (var i = 0; i < this.children.length; ++i) { - var child = this$1.children[i], sz = child.chunkSize(); - if (at <= sz) { - child.insertInner(at, lines, height); - if (child.lines && child.lines.length > 50) { - // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced. - // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest. - var remaining = child.lines.length % 25 + 25; - for (var pos = remaining; pos < child.lines.length;) { - var leaf = new LeafChunk(child.lines.slice(pos, pos += 25)); - child.height -= leaf.height; - this$1.children.splice(++i, 0, leaf); - leaf.parent = this$1; - } - child.lines = child.lines.slice(0, remaining); - this$1.maybeSpill(); - } - break - } - at -= sz; - } - }, - - // When a node has grown, check whether it should be split. - maybeSpill: function() { - if (this.children.length <= 10) { return } - var me = this; - do { - var spilled = me.children.splice(me.children.length - 5, 5); - var sibling = new BranchChunk(spilled); - if (!me.parent) { // Become the parent node - var copy = new BranchChunk(me.children); - copy.parent = me; - me.children = [copy, sibling]; - me = copy; - } else { - me.size -= sibling.size; - me.height -= sibling.height; - var myIndex = indexOf(me.parent.children, me); - me.parent.children.splice(myIndex + 1, 0, sibling); - } - sibling.parent = me.parent; - } while (me.children.length > 10) - me.parent.maybeSpill(); - }, - - iterN: function(at, n, op) { - var this$1 = this; - - for (var i = 0; i < this.children.length; ++i) { - var child = this$1.children[i], sz = child.chunkSize(); - if (at < sz) { - var used = Math.min(n, sz - at); - if (child.iterN(at, used, op)) { return true } - if ((n -= used) == 0) { break } - at = 0; - } else { at -= sz; } - } - } -}; - -// Line widgets are block elements displayed above or below a line. - -var LineWidget = function(doc, node, options) { - var this$1 = this; - - if (options) { for (var opt in options) { if (options.hasOwnProperty(opt)) - { this$1[opt] = options[opt]; } } } - this.doc = doc; - this.node = node; -}; - -LineWidget.prototype.clear = function () { - var this$1 = this; - - var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line); - if (no == null || !ws) { return } - for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1); } } - if (!ws.length) { line.widgets = null; } - var height = widgetHeight(this); - updateLineHeight(line, Math.max(0, line.height - height)); - if (cm) { - runInOp(cm, function () { - adjustScrollWhenAboveVisible(cm, line, -height); - regLineChange(cm, no, "widget"); - }); - signalLater(cm, "lineWidgetCleared", cm, this, no); - } -}; - -LineWidget.prototype.changed = function () { - var this$1 = this; - - var oldH = this.height, cm = this.doc.cm, line = this.line; - this.height = null; - var diff = widgetHeight(this) - oldH; - if (!diff) { return } - updateLineHeight(line, line.height + diff); - if (cm) { - runInOp(cm, function () { - cm.curOp.forceUpdate = true; - adjustScrollWhenAboveVisible(cm, line, diff); - signalLater(cm, "lineWidgetChanged", cm, this$1, lineNo(line)); - }); - } -}; -eventMixin(LineWidget); - -function adjustScrollWhenAboveVisible(cm, line, diff) { - if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop)) - { addToScrollTop(cm, diff); } -} - -function addLineWidget(doc, handle, node, options) { - var widget = new LineWidget(doc, node, options); - var cm = doc.cm; - if (cm && widget.noHScroll) { cm.display.alignWidgets = true; } - changeLine(doc, handle, "widget", function (line) { - var widgets = line.widgets || (line.widgets = []); - if (widget.insertAt == null) { widgets.push(widget); } - else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget); } - widget.line = line; - if (cm && !lineIsHidden(doc, line)) { - var aboveVisible = heightAtLine(line) < doc.scrollTop; - updateLineHeight(line, line.height + widgetHeight(widget)); - if (aboveVisible) { addToScrollTop(cm, widget.height); } - cm.curOp.forceUpdate = true; - } - return true - }); - if (cm) { signalLater(cm, "lineWidgetAdded", cm, widget, typeof handle == "number" ? handle : lineNo(handle)); } - return widget -} - -// TEXTMARKERS - -// Created with markText and setBookmark methods. A TextMarker is a -// handle that can be used to clear or find a marked position in the -// document. Line objects hold arrays (markedSpans) containing -// {from, to, marker} object pointing to such marker objects, and -// indicating that such a marker is present on that line. Multiple -// lines may point to the same marker when it spans across lines. -// The spans will have null for their from/to properties when the -// marker continues beyond the start/end of the line. Markers have -// links back to the lines they currently touch. - -// Collapsed markers have unique ids, in order to be able to order -// them, which is needed for uniquely determining an outer marker -// when they overlap (they may nest, but not partially overlap). -var nextMarkerId = 0; - -var TextMarker = function(doc, type) { - this.lines = []; - this.type = type; - this.doc = doc; - this.id = ++nextMarkerId; -}; - -// Clear the marker. -TextMarker.prototype.clear = function () { - var this$1 = this; - - if (this.explicitlyCleared) { return } - var cm = this.doc.cm, withOp = cm && !cm.curOp; - if (withOp) { startOperation(cm); } - if (hasHandler(this, "clear")) { - var found = this.find(); - if (found) { signalLater(this, "clear", found.from, found.to); } - } - var min = null, max = null; - for (var i = 0; i < this.lines.length; ++i) { - var line = this$1.lines[i]; - var span = getMarkedSpanFor(line.markedSpans, this$1); - if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), "text"); } - else if (cm) { - if (span.to != null) { max = lineNo(line); } - if (span.from != null) { min = lineNo(line); } - } - line.markedSpans = removeMarkedSpan(line.markedSpans, span); - if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm) - { updateLineHeight(line, textHeight(cm.display)); } - } - if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) { - var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual); - if (len > cm.display.maxLineLength) { - cm.display.maxLine = visual; - cm.display.maxLineLength = len; - cm.display.maxLineChanged = true; - } - } } - - if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1); } - this.lines.length = 0; - this.explicitlyCleared = true; - if (this.atomic && this.doc.cantEdit) { - this.doc.cantEdit = false; - if (cm) { reCheckSelection(cm.doc); } - } - if (cm) { signalLater(cm, "markerCleared", cm, this, min, max); } - if (withOp) { endOperation(cm); } - if (this.parent) { this.parent.clear(); } -}; - -// Find the position of the marker in the document. Returns a {from, -// to} object by default. Side can be passed to get a specific side -// -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the -// Pos objects returned contain a line object, rather than a line -// number (used to prevent looking up the same line twice). -TextMarker.prototype.find = function (side, lineObj) { - var this$1 = this; - - if (side == null && this.type == "bookmark") { side = 1; } - var from, to; - for (var i = 0; i < this.lines.length; ++i) { - var line = this$1.lines[i]; - var span = getMarkedSpanFor(line.markedSpans, this$1); - if (span.from != null) { - from = Pos(lineObj ? line : lineNo(line), span.from); - if (side == -1) { return from } - } - if (span.to != null) { - to = Pos(lineObj ? line : lineNo(line), span.to); - if (side == 1) { return to } - } - } - return from && {from: from, to: to} -}; - -// Signals that the marker's widget changed, and surrounding layout -// should be recomputed. -TextMarker.prototype.changed = function () { - var this$1 = this; - - var pos = this.find(-1, true), widget = this, cm = this.doc.cm; - if (!pos || !cm) { return } - runInOp(cm, function () { - var line = pos.line, lineN = lineNo(pos.line); - var view = findViewForLine(cm, lineN); - if (view) { - clearLineMeasurementCacheFor(view); - cm.curOp.selectionChanged = cm.curOp.forceUpdate = true; - } - cm.curOp.updateMaxLine = true; - if (!lineIsHidden(widget.doc, line) && widget.height != null) { - var oldHeight = widget.height; - widget.height = null; - var dHeight = widgetHeight(widget) - oldHeight; - if (dHeight) - { updateLineHeight(line, line.height + dHeight); } - } - signalLater(cm, "markerChanged", cm, this$1); - }); -}; - -TextMarker.prototype.attachLine = function (line) { - if (!this.lines.length && this.doc.cm) { - var op = this.doc.cm.curOp; - if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1) - { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this); } - } - this.lines.push(line); -}; - -TextMarker.prototype.detachLine = function (line) { - this.lines.splice(indexOf(this.lines, line), 1); - if (!this.lines.length && this.doc.cm) { - var op = this.doc.cm.curOp;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this); - } -}; -eventMixin(TextMarker); - -// Create a marker, wire it up to the right lines, and -function markText(doc, from, to, options, type) { - // Shared markers (across linked documents) are handled separately - // (markTextShared will call out to this again, once per - // document). - if (options && options.shared) { return markTextShared(doc, from, to, options, type) } - // Ensure we are in an operation. - if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) } - - var marker = new TextMarker(doc, type), diff = cmp(from, to); - if (options) { copyObj(options, marker, false); } - // Don't connect empty markers unless clearWhenEmpty is false - if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false) - { return marker } - if (marker.replacedWith) { - // Showing up as a widget implies collapsed (widget replaces text) - marker.collapsed = true; - marker.widgetNode = eltP("span", [marker.replacedWith], "CodeMirror-widget"); - if (!options.handleMouseEvents) { marker.widgetNode.setAttribute("cm-ignore-events", "true"); } - if (options.insertLeft) { marker.widgetNode.insertLeft = true; } - } - if (marker.collapsed) { - if (conflictingCollapsedRange(doc, from.line, from, to, marker) || - from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker)) - { throw new Error("Inserting collapsed marker partially overlapping an existing one") } - seeCollapsedSpans(); - } - - if (marker.addToHistory) - { addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN); } - - var curLine = from.line, cm = doc.cm, updateMaxLine; - doc.iter(curLine, to.line + 1, function (line) { - if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine) - { updateMaxLine = true; } - if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0); } - addMarkedSpan(line, new MarkedSpan(marker, - curLine == from.line ? from.ch : null, - curLine == to.line ? to.ch : null)); - ++curLine; - }); - // lineIsHidden depends on the presence of the spans, so needs a second pass - if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) { - if (lineIsHidden(doc, line)) { updateLineHeight(line, 0); } - }); } - - if (marker.clearOnEnter) { on(marker, "beforeCursorEnter", function () { return marker.clear(); }); } - - if (marker.readOnly) { - seeReadOnlySpans(); - if (doc.history.done.length || doc.history.undone.length) - { doc.clearHistory(); } - } - if (marker.collapsed) { - marker.id = ++nextMarkerId; - marker.atomic = true; - } - if (cm) { - // Sync editor state - if (updateMaxLine) { cm.curOp.updateMaxLine = true; } - if (marker.collapsed) - { regChange(cm, from.line, to.line + 1); } - else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css) - { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, "text"); } } - if (marker.atomic) { reCheckSelection(cm.doc); } - signalLater(cm, "markerAdded", cm, marker); - } - return marker -} - -// SHARED TEXTMARKERS - -// A shared marker spans multiple linked documents. It is -// implemented as a meta-marker-object controlling multiple normal -// markers. -var SharedTextMarker = function(markers, primary) { - var this$1 = this; - - this.markers = markers; - this.primary = primary; - for (var i = 0; i < markers.length; ++i) - { markers[i].parent = this$1; } -}; - -SharedTextMarker.prototype.clear = function () { - var this$1 = this; - - if (this.explicitlyCleared) { return } - this.explicitlyCleared = true; - for (var i = 0; i < this.markers.length; ++i) - { this$1.markers[i].clear(); } - signalLater(this, "clear"); -}; - -SharedTextMarker.prototype.find = function (side, lineObj) { - return this.primary.find(side, lineObj) -}; -eventMixin(SharedTextMarker); - -function markTextShared(doc, from, to, options, type) { - options = copyObj(options); - options.shared = false; - var markers = [markText(doc, from, to, options, type)], primary = markers[0]; - var widget = options.widgetNode; - linkedDocs(doc, function (doc) { - if (widget) { options.widgetNode = widget.cloneNode(true); } - markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type)); - for (var i = 0; i < doc.linked.length; ++i) - { if (doc.linked[i].isParent) { return } } - primary = lst(markers); - }); - return new SharedTextMarker(markers, primary) -} - -function findSharedMarkers(doc) { - return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; }) -} - -function copySharedMarkers(doc, markers) { - for (var i = 0; i < markers.length; i++) { - var marker = markers[i], pos = marker.find(); - var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to); - if (cmp(mFrom, mTo)) { - var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type); - marker.markers.push(subMark); - subMark.parent = marker; - } - } -} - -function detachSharedMarkers(markers) { - var loop = function ( i ) { - var marker = markers[i], linked = [marker.primary.doc]; - linkedDocs(marker.primary.doc, function (d) { return linked.push(d); }); - for (var j = 0; j < marker.markers.length; j++) { - var subMarker = marker.markers[j]; - if (indexOf(linked, subMarker.doc) == -1) { - subMarker.parent = null; - marker.markers.splice(j--, 1); - } - } - }; - - for (var i = 0; i < markers.length; i++) loop( i ); -} - -var nextDocId = 0; -var Doc = function(text, mode, firstLine, lineSep, direction) { - if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep, direction) } - if (firstLine == null) { firstLine = 0; } - - BranchChunk.call(this, [new LeafChunk([new Line("", null)])]); - this.first = firstLine; - this.scrollTop = this.scrollLeft = 0; - this.cantEdit = false; - this.cleanGeneration = 1; - this.modeFrontier = this.highlightFrontier = firstLine; - var start = Pos(firstLine, 0); - this.sel = simpleSelection(start); - this.history = new History(null); - this.id = ++nextDocId; - this.modeOption = mode; - this.lineSep = lineSep; - this.direction = (direction == "rtl") ? "rtl" : "ltr"; - this.extend = false; - - if (typeof text == "string") { text = this.splitLines(text); } - updateDoc(this, {from: start, to: start, text: text}); - setSelection(this, simpleSelection(start), sel_dontScroll); -}; - -Doc.prototype = createObj(BranchChunk.prototype, { - constructor: Doc, - // Iterate over the document. Supports two forms -- with only one - // argument, it calls that for each line in the document. With - // three, it iterates over the range given by the first two (with - // the second being non-inclusive). - iter: function(from, to, op) { - if (op) { this.iterN(from - this.first, to - from, op); } - else { this.iterN(this.first, this.first + this.size, from); } - }, - - // Non-public interface for adding and removing lines. - insert: function(at, lines) { - var height = 0; - for (var i = 0; i < lines.length; ++i) { height += lines[i].height; } - this.insertInner(at - this.first, lines, height); - }, - remove: function(at, n) { this.removeInner(at - this.first, n); }, - - // From here, the methods are part of the public interface. Most - // are also available from CodeMirror (editor) instances. - - getValue: function(lineSep) { - var lines = getLines(this, this.first, this.first + this.size); - if (lineSep === false) { return lines } - return lines.join(lineSep || this.lineSeparator()) - }, - setValue: docMethodOp(function(code) { - var top = Pos(this.first, 0), last = this.first + this.size - 1; - makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length), - text: this.splitLines(code), origin: "setValue", full: true}, true); - if (this.cm) { scrollToCoords(this.cm, 0, 0); } - setSelection(this, simpleSelection(top), sel_dontScroll); - }), - replaceRange: function(code, from, to, origin) { - from = clipPos(this, from); - to = to ? clipPos(this, to) : from; - replaceRange(this, code, from, to, origin); - }, - getRange: function(from, to, lineSep) { - var lines = getBetween(this, clipPos(this, from), clipPos(this, to)); - if (lineSep === false) { return lines } - return lines.join(lineSep || this.lineSeparator()) - }, - - getLine: function(line) {var l = this.getLineHandle(line); return l && l.text}, - - getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }}, - getLineNumber: function(line) {return lineNo(line)}, - - getLineHandleVisualStart: function(line) { - if (typeof line == "number") { line = getLine(this, line); } - return visualLine(line) - }, - - lineCount: function() {return this.size}, - firstLine: function() {return this.first}, - lastLine: function() {return this.first + this.size - 1}, - - clipPos: function(pos) {return clipPos(this, pos)}, - - getCursor: function(start) { - var range$$1 = this.sel.primary(), pos; - if (start == null || start == "head") { pos = range$$1.head; } - else if (start == "anchor") { pos = range$$1.anchor; } - else if (start == "end" || start == "to" || start === false) { pos = range$$1.to(); } - else { pos = range$$1.from(); } - return pos - }, - listSelections: function() { return this.sel.ranges }, - somethingSelected: function() {return this.sel.somethingSelected()}, - - setCursor: docMethodOp(function(line, ch, options) { - setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options); - }), - setSelection: docMethodOp(function(anchor, head, options) { - setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options); - }), - extendSelection: docMethodOp(function(head, other, options) { - extendSelection(this, clipPos(this, head), other && clipPos(this, other), options); - }), - extendSelections: docMethodOp(function(heads, options) { - extendSelections(this, clipPosArray(this, heads), options); - }), - extendSelectionsBy: docMethodOp(function(f, options) { - var heads = map(this.sel.ranges, f); - extendSelections(this, clipPosArray(this, heads), options); - }), - setSelections: docMethodOp(function(ranges, primary, options) { - var this$1 = this; - - if (!ranges.length) { return } - var out = []; - for (var i = 0; i < ranges.length; i++) - { out[i] = new Range(clipPos(this$1, ranges[i].anchor), - clipPos(this$1, ranges[i].head)); } - if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex); } - setSelection(this, normalizeSelection(out, primary), options); - }), - addSelection: docMethodOp(function(anchor, head, options) { - var ranges = this.sel.ranges.slice(0); - ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor))); - setSelection(this, normalizeSelection(ranges, ranges.length - 1), options); - }), - - getSelection: function(lineSep) { - var this$1 = this; - - var ranges = this.sel.ranges, lines; - for (var i = 0; i < ranges.length; i++) { - var sel = getBetween(this$1, ranges[i].from(), ranges[i].to()); - lines = lines ? lines.concat(sel) : sel; - } - if (lineSep === false) { return lines } - else { return lines.join(lineSep || this.lineSeparator()) } - }, - getSelections: function(lineSep) { - var this$1 = this; - - var parts = [], ranges = this.sel.ranges; - for (var i = 0; i < ranges.length; i++) { - var sel = getBetween(this$1, ranges[i].from(), ranges[i].to()); - if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()); } - parts[i] = sel; - } - return parts - }, - replaceSelection: function(code, collapse, origin) { - var dup = []; - for (var i = 0; i < this.sel.ranges.length; i++) - { dup[i] = code; } - this.replaceSelections(dup, collapse, origin || "+input"); - }, - replaceSelections: docMethodOp(function(code, collapse, origin) { - var this$1 = this; - - var changes = [], sel = this.sel; - for (var i = 0; i < sel.ranges.length; i++) { - var range$$1 = sel.ranges[i]; - changes[i] = {from: range$$1.from(), to: range$$1.to(), text: this$1.splitLines(code[i]), origin: origin}; - } - var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse); - for (var i$1 = changes.length - 1; i$1 >= 0; i$1--) - { makeChange(this$1, changes[i$1]); } - if (newSel) { setSelectionReplaceHistory(this, newSel); } - else if (this.cm) { ensureCursorVisible(this.cm); } - }), - undo: docMethodOp(function() {makeChangeFromHistory(this, "undo");}), - redo: docMethodOp(function() {makeChangeFromHistory(this, "redo");}), - undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true);}), - redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true);}), - - setExtending: function(val) {this.extend = val;}, - getExtending: function() {return this.extend}, - - historySize: function() { - var hist = this.history, done = 0, undone = 0; - for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done; } } - for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone; } } - return {undo: done, redo: undone} - }, - clearHistory: function() {this.history = new History(this.history.maxGeneration);}, - - markClean: function() { - this.cleanGeneration = this.changeGeneration(true); - }, - changeGeneration: function(forceSplit) { - if (forceSplit) - { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null; } - return this.history.generation - }, - isClean: function (gen) { - return this.history.generation == (gen || this.cleanGeneration) - }, - - getHistory: function() { - return {done: copyHistoryArray(this.history.done), - undone: copyHistoryArray(this.history.undone)} - }, - setHistory: function(histData) { - var hist = this.history = new History(this.history.maxGeneration); - hist.done = copyHistoryArray(histData.done.slice(0), null, true); - hist.undone = copyHistoryArray(histData.undone.slice(0), null, true); - }, - - setGutterMarker: docMethodOp(function(line, gutterID, value) { - return changeLine(this, line, "gutter", function (line) { - var markers = line.gutterMarkers || (line.gutterMarkers = {}); - markers[gutterID] = value; - if (!value && isEmpty(markers)) { line.gutterMarkers = null; } - return true - }) - }), - - clearGutter: docMethodOp(function(gutterID) { - var this$1 = this; - - this.iter(function (line) { - if (line.gutterMarkers && line.gutterMarkers[gutterID]) { - changeLine(this$1, line, "gutter", function () { - line.gutterMarkers[gutterID] = null; - if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null; } - return true - }); - } - }); - }), - - lineInfo: function(line) { - var n; - if (typeof line == "number") { - if (!isLine(this, line)) { return null } - n = line; - line = getLine(this, line); - if (!line) { return null } - } else { - n = lineNo(line); - if (n == null) { return null } - } - return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers, - textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass, - widgets: line.widgets} - }, - - addLineClass: docMethodOp(function(handle, where, cls) { - return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) { - var prop = where == "text" ? "textClass" - : where == "background" ? "bgClass" - : where == "gutter" ? "gutterClass" : "wrapClass"; - if (!line[prop]) { line[prop] = cls; } - else if (classTest(cls).test(line[prop])) { return false } - else { line[prop] += " " + cls; } - return true - }) - }), - removeLineClass: docMethodOp(function(handle, where, cls) { - return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) { - var prop = where == "text" ? "textClass" - : where == "background" ? "bgClass" - : where == "gutter" ? "gutterClass" : "wrapClass"; - var cur = line[prop]; - if (!cur) { return false } - else if (cls == null) { line[prop] = null; } - else { - var found = cur.match(classTest(cls)); - if (!found) { return false } - var end = found.index + found[0].length; - line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null; - } - return true - }) - }), - - addLineWidget: docMethodOp(function(handle, node, options) { - return addLineWidget(this, handle, node, options) - }), - removeLineWidget: function(widget) { widget.clear(); }, - - markText: function(from, to, options) { - return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range") - }, - setBookmark: function(pos, options) { - var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options), - insertLeft: options && options.insertLeft, - clearWhenEmpty: false, shared: options && options.shared, - handleMouseEvents: options && options.handleMouseEvents}; - pos = clipPos(this, pos); - return markText(this, pos, pos, realOpts, "bookmark") - }, - findMarksAt: function(pos) { - pos = clipPos(this, pos); - var markers = [], spans = getLine(this, pos.line).markedSpans; - if (spans) { for (var i = 0; i < spans.length; ++i) { - var span = spans[i]; - if ((span.from == null || span.from <= pos.ch) && - (span.to == null || span.to >= pos.ch)) - { markers.push(span.marker.parent || span.marker); } - } } - return markers - }, - findMarks: function(from, to, filter) { - from = clipPos(this, from); to = clipPos(this, to); - var found = [], lineNo$$1 = from.line; - this.iter(from.line, to.line + 1, function (line) { - var spans = line.markedSpans; - if (spans) { for (var i = 0; i < spans.length; i++) { - var span = spans[i]; - if (!(span.to != null && lineNo$$1 == from.line && from.ch >= span.to || - span.from == null && lineNo$$1 != from.line || - span.from != null && lineNo$$1 == to.line && span.from >= to.ch) && - (!filter || filter(span.marker))) - { found.push(span.marker.parent || span.marker); } - } } - ++lineNo$$1; - }); - return found - }, - getAllMarks: function() { - var markers = []; - this.iter(function (line) { - var sps = line.markedSpans; - if (sps) { for (var i = 0; i < sps.length; ++i) - { if (sps[i].from != null) { markers.push(sps[i].marker); } } } - }); - return markers - }, - - posFromIndex: function(off) { - var ch, lineNo$$1 = this.first, sepSize = this.lineSeparator().length; - this.iter(function (line) { - var sz = line.text.length + sepSize; - if (sz > off) { ch = off; return true } - off -= sz; - ++lineNo$$1; - }); - return clipPos(this, Pos(lineNo$$1, ch)) - }, - indexFromPos: function (coords) { - coords = clipPos(this, coords); - var index = coords.ch; - if (coords.line < this.first || coords.ch < 0) { return 0 } - var sepSize = this.lineSeparator().length; - this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value - index += line.text.length + sepSize; - }); - return index - }, - - copy: function(copyHistory) { - var doc = new Doc(getLines(this, this.first, this.first + this.size), - this.modeOption, this.first, this.lineSep, this.direction); - doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft; - doc.sel = this.sel; - doc.extend = false; - if (copyHistory) { - doc.history.undoDepth = this.history.undoDepth; - doc.setHistory(this.getHistory()); - } - return doc - }, - - linkedDoc: function(options) { - if (!options) { options = {}; } - var from = this.first, to = this.first + this.size; - if (options.from != null && options.from > from) { from = options.from; } - if (options.to != null && options.to < to) { to = options.to; } - var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction); - if (options.sharedHist) { copy.history = this.history - ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist}); - copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]; - copySharedMarkers(copy, findSharedMarkers(this)); - return copy - }, - unlinkDoc: function(other) { - var this$1 = this; - - if (other instanceof CodeMirror$1) { other = other.doc; } - if (this.linked) { for (var i = 0; i < this.linked.length; ++i) { - var link = this$1.linked[i]; - if (link.doc != other) { continue } - this$1.linked.splice(i, 1); - other.unlinkDoc(this$1); - detachSharedMarkers(findSharedMarkers(this$1)); - break - } } - // If the histories were shared, split them again - if (other.history == this.history) { - var splitIds = [other.id]; - linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true); - other.history = new History(null); - other.history.done = copyHistoryArray(this.history.done, splitIds); - other.history.undone = copyHistoryArray(this.history.undone, splitIds); - } - }, - iterLinkedDocs: function(f) {linkedDocs(this, f);}, - - getMode: function() {return this.mode}, - getEditor: function() {return this.cm}, - - splitLines: function(str) { - if (this.lineSep) { return str.split(this.lineSep) } - return splitLinesAuto(str) - }, - lineSeparator: function() { return this.lineSep || "\n" }, - - setDirection: docMethodOp(function (dir) { - if (dir != "rtl") { dir = "ltr"; } - if (dir == this.direction) { return } - this.direction = dir; - this.iter(function (line) { return line.order = null; }); - if (this.cm) { directionChanged(this.cm); } - }) -}); - -// Public alias. -Doc.prototype.eachLine = Doc.prototype.iter; - -// Kludge to work around strange IE behavior where it'll sometimes -// re-fire a series of drag-related events right after the drop (#1551) -var lastDrop = 0; - -function onDrop(e) { - var cm = this; - clearDragCursor(cm); - if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) - { return } - e_preventDefault(e); - if (ie) { lastDrop = +new Date; } - var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files; - if (!pos || cm.isReadOnly()) { return } - // Might be a file drop, in which case we simply extract the text - // and insert it. - if (files && files.length && window.FileReader && window.File) { - var n = files.length, text = Array(n), read = 0; - var loadFile = function (file, i) { - if (cm.options.allowDropFileTypes && - indexOf(cm.options.allowDropFileTypes, file.type) == -1) - { return } - - var reader = new FileReader; - reader.onload = operation(cm, function () { - var content = reader.result; - if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) { content = ""; } - text[i] = content; - if (++read == n) { - pos = clipPos(cm.doc, pos); - var change = {from: pos, to: pos, - text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())), - origin: "paste"}; - makeChange(cm.doc, change); - setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change))); - } - }); - reader.readAsText(file); - }; - for (var i = 0; i < n; ++i) { loadFile(files[i], i); } - } else { // Normal drop - // Don't do a replace if the drop happened inside of the selected text. - if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) { - cm.state.draggingText(e); - // Ensure the editor is re-focused - setTimeout(function () { return cm.display.input.focus(); }, 20); - return - } - try { - var text$1 = e.dataTransfer.getData("Text"); - if (text$1) { - var selected; - if (cm.state.draggingText && !cm.state.draggingText.copy) - { selected = cm.listSelections(); } - setSelectionNoUndo(cm.doc, simpleSelection(pos, pos)); - if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1) - { replaceRange(cm.doc, "", selected[i$1].anchor, selected[i$1].head, "drag"); } } - cm.replaceSelection(text$1, "around", "paste"); - cm.display.input.focus(); - } - } - catch(e){} - } -} - -function onDragStart(cm, e) { - if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return } - if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return } - - e.dataTransfer.setData("Text", cm.getSelection()); - e.dataTransfer.effectAllowed = "copyMove"; - - // Use dummy image instead of default browsers image. - // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there. - if (e.dataTransfer.setDragImage && !safari) { - var img = elt("img", null, null, "position: fixed; left: 0; top: 0;"); - img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="; - if (presto) { - img.width = img.height = 1; - cm.display.wrapper.appendChild(img); - // Force a relayout, or Opera won't use our image for some obscure reason - img._top = img.offsetTop; - } - e.dataTransfer.setDragImage(img, 0, 0); - if (presto) { img.parentNode.removeChild(img); } - } -} - -function onDragOver(cm, e) { - var pos = posFromMouse(cm, e); - if (!pos) { return } - var frag = document.createDocumentFragment(); - drawSelectionCursor(cm, pos, frag); - if (!cm.display.dragCursor) { - cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors"); - cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv); - } - removeChildrenAndAdd(cm.display.dragCursor, frag); -} - -function clearDragCursor(cm) { - if (cm.display.dragCursor) { - cm.display.lineSpace.removeChild(cm.display.dragCursor); - cm.display.dragCursor = null; - } -} - -// These must be handled carefully, because naively registering a -// handler for each editor will cause the editors to never be -// garbage collected. - -function forEachCodeMirror(f) { - if (!document.getElementsByClassName) { return } - var byClass = document.getElementsByClassName("CodeMirror"); - for (var i = 0; i < byClass.length; i++) { - var cm = byClass[i].CodeMirror; - if (cm) { f(cm); } - } -} - -var globalsRegistered = false; -function ensureGlobalHandlers() { - if (globalsRegistered) { return } - registerGlobalHandlers(); - globalsRegistered = true; -} -function registerGlobalHandlers() { - // When the window resizes, we need to refresh active editors. - var resizeTimer; - on(window, "resize", function () { - if (resizeTimer == null) { resizeTimer = setTimeout(function () { - resizeTimer = null; - forEachCodeMirror(onResize); - }, 100); } - }); - // When the window loses focus, we want to show the editor as blurred - on(window, "blur", function () { return forEachCodeMirror(onBlur); }); -} -// Called when the window resizes -function onResize(cm) { - var d = cm.display; - if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth) - { return } - // Might be a text scaling operation, clear size caches. - d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null; - d.scrollbarsClipped = false; - cm.setSize(); -} - -var keyNames = { - 3: "Pause", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt", - 19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End", - 36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert", - 46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod", - 106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete", 145: "ScrollLock", - 173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\", - 221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete", - 63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert" -}; - -// Number keys -for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i); } -// Alphabetic keys -for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1); } -// Function keys -for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2; } - -var keyMap = {}; - -keyMap.basic = { - "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown", - "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown", - "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore", - "Tab": "defaultTab", "Shift-Tab": "indentAuto", - "Enter": "newlineAndIndent", "Insert": "toggleOverwrite", - "Esc": "singleSelection" -}; -// Note that the save and find-related commands aren't defined by -// default. User code or addons can define them. Unknown commands -// are simply ignored. -keyMap.pcDefault = { - "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo", - "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown", - "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd", - "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find", - "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll", - "Ctrl-[": "indentLess", "Ctrl-]": "indentMore", - "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection", - fallthrough: "basic" -}; -// Very basic readline/emacs-style bindings, which are standard on Mac. -keyMap.emacsy = { - "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown", - "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd", - "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore", - "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars", - "Ctrl-O": "openLine" -}; -keyMap.macDefault = { - "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo", - "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft", - "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore", - "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find", - "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll", - "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight", - "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd", - fallthrough: ["basic", "emacsy"] -}; -keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault; - -// KEYMAP DISPATCH - -function normalizeKeyName(name) { - var parts = name.split(/-(?!$)/); - name = parts[parts.length - 1]; - var alt, ctrl, shift, cmd; - for (var i = 0; i < parts.length - 1; i++) { - var mod = parts[i]; - if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true; } - else if (/^a(lt)?$/i.test(mod)) { alt = true; } - else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true; } - else if (/^s(hift)?$/i.test(mod)) { shift = true; } - else { throw new Error("Unrecognized modifier name: " + mod) } - } - if (alt) { name = "Alt-" + name; } - if (ctrl) { name = "Ctrl-" + name; } - if (cmd) { name = "Cmd-" + name; } - if (shift) { name = "Shift-" + name; } - return name -} - -// This is a kludge to keep keymaps mostly working as raw objects -// (backwards compatibility) while at the same time support features -// like normalization and multi-stroke key bindings. It compiles a -// new normalized keymap, and then updates the old object to reflect -// this. -function normalizeKeyMap(keymap) { - var copy = {}; - for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) { - var value = keymap[keyname]; - if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue } - if (value == "...") { delete keymap[keyname]; continue } - - var keys = map(keyname.split(" "), normalizeKeyName); - for (var i = 0; i < keys.length; i++) { - var val = (void 0), name = (void 0); - if (i == keys.length - 1) { - name = keys.join(" "); - val = value; - } else { - name = keys.slice(0, i + 1).join(" "); - val = "..."; - } - var prev = copy[name]; - if (!prev) { copy[name] = val; } - else if (prev != val) { throw new Error("Inconsistent bindings for " + name) } - } - delete keymap[keyname]; - } } - for (var prop in copy) { keymap[prop] = copy[prop]; } - return keymap -} - -function lookupKey(key, map$$1, handle, context) { - map$$1 = getKeyMap(map$$1); - var found = map$$1.call ? map$$1.call(key, context) : map$$1[key]; - if (found === false) { return "nothing" } - if (found === "...") { return "multi" } - if (found != null && handle(found)) { return "handled" } - - if (map$$1.fallthrough) { - if (Object.prototype.toString.call(map$$1.fallthrough) != "[object Array]") - { return lookupKey(key, map$$1.fallthrough, handle, context) } - for (var i = 0; i < map$$1.fallthrough.length; i++) { - var result = lookupKey(key, map$$1.fallthrough[i], handle, context); - if (result) { return result } - } - } -} - -// Modifier key presses don't count as 'real' key presses for the -// purpose of keymap fallthrough. -function isModifierKey(value) { - var name = typeof value == "string" ? value : keyNames[value.keyCode]; - return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod" -} - -function addModifierNames(name, event, noShift) { - var base = name; - if (event.altKey && base != "Alt") { name = "Alt-" + name; } - if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") { name = "Ctrl-" + name; } - if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") { name = "Cmd-" + name; } - if (!noShift && event.shiftKey && base != "Shift") { name = "Shift-" + name; } - return name -} - -// Look up the name of a key as indicated by an event object. -function keyName(event, noShift) { - if (presto && event.keyCode == 34 && event["char"]) { return false } - var name = keyNames[event.keyCode]; - if (name == null || event.altGraphKey) { return false } - // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause, - // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+) - if (event.keyCode == 3 && event.code) { name = event.code; } - return addModifierNames(name, event, noShift) -} - -function getKeyMap(val) { - return typeof val == "string" ? keyMap[val] : val -} - -// Helper for deleting text near the selection(s), used to implement -// backspace, delete, and similar functionality. -function deleteNearSelection(cm, compute) { - var ranges = cm.doc.sel.ranges, kill = []; - // Build up a set of ranges to kill first, merging overlapping - // ranges. - for (var i = 0; i < ranges.length; i++) { - var toKill = compute(ranges[i]); - while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) { - var replaced = kill.pop(); - if (cmp(replaced.from, toKill.from) < 0) { - toKill.from = replaced.from; - break - } - } - kill.push(toKill); - } - // Next, remove those actual ranges. - runInOp(cm, function () { - for (var i = kill.length - 1; i >= 0; i--) - { replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete"); } - ensureCursorVisible(cm); - }); -} - -function moveCharLogically(line, ch, dir) { - var target = skipExtendingChars(line.text, ch + dir, dir); - return target < 0 || target > line.text.length ? null : target -} - -function moveLogically(line, start, dir) { - var ch = moveCharLogically(line, start.ch, dir); - return ch == null ? null : new Pos(start.line, ch, dir < 0 ? "after" : "before") -} - -function endOfLine(visually, cm, lineObj, lineNo, dir) { - if (visually) { - var order = getOrder(lineObj, cm.doc.direction); - if (order) { - var part = dir < 0 ? lst(order) : order[0]; - var moveInStorageOrder = (dir < 0) == (part.level == 1); - var sticky = moveInStorageOrder ? "after" : "before"; - var ch; - // With a wrapped rtl chunk (possibly spanning multiple bidi parts), - // it could be that the last bidi part is not on the last visual line, - // since visual lines contain content order-consecutive chunks. - // Thus, in rtl, we are looking for the first (content-order) character - // in the rtl chunk that is on the last line (that is, the same line - // as the last (content-order) character). - if (part.level > 0 || cm.doc.direction == "rtl") { - var prep = prepareMeasureForLine(cm, lineObj); - ch = dir < 0 ? lineObj.text.length - 1 : 0; - var targetTop = measureCharPrepared(cm, prep, ch).top; - ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch); - if (sticky == "before") { ch = moveCharLogically(lineObj, ch, 1); } - } else { ch = dir < 0 ? part.to : part.from; } - return new Pos(lineNo, ch, sticky) - } - } - return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? "before" : "after") -} - -function moveVisually(cm, line, start, dir) { - var bidi = getOrder(line, cm.doc.direction); - if (!bidi) { return moveLogically(line, start, dir) } - if (start.ch >= line.text.length) { - start.ch = line.text.length; - start.sticky = "before"; - } else if (start.ch <= 0) { - start.ch = 0; - start.sticky = "after"; - } - var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos]; - if (cm.doc.direction == "ltr" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) { - // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines, - // nothing interesting happens. - return moveLogically(line, start, dir) - } - - var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); }; - var prep; - var getWrappedLineExtent = function (ch) { - if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} } - prep = prep || prepareMeasureForLine(cm, line); - return wrappedLineExtentChar(cm, line, prep, ch) - }; - var wrappedLineExtent = getWrappedLineExtent(start.sticky == "before" ? mv(start, -1) : start.ch); - - if (cm.doc.direction == "rtl" || part.level == 1) { - var moveInStorageOrder = (part.level == 1) == (dir < 0); - var ch = mv(start, moveInStorageOrder ? 1 : -1); - if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) { - // Case 2: We move within an rtl part or in an rtl editor on the same visual line - var sticky = moveInStorageOrder ? "before" : "after"; - return new Pos(start.line, ch, sticky) - } - } - - // Case 3: Could not move within this bidi part in this visual line, so leave - // the current bidi part - - var searchInVisualLine = function (partPos, dir, wrappedLineExtent) { - var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder - ? new Pos(start.line, mv(ch, 1), "before") - : new Pos(start.line, ch, "after"); }; - - for (; partPos >= 0 && partPos < bidi.length; partPos += dir) { - var part = bidi[partPos]; - var moveInStorageOrder = (dir > 0) == (part.level != 1); - var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1); - if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) } - ch = moveInStorageOrder ? part.from : mv(part.to, -1); - if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) } - } - }; - - // Case 3a: Look for other bidi parts on the same visual line - var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent); - if (res) { return res } - - // Case 3b: Look for other bidi parts on the next visual line - var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1); - if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) { - res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh)); - if (res) { return res } - } - - // Case 4: Nowhere to move - return null -} - -// Commands are parameter-less actions that can be performed on an -// editor, mostly used for keybindings. -var commands = { - selectAll: selectAll, - singleSelection: function (cm) { return cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll); }, - killLine: function (cm) { return deleteNearSelection(cm, function (range) { - if (range.empty()) { - var len = getLine(cm.doc, range.head.line).text.length; - if (range.head.ch == len && range.head.line < cm.lastLine()) - { return {from: range.head, to: Pos(range.head.line + 1, 0)} } - else - { return {from: range.head, to: Pos(range.head.line, len)} } - } else { - return {from: range.from(), to: range.to()} - } - }); }, - deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({ - from: Pos(range.from().line, 0), - to: clipPos(cm.doc, Pos(range.to().line + 1, 0)) - }); }); }, - delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({ - from: Pos(range.from().line, 0), to: range.from() - }); }); }, - delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { - var top = cm.charCoords(range.head, "div").top + 5; - var leftPos = cm.coordsChar({left: 0, top: top}, "div"); - return {from: leftPos, to: range.from()} - }); }, - delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) { - var top = cm.charCoords(range.head, "div").top + 5; - var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div"); - return {from: range.from(), to: rightPos } - }); }, - undo: function (cm) { return cm.undo(); }, - redo: function (cm) { return cm.redo(); }, - undoSelection: function (cm) { return cm.undoSelection(); }, - redoSelection: function (cm) { return cm.redoSelection(); }, - goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); }, - goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); }, - goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); }, - {origin: "+move", bias: 1} - ); }, - goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); }, - {origin: "+move", bias: 1} - ); }, - goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); }, - {origin: "+move", bias: -1} - ); }, - goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) { - var top = cm.cursorCoords(range.head, "div").top + 5; - return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div") - }, sel_move); }, - goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) { - var top = cm.cursorCoords(range.head, "div").top + 5; - return cm.coordsChar({left: 0, top: top}, "div") - }, sel_move); }, - goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) { - var top = cm.cursorCoords(range.head, "div").top + 5; - var pos = cm.coordsChar({left: 0, top: top}, "div"); - if (pos.ch < cm.getLine(pos.line).search(/\S/)) { return lineStartSmart(cm, range.head) } - return pos - }, sel_move); }, - goLineUp: function (cm) { return cm.moveV(-1, "line"); }, - goLineDown: function (cm) { return cm.moveV(1, "line"); }, - goPageUp: function (cm) { return cm.moveV(-1, "page"); }, - goPageDown: function (cm) { return cm.moveV(1, "page"); }, - goCharLeft: function (cm) { return cm.moveH(-1, "char"); }, - goCharRight: function (cm) { return cm.moveH(1, "char"); }, - goColumnLeft: function (cm) { return cm.moveH(-1, "column"); }, - goColumnRight: function (cm) { return cm.moveH(1, "column"); }, - goWordLeft: function (cm) { return cm.moveH(-1, "word"); }, - goGroupRight: function (cm) { return cm.moveH(1, "group"); }, - goGroupLeft: function (cm) { return cm.moveH(-1, "group"); }, - goWordRight: function (cm) { return cm.moveH(1, "word"); }, - delCharBefore: function (cm) { return cm.deleteH(-1, "char"); }, - delCharAfter: function (cm) { return cm.deleteH(1, "char"); }, - delWordBefore: function (cm) { return cm.deleteH(-1, "word"); }, - delWordAfter: function (cm) { return cm.deleteH(1, "word"); }, - delGroupBefore: function (cm) { return cm.deleteH(-1, "group"); }, - delGroupAfter: function (cm) { return cm.deleteH(1, "group"); }, - indentAuto: function (cm) { return cm.indentSelection("smart"); }, - indentMore: function (cm) { return cm.indentSelection("add"); }, - indentLess: function (cm) { return cm.indentSelection("subtract"); }, - insertTab: function (cm) { return cm.replaceSelection("\t"); }, - insertSoftTab: function (cm) { - var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize; - for (var i = 0; i < ranges.length; i++) { - var pos = ranges[i].from(); - var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize); - spaces.push(spaceStr(tabSize - col % tabSize)); - } - cm.replaceSelections(spaces); - }, - defaultTab: function (cm) { - if (cm.somethingSelected()) { cm.indentSelection("add"); } - else { cm.execCommand("insertTab"); } - }, - // Swap the two chars left and right of each selection's head. - // Move cursor behind the two swapped characters afterwards. - // - // Doesn't consider line feeds a character. - // Doesn't scan more than one line above to find a character. - // Doesn't do anything on an empty line. - // Doesn't do anything with non-empty selections. - transposeChars: function (cm) { return runInOp(cm, function () { - var ranges = cm.listSelections(), newSel = []; - for (var i = 0; i < ranges.length; i++) { - if (!ranges[i].empty()) { continue } - var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text; - if (line) { - if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1); } - if (cur.ch > 0) { - cur = new Pos(cur.line, cur.ch + 1); - cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2), - Pos(cur.line, cur.ch - 2), cur, "+transpose"); - } else if (cur.line > cm.doc.first) { - var prev = getLine(cm.doc, cur.line - 1).text; - if (prev) { - cur = new Pos(cur.line, 1); - cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() + - prev.charAt(prev.length - 1), - Pos(cur.line - 1, prev.length - 1), cur, "+transpose"); - } - } - } - newSel.push(new Range(cur, cur)); - } - cm.setSelections(newSel); - }); }, - newlineAndIndent: function (cm) { return runInOp(cm, function () { - var sels = cm.listSelections(); - for (var i = sels.length - 1; i >= 0; i--) - { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input"); } - sels = cm.listSelections(); - for (var i$1 = 0; i$1 < sels.length; i$1++) - { cm.indentLine(sels[i$1].from().line, null, true); } - ensureCursorVisible(cm); - }); }, - openLine: function (cm) { return cm.replaceSelection("\n", "start"); }, - toggleOverwrite: function (cm) { return cm.toggleOverwrite(); } -}; - - -function lineStart(cm, lineN) { - var line = getLine(cm.doc, lineN); - var visual = visualLine(line); - if (visual != line) { lineN = lineNo(visual); } - return endOfLine(true, cm, visual, lineN, 1) -} -function lineEnd(cm, lineN) { - var line = getLine(cm.doc, lineN); - var visual = visualLineEnd(line); - if (visual != line) { lineN = lineNo(visual); } - return endOfLine(true, cm, line, lineN, -1) -} -function lineStartSmart(cm, pos) { - var start = lineStart(cm, pos.line); - var line = getLine(cm.doc, start.line); - var order = getOrder(line, cm.doc.direction); - if (!order || order[0].level == 0) { - var firstNonWS = Math.max(0, line.text.search(/\S/)); - var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch; - return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky) - } - return start -} - -// Run a handler that was bound to a key. -function doHandleBinding(cm, bound, dropShift) { - if (typeof bound == "string") { - bound = commands[bound]; - if (!bound) { return false } - } - // Ensure previous input has been read, so that the handler sees a - // consistent view of the document - cm.display.input.ensurePolled(); - var prevShift = cm.display.shift, done = false; - try { - if (cm.isReadOnly()) { cm.state.suppressEdits = true; } - if (dropShift) { cm.display.shift = false; } - done = bound(cm) != Pass; - } finally { - cm.display.shift = prevShift; - cm.state.suppressEdits = false; - } - return done -} - -function lookupKeyForEditor(cm, name, handle) { - for (var i = 0; i < cm.state.keyMaps.length; i++) { - var result = lookupKey(name, cm.state.keyMaps[i], handle, cm); - if (result) { return result } - } - return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm)) - || lookupKey(name, cm.options.keyMap, handle, cm) -} - -// Note that, despite the name, this function is also used to check -// for bound mouse clicks. - -var stopSeq = new Delayed; - -function dispatchKey(cm, name, e, handle) { - var seq = cm.state.keySeq; - if (seq) { - if (isModifierKey(name)) { return "handled" } - if (/\'$/.test(name)) - { cm.state.keySeq = null; } - else - { stopSeq.set(50, function () { - if (cm.state.keySeq == seq) { - cm.state.keySeq = null; - cm.display.input.reset(); - } - }); } - if (dispatchKeyInner(cm, seq + " " + name, e, handle)) { return true } - } - return dispatchKeyInner(cm, name, e, handle) -} - -function dispatchKeyInner(cm, name, e, handle) { - var result = lookupKeyForEditor(cm, name, handle); - - if (result == "multi") - { cm.state.keySeq = name; } - if (result == "handled") - { signalLater(cm, "keyHandled", cm, name, e); } - - if (result == "handled" || result == "multi") { - e_preventDefault(e); - restartBlink(cm); - } - - return !!result -} - -// Handle a key from the keydown event. -function handleKeyBinding(cm, e) { - var name = keyName(e, true); - if (!name) { return false } - - if (e.shiftKey && !cm.state.keySeq) { - // First try to resolve full name (including 'Shift-'). Failing - // that, see if there is a cursor-motion command (starting with - // 'go') bound to the keyname without 'Shift-'. - return dispatchKey(cm, "Shift-" + name, e, function (b) { return doHandleBinding(cm, b, true); }) - || dispatchKey(cm, name, e, function (b) { - if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion) - { return doHandleBinding(cm, b) } - }) - } else { - return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); }) - } -} - -// Handle a key from the keypress event -function handleCharBinding(cm, e, ch) { - return dispatchKey(cm, "'" + ch + "'", e, function (b) { return doHandleBinding(cm, b, true); }) -} - -var lastStoppedKey = null; -function onKeyDown(e) { - var cm = this; - cm.curOp.focus = activeElt(); - if (signalDOMEvent(cm, e)) { return } - // IE does strange things with escape. - if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false; } - var code = e.keyCode; - cm.display.shift = code == 16 || e.shiftKey; - var handled = handleKeyBinding(cm, e); - if (presto) { - lastStoppedKey = handled ? code : null; - // Opera has no cut event... we try to at least catch the key combo - if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey)) - { cm.replaceSelection("", null, "cut"); } - } - - // Turn mouse into crosshair when Alt is held on Mac. - if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className)) - { showCrossHair(cm); } -} - -function showCrossHair(cm) { - var lineDiv = cm.display.lineDiv; - addClass(lineDiv, "CodeMirror-crosshair"); - - function up(e) { - if (e.keyCode == 18 || !e.altKey) { - rmClass(lineDiv, "CodeMirror-crosshair"); - off(document, "keyup", up); - off(document, "mouseover", up); - } - } - on(document, "keyup", up); - on(document, "mouseover", up); -} - -function onKeyUp(e) { - if (e.keyCode == 16) { this.doc.sel.shift = false; } - signalDOMEvent(this, e); -} - -function onKeyPress(e) { - var cm = this; - if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return } - var keyCode = e.keyCode, charCode = e.charCode; - if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return} - if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return } - var ch = String.fromCharCode(charCode == null ? keyCode : charCode); - // Some browsers fire keypress events for backspace - if (ch == "\x08") { return } - if (handleCharBinding(cm, e, ch)) { return } - cm.display.input.onKeyPress(e); -} - -var DOUBLECLICK_DELAY = 400; - -var PastClick = function(time, pos, button) { - this.time = time; - this.pos = pos; - this.button = button; -}; - -PastClick.prototype.compare = function (time, pos, button) { - return this.time + DOUBLECLICK_DELAY > time && - cmp(pos, this.pos) == 0 && button == this.button -}; - -var lastClick; -var lastDoubleClick; -function clickRepeat(pos, button) { - var now = +new Date; - if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) { - lastClick = lastDoubleClick = null; - return "triple" - } else if (lastClick && lastClick.compare(now, pos, button)) { - lastDoubleClick = new PastClick(now, pos, button); - lastClick = null; - return "double" - } else { - lastClick = new PastClick(now, pos, button); - lastDoubleClick = null; - return "single" - } -} - -// A mouse down can be a single click, double click, triple click, -// start of selection drag, start of text drag, new cursor -// (ctrl-click), rectangle drag (alt-drag), or xwin -// middle-click-paste. Or it might be a click on something we should -// not interfere with, such as a scrollbar or widget. -function onMouseDown(e) { - var cm = this, display = cm.display; - if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return } - display.input.ensurePolled(); - display.shift = e.shiftKey; - - if (eventInWidget(display, e)) { - if (!webkit) { - // Briefly turn off draggability, to allow widgets to do - // normal dragging things. - display.scroller.draggable = false; - setTimeout(function () { return display.scroller.draggable = true; }, 100); - } - return - } - if (clickInGutter(cm, e)) { return } - var pos = posFromMouse(cm, e), button = e_button(e), repeat = pos ? clickRepeat(pos, button) : "single"; - window.focus(); - - // #3261: make sure, that we're not starting a second selection - if (button == 1 && cm.state.selectingText) - { cm.state.selectingText(e); } - - if (pos && handleMappedButton(cm, button, pos, repeat, e)) { return } - - if (button == 1) { - if (pos) { leftButtonDown(cm, pos, repeat, e); } - else if (e_target(e) == display.scroller) { e_preventDefault(e); } - } else if (button == 2) { - if (pos) { extendSelection(cm.doc, pos); } - setTimeout(function () { return display.input.focus(); }, 20); - } else if (button == 3) { - if (captureRightClick) { onContextMenu(cm, e); } - else { delayBlurEvent(cm); } - } -} - -function handleMappedButton(cm, button, pos, repeat, event) { - var name = "Click"; - if (repeat == "double") { name = "Double" + name; } - else if (repeat == "triple") { name = "Triple" + name; } - name = (button == 1 ? "Left" : button == 2 ? "Middle" : "Right") + name; - - return dispatchKey(cm, addModifierNames(name, event), event, function (bound) { - if (typeof bound == "string") { bound = commands[bound]; } - if (!bound) { return false } - var done = false; - try { - if (cm.isReadOnly()) { cm.state.suppressEdits = true; } - done = bound(cm, pos) != Pass; - } finally { - cm.state.suppressEdits = false; - } - return done - }) -} - -function configureMouse(cm, repeat, event) { - var option = cm.getOption("configureMouse"); - var value = option ? option(cm, repeat, event) : {}; - if (value.unit == null) { - var rect = chromeOS ? event.shiftKey && event.metaKey : event.altKey; - value.unit = rect ? "rectangle" : repeat == "single" ? "char" : repeat == "double" ? "word" : "line"; - } - if (value.extend == null || cm.doc.extend) { value.extend = cm.doc.extend || event.shiftKey; } - if (value.addNew == null) { value.addNew = mac ? event.metaKey : event.ctrlKey; } - if (value.moveOnDrag == null) { value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey); } - return value -} - -function leftButtonDown(cm, pos, repeat, event) { - if (ie) { setTimeout(bind(ensureFocus, cm), 0); } - else { cm.curOp.focus = activeElt(); } - - var behavior = configureMouse(cm, repeat, event); - - var sel = cm.doc.sel, contained; - if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() && - repeat == "single" && (contained = sel.contains(pos)) > -1 && - (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) && - (cmp(contained.to(), pos) > 0 || pos.xRel < 0)) - { leftButtonStartDrag(cm, event, pos, behavior); } - else - { leftButtonSelect(cm, event, pos, behavior); } -} - -// Start a text drag. When it ends, see if any dragging actually -// happen, and treat as a click if it didn't. -function leftButtonStartDrag(cm, event, pos, behavior) { - var display = cm.display, moved = false; - var dragEnd = operation(cm, function (e) { - if (webkit) { display.scroller.draggable = false; } - cm.state.draggingText = false; - off(display.wrapper.ownerDocument, "mouseup", dragEnd); - off(display.wrapper.ownerDocument, "mousemove", mouseMove); - off(display.scroller, "dragstart", dragStart); - off(display.scroller, "drop", dragEnd); - if (!moved) { - e_preventDefault(e); - if (!behavior.addNew) - { extendSelection(cm.doc, pos, null, null, behavior.extend); } - // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081) - if (webkit || ie && ie_version == 9) - { setTimeout(function () {display.wrapper.ownerDocument.body.focus(); display.input.focus();}, 20); } - else - { display.input.focus(); } - } - }); - var mouseMove = function(e2) { - moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10; - }; - var dragStart = function () { return moved = true; }; - // Let the drag handler handle this. - if (webkit) { display.scroller.draggable = true; } - cm.state.draggingText = dragEnd; - dragEnd.copy = !behavior.moveOnDrag; - // IE's approach to draggable - if (display.scroller.dragDrop) { display.scroller.dragDrop(); } - on(display.wrapper.ownerDocument, "mouseup", dragEnd); - on(display.wrapper.ownerDocument, "mousemove", mouseMove); - on(display.scroller, "dragstart", dragStart); - on(display.scroller, "drop", dragEnd); - - delayBlurEvent(cm); - setTimeout(function () { return display.input.focus(); }, 20); -} - -function rangeForUnit(cm, pos, unit) { - if (unit == "char") { return new Range(pos, pos) } - if (unit == "word") { return cm.findWordAt(pos) } - if (unit == "line") { return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) } - var result = unit(cm, pos); - return new Range(result.from, result.to) -} - -// Normal selection, as opposed to text dragging. -function leftButtonSelect(cm, event, start, behavior) { - var display = cm.display, doc = cm.doc; - e_preventDefault(event); - - var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges; - if (behavior.addNew && !behavior.extend) { - ourIndex = doc.sel.contains(start); - if (ourIndex > -1) - { ourRange = ranges[ourIndex]; } - else - { ourRange = new Range(start, start); } - } else { - ourRange = doc.sel.primary(); - ourIndex = doc.sel.primIndex; - } - - if (behavior.unit == "rectangle") { - if (!behavior.addNew) { ourRange = new Range(start, start); } - start = posFromMouse(cm, event, true, true); - ourIndex = -1; - } else { - var range$$1 = rangeForUnit(cm, start, behavior.unit); - if (behavior.extend) - { ourRange = extendRange(ourRange, range$$1.anchor, range$$1.head, behavior.extend); } - else - { ourRange = range$$1; } - } - - if (!behavior.addNew) { - ourIndex = 0; - setSelection(doc, new Selection([ourRange], 0), sel_mouse); - startSel = doc.sel; - } else if (ourIndex == -1) { - ourIndex = ranges.length; - setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex), - {scroll: false, origin: "*mouse"}); - } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == "char" && !behavior.extend) { - setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0), - {scroll: false, origin: "*mouse"}); - startSel = doc.sel; - } else { - replaceOneSelection(doc, ourIndex, ourRange, sel_mouse); - } - - var lastPos = start; - function extendTo(pos) { - if (cmp(lastPos, pos) == 0) { return } - lastPos = pos; - - if (behavior.unit == "rectangle") { - var ranges = [], tabSize = cm.options.tabSize; - var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize); - var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize); - var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol); - for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line)); - line <= end; line++) { - var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize); - if (left == right) - { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))); } - else if (text.length > leftPos) - { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))); } - } - if (!ranges.length) { ranges.push(new Range(start, start)); } - setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex), - {origin: "*mouse", scroll: false}); - cm.scrollIntoView(pos); - } else { - var oldRange = ourRange; - var range$$1 = rangeForUnit(cm, pos, behavior.unit); - var anchor = oldRange.anchor, head; - if (cmp(range$$1.anchor, anchor) > 0) { - head = range$$1.head; - anchor = minPos(oldRange.from(), range$$1.anchor); - } else { - head = range$$1.anchor; - anchor = maxPos(oldRange.to(), range$$1.head); - } - var ranges$1 = startSel.ranges.slice(0); - ranges$1[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head)); - setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse); - } - } - - var editorSize = display.wrapper.getBoundingClientRect(); - // Used to ensure timeout re-tries don't fire when another extend - // happened in the meantime (clearTimeout isn't reliable -- at - // least on Chrome, the timeouts still happen even when cleared, - // if the clear happens after their scheduled firing time). - var counter = 0; - - function extend(e) { - var curCount = ++counter; - var cur = posFromMouse(cm, e, true, behavior.unit == "rectangle"); - if (!cur) { return } - if (cmp(cur, lastPos) != 0) { - cm.curOp.focus = activeElt(); - extendTo(cur); - var visible = visibleLines(display, doc); - if (cur.line >= visible.to || cur.line < visible.from) - { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e); }}), 150); } - } else { - var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0; - if (outside) { setTimeout(operation(cm, function () { - if (counter != curCount) { return } - display.scroller.scrollTop += outside; - extend(e); - }), 50); } - } - } - - function done(e) { - cm.state.selectingText = false; - counter = Infinity; - e_preventDefault(e); - display.input.focus(); - off(display.wrapper.ownerDocument, "mousemove", move); - off(display.wrapper.ownerDocument, "mouseup", up); - doc.history.lastSelOrigin = null; - } - - var move = operation(cm, function (e) { - if (e.buttons === 0 || !e_button(e)) { done(e); } - else { extend(e); } - }); - var up = operation(cm, done); - cm.state.selectingText = up; - on(display.wrapper.ownerDocument, "mousemove", move); - on(display.wrapper.ownerDocument, "mouseup", up); -} - -// Used when mouse-selecting to adjust the anchor to the proper side -// of a bidi jump depending on the visual position of the head. -function bidiSimplify(cm, range$$1) { - var anchor = range$$1.anchor; - var head = range$$1.head; - var anchorLine = getLine(cm.doc, anchor.line); - if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) { return range$$1 } - var order = getOrder(anchorLine); - if (!order) { return range$$1 } - var index = getBidiPartAt(order, anchor.ch, anchor.sticky), part = order[index]; - if (part.from != anchor.ch && part.to != anchor.ch) { return range$$1 } - var boundary = index + ((part.from == anchor.ch) == (part.level != 1) ? 0 : 1); - if (boundary == 0 || boundary == order.length) { return range$$1 } - - // Compute the relative visual position of the head compared to the - // anchor (<0 is to the left, >0 to the right) - var leftSide; - if (head.line != anchor.line) { - leftSide = (head.line - anchor.line) * (cm.doc.direction == "ltr" ? 1 : -1) > 0; - } else { - var headIndex = getBidiPartAt(order, head.ch, head.sticky); - var dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1); - if (headIndex == boundary - 1 || headIndex == boundary) - { leftSide = dir < 0; } - else - { leftSide = dir > 0; } - } - - var usePart = order[boundary + (leftSide ? -1 : 0)]; - var from = leftSide == (usePart.level == 1); - var ch = from ? usePart.from : usePart.to, sticky = from ? "after" : "before"; - return anchor.ch == ch && anchor.sticky == sticky ? range$$1 : new Range(new Pos(anchor.line, ch, sticky), head) -} - - -// Determines whether an event happened in the gutter, and fires the -// handlers for the corresponding event. -function gutterEvent(cm, e, type, prevent) { - var mX, mY; - if (e.touches) { - mX = e.touches[0].clientX; - mY = e.touches[0].clientY; - } else { - try { mX = e.clientX; mY = e.clientY; } - catch(e) { return false } - } - if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false } - if (prevent) { e_preventDefault(e); } - - var display = cm.display; - var lineBox = display.lineDiv.getBoundingClientRect(); - - if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) } - mY -= lineBox.top - display.viewOffset; - - for (var i = 0; i < cm.options.gutters.length; ++i) { - var g = display.gutters.childNodes[i]; - if (g && g.getBoundingClientRect().right >= mX) { - var line = lineAtHeight(cm.doc, mY); - var gutter = cm.options.gutters[i]; - signal(cm, type, cm, line, gutter, e); - return e_defaultPrevented(e) - } - } -} - -function clickInGutter(cm, e) { - return gutterEvent(cm, e, "gutterClick", true) -} - -// CONTEXT MENU HANDLING - -// To make the context menu work, we need to briefly unhide the -// textarea (making it as unobtrusive as possible) to let the -// right-click take effect on it. -function onContextMenu(cm, e) { - if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return } - if (signalDOMEvent(cm, e, "contextmenu")) { return } - cm.display.input.onContextMenu(e); -} - -function contextMenuInGutter(cm, e) { - if (!hasHandler(cm, "gutterContextMenu")) { return false } - return gutterEvent(cm, e, "gutterContextMenu", false) -} - -function themeChanged(cm) { - cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") + - cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-"); - clearCaches(cm); -} - -var Init = {toString: function(){return "CodeMirror.Init"}}; - -var defaults = {}; -var optionHandlers = {}; - -function defineOptions(CodeMirror) { - var optionHandlers = CodeMirror.optionHandlers; - - function option(name, deflt, handle, notOnInit) { - CodeMirror.defaults[name] = deflt; - if (handle) { optionHandlers[name] = - notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old); }} : handle; } - } - - CodeMirror.defineOption = option; - - // Passed to option handlers when there is no old value. - CodeMirror.Init = Init; - - // These two are, on init, called from the constructor because they - // have to be initialized before the editor can start at all. - option("value", "", function (cm, val) { return cm.setValue(val); }, true); - option("mode", null, function (cm, val) { - cm.doc.modeOption = val; - loadMode(cm); - }, true); - - option("indentUnit", 2, loadMode, true); - option("indentWithTabs", false); - option("smartIndent", true); - option("tabSize", 4, function (cm) { - resetModeState(cm); - clearCaches(cm); - regChange(cm); - }, true); - - option("lineSeparator", null, function (cm, val) { - cm.doc.lineSep = val; - if (!val) { return } - var newBreaks = [], lineNo = cm.doc.first; - cm.doc.iter(function (line) { - for (var pos = 0;;) { - var found = line.text.indexOf(val, pos); - if (found == -1) { break } - pos = found + val.length; - newBreaks.push(Pos(lineNo, found)); - } - lineNo++; - }); - for (var i = newBreaks.length - 1; i >= 0; i--) - { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)); } - }); - option("specialChars", /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028\u2029\ufeff]/g, function (cm, val, old) { - cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g"); - if (old != Init) { cm.refresh(); } - }); - option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true); - option("electricChars", true); - option("inputStyle", mobile ? "contenteditable" : "textarea", function () { - throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME - }, true); - option("spellcheck", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true); - option("rtlMoveVisually", !windows); - option("wholeLineUpdateBefore", true); - - option("theme", "default", function (cm) { - themeChanged(cm); - guttersChanged(cm); - }, true); - option("keyMap", "default", function (cm, val, old) { - var next = getKeyMap(val); - var prev = old != Init && getKeyMap(old); - if (prev && prev.detach) { prev.detach(cm, next); } - if (next.attach) { next.attach(cm, prev || null); } - }); - option("extraKeys", null); - option("configureMouse", null); - - option("lineWrapping", false, wrappingChanged, true); - option("gutters", [], function (cm) { - setGuttersForLineNumbers(cm.options); - guttersChanged(cm); - }, true); - option("fixedGutter", true, function (cm, val) { - cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0"; - cm.refresh(); - }, true); - option("coverGutterNextToScrollbar", false, function (cm) { return updateScrollbars(cm); }, true); - option("scrollbarStyle", "native", function (cm) { - initScrollbars(cm); - updateScrollbars(cm); - cm.display.scrollbars.setScrollTop(cm.doc.scrollTop); - cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft); - }, true); - option("lineNumbers", false, function (cm) { - setGuttersForLineNumbers(cm.options); - guttersChanged(cm); - }, true); - option("firstLineNumber", 1, guttersChanged, true); - option("lineNumberFormatter", function (integer) { return integer; }, guttersChanged, true); - option("showCursorWhenSelecting", false, updateSelection, true); - - option("resetSelectionOnContextMenu", true); - option("lineWiseCopyCut", true); - option("pasteLinesPerSelection", true); - - option("readOnly", false, function (cm, val) { - if (val == "nocursor") { - onBlur(cm); - cm.display.input.blur(); - } - cm.display.input.readOnlyChanged(val); - }); - option("disableInput", false, function (cm, val) {if (!val) { cm.display.input.reset(); }}, true); - option("dragDrop", true, dragDropChanged); - option("allowDropFileTypes", null); - - option("cursorBlinkRate", 530); - option("cursorScrollMargin", 0); - option("cursorHeight", 1, updateSelection, true); - option("singleCursorHeightPerLine", true, updateSelection, true); - option("workTime", 100); - option("workDelay", 100); - option("flattenSpans", true, resetModeState, true); - option("addModeClass", false, resetModeState, true); - option("pollInterval", 100); - option("undoDepth", 200, function (cm, val) { return cm.doc.history.undoDepth = val; }); - option("historyEventDelay", 1250); - option("viewportMargin", 10, function (cm) { return cm.refresh(); }, true); - option("maxHighlightLength", 10000, resetModeState, true); - option("moveInputWithCursor", true, function (cm, val) { - if (!val) { cm.display.input.resetPosition(); } - }); - - option("tabindex", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || ""; }); - option("autofocus", null); - option("direction", "ltr", function (cm, val) { return cm.doc.setDirection(val); }, true); -} - -function guttersChanged(cm) { - updateGutters(cm); - regChange(cm); - alignHorizontally(cm); -} - -function dragDropChanged(cm, value, old) { - var wasOn = old && old != Init; - if (!value != !wasOn) { - var funcs = cm.display.dragFunctions; - var toggle = value ? on : off; - toggle(cm.display.scroller, "dragstart", funcs.start); - toggle(cm.display.scroller, "dragenter", funcs.enter); - toggle(cm.display.scroller, "dragover", funcs.over); - toggle(cm.display.scroller, "dragleave", funcs.leave); - toggle(cm.display.scroller, "drop", funcs.drop); - } -} - -function wrappingChanged(cm) { - if (cm.options.lineWrapping) { - addClass(cm.display.wrapper, "CodeMirror-wrap"); - cm.display.sizer.style.minWidth = ""; - cm.display.sizerWidth = null; - } else { - rmClass(cm.display.wrapper, "CodeMirror-wrap"); - findMaxLine(cm); - } - estimateLineHeights(cm); - regChange(cm); - clearCaches(cm); - setTimeout(function () { return updateScrollbars(cm); }, 100); -} - -// A CodeMirror instance represents an editor. This is the object -// that user code is usually dealing with. - -function CodeMirror$1(place, options) { - var this$1 = this; - - if (!(this instanceof CodeMirror$1)) { return new CodeMirror$1(place, options) } - - this.options = options = options ? copyObj(options) : {}; - // Determine effective options based on given values and defaults. - copyObj(defaults, options, false); - setGuttersForLineNumbers(options); - - var doc = options.value; - if (typeof doc == "string") { doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction); } - this.doc = doc; - - var input = new CodeMirror$1.inputStyles[options.inputStyle](this); - var display = this.display = new Display(place, doc, input); - display.wrapper.CodeMirror = this; - updateGutters(this); - themeChanged(this); - if (options.lineWrapping) - { this.display.wrapper.className += " CodeMirror-wrap"; } - initScrollbars(this); - - this.state = { - keyMaps: [], // stores maps added by addKeyMap - overlays: [], // highlighting overlays, as added by addOverlay - modeGen: 0, // bumped when mode/overlay changes, used to invalidate highlighting info - overwrite: false, - delayingBlurEvent: false, - focused: false, - suppressEdits: false, // used to disable editing during key handlers when in readOnly mode - pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll - selectingText: false, - draggingText: false, - highlight: new Delayed(), // stores highlight worker timeout - keySeq: null, // Unfinished key sequence - specialChars: null - }; - - if (options.autofocus && !mobile) { display.input.focus(); } - - // Override magic textarea content restore that IE sometimes does - // on our hidden textarea on reload - if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20); } - - registerEventHandlers(this); - ensureGlobalHandlers(); - - startOperation(this); - this.curOp.forceUpdate = true; - attachDoc(this, doc); - - if ((options.autofocus && !mobile) || this.hasFocus()) - { setTimeout(bind(onFocus, this), 20); } - else - { onBlur(this); } - - for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt)) - { optionHandlers[opt](this$1, options[opt], Init); } } - maybeUpdateLineNumberWidth(this); - if (options.finishInit) { options.finishInit(this); } - for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1); } - endOperation(this); - // Suppress optimizelegibility in Webkit, since it breaks text - // measuring on line wrapping boundaries. - if (webkit && options.lineWrapping && - getComputedStyle(display.lineDiv).textRendering == "optimizelegibility") - { display.lineDiv.style.textRendering = "auto"; } -} - -// The default configuration options. -CodeMirror$1.defaults = defaults; -// Functions to run when options are changed. -CodeMirror$1.optionHandlers = optionHandlers; - -// Attach the necessary event handlers when initializing the editor -function registerEventHandlers(cm) { - var d = cm.display; - on(d.scroller, "mousedown", operation(cm, onMouseDown)); - // Older IE's will not fire a second mousedown for a double click - if (ie && ie_version < 11) - { on(d.scroller, "dblclick", operation(cm, function (e) { - if (signalDOMEvent(cm, e)) { return } - var pos = posFromMouse(cm, e); - if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return } - e_preventDefault(e); - var word = cm.findWordAt(pos); - extendSelection(cm.doc, word.anchor, word.head); - })); } - else - { on(d.scroller, "dblclick", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }); } - // Some browsers fire contextmenu *after* opening the menu, at - // which point we can't mess with it anymore. Context menu is - // handled in onMouseDown for these browsers. - if (!captureRightClick) { on(d.scroller, "contextmenu", function (e) { return onContextMenu(cm, e); }); } - - // Used to suppress mouse event handling when a touch happens - var touchFinished, prevTouch = {end: 0}; - function finishTouch() { - if (d.activeTouch) { - touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000); - prevTouch = d.activeTouch; - prevTouch.end = +new Date; - } - } - function isMouseLikeTouchEvent(e) { - if (e.touches.length != 1) { return false } - var touch = e.touches[0]; - return touch.radiusX <= 1 && touch.radiusY <= 1 - } - function farAway(touch, other) { - if (other.left == null) { return true } - var dx = other.left - touch.left, dy = other.top - touch.top; - return dx * dx + dy * dy > 20 * 20 - } - on(d.scroller, "touchstart", function (e) { - if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) { - d.input.ensurePolled(); - clearTimeout(touchFinished); - var now = +new Date; - d.activeTouch = {start: now, moved: false, - prev: now - prevTouch.end <= 300 ? prevTouch : null}; - if (e.touches.length == 1) { - d.activeTouch.left = e.touches[0].pageX; - d.activeTouch.top = e.touches[0].pageY; - } - } - }); - on(d.scroller, "touchmove", function () { - if (d.activeTouch) { d.activeTouch.moved = true; } - }); - on(d.scroller, "touchend", function (e) { - var touch = d.activeTouch; - if (touch && !eventInWidget(d, e) && touch.left != null && - !touch.moved && new Date - touch.start < 300) { - var pos = cm.coordsChar(d.activeTouch, "page"), range; - if (!touch.prev || farAway(touch, touch.prev)) // Single tap - { range = new Range(pos, pos); } - else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap - { range = cm.findWordAt(pos); } - else // Triple tap - { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))); } - cm.setSelection(range.anchor, range.head); - cm.focus(); - e_preventDefault(e); - } - finishTouch(); - }); - on(d.scroller, "touchcancel", finishTouch); - - // Sync scrolling between fake scrollbars and real scrollable - // area, ensure viewport is updated when scrolling. - on(d.scroller, "scroll", function () { - if (d.scroller.clientHeight) { - updateScrollTop(cm, d.scroller.scrollTop); - setScrollLeft(cm, d.scroller.scrollLeft, true); - signal(cm, "scroll", cm); - } - }); - - // Listen to wheel events in order to try and update the viewport on time. - on(d.scroller, "mousewheel", function (e) { return onScrollWheel(cm, e); }); - on(d.scroller, "DOMMouseScroll", function (e) { return onScrollWheel(cm, e); }); - - // Prevent wrapper from ever scrolling - on(d.wrapper, "scroll", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; }); - - d.dragFunctions = { - enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e); }}, - over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e); }}, - start: function (e) { return onDragStart(cm, e); }, - drop: operation(cm, onDrop), - leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm); }} - }; - - var inp = d.input.getField(); - on(inp, "keyup", function (e) { return onKeyUp.call(cm, e); }); - on(inp, "keydown", operation(cm, onKeyDown)); - on(inp, "keypress", operation(cm, onKeyPress)); - on(inp, "focus", function (e) { return onFocus(cm, e); }); - on(inp, "blur", function (e) { return onBlur(cm, e); }); -} - -var initHooks = []; -CodeMirror$1.defineInitHook = function (f) { return initHooks.push(f); }; - -// Indent the given line. The how parameter can be "smart", -// "add"/null, "subtract", or "prev". When aggressive is false -// (typically set to true for forced single-line indents), empty -// lines are not indented, and places where the mode returns Pass -// are left alone. -function indentLine(cm, n, how, aggressive) { - var doc = cm.doc, state; - if (how == null) { how = "add"; } - if (how == "smart") { - // Fall back to "prev" when the mode doesn't have an indentation - // method. - if (!doc.mode.indent) { how = "prev"; } - else { state = getContextBefore(cm, n).state; } - } - - var tabSize = cm.options.tabSize; - var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize); - if (line.stateAfter) { line.stateAfter = null; } - var curSpaceString = line.text.match(/^\s*/)[0], indentation; - if (!aggressive && !/\S/.test(line.text)) { - indentation = 0; - how = "not"; - } else if (how == "smart") { - indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text); - if (indentation == Pass || indentation > 150) { - if (!aggressive) { return } - how = "prev"; - } - } - if (how == "prev") { - if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize); } - else { indentation = 0; } - } else if (how == "add") { - indentation = curSpace + cm.options.indentUnit; - } else if (how == "subtract") { - indentation = curSpace - cm.options.indentUnit; - } else if (typeof how == "number") { - indentation = curSpace + how; - } - indentation = Math.max(0, indentation); - - var indentString = "", pos = 0; - if (cm.options.indentWithTabs) - { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t";} } - if (pos < indentation) { indentString += spaceStr(indentation - pos); } - - if (indentString != curSpaceString) { - replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input"); - line.stateAfter = null; - return true - } else { - // Ensure that, if the cursor was in the whitespace at the start - // of the line, it is moved to the end of that space. - for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) { - var range = doc.sel.ranges[i$1]; - if (range.head.line == n && range.head.ch < curSpaceString.length) { - var pos$1 = Pos(n, curSpaceString.length); - replaceOneSelection(doc, i$1, new Range(pos$1, pos$1)); - break - } - } - } -} - -// This will be set to a {lineWise: bool, text: [string]} object, so -// that, when pasting, we know what kind of selections the copied -// text was made out of. -var lastCopied = null; - -function setLastCopied(newLastCopied) { - lastCopied = newLastCopied; -} - -function applyTextInput(cm, inserted, deleted, sel, origin) { - var doc = cm.doc; - cm.display.shift = false; - if (!sel) { sel = doc.sel; } - - var paste = cm.state.pasteIncoming || origin == "paste"; - var textLines = splitLinesAuto(inserted), multiPaste = null; - // When pasting N lines into N selections, insert one line per selection - if (paste && sel.ranges.length > 1) { - if (lastCopied && lastCopied.text.join("\n") == inserted) { - if (sel.ranges.length % lastCopied.text.length == 0) { - multiPaste = []; - for (var i = 0; i < lastCopied.text.length; i++) - { multiPaste.push(doc.splitLines(lastCopied.text[i])); } - } - } else if (textLines.length == sel.ranges.length && cm.options.pasteLinesPerSelection) { - multiPaste = map(textLines, function (l) { return [l]; }); - } - } - - var updateInput; - // Normal behavior is to insert the new text into every selection - for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) { - var range$$1 = sel.ranges[i$1]; - var from = range$$1.from(), to = range$$1.to(); - if (range$$1.empty()) { - if (deleted && deleted > 0) // Handle deletion - { from = Pos(from.line, from.ch - deleted); } - else if (cm.state.overwrite && !paste) // Handle overwrite - { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)); } - else if (lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == inserted) - { from = to = Pos(from.line, 0); } - } - updateInput = cm.curOp.updateInput; - var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines, - origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")}; - makeChange(cm.doc, changeEvent); - signalLater(cm, "inputRead", cm, changeEvent); - } - if (inserted && !paste) - { triggerElectric(cm, inserted); } - - ensureCursorVisible(cm); - cm.curOp.updateInput = updateInput; - cm.curOp.typing = true; - cm.state.pasteIncoming = cm.state.cutIncoming = false; -} - -function handlePaste(e, cm) { - var pasted = e.clipboardData && e.clipboardData.getData("Text"); - if (pasted) { - e.preventDefault(); - if (!cm.isReadOnly() && !cm.options.disableInput) - { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, "paste"); }); } - return true - } -} - -function triggerElectric(cm, inserted) { - // When an 'electric' character is inserted, immediately trigger a reindent - if (!cm.options.electricChars || !cm.options.smartIndent) { return } - var sel = cm.doc.sel; - - for (var i = sel.ranges.length - 1; i >= 0; i--) { - var range$$1 = sel.ranges[i]; - if (range$$1.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range$$1.head.line)) { continue } - var mode = cm.getModeAt(range$$1.head); - var indented = false; - if (mode.electricChars) { - for (var j = 0; j < mode.electricChars.length; j++) - { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) { - indented = indentLine(cm, range$$1.head.line, "smart"); - break - } } - } else if (mode.electricInput) { - if (mode.electricInput.test(getLine(cm.doc, range$$1.head.line).text.slice(0, range$$1.head.ch))) - { indented = indentLine(cm, range$$1.head.line, "smart"); } - } - if (indented) { signalLater(cm, "electricInput", cm, range$$1.head.line); } - } -} - -function copyableRanges(cm) { - var text = [], ranges = []; - for (var i = 0; i < cm.doc.sel.ranges.length; i++) { - var line = cm.doc.sel.ranges[i].head.line; - var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}; - ranges.push(lineRange); - text.push(cm.getRange(lineRange.anchor, lineRange.head)); - } - return {text: text, ranges: ranges} -} - -function disableBrowserMagic(field, spellcheck) { - field.setAttribute("autocorrect", "off"); - field.setAttribute("autocapitalize", "off"); - field.setAttribute("spellcheck", !!spellcheck); -} - -function hiddenTextarea() { - var te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none"); - var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;"); - // The textarea is kept positioned near the cursor to prevent the - // fact that it'll be scrolled into view on input from scrolling - // our fake cursor out of view. On webkit, when wrap=off, paste is - // very slow. So make the area wide instead. - if (webkit) { te.style.width = "1000px"; } - else { te.setAttribute("wrap", "off"); } - // If border: 0; -- iOS fails to open keyboard (issue #1287) - if (ios) { te.style.border = "1px solid black"; } - disableBrowserMagic(te); - return div -} - -// The publicly visible API. Note that methodOp(f) means -// 'wrap f in an operation, performed on its `this` parameter'. - -// This is not the complete set of editor methods. Most of the -// methods defined on the Doc type are also injected into -// CodeMirror.prototype, for backwards compatibility and -// convenience. - -var addEditorMethods = function(CodeMirror) { - var optionHandlers = CodeMirror.optionHandlers; - - var helpers = CodeMirror.helpers = {}; - - CodeMirror.prototype = { - constructor: CodeMirror, - focus: function(){window.focus(); this.display.input.focus();}, - - setOption: function(option, value) { - var options = this.options, old = options[option]; - if (options[option] == value && option != "mode") { return } - options[option] = value; - if (optionHandlers.hasOwnProperty(option)) - { operation(this, optionHandlers[option])(this, value, old); } - signal(this, "optionChange", this, option); - }, - - getOption: function(option) {return this.options[option]}, - getDoc: function() {return this.doc}, - - addKeyMap: function(map$$1, bottom) { - this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map$$1)); - }, - removeKeyMap: function(map$$1) { - var maps = this.state.keyMaps; - for (var i = 0; i < maps.length; ++i) - { if (maps[i] == map$$1 || maps[i].name == map$$1) { - maps.splice(i, 1); - return true - } } - }, - - addOverlay: methodOp(function(spec, options) { - var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec); - if (mode.startState) { throw new Error("Overlays may not be stateful.") } - insertSorted(this.state.overlays, - {mode: mode, modeSpec: spec, opaque: options && options.opaque, - priority: (options && options.priority) || 0}, - function (overlay) { return overlay.priority; }); - this.state.modeGen++; - regChange(this); - }), - removeOverlay: methodOp(function(spec) { - var this$1 = this; - - var overlays = this.state.overlays; - for (var i = 0; i < overlays.length; ++i) { - var cur = overlays[i].modeSpec; - if (cur == spec || typeof spec == "string" && cur.name == spec) { - overlays.splice(i, 1); - this$1.state.modeGen++; - regChange(this$1); - return - } - } - }), - - indentLine: methodOp(function(n, dir, aggressive) { - if (typeof dir != "string" && typeof dir != "number") { - if (dir == null) { dir = this.options.smartIndent ? "smart" : "prev"; } - else { dir = dir ? "add" : "subtract"; } - } - if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive); } - }), - indentSelection: methodOp(function(how) { - var this$1 = this; - - var ranges = this.doc.sel.ranges, end = -1; - for (var i = 0; i < ranges.length; i++) { - var range$$1 = ranges[i]; - if (!range$$1.empty()) { - var from = range$$1.from(), to = range$$1.to(); - var start = Math.max(end, from.line); - end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1; - for (var j = start; j < end; ++j) - { indentLine(this$1, j, how); } - var newRanges = this$1.doc.sel.ranges; - if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0) - { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll); } - } else if (range$$1.head.line > end) { - indentLine(this$1, range$$1.head.line, how, true); - end = range$$1.head.line; - if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1); } - } - } - }), - - // Fetch the parser token for a given character. Useful for hacks - // that want to inspect the mode state (say, for completion). - getTokenAt: function(pos, precise) { - return takeToken(this, pos, precise) - }, - - getLineTokens: function(line, precise) { - return takeToken(this, Pos(line), precise, true) - }, - - getTokenTypeAt: function(pos) { - pos = clipPos(this.doc, pos); - var styles = getLineStyles(this, getLine(this.doc, pos.line)); - var before = 0, after = (styles.length - 1) / 2, ch = pos.ch; - var type; - if (ch == 0) { type = styles[2]; } - else { for (;;) { - var mid = (before + after) >> 1; - if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid; } - else if (styles[mid * 2 + 1] < ch) { before = mid + 1; } - else { type = styles[mid * 2 + 2]; break } - } } - var cut = type ? type.indexOf("overlay ") : -1; - return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1) - }, - - getModeAt: function(pos) { - var mode = this.doc.mode; - if (!mode.innerMode) { return mode } - return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode - }, - - getHelper: function(pos, type) { - return this.getHelpers(pos, type)[0] - }, - - getHelpers: function(pos, type) { - var this$1 = this; - - var found = []; - if (!helpers.hasOwnProperty(type)) { return found } - var help = helpers[type], mode = this.getModeAt(pos); - if (typeof mode[type] == "string") { - if (help[mode[type]]) { found.push(help[mode[type]]); } - } else if (mode[type]) { - for (var i = 0; i < mode[type].length; i++) { - var val = help[mode[type][i]]; - if (val) { found.push(val); } - } - } else if (mode.helperType && help[mode.helperType]) { - found.push(help[mode.helperType]); - } else if (help[mode.name]) { - found.push(help[mode.name]); - } - for (var i$1 = 0; i$1 < help._global.length; i$1++) { - var cur = help._global[i$1]; - if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1) - { found.push(cur.val); } - } - return found - }, - - getStateAfter: function(line, precise) { - var doc = this.doc; - line = clipLine(doc, line == null ? doc.first + doc.size - 1: line); - return getContextBefore(this, line + 1, precise).state - }, - - cursorCoords: function(start, mode) { - var pos, range$$1 = this.doc.sel.primary(); - if (start == null) { pos = range$$1.head; } - else if (typeof start == "object") { pos = clipPos(this.doc, start); } - else { pos = start ? range$$1.from() : range$$1.to(); } - return cursorCoords(this, pos, mode || "page") - }, - - charCoords: function(pos, mode) { - return charCoords(this, clipPos(this.doc, pos), mode || "page") - }, - - coordsChar: function(coords, mode) { - coords = fromCoordSystem(this, coords, mode || "page"); - return coordsChar(this, coords.left, coords.top) - }, - - lineAtHeight: function(height, mode) { - height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top; - return lineAtHeight(this.doc, height + this.display.viewOffset) - }, - heightAtLine: function(line, mode, includeWidgets) { - var end = false, lineObj; - if (typeof line == "number") { - var last = this.doc.first + this.doc.size - 1; - if (line < this.doc.first) { line = this.doc.first; } - else if (line > last) { line = last; end = true; } - lineObj = getLine(this.doc, line); - } else { - lineObj = line; - } - return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page", includeWidgets || end).top + - (end ? this.doc.height - heightAtLine(lineObj) : 0) - }, - - defaultTextHeight: function() { return textHeight(this.display) }, - defaultCharWidth: function() { return charWidth(this.display) }, - - getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}}, - - addWidget: function(pos, node, scroll, vert, horiz) { - var display = this.display; - pos = cursorCoords(this, clipPos(this.doc, pos)); - var top = pos.bottom, left = pos.left; - node.style.position = "absolute"; - node.setAttribute("cm-ignore-events", "true"); - this.display.input.setUneditable(node); - display.sizer.appendChild(node); - if (vert == "over") { - top = pos.top; - } else if (vert == "above" || vert == "near") { - var vspace = Math.max(display.wrapper.clientHeight, this.doc.height), - hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth); - // Default to positioning above (if specified and possible); otherwise default to positioning below - if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight) - { top = pos.top - node.offsetHeight; } - else if (pos.bottom + node.offsetHeight <= vspace) - { top = pos.bottom; } - if (left + node.offsetWidth > hspace) - { left = hspace - node.offsetWidth; } - } - node.style.top = top + "px"; - node.style.left = node.style.right = ""; - if (horiz == "right") { - left = display.sizer.clientWidth - node.offsetWidth; - node.style.right = "0px"; - } else { - if (horiz == "left") { left = 0; } - else if (horiz == "middle") { left = (display.sizer.clientWidth - node.offsetWidth) / 2; } - node.style.left = left + "px"; - } - if (scroll) - { scrollIntoView(this, {left: left, top: top, right: left + node.offsetWidth, bottom: top + node.offsetHeight}); } - }, - - triggerOnKeyDown: methodOp(onKeyDown), - triggerOnKeyPress: methodOp(onKeyPress), - triggerOnKeyUp: onKeyUp, - triggerOnMouseDown: methodOp(onMouseDown), - - execCommand: function(cmd) { - if (commands.hasOwnProperty(cmd)) - { return commands[cmd].call(null, this) } - }, - - triggerElectric: methodOp(function(text) { triggerElectric(this, text); }), - - findPosH: function(from, amount, unit, visually) { - var this$1 = this; - - var dir = 1; - if (amount < 0) { dir = -1; amount = -amount; } - var cur = clipPos(this.doc, from); - for (var i = 0; i < amount; ++i) { - cur = findPosH(this$1.doc, cur, dir, unit, visually); - if (cur.hitSide) { break } - } - return cur - }, - - moveH: methodOp(function(dir, unit) { - var this$1 = this; - - this.extendSelectionsBy(function (range$$1) { - if (this$1.display.shift || this$1.doc.extend || range$$1.empty()) - { return findPosH(this$1.doc, range$$1.head, dir, unit, this$1.options.rtlMoveVisually) } - else - { return dir < 0 ? range$$1.from() : range$$1.to() } - }, sel_move); - }), - - deleteH: methodOp(function(dir, unit) { - var sel = this.doc.sel, doc = this.doc; - if (sel.somethingSelected()) - { doc.replaceSelection("", null, "+delete"); } - else - { deleteNearSelection(this, function (range$$1) { - var other = findPosH(doc, range$$1.head, dir, unit, false); - return dir < 0 ? {from: other, to: range$$1.head} : {from: range$$1.head, to: other} - }); } - }), - - findPosV: function(from, amount, unit, goalColumn) { - var this$1 = this; - - var dir = 1, x = goalColumn; - if (amount < 0) { dir = -1; amount = -amount; } - var cur = clipPos(this.doc, from); - for (var i = 0; i < amount; ++i) { - var coords = cursorCoords(this$1, cur, "div"); - if (x == null) { x = coords.left; } - else { coords.left = x; } - cur = findPosV(this$1, coords, dir, unit); - if (cur.hitSide) { break } - } - return cur - }, - - moveV: methodOp(function(dir, unit) { - var this$1 = this; - - var doc = this.doc, goals = []; - var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected(); - doc.extendSelectionsBy(function (range$$1) { - if (collapse) - { return dir < 0 ? range$$1.from() : range$$1.to() } - var headPos = cursorCoords(this$1, range$$1.head, "div"); - if (range$$1.goalColumn != null) { headPos.left = range$$1.goalColumn; } - goals.push(headPos.left); - var pos = findPosV(this$1, headPos, dir, unit); - if (unit == "page" && range$$1 == doc.sel.primary()) - { addToScrollTop(this$1, charCoords(this$1, pos, "div").top - headPos.top); } - return pos - }, sel_move); - if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++) - { doc.sel.ranges[i].goalColumn = goals[i]; } } - }), - - // Find the word at the given position (as returned by coordsChar). - findWordAt: function(pos) { - var doc = this.doc, line = getLine(doc, pos.line).text; - var start = pos.ch, end = pos.ch; - if (line) { - var helper = this.getHelper(pos, "wordChars"); - if ((pos.sticky == "before" || end == line.length) && start) { --start; } else { ++end; } - var startChar = line.charAt(start); - var check = isWordChar(startChar, helper) - ? function (ch) { return isWordChar(ch, helper); } - : /\s/.test(startChar) ? function (ch) { return /\s/.test(ch); } - : function (ch) { return (!/\s/.test(ch) && !isWordChar(ch)); }; - while (start > 0 && check(line.charAt(start - 1))) { --start; } - while (end < line.length && check(line.charAt(end))) { ++end; } - } - return new Range(Pos(pos.line, start), Pos(pos.line, end)) - }, - - toggleOverwrite: function(value) { - if (value != null && value == this.state.overwrite) { return } - if (this.state.overwrite = !this.state.overwrite) - { addClass(this.display.cursorDiv, "CodeMirror-overwrite"); } - else - { rmClass(this.display.cursorDiv, "CodeMirror-overwrite"); } - - signal(this, "overwriteToggle", this, this.state.overwrite); - }, - hasFocus: function() { return this.display.input.getField() == activeElt() }, - isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) }, - - scrollTo: methodOp(function (x, y) { scrollToCoords(this, x, y); }), - getScrollInfo: function() { - var scroller = this.display.scroller; - return {left: scroller.scrollLeft, top: scroller.scrollTop, - height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight, - width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth, - clientHeight: displayHeight(this), clientWidth: displayWidth(this)} - }, - - scrollIntoView: methodOp(function(range$$1, margin) { - if (range$$1 == null) { - range$$1 = {from: this.doc.sel.primary().head, to: null}; - if (margin == null) { margin = this.options.cursorScrollMargin; } - } else if (typeof range$$1 == "number") { - range$$1 = {from: Pos(range$$1, 0), to: null}; - } else if (range$$1.from == null) { - range$$1 = {from: range$$1, to: null}; - } - if (!range$$1.to) { range$$1.to = range$$1.from; } - range$$1.margin = margin || 0; - - if (range$$1.from.line != null) { - scrollToRange(this, range$$1); - } else { - scrollToCoordsRange(this, range$$1.from, range$$1.to, range$$1.margin); - } - }), - - setSize: methodOp(function(width, height) { - var this$1 = this; - - var interpret = function (val) { return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val; }; - if (width != null) { this.display.wrapper.style.width = interpret(width); } - if (height != null) { this.display.wrapper.style.height = interpret(height); } - if (this.options.lineWrapping) { clearLineMeasurementCache(this); } - var lineNo$$1 = this.display.viewFrom; - this.doc.iter(lineNo$$1, this.display.viewTo, function (line) { - if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) - { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo$$1, "widget"); break } } } - ++lineNo$$1; - }); - this.curOp.forceUpdate = true; - signal(this, "refresh", this); - }), - - operation: function(f){return runInOp(this, f)}, - startOperation: function(){return startOperation(this)}, - endOperation: function(){return endOperation(this)}, - - refresh: methodOp(function() { - var oldHeight = this.display.cachedTextHeight; - regChange(this); - this.curOp.forceUpdate = true; - clearCaches(this); - scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop); - updateGutterSpace(this); - if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5) - { estimateLineHeights(this); } - signal(this, "refresh", this); - }), - - swapDoc: methodOp(function(doc) { - var old = this.doc; - old.cm = null; - attachDoc(this, doc); - clearCaches(this); - this.display.input.reset(); - scrollToCoords(this, doc.scrollLeft, doc.scrollTop); - this.curOp.forceScroll = true; - signalLater(this, "swapDoc", this, old); - return old - }), - - getInputField: function(){return this.display.input.getField()}, - getWrapperElement: function(){return this.display.wrapper}, - getScrollerElement: function(){return this.display.scroller}, - getGutterElement: function(){return this.display.gutters} - }; - eventMixin(CodeMirror); - - CodeMirror.registerHelper = function(type, name, value) { - if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []}; } - helpers[type][name] = value; - }; - CodeMirror.registerGlobalHelper = function(type, name, predicate, value) { - CodeMirror.registerHelper(type, name, value); - helpers[type]._global.push({pred: predicate, val: value}); - }; -}; - -// Used for horizontal relative motion. Dir is -1 or 1 (left or -// right), unit can be "char", "column" (like char, but doesn't -// cross line boundaries), "word" (across next word), or "group" (to -// the start of next group of word or non-word-non-whitespace -// chars). The visually param controls whether, in right-to-left -// text, direction 1 means to move towards the next index in the -// string, or towards the character to the right of the current -// position. The resulting position will have a hitSide=true -// property if it reached the end of the document. -function findPosH(doc, pos, dir, unit, visually) { - var oldPos = pos; - var origDir = dir; - var lineObj = getLine(doc, pos.line); - function findNextLine() { - var l = pos.line + dir; - if (l < doc.first || l >= doc.first + doc.size) { return false } - pos = new Pos(l, pos.ch, pos.sticky); - return lineObj = getLine(doc, l) - } - function moveOnce(boundToLine) { - var next; - if (visually) { - next = moveVisually(doc.cm, lineObj, pos, dir); - } else { - next = moveLogically(lineObj, pos, dir); - } - if (next == null) { - if (!boundToLine && findNextLine()) - { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir); } - else - { return false } - } else { - pos = next; - } - return true - } - - if (unit == "char") { - moveOnce(); - } else if (unit == "column") { - moveOnce(true); - } else if (unit == "word" || unit == "group") { - var sawType = null, group = unit == "group"; - var helper = doc.cm && doc.cm.getHelper(pos, "wordChars"); - for (var first = true;; first = false) { - if (dir < 0 && !moveOnce(!first)) { break } - var cur = lineObj.text.charAt(pos.ch) || "\n"; - var type = isWordChar(cur, helper) ? "w" - : group && cur == "\n" ? "n" - : !group || /\s/.test(cur) ? null - : "p"; - if (group && !first && !type) { type = "s"; } - if (sawType && sawType != type) { - if (dir < 0) {dir = 1; moveOnce(); pos.sticky = "after";} - break - } - - if (type) { sawType = type; } - if (dir > 0 && !moveOnce(!first)) { break } - } - } - var result = skipAtomic(doc, pos, oldPos, origDir, true); - if (equalCursorPos(oldPos, result)) { result.hitSide = true; } - return result -} - -// For relative vertical movement. Dir may be -1 or 1. Unit can be -// "page" or "line". The resulting position will have a hitSide=true -// property if it reached the end of the document. -function findPosV(cm, pos, dir, unit) { - var doc = cm.doc, x = pos.left, y; - if (unit == "page") { - var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight); - var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3); - y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount; - - } else if (unit == "line") { - y = dir > 0 ? pos.bottom + 3 : pos.top - 3; - } - var target; - for (;;) { - target = coordsChar(cm, x, y); - if (!target.outside) { break } - if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break } - y += dir * 5; - } - return target -} - -// CONTENTEDITABLE INPUT STYLE - -var ContentEditableInput = function(cm) { - this.cm = cm; - this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null; - this.polling = new Delayed(); - this.composing = null; - this.gracePeriod = false; - this.readDOMTimeout = null; -}; - -ContentEditableInput.prototype.init = function (display) { - var this$1 = this; - - var input = this, cm = input.cm; - var div = input.div = display.lineDiv; - disableBrowserMagic(div, cm.options.spellcheck); - - on(div, "paste", function (e) { - if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return } - // IE doesn't fire input events, so we schedule a read for the pasted content in this way - if (ie_version <= 11) { setTimeout(operation(cm, function () { return this$1.updateFromDOM(); }), 20); } - }); - - on(div, "compositionstart", function (e) { - this$1.composing = {data: e.data, done: false}; - }); - on(div, "compositionupdate", function (e) { - if (!this$1.composing) { this$1.composing = {data: e.data, done: false}; } - }); - on(div, "compositionend", function (e) { - if (this$1.composing) { - if (e.data != this$1.composing.data) { this$1.readFromDOMSoon(); } - this$1.composing.done = true; - } - }); - - on(div, "touchstart", function () { return input.forceCompositionEnd(); }); - - on(div, "input", function () { - if (!this$1.composing) { this$1.readFromDOMSoon(); } - }); - - function onCopyCut(e) { - if (signalDOMEvent(cm, e)) { return } - if (cm.somethingSelected()) { - setLastCopied({lineWise: false, text: cm.getSelections()}); - if (e.type == "cut") { cm.replaceSelection("", null, "cut"); } - } else if (!cm.options.lineWiseCopyCut) { - return - } else { - var ranges = copyableRanges(cm); - setLastCopied({lineWise: true, text: ranges.text}); - if (e.type == "cut") { - cm.operation(function () { - cm.setSelections(ranges.ranges, 0, sel_dontScroll); - cm.replaceSelection("", null, "cut"); - }); - } - } - if (e.clipboardData) { - e.clipboardData.clearData(); - var content = lastCopied.text.join("\n"); - // iOS exposes the clipboard API, but seems to discard content inserted into it - e.clipboardData.setData("Text", content); - if (e.clipboardData.getData("Text") == content) { - e.preventDefault(); - return - } - } - // Old-fashioned briefly-focus-a-textarea hack - var kludge = hiddenTextarea(), te = kludge.firstChild; - cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild); - te.value = lastCopied.text.join("\n"); - var hadFocus = document.activeElement; - selectInput(te); - setTimeout(function () { - cm.display.lineSpace.removeChild(kludge); - hadFocus.focus(); - if (hadFocus == div) { input.showPrimarySelection(); } - }, 50); - } - on(div, "copy", onCopyCut); - on(div, "cut", onCopyCut); -}; - -ContentEditableInput.prototype.prepareSelection = function () { - var result = prepareSelection(this.cm, false); - result.focus = this.cm.state.focused; - return result -}; - -ContentEditableInput.prototype.showSelection = function (info, takeFocus) { - if (!info || !this.cm.display.view.length) { return } - if (info.focus || takeFocus) { this.showPrimarySelection(); } - this.showMultipleSelections(info); -}; - -ContentEditableInput.prototype.getSelection = function () { - return this.cm.display.wrapper.ownerDocument.getSelection() -}; - -ContentEditableInput.prototype.showPrimarySelection = function () { - var sel = this.getSelection(), cm = this.cm, prim = cm.doc.sel.primary(); - var from = prim.from(), to = prim.to(); - - if (cm.display.viewTo == cm.display.viewFrom || from.line >= cm.display.viewTo || to.line < cm.display.viewFrom) { - sel.removeAllRanges(); - return - } - - var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset); - var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset); - if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad && - cmp(minPos(curAnchor, curFocus), from) == 0 && - cmp(maxPos(curAnchor, curFocus), to) == 0) - { return } - - var view = cm.display.view; - var start = (from.line >= cm.display.viewFrom && posToDOM(cm, from)) || - {node: view[0].measure.map[2], offset: 0}; - var end = to.line < cm.display.viewTo && posToDOM(cm, to); - if (!end) { - var measure = view[view.length - 1].measure; - var map$$1 = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map; - end = {node: map$$1[map$$1.length - 1], offset: map$$1[map$$1.length - 2] - map$$1[map$$1.length - 3]}; - } - - if (!start || !end) { - sel.removeAllRanges(); - return - } - - var old = sel.rangeCount && sel.getRangeAt(0), rng; - try { rng = range(start.node, start.offset, end.offset, end.node); } - catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible - if (rng) { - if (!gecko && cm.state.focused) { - sel.collapse(start.node, start.offset); - if (!rng.collapsed) { - sel.removeAllRanges(); - sel.addRange(rng); - } - } else { - sel.removeAllRanges(); - sel.addRange(rng); - } - if (old && sel.anchorNode == null) { sel.addRange(old); } - else if (gecko) { this.startGracePeriod(); } - } - this.rememberSelection(); -}; - -ContentEditableInput.prototype.startGracePeriod = function () { - var this$1 = this; - - clearTimeout(this.gracePeriod); - this.gracePeriod = setTimeout(function () { - this$1.gracePeriod = false; - if (this$1.selectionChanged()) - { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }); } - }, 20); -}; - -ContentEditableInput.prototype.showMultipleSelections = function (info) { - removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors); - removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection); -}; - -ContentEditableInput.prototype.rememberSelection = function () { - var sel = this.getSelection(); - this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset; - this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset; -}; - -ContentEditableInput.prototype.selectionInEditor = function () { - var sel = this.getSelection(); - if (!sel.rangeCount) { return false } - var node = sel.getRangeAt(0).commonAncestorContainer; - return contains(this.div, node) -}; - -ContentEditableInput.prototype.focus = function () { - if (this.cm.options.readOnly != "nocursor") { - if (!this.selectionInEditor()) - { this.showSelection(this.prepareSelection(), true); } - this.div.focus(); - } -}; -ContentEditableInput.prototype.blur = function () { this.div.blur(); }; -ContentEditableInput.prototype.getField = function () { return this.div }; - -ContentEditableInput.prototype.supportsTouch = function () { return true }; - -ContentEditableInput.prototype.receivedFocus = function () { - var input = this; - if (this.selectionInEditor()) - { this.pollSelection(); } - else - { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }); } - - function poll() { - if (input.cm.state.focused) { - input.pollSelection(); - input.polling.set(input.cm.options.pollInterval, poll); - } - } - this.polling.set(this.cm.options.pollInterval, poll); -}; - -ContentEditableInput.prototype.selectionChanged = function () { - var sel = this.getSelection(); - return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset || - sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset -}; - -ContentEditableInput.prototype.pollSelection = function () { - if (this.readDOMTimeout != null || this.gracePeriod || !this.selectionChanged()) { return } - var sel = this.getSelection(), cm = this.cm; - // On Android Chrome (version 56, at least), backspacing into an - // uneditable block element will put the cursor in that element, - // and then, because it's not editable, hide the virtual keyboard. - // Because Android doesn't allow us to actually detect backspace - // presses in a sane way, this code checks for when that happens - // and simulates a backspace press in this case. - if (android && chrome && this.cm.options.gutters.length && isInGutter(sel.anchorNode)) { - this.cm.triggerOnKeyDown({type: "keydown", keyCode: 8, preventDefault: Math.abs}); - this.blur(); - this.focus(); - return - } - if (this.composing) { return } - this.rememberSelection(); - var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset); - var head = domToPos(cm, sel.focusNode, sel.focusOffset); - if (anchor && head) { runInOp(cm, function () { - setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll); - if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true; } - }); } -}; - -ContentEditableInput.prototype.pollContent = function () { - if (this.readDOMTimeout != null) { - clearTimeout(this.readDOMTimeout); - this.readDOMTimeout = null; - } - - var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary(); - var from = sel.from(), to = sel.to(); - if (from.ch == 0 && from.line > cm.firstLine()) - { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length); } - if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine()) - { to = Pos(to.line + 1, 0); } - if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false } - - var fromIndex, fromLine, fromNode; - if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) { - fromLine = lineNo(display.view[0].line); - fromNode = display.view[0].node; - } else { - fromLine = lineNo(display.view[fromIndex].line); - fromNode = display.view[fromIndex - 1].node.nextSibling; - } - var toIndex = findViewIndex(cm, to.line); - var toLine, toNode; - if (toIndex == display.view.length - 1) { - toLine = display.viewTo - 1; - toNode = display.lineDiv.lastChild; - } else { - toLine = lineNo(display.view[toIndex + 1].line) - 1; - toNode = display.view[toIndex + 1].node.previousSibling; - } - - if (!fromNode) { return false } - var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine)); - var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length)); - while (newText.length > 1 && oldText.length > 1) { - if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; } - else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; } - else { break } - } - - var cutFront = 0, cutEnd = 0; - var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length); - while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront)) - { ++cutFront; } - var newBot = lst(newText), oldBot = lst(oldText); - var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0), - oldBot.length - (oldText.length == 1 ? cutFront : 0)); - while (cutEnd < maxCutEnd && - newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) - { ++cutEnd; } - // Try to move start of change to start of selection if ambiguous - if (newText.length == 1 && oldText.length == 1 && fromLine == from.line) { - while (cutFront && cutFront > from.ch && - newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) { - cutFront--; - cutEnd++; - } - } - - newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\u200b+/, ""); - newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, ""); - - var chFrom = Pos(fromLine, cutFront); - var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0); - if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) { - replaceRange(cm.doc, newText, chFrom, chTo, "+input"); - return true - } -}; - -ContentEditableInput.prototype.ensurePolled = function () { - this.forceCompositionEnd(); -}; -ContentEditableInput.prototype.reset = function () { - this.forceCompositionEnd(); -}; -ContentEditableInput.prototype.forceCompositionEnd = function () { - if (!this.composing) { return } - clearTimeout(this.readDOMTimeout); - this.composing = null; - this.updateFromDOM(); - this.div.blur(); - this.div.focus(); -}; -ContentEditableInput.prototype.readFromDOMSoon = function () { - var this$1 = this; - - if (this.readDOMTimeout != null) { return } - this.readDOMTimeout = setTimeout(function () { - this$1.readDOMTimeout = null; - if (this$1.composing) { - if (this$1.composing.done) { this$1.composing = null; } - else { return } - } - this$1.updateFromDOM(); - }, 80); -}; - -ContentEditableInput.prototype.updateFromDOM = function () { - var this$1 = this; - - if (this.cm.isReadOnly() || !this.pollContent()) - { runInOp(this.cm, function () { return regChange(this$1.cm); }); } -}; - -ContentEditableInput.prototype.setUneditable = function (node) { - node.contentEditable = "false"; -}; - -ContentEditableInput.prototype.onKeyPress = function (e) { - if (e.charCode == 0 || this.composing) { return } - e.preventDefault(); - if (!this.cm.isReadOnly()) - { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0); } -}; - -ContentEditableInput.prototype.readOnlyChanged = function (val) { - this.div.contentEditable = String(val != "nocursor"); -}; - -ContentEditableInput.prototype.onContextMenu = function () {}; -ContentEditableInput.prototype.resetPosition = function () {}; - -ContentEditableInput.prototype.needsContentAttribute = true; - -function posToDOM(cm, pos) { - var view = findViewForLine(cm, pos.line); - if (!view || view.hidden) { return null } - var line = getLine(cm.doc, pos.line); - var info = mapFromLineView(view, line, pos.line); - - var order = getOrder(line, cm.doc.direction), side = "left"; - if (order) { - var partPos = getBidiPartAt(order, pos.ch); - side = partPos % 2 ? "right" : "left"; - } - var result = nodeAndOffsetInLineMap(info.map, pos.ch, side); - result.offset = result.collapse == "right" ? result.end : result.start; - return result -} - -function isInGutter(node) { - for (var scan = node; scan; scan = scan.parentNode) - { if (/CodeMirror-gutter-wrapper/.test(scan.className)) { return true } } - return false -} - -function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos } - -function domTextBetween(cm, from, to, fromLine, toLine) { - var text = "", closing = false, lineSep = cm.doc.lineSeparator(), extraLinebreak = false; - function recognizeMarker(id) { return function (marker) { return marker.id == id; } } - function close() { - if (closing) { - text += lineSep; - if (extraLinebreak) { text += lineSep; } - closing = extraLinebreak = false; - } - } - function addText(str) { - if (str) { - close(); - text += str; - } - } - function walk(node) { - if (node.nodeType == 1) { - var cmText = node.getAttribute("cm-text"); - if (cmText) { - addText(cmText); - return - } - var markerID = node.getAttribute("cm-marker"), range$$1; - if (markerID) { - var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID)); - if (found.length && (range$$1 = found[0].find(0))) - { addText(getBetween(cm.doc, range$$1.from, range$$1.to).join(lineSep)); } - return - } - if (node.getAttribute("contenteditable") == "false") { return } - var isBlock = /^(pre|div|p|li|table|br)$/i.test(node.nodeName); - if (!/^br$/i.test(node.nodeName) && node.textContent.length == 0) { return } - - if (isBlock) { close(); } - for (var i = 0; i < node.childNodes.length; i++) - { walk(node.childNodes[i]); } - - if (/^(pre|p)$/i.test(node.nodeName)) { extraLinebreak = true; } - if (isBlock) { closing = true; } - } else if (node.nodeType == 3) { - addText(node.nodeValue.replace(/\u200b/g, "").replace(/\u00a0/g, " ")); - } - } - for (;;) { - walk(from); - if (from == to) { break } - from = from.nextSibling; - extraLinebreak = false; - } - return text -} - -function domToPos(cm, node, offset) { - var lineNode; - if (node == cm.display.lineDiv) { - lineNode = cm.display.lineDiv.childNodes[offset]; - if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) } - node = null; offset = 0; - } else { - for (lineNode = node;; lineNode = lineNode.parentNode) { - if (!lineNode || lineNode == cm.display.lineDiv) { return null } - if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break } - } - } - for (var i = 0; i < cm.display.view.length; i++) { - var lineView = cm.display.view[i]; - if (lineView.node == lineNode) - { return locateNodeInLineView(lineView, node, offset) } - } -} - -function locateNodeInLineView(lineView, node, offset) { - var wrapper = lineView.text.firstChild, bad = false; - if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) } - if (node == wrapper) { - bad = true; - node = wrapper.childNodes[offset]; - offset = 0; - if (!node) { - var line = lineView.rest ? lst(lineView.rest) : lineView.line; - return badPos(Pos(lineNo(line), line.text.length), bad) - } - } - - var textNode = node.nodeType == 3 ? node : null, topNode = node; - if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) { - textNode = node.firstChild; - if (offset) { offset = textNode.nodeValue.length; } - } - while (topNode.parentNode != wrapper) { topNode = topNode.parentNode; } - var measure = lineView.measure, maps = measure.maps; - - function find(textNode, topNode, offset) { - for (var i = -1; i < (maps ? maps.length : 0); i++) { - var map$$1 = i < 0 ? measure.map : maps[i]; - for (var j = 0; j < map$$1.length; j += 3) { - var curNode = map$$1[j + 2]; - if (curNode == textNode || curNode == topNode) { - var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]); - var ch = map$$1[j] + offset; - if (offset < 0 || curNode != textNode) { ch = map$$1[j + (offset ? 1 : 0)]; } - return Pos(line, ch) - } - } - } - } - var found = find(textNode, topNode, offset); - if (found) { return badPos(found, bad) } - - // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems - for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) { - found = find(after, after.firstChild, 0); - if (found) - { return badPos(Pos(found.line, found.ch - dist), bad) } - else - { dist += after.textContent.length; } - } - for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) { - found = find(before, before.firstChild, -1); - if (found) - { return badPos(Pos(found.line, found.ch + dist$1), bad) } - else - { dist$1 += before.textContent.length; } - } -} - -// TEXTAREA INPUT STYLE - -var TextareaInput = function(cm) { - this.cm = cm; - // See input.poll and input.reset - this.prevInput = ""; - - // Flag that indicates whether we expect input to appear real soon - // now (after some event like 'keypress' or 'input') and are - // polling intensively. - this.pollingFast = false; - // Self-resetting timeout for the poller - this.polling = new Delayed(); - // Used to work around IE issue with selection being forgotten when focus moves away from textarea - this.hasSelection = false; - this.composing = null; -}; - -TextareaInput.prototype.init = function (display) { - var this$1 = this; - - var input = this, cm = this.cm; - this.createField(display); - var te = this.textarea; - - display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild); - - // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore) - if (ios) { te.style.width = "0px"; } - - on(te, "input", function () { - if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null; } - input.poll(); - }); - - on(te, "paste", function (e) { - if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return } - - cm.state.pasteIncoming = true; - input.fastPoll(); - }); - - function prepareCopyCut(e) { - if (signalDOMEvent(cm, e)) { return } - if (cm.somethingSelected()) { - setLastCopied({lineWise: false, text: cm.getSelections()}); - } else if (!cm.options.lineWiseCopyCut) { - return - } else { - var ranges = copyableRanges(cm); - setLastCopied({lineWise: true, text: ranges.text}); - if (e.type == "cut") { - cm.setSelections(ranges.ranges, null, sel_dontScroll); - } else { - input.prevInput = ""; - te.value = ranges.text.join("\n"); - selectInput(te); - } - } - if (e.type == "cut") { cm.state.cutIncoming = true; } - } - on(te, "cut", prepareCopyCut); - on(te, "copy", prepareCopyCut); - - on(display.scroller, "paste", function (e) { - if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return } - cm.state.pasteIncoming = true; - input.focus(); - }); - - // Prevent normal selection in the editor (we handle our own) - on(display.lineSpace, "selectstart", function (e) { - if (!eventInWidget(display, e)) { e_preventDefault(e); } - }); - - on(te, "compositionstart", function () { - var start = cm.getCursor("from"); - if (input.composing) { input.composing.range.clear(); } - input.composing = { - start: start, - range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"}) - }; - }); - on(te, "compositionend", function () { - if (input.composing) { - input.poll(); - input.composing.range.clear(); - input.composing = null; - } - }); -}; - -TextareaInput.prototype.createField = function (_display) { - // Wraps and hides input textarea - this.wrapper = hiddenTextarea(); - // The semihidden textarea that is focused when the editor is - // focused, and receives input. - this.textarea = this.wrapper.firstChild; -}; - -TextareaInput.prototype.prepareSelection = function () { - // Redraw the selection and/or cursor - var cm = this.cm, display = cm.display, doc = cm.doc; - var result = prepareSelection(cm); - - // Move the hidden textarea near the cursor to prevent scrolling artifacts - if (cm.options.moveInputWithCursor) { - var headPos = cursorCoords(cm, doc.sel.primary().head, "div"); - var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect(); - result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10, - headPos.top + lineOff.top - wrapOff.top)); - result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10, - headPos.left + lineOff.left - wrapOff.left)); - } - - return result -}; - -TextareaInput.prototype.showSelection = function (drawn) { - var cm = this.cm, display = cm.display; - removeChildrenAndAdd(display.cursorDiv, drawn.cursors); - removeChildrenAndAdd(display.selectionDiv, drawn.selection); - if (drawn.teTop != null) { - this.wrapper.style.top = drawn.teTop + "px"; - this.wrapper.style.left = drawn.teLeft + "px"; - } -}; - -// Reset the input to correspond to the selection (or to be empty, -// when not typing and nothing is selected) -TextareaInput.prototype.reset = function (typing) { - if (this.contextMenuPending || this.composing) { return } - var cm = this.cm; - if (cm.somethingSelected()) { - this.prevInput = ""; - var content = cm.getSelection(); - this.textarea.value = content; - if (cm.state.focused) { selectInput(this.textarea); } - if (ie && ie_version >= 9) { this.hasSelection = content; } - } else if (!typing) { - this.prevInput = this.textarea.value = ""; - if (ie && ie_version >= 9) { this.hasSelection = null; } - } -}; - -TextareaInput.prototype.getField = function () { return this.textarea }; - -TextareaInput.prototype.supportsTouch = function () { return false }; - -TextareaInput.prototype.focus = function () { - if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) { - try { this.textarea.focus(); } - catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM - } -}; - -TextareaInput.prototype.blur = function () { this.textarea.blur(); }; - -TextareaInput.prototype.resetPosition = function () { - this.wrapper.style.top = this.wrapper.style.left = 0; -}; - -TextareaInput.prototype.receivedFocus = function () { this.slowPoll(); }; - -// Poll for input changes, using the normal rate of polling. This -// runs as long as the editor is focused. -TextareaInput.prototype.slowPoll = function () { - var this$1 = this; - - if (this.pollingFast) { return } - this.polling.set(this.cm.options.pollInterval, function () { - this$1.poll(); - if (this$1.cm.state.focused) { this$1.slowPoll(); } - }); -}; - -// When an event has just come in that is likely to add or change -// something in the input textarea, we poll faster, to ensure that -// the change appears on the screen quickly. -TextareaInput.prototype.fastPoll = function () { - var missed = false, input = this; - input.pollingFast = true; - function p() { - var changed = input.poll(); - if (!changed && !missed) {missed = true; input.polling.set(60, p);} - else {input.pollingFast = false; input.slowPoll();} - } - input.polling.set(20, p); -}; - -// Read input from the textarea, and update the document to match. -// When something is selected, it is present in the textarea, and -// selected (unless it is huge, in which case a placeholder is -// used). When nothing is selected, the cursor sits after previously -// seen text (can be empty), which is stored in prevInput (we must -// not reset the textarea when typing, because that breaks IME). -TextareaInput.prototype.poll = function () { - var this$1 = this; - - var cm = this.cm, input = this.textarea, prevInput = this.prevInput; - // Since this is called a *lot*, try to bail out as cheaply as - // possible when it is clear that nothing happened. hasSelection - // will be the case when there is a lot of text in the textarea, - // in which case reading its value would be expensive. - if (this.contextMenuPending || !cm.state.focused || - (hasSelection(input) && !prevInput && !this.composing) || - cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq) - { return false } - - var text = input.value; - // If nothing changed, bail. - if (text == prevInput && !cm.somethingSelected()) { return false } - // Work around nonsensical selection resetting in IE9/10, and - // inexplicable appearance of private area unicode characters on - // some key combos in Mac (#2689). - if (ie && ie_version >= 9 && this.hasSelection === text || - mac && /[\uf700-\uf7ff]/.test(text)) { - cm.display.input.reset(); - return false - } - - if (cm.doc.sel == cm.display.selForContextMenu) { - var first = text.charCodeAt(0); - if (first == 0x200b && !prevInput) { prevInput = "\u200b"; } - if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") } - } - // Find the part of the input that is actually new - var same = 0, l = Math.min(prevInput.length, text.length); - while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same; } - - runInOp(cm, function () { - applyTextInput(cm, text.slice(same), prevInput.length - same, - null, this$1.composing ? "*compose" : null); - - // Don't leave long text in the textarea, since it makes further polling slow - if (text.length > 1000 || text.indexOf("\n") > -1) { input.value = this$1.prevInput = ""; } - else { this$1.prevInput = text; } - - if (this$1.composing) { - this$1.composing.range.clear(); - this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor("to"), - {className: "CodeMirror-composing"}); - } - }); - return true -}; - -TextareaInput.prototype.ensurePolled = function () { - if (this.pollingFast && this.poll()) { this.pollingFast = false; } -}; - -TextareaInput.prototype.onKeyPress = function () { - if (ie && ie_version >= 9) { this.hasSelection = null; } - this.fastPoll(); -}; - -TextareaInput.prototype.onContextMenu = function (e) { - var input = this, cm = input.cm, display = cm.display, te = input.textarea; - var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop; - if (!pos || presto) { return } // Opera is difficult. - - // Reset the current text selection only if the click is done outside of the selection - // and 'resetSelectionOnContextMenu' option is true. - var reset = cm.options.resetSelectionOnContextMenu; - if (reset && cm.doc.sel.contains(pos) == -1) - { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll); } - - var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText; - input.wrapper.style.cssText = "position: absolute"; - var wrapperBox = input.wrapper.getBoundingClientRect(); - te.style.cssText = "position: absolute; width: 30px; height: 30px;\n top: " + (e.clientY - wrapperBox.top - 5) + "px; left: " + (e.clientX - wrapperBox.left - 5) + "px;\n z-index: 1000; background: " + (ie ? "rgba(255, 255, 255, .05)" : "transparent") + ";\n outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);"; - var oldScrollY; - if (webkit) { oldScrollY = window.scrollY; } // Work around Chrome issue (#2712) - display.input.focus(); - if (webkit) { window.scrollTo(null, oldScrollY); } - display.input.reset(); - // Adds "Select all" to context menu in FF - if (!cm.somethingSelected()) { te.value = input.prevInput = " "; } - input.contextMenuPending = true; - display.selForContextMenu = cm.doc.sel; - clearTimeout(display.detectingSelectAll); - - // Select-all will be greyed out if there's nothing to select, so - // this adds a zero-width space so that we can later check whether - // it got selected. - function prepareSelectAllHack() { - if (te.selectionStart != null) { - var selected = cm.somethingSelected(); - var extval = "\u200b" + (selected ? te.value : ""); - te.value = "\u21da"; // Used to catch context-menu undo - te.value = extval; - input.prevInput = selected ? "" : "\u200b"; - te.selectionStart = 1; te.selectionEnd = extval.length; - // Re-set this, in case some other handler touched the - // selection in the meantime. - display.selForContextMenu = cm.doc.sel; - } - } - function rehide() { - input.contextMenuPending = false; - input.wrapper.style.cssText = oldWrapperCSS; - te.style.cssText = oldCSS; - if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos); } - - // Try to detect the user choosing select-all - if (te.selectionStart != null) { - if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack(); } - var i = 0, poll = function () { - if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 && - te.selectionEnd > 0 && input.prevInput == "\u200b") { - operation(cm, selectAll)(cm); - } else if (i++ < 10) { - display.detectingSelectAll = setTimeout(poll, 500); - } else { - display.selForContextMenu = null; - display.input.reset(); - } - }; - display.detectingSelectAll = setTimeout(poll, 200); - } - } - - if (ie && ie_version >= 9) { prepareSelectAllHack(); } - if (captureRightClick) { - e_stop(e); - var mouseup = function () { - off(window, "mouseup", mouseup); - setTimeout(rehide, 20); - }; - on(window, "mouseup", mouseup); - } else { - setTimeout(rehide, 50); - } -}; - -TextareaInput.prototype.readOnlyChanged = function (val) { - if (!val) { this.reset(); } - this.textarea.disabled = val == "nocursor"; -}; - -TextareaInput.prototype.setUneditable = function () {}; - -TextareaInput.prototype.needsContentAttribute = false; - -function fromTextArea(textarea, options) { - options = options ? copyObj(options) : {}; - options.value = textarea.value; - if (!options.tabindex && textarea.tabIndex) - { options.tabindex = textarea.tabIndex; } - if (!options.placeholder && textarea.placeholder) - { options.placeholder = textarea.placeholder; } - // Set autofocus to true if this textarea is focused, or if it has - // autofocus and no other element is focused. - if (options.autofocus == null) { - var hasFocus = activeElt(); - options.autofocus = hasFocus == textarea || - textarea.getAttribute("autofocus") != null && hasFocus == document.body; - } - - function save() {textarea.value = cm.getValue();} - - var realSubmit; - if (textarea.form) { - on(textarea.form, "submit", save); - // Deplorable hack to make the submit method do the right thing. - if (!options.leaveSubmitMethodAlone) { - var form = textarea.form; - realSubmit = form.submit; - try { - var wrappedSubmit = form.submit = function () { - save(); - form.submit = realSubmit; - form.submit(); - form.submit = wrappedSubmit; - }; - } catch(e) {} - } - } - - options.finishInit = function (cm) { - cm.save = save; - cm.getTextArea = function () { return textarea; }; - cm.toTextArea = function () { - cm.toTextArea = isNaN; // Prevent this from being ran twice - save(); - textarea.parentNode.removeChild(cm.getWrapperElement()); - textarea.style.display = ""; - if (textarea.form) { - off(textarea.form, "submit", save); - if (typeof textarea.form.submit == "function") - { textarea.form.submit = realSubmit; } - } - }; - }; - - textarea.style.display = "none"; - var cm = CodeMirror$1(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); }, - options); - return cm -} - -function addLegacyProps(CodeMirror) { - CodeMirror.off = off; - CodeMirror.on = on; - CodeMirror.wheelEventPixels = wheelEventPixels; - CodeMirror.Doc = Doc; - CodeMirror.splitLines = splitLinesAuto; - CodeMirror.countColumn = countColumn; - CodeMirror.findColumn = findColumn; - CodeMirror.isWordChar = isWordCharBasic; - CodeMirror.Pass = Pass; - CodeMirror.signal = signal; - CodeMirror.Line = Line; - CodeMirror.changeEnd = changeEnd; - CodeMirror.scrollbarModel = scrollbarModel; - CodeMirror.Pos = Pos; - CodeMirror.cmpPos = cmp; - CodeMirror.modes = modes; - CodeMirror.mimeModes = mimeModes; - CodeMirror.resolveMode = resolveMode; - CodeMirror.getMode = getMode; - CodeMirror.modeExtensions = modeExtensions; - CodeMirror.extendMode = extendMode; - CodeMirror.copyState = copyState; - CodeMirror.startState = startState; - CodeMirror.innerMode = innerMode; - CodeMirror.commands = commands; - CodeMirror.keyMap = keyMap; - CodeMirror.keyName = keyName; - CodeMirror.isModifierKey = isModifierKey; - CodeMirror.lookupKey = lookupKey; - CodeMirror.normalizeKeyMap = normalizeKeyMap; - CodeMirror.StringStream = StringStream; - CodeMirror.SharedTextMarker = SharedTextMarker; - CodeMirror.TextMarker = TextMarker; - CodeMirror.LineWidget = LineWidget; - CodeMirror.e_preventDefault = e_preventDefault; - CodeMirror.e_stopPropagation = e_stopPropagation; - CodeMirror.e_stop = e_stop; - CodeMirror.addClass = addClass; - CodeMirror.contains = contains; - CodeMirror.rmClass = rmClass; - CodeMirror.keyNames = keyNames; -} - -// EDITOR CONSTRUCTOR - -defineOptions(CodeMirror$1); - -addEditorMethods(CodeMirror$1); - -// Set up methods on CodeMirror's prototype to redirect to the editor's document. -var dontDelegate = "iter insert remove copy getEditor constructor".split(" "); -for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0) - { CodeMirror$1.prototype[prop] = (function(method) { - return function() {return method.apply(this.doc, arguments)} - })(Doc.prototype[prop]); } } - -eventMixin(Doc); - -// INPUT HANDLING - -CodeMirror$1.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput}; - -// MODE DEFINITION AND QUERYING - -// Extra arguments are stored as the mode's dependencies, which is -// used by (legacy) mechanisms like loadmode.js to automatically -// load a mode. (Preferred mechanism is the require/define calls.) -CodeMirror$1.defineMode = function(name/*, mode, …*/) { - if (!CodeMirror$1.defaults.mode && name != "null") { CodeMirror$1.defaults.mode = name; } - defineMode.apply(this, arguments); -}; - -CodeMirror$1.defineMIME = defineMIME; - -// Minimal default mode. -CodeMirror$1.defineMode("null", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); }); -CodeMirror$1.defineMIME("text/plain", "null"); - -// EXTENSIONS - -CodeMirror$1.defineExtension = function (name, func) { - CodeMirror$1.prototype[name] = func; -}; -CodeMirror$1.defineDocExtension = function (name, func) { - Doc.prototype[name] = func; -}; - -CodeMirror$1.fromTextArea = fromTextArea; - -addLegacyProps(CodeMirror$1); - -CodeMirror$1.version = "5.38.0"; - -return CodeMirror$1; - -}))); - - -/***/ }), - -/***/ "./node_modules/codemirror/mode/clojure/clojure.js": -/***/ (function(module, exports, __webpack_require__) { - -// CodeMirror, copyright (c) by Marijn Haverbeke and others -// Distributed under an MIT license: http://codemirror.net/LICENSE - -/** - * Author: Hans Engel - * Branched from CodeMirror's Scheme mode (by Koh Zi Han, based on implementation by Koh Zi Chun) - */ - -(function(mod) { - if (true) // CommonJS - mod(__webpack_require__("./node_modules/codemirror/lib/codemirror.js")); - else {} -})(function(CodeMirror) { -"use strict"; - -CodeMirror.defineMode("clojure", function (options) { - var BUILTIN = "builtin", COMMENT = "comment", STRING = "string", CHARACTER = "string-2", - ATOM = "atom", NUMBER = "number", BRACKET = "bracket", KEYWORD = "keyword", VAR = "variable"; - var INDENT_WORD_SKIP = options.indentUnit || 2; - var NORMAL_INDENT_UNIT = options.indentUnit || 2; - - function makeKeywords(str) { - var obj = {}, words = str.split(" "); - for (var i = 0; i < words.length; ++i) obj[words[i]] = true; - return obj; - } - - var atoms = makeKeywords("true false nil"); - - var keywords = makeKeywords( - "defn defn- def def- defonce defmulti defmethod defmacro defstruct deftype defprotocol defrecord defproject deftest " + - "slice defalias defhinted defmacro- defn-memo defnk defnk defonce- defunbound defunbound- defvar defvar- let letfn " + - "do case cond condp for loop recur when when-not when-let when-first if if-let if-not . .. -> ->> doto and or dosync " + - "doseq dotimes dorun doall load import unimport ns in-ns refer try catch finally throw with-open with-local-vars " + - "binding gen-class gen-and-load-class gen-and-save-class handler-case handle"); - - var builtins = makeKeywords( - "* *' *1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* " + - "*compile-path* *compiler-options* *data-readers* *e *err* *file* *flush-on-newline* *fn-loader* *in* " + - "*math-context* *ns* *out* *print-dup* *print-length* *print-level* *print-meta* *print-readably* *read-eval* " + - "*source-path* *unchecked-math* *use-context-classloader* *verbose-defrecords* *warn-on-reflection* + +' - -' -> " + - "->> ->ArrayChunk ->Vec ->VecNode ->VecSeq -cache-protocol-fn -reset-methods .. / < <= = == > >= EMPTY-NODE accessor " + - "aclone add-classpath add-watch agent agent-error agent-errors aget alength alias all-ns alter alter-meta! " + - "alter-var-root amap ancestors and apply areduce array-map aset aset-boolean aset-byte aset-char aset-double " + - "aset-float aset-int aset-long aset-short assert assoc assoc! assoc-in associative? atom await await-for await1 " + - "bases bean bigdec bigint biginteger binding bit-and bit-and-not bit-clear bit-flip bit-not bit-or bit-set " + - "bit-shift-left bit-shift-right bit-test bit-xor boolean boolean-array booleans bound-fn bound-fn* bound? butlast " + - "byte byte-array bytes case cat cast char char-array char-escape-string char-name-string char? chars chunk chunk-append " + - "chunk-buffer chunk-cons chunk-first chunk-next chunk-rest chunked-seq? class class? clear-agent-errors " + - "clojure-version coll? comment commute comp comparator compare compare-and-set! compile complement completing concat cond condp " + - "conj conj! cons constantly construct-proxy contains? count counted? create-ns create-struct cycle dec dec' decimal? " + - "declare dedupe default-data-readers definline definterface defmacro defmethod defmulti defn defn- defonce defprotocol " + - "defrecord defstruct deftype delay delay? deliver denominator deref derive descendants destructure disj disj! dissoc " + - "dissoc! distinct distinct? doall dorun doseq dosync dotimes doto double double-array doubles drop drop-last " + - "drop-while eduction empty empty? ensure enumeration-seq error-handler error-mode eval even? every-pred every? ex-data ex-info " + - "extend extend-protocol extend-type extenders extends? false? ffirst file-seq filter filterv find find-keyword " + - "find-ns find-protocol-impl find-protocol-method find-var first flatten float float-array float? floats flush fn fn? " + - "fnext fnil for force format frequencies future future-call future-cancel future-cancelled? future-done? future? " + - "gen-class gen-interface gensym get get-in get-method get-proxy-class get-thread-bindings get-validator group-by hash " + - "hash-combine hash-map hash-set identical? identity if-let if-not ifn? import in-ns inc inc' init-proxy instance? " + - "int int-array integer? interleave intern interpose into into-array ints io! isa? iterate iterator-seq juxt keep " + - "keep-indexed key keys keyword keyword? last lazy-cat lazy-seq let letfn line-seq list list* list? load load-file " + - "load-reader load-string loaded-libs locking long long-array longs loop macroexpand macroexpand-1 make-array " + - "make-hierarchy map map-indexed map? mapcat mapv max max-key memfn memoize merge merge-with meta method-sig methods " + - "min min-key mod munge name namespace namespace-munge neg? newline next nfirst nil? nnext not not-any? not-empty " + - "not-every? not= ns ns-aliases ns-imports ns-interns ns-map ns-name ns-publics ns-refers ns-resolve ns-unalias " + - "ns-unmap nth nthnext nthrest num number? numerator object-array odd? or parents partial partition partition-all " + - "partition-by pcalls peek persistent! pmap pop pop! pop-thread-bindings pos? pr pr-str prefer-method prefers " + - "primitives-classnames print print-ctor print-dup print-method print-simple print-str printf println println-str " + - "prn prn-str promise proxy proxy-call-with-super proxy-mappings proxy-name proxy-super push-thread-bindings pvalues " + - "quot rand rand-int rand-nth random-sample range ratio? rational? rationalize re-find re-groups re-matcher re-matches re-pattern " + - "re-seq read read-line read-string realized? reduce reduce-kv reductions ref ref-history-count ref-max-history " + - "ref-min-history ref-set refer refer-clojure reify release-pending-sends rem remove remove-all-methods " + - "remove-method remove-ns remove-watch repeat repeatedly replace replicate require reset! reset-meta! resolve rest " + - "restart-agent resultset-seq reverse reversible? rseq rsubseq satisfies? second select-keys send send-off seq seq? " + - "seque sequence sequential? set set-error-handler! set-error-mode! set-validator! set? short short-array shorts " + - "shuffle shutdown-agents slurp some some-fn sort sort-by sorted-map sorted-map-by sorted-set sorted-set-by sorted? " + - "special-symbol? spit split-at split-with str string? struct struct-map subs subseq subvec supers swap! symbol " + - "symbol? sync take take-last take-nth take-while test the-ns thread-bound? time to-array to-array-2d trampoline transduce " + - "transient tree-seq true? type unchecked-add unchecked-add-int unchecked-byte unchecked-char unchecked-dec " + - "unchecked-dec-int unchecked-divide-int unchecked-double unchecked-float unchecked-inc unchecked-inc-int " + - "unchecked-int unchecked-long unchecked-multiply unchecked-multiply-int unchecked-negate unchecked-negate-int "+ - "unchecked-remainder-int unchecked-short unchecked-subtract unchecked-subtract-int underive unquote " + - "unquote-splicing update update-in update-proxy use val vals var-get var-set var? vary-meta vec vector vector-of " + - "vector? volatile! volatile? vreset! vswap! when when-first when-let when-not while with-bindings with-bindings* with-in-str with-loading-context " + - "with-local-vars with-meta with-open with-out-str with-precision with-redefs with-redefs-fn xml-seq zero? zipmap " + - "*default-data-reader-fn* as-> cond-> cond->> reduced reduced? send-via set-agent-send-executor! " + - "set-agent-send-off-executor! some-> some->>"); - - var indentKeys = makeKeywords( - // Built-ins - "ns fn def defn defmethod bound-fn if if-not case condp when while when-not when-first do future comment doto " + - "locking proxy with-open with-precision reify deftype defrecord defprotocol extend extend-protocol extend-type " + - "try catch " + - - // Binding forms - "let letfn binding loop for doseq dotimes when-let if-let " + - - // Data structures - "defstruct struct-map assoc " + - - // clojure.test - "testing deftest " + - - // contrib - "handler-case handle dotrace deftrace"); - - var tests = { - digit: /\d/, - digit_or_colon: /[\d:]/, - hex: /[0-9a-f]/i, - sign: /[+-]/, - exponent: /e/i, - keyword_char: /[^\s\(\[\;\)\]]/, - symbol: /[\w*+!\-\._?:<>\/\xa1-\uffff]/, - block_indent: /^(?:def|with)[^\/]+$|\/(?:def|with)/ - }; - - function stateStack(indent, type, prev) { // represents a state stack object - this.indent = indent; - this.type = type; - this.prev = prev; - } - - function pushStack(state, indent, type) { - state.indentStack = new stateStack(indent, type, state.indentStack); - } - - function popStack(state) { - state.indentStack = state.indentStack.prev; - } - - function isNumber(ch, stream){ - // hex - if ( ch === '0' && stream.eat(/x/i) ) { - stream.eatWhile(tests.hex); - return true; - } - - // leading sign - if ( ( ch == '+' || ch == '-' ) && ( tests.digit.test(stream.peek()) ) ) { - stream.eat(tests.sign); - ch = stream.next(); - } - - if ( tests.digit.test(ch) ) { - stream.eat(ch); - stream.eatWhile(tests.digit); - - if ( '.' == stream.peek() ) { - stream.eat('.'); - stream.eatWhile(tests.digit); - } else if ('/' == stream.peek() ) { - stream.eat('/'); - stream.eatWhile(tests.digit); - } - - if ( stream.eat(tests.exponent) ) { - stream.eat(tests.sign); - stream.eatWhile(tests.digit); - } - - return true; - } - - return false; - } - - // Eat character that starts after backslash \ - function eatCharacter(stream) { - var first = stream.next(); - // Read special literals: backspace, newline, space, return. - // Just read all lowercase letters. - if (first && first.match(/[a-z]/) && stream.match(/[a-z]+/, true)) { - return; - } - // Read unicode character: \u1000 \uA0a1 - if (first === "u") { - stream.match(/[0-9a-z]{4}/i, true); - } - } - - return { - startState: function () { - return { - indentStack: null, - indentation: 0, - mode: false - }; - }, - - token: function (stream, state) { - if (state.indentStack == null && stream.sol()) { - // update indentation, but only if indentStack is empty - state.indentation = stream.indentation(); - } - - // skip spaces - if (state.mode != "string" && stream.eatSpace()) { - return null; - } - var returnType = null; - - switch(state.mode){ - case "string": // multi-line string parsing mode - var next, escaped = false; - while ((next = stream.next()) != null) { - if (next == "\"" && !escaped) { - - state.mode = false; - break; - } - escaped = !escaped && next == "\\"; - } - returnType = STRING; // continue on in string mode - break; - default: // default parsing mode - var ch = stream.next(); - - if (ch == "\"") { - state.mode = "string"; - returnType = STRING; - } else if (ch == "\\") { - eatCharacter(stream); - returnType = CHARACTER; - } else if (ch == "'" && !( tests.digit_or_colon.test(stream.peek()) )) { - returnType = ATOM; - } else if (ch == ";") { // comment - stream.skipToEnd(); // rest of the line is a comment - returnType = COMMENT; - } else if (isNumber(ch,stream)){ - returnType = NUMBER; - } else if (ch == "(" || ch == "[" || ch == "{" ) { - var keyWord = '', indentTemp = stream.column(), letter; - /** - Either - (indent-word .. - (non-indent-word .. - (;something else, bracket, etc. - */ - - if (ch == "(") while ((letter = stream.eat(tests.keyword_char)) != null) { - keyWord += letter; - } - - if (keyWord.length > 0 && (indentKeys.propertyIsEnumerable(keyWord) || - tests.block_indent.test(keyWord))) { // indent-word - pushStack(state, indentTemp + INDENT_WORD_SKIP, ch); - } else { // non-indent word - // we continue eating the spaces - stream.eatSpace(); - if (stream.eol() || stream.peek() == ";") { - // nothing significant after - // we restart indentation the user defined spaces after - pushStack(state, indentTemp + NORMAL_INDENT_UNIT, ch); - } else { - pushStack(state, indentTemp + stream.current().length, ch); // else we match - } - } - stream.backUp(stream.current().length - 1); // undo all the eating - - returnType = BRACKET; - } else if (ch == ")" || ch == "]" || ch == "}") { - returnType = BRACKET; - if (state.indentStack != null && state.indentStack.type == (ch == ")" ? "(" : (ch == "]" ? "[" :"{"))) { - popStack(state); - } - } else if ( ch == ":" ) { - stream.eatWhile(tests.symbol); - return ATOM; - } else { - stream.eatWhile(tests.symbol); - - if (keywords && keywords.propertyIsEnumerable(stream.current())) { - returnType = KEYWORD; - } else if (builtins && builtins.propertyIsEnumerable(stream.current())) { - returnType = BUILTIN; - } else if (atoms && atoms.propertyIsEnumerable(stream.current())) { - returnType = ATOM; - } else { - returnType = VAR; - } - } - } - - return returnType; - }, - - indent: function (state) { - if (state.indentStack == null) return state.indentation; - return state.indentStack.indent; - }, - - closeBrackets: {pairs: "()[]{}\"\""}, - lineComment: ";;" - }; -}); - -CodeMirror.defineMIME("text/x-clojure", "clojure"); -CodeMirror.defineMIME("text/x-clojurescript", "clojure"); -CodeMirror.defineMIME("application/edn", "clojure"); - -}); - - -/***/ }), - -/***/ "./node_modules/codemirror/theme/duotone-light.css": -/***/ (function(module, exports, __webpack_require__) { - -// extracted by mini-css-extract-plugin - -/***/ }), - -/***/ "./node_modules/d/index.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var assign = __webpack_require__("./node_modules/es5-ext/object/assign/index.js") - , normalizeOpts = __webpack_require__("./node_modules/es5-ext/object/normalize-options.js") - , isCallable = __webpack_require__("./node_modules/es5-ext/object/is-callable.js") - , contains = __webpack_require__("./node_modules/es5-ext/string/#/contains/index.js") - - , d; - -d = module.exports = function (dscr, value/*, options*/) { - var c, e, w, options, desc; - if ((arguments.length < 2) || (typeof dscr !== 'string')) { - options = value; - value = dscr; - dscr = null; - } else { - options = arguments[2]; - } - if (dscr == null) { - c = w = true; - e = false; - } else { - c = contains.call(dscr, 'c'); - e = contains.call(dscr, 'e'); - w = contains.call(dscr, 'w'); - } - - desc = { value: value, configurable: c, enumerable: e, writable: w }; - return !options ? desc : assign(normalizeOpts(options), desc); -}; - -d.gs = function (dscr, get, set/*, options*/) { - var c, e, options, desc; - if (typeof dscr !== 'string') { - options = set; - set = get; - get = dscr; - dscr = null; - } else { - options = arguments[3]; - } - if (get == null) { - get = undefined; - } else if (!isCallable(get)) { - options = get; - get = set = undefined; - } else if (set == null) { - set = undefined; - } else if (!isCallable(set)) { - options = set; - set = undefined; - } - if (dscr == null) { - c = true; - e = false; - } else { - c = contains.call(dscr, 'c'); - e = contains.call(dscr, 'e'); - } - - desc = { get: get, set: set, configurable: c, enumerable: e }; - return !options ? desc : assign(normalizeOpts(options), desc); -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/function/noop.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -// eslint-disable-next-line no-empty-function -module.exports = function () {}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/assign/index.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = __webpack_require__("./node_modules/es5-ext/object/assign/is-implemented.js")() - ? Object.assign - : __webpack_require__("./node_modules/es5-ext/object/assign/shim.js"); - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/assign/is-implemented.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = function () { - var assign = Object.assign, obj; - if (typeof assign !== "function") return false; - obj = { foo: "raz" }; - assign(obj, { bar: "dwa" }, { trzy: "trzy" }); - return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy"; -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/assign/shim.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var keys = __webpack_require__("./node_modules/es5-ext/object/keys/index.js") - , value = __webpack_require__("./node_modules/es5-ext/object/valid-value.js") - , max = Math.max; - -module.exports = function (dest, src /*, …srcn*/) { - var error, i, length = max(arguments.length, 2), assign; - dest = Object(value(dest)); - assign = function (key) { - try { - dest[key] = src[key]; - } catch (e) { - if (!error) error = e; - } - }; - for (i = 1; i < length; ++i) { - src = arguments[i]; - keys(src).forEach(assign); - } - if (error !== undefined) throw error; - return dest; -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/is-callable.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; -// Deprecated - - - -module.exports = function (obj) { - return typeof obj === "function"; -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/is-value.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var _undefined = __webpack_require__("./node_modules/es5-ext/function/noop.js")(); // Support ES3 engines - -module.exports = function (val) { - return (val !== _undefined) && (val !== null); -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/keys/index.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = __webpack_require__("./node_modules/es5-ext/object/keys/is-implemented.js")() - ? Object.keys - : __webpack_require__("./node_modules/es5-ext/object/keys/shim.js"); - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/keys/is-implemented.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = function () { - try { - Object.keys("primitive"); - return true; - } catch (e) { - return false; -} -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/keys/shim.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var isValue = __webpack_require__("./node_modules/es5-ext/object/is-value.js"); - -var keys = Object.keys; - -module.exports = function (object) { - return keys(isValue(object) ? Object(object) : object); -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/normalize-options.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var isValue = __webpack_require__("./node_modules/es5-ext/object/is-value.js"); - -var forEach = Array.prototype.forEach, create = Object.create; - -var process = function (src, obj) { - var key; - for (key in src) obj[key] = src[key]; -}; - -// eslint-disable-next-line no-unused-vars -module.exports = function (opts1 /*, …options*/) { - var result = create(null); - forEach.call(arguments, function (options) { - if (!isValue(options)) return; - process(Object(options), result); - }); - return result; -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/object/valid-value.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var isValue = __webpack_require__("./node_modules/es5-ext/object/is-value.js"); - -module.exports = function (value) { - if (!isValue(value)) throw new TypeError("Cannot use null or undefined"); - return value; -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/string/#/contains/index.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = __webpack_require__("./node_modules/es5-ext/string/#/contains/is-implemented.js")() - ? String.prototype.contains - : __webpack_require__("./node_modules/es5-ext/string/#/contains/shim.js"); - - -/***/ }), - -/***/ "./node_modules/es5-ext/string/#/contains/is-implemented.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var str = "razdwatrzy"; - -module.exports = function () { - if (typeof str.contains !== "function") return false; - return (str.contains("dwa") === true) && (str.contains("foo") === false); -}; - - -/***/ }), - -/***/ "./node_modules/es5-ext/string/#/contains/shim.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var indexOf = String.prototype.indexOf; - -module.exports = function (searchString/*, position*/) { - return indexOf.call(this, searchString, arguments[1]) > -1; -}; - - -/***/ }), - -/***/ "./node_modules/es6-symbol/index.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = __webpack_require__("./node_modules/es6-symbol/is-implemented.js")() ? Symbol : __webpack_require__("./node_modules/es6-symbol/polyfill.js"); - - -/***/ }), - -/***/ "./node_modules/es6-symbol/is-implemented.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var validTypes = { object: true, symbol: true }; - -module.exports = function () { - var symbol; - if (typeof Symbol !== 'function') return false; - symbol = Symbol('test symbol'); - try { String(symbol); } catch (e) { return false; } - - // Return 'true' also for polyfills - if (!validTypes[typeof Symbol.iterator]) return false; - if (!validTypes[typeof Symbol.toPrimitive]) return false; - if (!validTypes[typeof Symbol.toStringTag]) return false; - - return true; -}; - - -/***/ }), - -/***/ "./node_modules/es6-symbol/is-symbol.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -module.exports = function (x) { - if (!x) return false; - if (typeof x === 'symbol') return true; - if (!x.constructor) return false; - if (x.constructor.name !== 'Symbol') return false; - return (x[x.constructor.toStringTag] === 'Symbol'); -}; - - -/***/ }), - -/***/ "./node_modules/es6-symbol/polyfill.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; -// ES2015 Symbol polyfill for environments that do not (or partially) support it - - - -var d = __webpack_require__("./node_modules/d/index.js") - , validateSymbol = __webpack_require__("./node_modules/es6-symbol/validate-symbol.js") - - , create = Object.create, defineProperties = Object.defineProperties - , defineProperty = Object.defineProperty, objPrototype = Object.prototype - , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null) - , isNativeSafe; - -if (typeof Symbol === 'function') { - NativeSymbol = Symbol; - try { - String(NativeSymbol()); - isNativeSafe = true; - } catch (ignore) {} -} - -var generateName = (function () { - var created = create(null); - return function (desc) { - var postfix = 0, name, ie11BugWorkaround; - while (created[desc + (postfix || '')]) ++postfix; - desc += (postfix || ''); - created[desc] = true; - name = '@@' + desc; - defineProperty(objPrototype, name, d.gs(null, function (value) { - // For IE11 issue see: - // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/ - // ie11-broken-getters-on-dom-objects - // https://github.com/medikoo/es6-symbol/issues/12 - if (ie11BugWorkaround) return; - ie11BugWorkaround = true; - defineProperty(this, name, d(value)); - ie11BugWorkaround = false; - })); - return name; - }; -}()); - -// Internal constructor (not one exposed) for creating Symbol instances. -// This one is used to ensure that `someSymbol instanceof Symbol` always return false -HiddenSymbol = function Symbol(description) { - if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor'); - return SymbolPolyfill(description); -}; - -// Exposed `Symbol` constructor -// (returns instances of HiddenSymbol) -module.exports = SymbolPolyfill = function Symbol(description) { - var symbol; - if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor'); - if (isNativeSafe) return NativeSymbol(description); - symbol = create(HiddenSymbol.prototype); - description = (description === undefined ? '' : String(description)); - return defineProperties(symbol, { - __description__: d('', description), - __name__: d('', generateName(description)) - }); -}; -defineProperties(SymbolPolyfill, { - for: d(function (key) { - if (globalSymbols[key]) return globalSymbols[key]; - return (globalSymbols[key] = SymbolPolyfill(String(key))); - }), - keyFor: d(function (s) { - var key; - validateSymbol(s); - for (key in globalSymbols) if (globalSymbols[key] === s) return key; - }), - - // To ensure proper interoperability with other native functions (e.g. Array.from) - // fallback to eventual native implementation of given symbol - hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')), - isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) || - SymbolPolyfill('isConcatSpreadable')), - iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')), - match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')), - replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')), - search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')), - species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')), - split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')), - toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')), - toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')), - unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables')) -}); - -// Internal tweaks for real symbol producer -defineProperties(HiddenSymbol.prototype, { - constructor: d(SymbolPolyfill), - toString: d('', function () { return this.__name__; }) -}); - -// Proper implementation of methods exposed on Symbol.prototype -// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype -defineProperties(SymbolPolyfill.prototype, { - toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }), - valueOf: d(function () { return validateSymbol(this); }) -}); -defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function () { - var symbol = validateSymbol(this); - if (typeof symbol === 'symbol') return symbol; - return symbol.toString(); -})); -defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol')); - -// Proper implementaton of toPrimitive and toStringTag for returned symbol instances -defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag, - d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag])); - -// Note: It's important to define `toPrimitive` as last one, as some implementations -// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols) -// And that may invoke error in definition flow: -// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149 -defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive, - d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive])); - - -/***/ }), - -/***/ "./node_modules/es6-symbol/validate-symbol.js": -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var isSymbol = __webpack_require__("./node_modules/es6-symbol/is-symbol.js"); - -module.exports = function (value) { - if (!isSymbol(value)) throw new TypeError(value + " is not a symbol"); - return value; -}; - - -/***/ }), - -/***/ "./node_modules/inherits/inherits_browser.js": -/***/ (function(module, exports) { - -if (typeof Object.create === 'function') { - // implementation from standard node.js 'util' module - module.exports = function inherits(ctor, superCtor) { - ctor.super_ = superCtor - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - // old school shim for old browsers - module.exports = function inherits(ctor, superCtor) { - ctor.super_ = superCtor - var TempCtor = function () {} - TempCtor.prototype = superCtor.prototype - ctor.prototype = new TempCtor() - ctor.prototype.constructor = ctor - } -} - - -/***/ }), - -/***/ "./node_modules/is-buffer/index.js": -/***/ (function(module, exports) { - -/*! - * Determine if an object is a Buffer - * - * @author Feross Aboukhadijeh - * @license MIT - */ - -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -module.exports = function (obj) { - return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) -} - -function isBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) -} - - -/***/ }), - -/***/ "./node_modules/lodash/_DataView.js": -/***/ (function(module, exports, __webpack_require__) { - -var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), - root = __webpack_require__("./node_modules/lodash/_root.js"); - -/* Built-in method references that are verified to be native. */ -var DataView = getNative(root, 'DataView'); - -module.exports = DataView; - - -/***/ }), - -/***/ "./node_modules/lodash/_Hash.js": -/***/ (function(module, exports, __webpack_require__) { - -var hashClear = __webpack_require__("./node_modules/lodash/_hashClear.js"), - hashDelete = __webpack_require__("./node_modules/lodash/_hashDelete.js"), - hashGet = __webpack_require__("./node_modules/lodash/_hashGet.js"), - hashHas = __webpack_require__("./node_modules/lodash/_hashHas.js"), - hashSet = __webpack_require__("./node_modules/lodash/_hashSet.js"); - -/** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function Hash(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -// Add methods to `Hash`. -Hash.prototype.clear = hashClear; -Hash.prototype['delete'] = hashDelete; -Hash.prototype.get = hashGet; -Hash.prototype.has = hashHas; -Hash.prototype.set = hashSet; - -module.exports = Hash; - - -/***/ }), - -/***/ "./node_modules/lodash/_ListCache.js": -/***/ (function(module, exports, __webpack_require__) { - -var listCacheClear = __webpack_require__("./node_modules/lodash/_listCacheClear.js"), - listCacheDelete = __webpack_require__("./node_modules/lodash/_listCacheDelete.js"), - listCacheGet = __webpack_require__("./node_modules/lodash/_listCacheGet.js"), - listCacheHas = __webpack_require__("./node_modules/lodash/_listCacheHas.js"), - listCacheSet = __webpack_require__("./node_modules/lodash/_listCacheSet.js"); - -/** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function ListCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -// Add methods to `ListCache`. -ListCache.prototype.clear = listCacheClear; -ListCache.prototype['delete'] = listCacheDelete; -ListCache.prototype.get = listCacheGet; -ListCache.prototype.has = listCacheHas; -ListCache.prototype.set = listCacheSet; - -module.exports = ListCache; - - -/***/ }), - -/***/ "./node_modules/lodash/_Map.js": -/***/ (function(module, exports, __webpack_require__) { - -var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), - root = __webpack_require__("./node_modules/lodash/_root.js"); - -/* Built-in method references that are verified to be native. */ -var Map = getNative(root, 'Map'); - -module.exports = Map; - - -/***/ }), - -/***/ "./node_modules/lodash/_MapCache.js": -/***/ (function(module, exports, __webpack_require__) { - -var mapCacheClear = __webpack_require__("./node_modules/lodash/_mapCacheClear.js"), - mapCacheDelete = __webpack_require__("./node_modules/lodash/_mapCacheDelete.js"), - mapCacheGet = __webpack_require__("./node_modules/lodash/_mapCacheGet.js"), - mapCacheHas = __webpack_require__("./node_modules/lodash/_mapCacheHas.js"), - mapCacheSet = __webpack_require__("./node_modules/lodash/_mapCacheSet.js"); - -/** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function MapCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -// Add methods to `MapCache`. -MapCache.prototype.clear = mapCacheClear; -MapCache.prototype['delete'] = mapCacheDelete; -MapCache.prototype.get = mapCacheGet; -MapCache.prototype.has = mapCacheHas; -MapCache.prototype.set = mapCacheSet; - -module.exports = MapCache; - - -/***/ }), - -/***/ "./node_modules/lodash/_Promise.js": -/***/ (function(module, exports, __webpack_require__) { - -var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), - root = __webpack_require__("./node_modules/lodash/_root.js"); - -/* Built-in method references that are verified to be native. */ -var Promise = getNative(root, 'Promise'); - -module.exports = Promise; - - -/***/ }), - -/***/ "./node_modules/lodash/_Set.js": -/***/ (function(module, exports, __webpack_require__) { - -var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), - root = __webpack_require__("./node_modules/lodash/_root.js"); - -/* Built-in method references that are verified to be native. */ -var Set = getNative(root, 'Set'); - -module.exports = Set; - - -/***/ }), - -/***/ "./node_modules/lodash/_SetCache.js": -/***/ (function(module, exports, __webpack_require__) { - -var MapCache = __webpack_require__("./node_modules/lodash/_MapCache.js"), - setCacheAdd = __webpack_require__("./node_modules/lodash/_setCacheAdd.js"), - setCacheHas = __webpack_require__("./node_modules/lodash/_setCacheHas.js"); - -/** - * - * Creates an array cache object to store unique values. - * - * @private - * @constructor - * @param {Array} [values] The values to cache. - */ -function SetCache(values) { - var index = -1, - length = values == null ? 0 : values.length; - - this.__data__ = new MapCache; - while (++index < length) { - this.add(values[index]); - } -} - -// Add methods to `SetCache`. -SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; -SetCache.prototype.has = setCacheHas; - -module.exports = SetCache; - - -/***/ }), - -/***/ "./node_modules/lodash/_Stack.js": -/***/ (function(module, exports, __webpack_require__) { - -var ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"), - stackClear = __webpack_require__("./node_modules/lodash/_stackClear.js"), - stackDelete = __webpack_require__("./node_modules/lodash/_stackDelete.js"), - stackGet = __webpack_require__("./node_modules/lodash/_stackGet.js"), - stackHas = __webpack_require__("./node_modules/lodash/_stackHas.js"), - stackSet = __webpack_require__("./node_modules/lodash/_stackSet.js"); - -/** - * Creates a stack cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function Stack(entries) { - var data = this.__data__ = new ListCache(entries); - this.size = data.size; -} - -// Add methods to `Stack`. -Stack.prototype.clear = stackClear; -Stack.prototype['delete'] = stackDelete; -Stack.prototype.get = stackGet; -Stack.prototype.has = stackHas; -Stack.prototype.set = stackSet; - -module.exports = Stack; - - -/***/ }), - -/***/ "./node_modules/lodash/_Symbol.js": -/***/ (function(module, exports, __webpack_require__) { - -var root = __webpack_require__("./node_modules/lodash/_root.js"); - -/** Built-in value references. */ -var Symbol = root.Symbol; - -module.exports = Symbol; - - -/***/ }), - -/***/ "./node_modules/lodash/_Uint8Array.js": -/***/ (function(module, exports, __webpack_require__) { - -var root = __webpack_require__("./node_modules/lodash/_root.js"); - -/** Built-in value references. */ -var Uint8Array = root.Uint8Array; - -module.exports = Uint8Array; - - -/***/ }), - -/***/ "./node_modules/lodash/_WeakMap.js": -/***/ (function(module, exports, __webpack_require__) { - -var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"), - root = __webpack_require__("./node_modules/lodash/_root.js"); - -/* Built-in method references that are verified to be native. */ -var WeakMap = getNative(root, 'WeakMap'); - -module.exports = WeakMap; - - -/***/ }), - -/***/ "./node_modules/lodash/_arrayFilter.js": -/***/ (function(module, exports) { - -/** - * A specialized version of `_.filter` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ -function arrayFilter(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (predicate(value, index, array)) { - result[resIndex++] = value; - } - } - return result; -} - -module.exports = arrayFilter; - - -/***/ }), - -/***/ "./node_modules/lodash/_arrayLikeKeys.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseTimes = __webpack_require__("./node_modules/lodash/_baseTimes.js"), - isArguments = __webpack_require__("./node_modules/lodash/isArguments.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - isBuffer = __webpack_require__("./node_modules/lodash/isBuffer.js"), - isIndex = __webpack_require__("./node_modules/lodash/_isIndex.js"), - isTypedArray = __webpack_require__("./node_modules/lodash/isTypedArray.js"); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * Creates an array of the enumerable property names of the array-like `value`. - * - * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. - */ -function arrayLikeKeys(value, inherited) { - var isArr = isArray(value), - isArg = !isArr && isArguments(value), - isBuff = !isArr && !isArg && isBuffer(value), - isType = !isArr && !isArg && !isBuff && isTypedArray(value), - skipIndexes = isArr || isArg || isBuff || isType, - result = skipIndexes ? baseTimes(value.length, String) : [], - length = result.length; - - for (var key in value) { - if ((inherited || hasOwnProperty.call(value, key)) && - !(skipIndexes && ( - // Safari 9 has enumerable `arguments.length` in strict mode. - key == 'length' || - // Node.js 0.10 has enumerable non-index properties on buffers. - (isBuff && (key == 'offset' || key == 'parent')) || - // PhantomJS 2 has enumerable non-index properties on typed arrays. - (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || - // Skip index properties. - isIndex(key, length) - ))) { - result.push(key); - } - } - return result; -} - -module.exports = arrayLikeKeys; - - -/***/ }), - -/***/ "./node_modules/lodash/_arrayMap.js": -/***/ (function(module, exports) { - -/** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ -function arrayMap(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length, - result = Array(length); - - while (++index < length) { - result[index] = iteratee(array[index], index, array); - } - return result; -} - -module.exports = arrayMap; - - -/***/ }), - -/***/ "./node_modules/lodash/_arrayPush.js": -/***/ (function(module, exports) { - -/** - * Appends the elements of `values` to `array`. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. - */ -function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length; - - while (++index < length) { - array[offset + index] = values[index]; - } - return array; -} - -module.exports = arrayPush; - - -/***/ }), - -/***/ "./node_modules/lodash/_arrayShuffle.js": -/***/ (function(module, exports, __webpack_require__) { - -var copyArray = __webpack_require__("./node_modules/lodash/_copyArray.js"), - shuffleSelf = __webpack_require__("./node_modules/lodash/_shuffleSelf.js"); - -/** - * A specialized version of `_.shuffle` for arrays. - * - * @private - * @param {Array} array The array to shuffle. - * @returns {Array} Returns the new shuffled array. - */ -function arrayShuffle(array) { - return shuffleSelf(copyArray(array)); -} - -module.exports = arrayShuffle; - - -/***/ }), - -/***/ "./node_modules/lodash/_arraySome.js": -/***/ (function(module, exports) { - -/** - * A specialized version of `_.some` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ -function arraySome(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (predicate(array[index], index, array)) { - return true; - } - } - return false; -} - -module.exports = arraySome; - - -/***/ }), - -/***/ "./node_modules/lodash/_assocIndexOf.js": -/***/ (function(module, exports, __webpack_require__) { - -var eq = __webpack_require__("./node_modules/lodash/eq.js"); - -/** - * Gets the index at which the `key` is found in `array` of key-value pairs. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - */ -function assocIndexOf(array, key) { - var length = array.length; - while (length--) { - if (eq(array[length][0], key)) { - return length; - } - } - return -1; -} - -module.exports = assocIndexOf; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseEach.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseForOwn = __webpack_require__("./node_modules/lodash/_baseForOwn.js"), - createBaseEach = __webpack_require__("./node_modules/lodash/_createBaseEach.js"); - -/** - * The base implementation of `_.forEach` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ -var baseEach = createBaseEach(baseForOwn); - -module.exports = baseEach; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseFlatten.js": -/***/ (function(module, exports, __webpack_require__) { - -var arrayPush = __webpack_require__("./node_modules/lodash/_arrayPush.js"), - isFlattenable = __webpack_require__("./node_modules/lodash/_isFlattenable.js"); - -/** - * The base implementation of `_.flatten` with support for restricting flattening. - * - * @private - * @param {Array} array The array to flatten. - * @param {number} depth The maximum recursion depth. - * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. - * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. - * @param {Array} [result=[]] The initial result value. - * @returns {Array} Returns the new flattened array. - */ -function baseFlatten(array, depth, predicate, isStrict, result) { - var index = -1, - length = array.length; - - predicate || (predicate = isFlattenable); - result || (result = []); - - while (++index < length) { - var value = array[index]; - if (depth > 0 && predicate(value)) { - if (depth > 1) { - // Recursively flatten arrays (susceptible to call stack limits). - baseFlatten(value, depth - 1, predicate, isStrict, result); - } else { - arrayPush(result, value); - } - } else if (!isStrict) { - result[result.length] = value; - } - } - return result; -} - -module.exports = baseFlatten; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseFor.js": -/***/ (function(module, exports, __webpack_require__) { - -var createBaseFor = __webpack_require__("./node_modules/lodash/_createBaseFor.js"); - -/** - * The base implementation of `baseForOwn` which iterates over `object` - * properties returned by `keysFunc` and invokes `iteratee` for each property. - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ -var baseFor = createBaseFor(); - -module.exports = baseFor; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseForOwn.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseFor = __webpack_require__("./node_modules/lodash/_baseFor.js"), - keys = __webpack_require__("./node_modules/lodash/keys.js"); - -/** - * The base implementation of `_.forOwn` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ -function baseForOwn(object, iteratee) { - return object && baseFor(object, iteratee, keys); -} - -module.exports = baseForOwn; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseGet.js": -/***/ (function(module, exports, __webpack_require__) { - -var castPath = __webpack_require__("./node_modules/lodash/_castPath.js"), - toKey = __webpack_require__("./node_modules/lodash/_toKey.js"); - -/** - * The base implementation of `_.get` without support for default values. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. - */ -function baseGet(object, path) { - path = castPath(path, object); - - var index = 0, - length = path.length; - - while (object != null && index < length) { - object = object[toKey(path[index++])]; - } - return (index && index == length) ? object : undefined; -} - -module.exports = baseGet; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseGetAllKeys.js": -/***/ (function(module, exports, __webpack_require__) { - -var arrayPush = __webpack_require__("./node_modules/lodash/_arrayPush.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"); - -/** - * The base implementation of `getAllKeys` and `getAllKeysIn` which uses - * `keysFunc` and `symbolsFunc` to get the enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Function} keysFunc The function to get the keys of `object`. - * @param {Function} symbolsFunc The function to get the symbols of `object`. - * @returns {Array} Returns the array of property names and symbols. - */ -function baseGetAllKeys(object, keysFunc, symbolsFunc) { - var result = keysFunc(object); - return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); -} - -module.exports = baseGetAllKeys; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseGetTag.js": -/***/ (function(module, exports, __webpack_require__) { - -var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), - getRawTag = __webpack_require__("./node_modules/lodash/_getRawTag.js"), - objectToString = __webpack_require__("./node_modules/lodash/_objectToString.js"); - -/** `Object#toString` result references. */ -var nullTag = '[object Null]', - undefinedTag = '[object Undefined]'; - -/** Built-in value references. */ -var symToStringTag = Symbol ? Symbol.toStringTag : undefined; - -/** - * The base implementation of `getTag` without fallbacks for buggy environments. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ -function baseGetTag(value) { - if (value == null) { - return value === undefined ? undefinedTag : nullTag; - } - return (symToStringTag && symToStringTag in Object(value)) - ? getRawTag(value) - : objectToString(value); -} - -module.exports = baseGetTag; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseHasIn.js": -/***/ (function(module, exports) { - -/** - * The base implementation of `_.hasIn` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ -function baseHasIn(object, key) { - return object != null && key in Object(object); -} - -module.exports = baseHasIn; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIsArguments.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), - isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); - -/** `Object#toString` result references. */ -var argsTag = '[object Arguments]'; - -/** - * The base implementation of `_.isArguments`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - */ -function baseIsArguments(value) { - return isObjectLike(value) && baseGetTag(value) == argsTag; -} - -module.exports = baseIsArguments; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIsEqual.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseIsEqualDeep = __webpack_require__("./node_modules/lodash/_baseIsEqualDeep.js"), - isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); - -/** - * The base implementation of `_.isEqual` which supports partial comparisons - * and tracks traversed objects. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {boolean} bitmask The bitmask flags. - * 1 - Unordered comparison - * 2 - Partial comparison - * @param {Function} [customizer] The function to customize comparisons. - * @param {Object} [stack] Tracks traversed `value` and `other` objects. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - */ -function baseIsEqual(value, other, bitmask, customizer, stack) { - if (value === other) { - return true; - } - if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { - return value !== value && other !== other; - } - return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); -} - -module.exports = baseIsEqual; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIsEqualDeep.js": -/***/ (function(module, exports, __webpack_require__) { - -var Stack = __webpack_require__("./node_modules/lodash/_Stack.js"), - equalArrays = __webpack_require__("./node_modules/lodash/_equalArrays.js"), - equalByTag = __webpack_require__("./node_modules/lodash/_equalByTag.js"), - equalObjects = __webpack_require__("./node_modules/lodash/_equalObjects.js"), - getTag = __webpack_require__("./node_modules/lodash/_getTag.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - isBuffer = __webpack_require__("./node_modules/lodash/isBuffer.js"), - isTypedArray = __webpack_require__("./node_modules/lodash/isTypedArray.js"); - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1; - -/** `Object#toString` result references. */ -var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - objectTag = '[object Object]'; - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * A specialized version of `baseIsEqual` for arrays and objects which performs - * deep comparisons and tracks traversed objects enabling objects with circular - * references to be compared. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} [stack] Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ -function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { - var objIsArr = isArray(object), - othIsArr = isArray(other), - objTag = objIsArr ? arrayTag : getTag(object), - othTag = othIsArr ? arrayTag : getTag(other); - - objTag = objTag == argsTag ? objectTag : objTag; - othTag = othTag == argsTag ? objectTag : othTag; - - var objIsObj = objTag == objectTag, - othIsObj = othTag == objectTag, - isSameTag = objTag == othTag; - - if (isSameTag && isBuffer(object)) { - if (!isBuffer(other)) { - return false; - } - objIsArr = true; - objIsObj = false; - } - if (isSameTag && !objIsObj) { - stack || (stack = new Stack); - return (objIsArr || isTypedArray(object)) - ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) - : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); - } - if (!(bitmask & COMPARE_PARTIAL_FLAG)) { - var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), - othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); - - if (objIsWrapped || othIsWrapped) { - var objUnwrapped = objIsWrapped ? object.value() : object, - othUnwrapped = othIsWrapped ? other.value() : other; - - stack || (stack = new Stack); - return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); - } - } - if (!isSameTag) { - return false; - } - stack || (stack = new Stack); - return equalObjects(object, other, bitmask, customizer, equalFunc, stack); -} - -module.exports = baseIsEqualDeep; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIsMatch.js": -/***/ (function(module, exports, __webpack_require__) { - -var Stack = __webpack_require__("./node_modules/lodash/_Stack.js"), - baseIsEqual = __webpack_require__("./node_modules/lodash/_baseIsEqual.js"); - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - -/** - * The base implementation of `_.isMatch` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Array} matchData The property names, values, and compare flags to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - */ -function baseIsMatch(object, source, matchData, customizer) { - var index = matchData.length, - length = index, - noCustomizer = !customizer; - - if (object == null) { - return !length; - } - object = Object(object); - while (index--) { - var data = matchData[index]; - if ((noCustomizer && data[2]) - ? data[1] !== object[data[0]] - : !(data[0] in object) - ) { - return false; - } - } - while (++index < length) { - data = matchData[index]; - var key = data[0], - objValue = object[key], - srcValue = data[1]; - - if (noCustomizer && data[2]) { - if (objValue === undefined && !(key in object)) { - return false; - } - } else { - var stack = new Stack; - if (customizer) { - var result = customizer(objValue, srcValue, key, object, source, stack); - } - if (!(result === undefined - ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) - : result - )) { - return false; - } - } - } - return true; -} - -module.exports = baseIsMatch; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIsNative.js": -/***/ (function(module, exports, __webpack_require__) { - -var isFunction = __webpack_require__("./node_modules/lodash/isFunction.js"), - isMasked = __webpack_require__("./node_modules/lodash/_isMasked.js"), - isObject = __webpack_require__("./node_modules/lodash/isObject.js"), - toSource = __webpack_require__("./node_modules/lodash/_toSource.js"); - -/** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). - */ -var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; - -/** Used to detect host constructors (Safari). */ -var reIsHostCtor = /^\[object .+?Constructor\]$/; - -/** Used for built-in method references. */ -var funcProto = Function.prototype, - objectProto = Object.prototype; - -/** Used to resolve the decompiled source of functions. */ -var funcToString = funcProto.toString; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** Used to detect if a method is native. */ -var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' -); - -/** - * The base implementation of `_.isNative` without bad shim checks. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - */ -function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false; - } - var pattern = isFunction(value) ? reIsNative : reIsHostCtor; - return pattern.test(toSource(value)); -} - -module.exports = baseIsNative; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIsTypedArray.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), - isLength = __webpack_require__("./node_modules/lodash/isLength.js"), - isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); - -/** `Object#toString` result references. */ -var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - boolTag = '[object Boolean]', - dateTag = '[object Date]', - errorTag = '[object Error]', - funcTag = '[object Function]', - mapTag = '[object Map]', - numberTag = '[object Number]', - objectTag = '[object Object]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - weakMapTag = '[object WeakMap]'; - -var arrayBufferTag = '[object ArrayBuffer]', - dataViewTag = '[object DataView]', - float32Tag = '[object Float32Array]', - float64Tag = '[object Float64Array]', - int8Tag = '[object Int8Array]', - int16Tag = '[object Int16Array]', - int32Tag = '[object Int32Array]', - uint8Tag = '[object Uint8Array]', - uint8ClampedTag = '[object Uint8ClampedArray]', - uint16Tag = '[object Uint16Array]', - uint32Tag = '[object Uint32Array]'; - -/** Used to identify `toStringTag` values of typed arrays. */ -var typedArrayTags = {}; -typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = -typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = -typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = -typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = -typedArrayTags[uint32Tag] = true; -typedArrayTags[argsTag] = typedArrayTags[arrayTag] = -typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = -typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = -typedArrayTags[errorTag] = typedArrayTags[funcTag] = -typedArrayTags[mapTag] = typedArrayTags[numberTag] = -typedArrayTags[objectTag] = typedArrayTags[regexpTag] = -typedArrayTags[setTag] = typedArrayTags[stringTag] = -typedArrayTags[weakMapTag] = false; - -/** - * The base implementation of `_.isTypedArray` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - */ -function baseIsTypedArray(value) { - return isObjectLike(value) && - isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; -} - -module.exports = baseIsTypedArray; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseIteratee.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseMatches = __webpack_require__("./node_modules/lodash/_baseMatches.js"), - baseMatchesProperty = __webpack_require__("./node_modules/lodash/_baseMatchesProperty.js"), - identity = __webpack_require__("./node_modules/lodash/identity.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - property = __webpack_require__("./node_modules/lodash/property.js"); - -/** - * The base implementation of `_.iteratee`. - * - * @private - * @param {*} [value=_.identity] The value to convert to an iteratee. - * @returns {Function} Returns the iteratee. - */ -function baseIteratee(value) { - // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. - // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. - if (typeof value == 'function') { - return value; - } - if (value == null) { - return identity; - } - if (typeof value == 'object') { - return isArray(value) - ? baseMatchesProperty(value[0], value[1]) - : baseMatches(value); - } - return property(value); -} - -module.exports = baseIteratee; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseKeys.js": -/***/ (function(module, exports, __webpack_require__) { - -var isPrototype = __webpack_require__("./node_modules/lodash/_isPrototype.js"), - nativeKeys = __webpack_require__("./node_modules/lodash/_nativeKeys.js"); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ -function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object); - } - var result = []; - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != 'constructor') { - result.push(key); - } - } - return result; -} - -module.exports = baseKeys; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseMap.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseEach = __webpack_require__("./node_modules/lodash/_baseEach.js"), - isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"); - -/** - * The base implementation of `_.map` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ -function baseMap(collection, iteratee) { - var index = -1, - result = isArrayLike(collection) ? Array(collection.length) : []; - - baseEach(collection, function(value, key, collection) { - result[++index] = iteratee(value, key, collection); - }); - return result; -} - -module.exports = baseMap; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseMatches.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseIsMatch = __webpack_require__("./node_modules/lodash/_baseIsMatch.js"), - getMatchData = __webpack_require__("./node_modules/lodash/_getMatchData.js"), - matchesStrictComparable = __webpack_require__("./node_modules/lodash/_matchesStrictComparable.js"); - -/** - * The base implementation of `_.matches` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property values to match. - * @returns {Function} Returns the new spec function. - */ -function baseMatches(source) { - var matchData = getMatchData(source); - if (matchData.length == 1 && matchData[0][2]) { - return matchesStrictComparable(matchData[0][0], matchData[0][1]); - } - return function(object) { - return object === source || baseIsMatch(object, source, matchData); - }; -} - -module.exports = baseMatches; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseMatchesProperty.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseIsEqual = __webpack_require__("./node_modules/lodash/_baseIsEqual.js"), - get = __webpack_require__("./node_modules/lodash/get.js"), - hasIn = __webpack_require__("./node_modules/lodash/hasIn.js"), - isKey = __webpack_require__("./node_modules/lodash/_isKey.js"), - isStrictComparable = __webpack_require__("./node_modules/lodash/_isStrictComparable.js"), - matchesStrictComparable = __webpack_require__("./node_modules/lodash/_matchesStrictComparable.js"), - toKey = __webpack_require__("./node_modules/lodash/_toKey.js"); - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - -/** - * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. - * - * @private - * @param {string} path The path of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ -function baseMatchesProperty(path, srcValue) { - if (isKey(path) && isStrictComparable(srcValue)) { - return matchesStrictComparable(toKey(path), srcValue); - } - return function(object) { - var objValue = get(object, path); - return (objValue === undefined && objValue === srcValue) - ? hasIn(object, path) - : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); - }; -} - -module.exports = baseMatchesProperty; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseProperty.js": -/***/ (function(module, exports) { - -/** - * The base implementation of `_.property` without support for deep paths. - * - * @private - * @param {string} key The key of the property to get. - * @returns {Function} Returns the new accessor function. - */ -function baseProperty(key) { - return function(object) { - return object == null ? undefined : object[key]; - }; -} - -module.exports = baseProperty; - - -/***/ }), - -/***/ "./node_modules/lodash/_basePropertyDeep.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGet = __webpack_require__("./node_modules/lodash/_baseGet.js"); - -/** - * A specialized version of `baseProperty` which supports deep paths. - * - * @private - * @param {Array|string} path The path of the property to get. - * @returns {Function} Returns the new accessor function. - */ -function basePropertyDeep(path) { - return function(object) { - return baseGet(object, path); - }; -} - -module.exports = basePropertyDeep; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseRandom.js": -/***/ (function(module, exports) { - -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeFloor = Math.floor, - nativeRandom = Math.random; - -/** - * The base implementation of `_.random` without support for returning - * floating-point numbers. - * - * @private - * @param {number} lower The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the random number. - */ -function baseRandom(lower, upper) { - return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); -} - -module.exports = baseRandom; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseRange.js": -/***/ (function(module, exports) { - -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeCeil = Math.ceil, - nativeMax = Math.max; - -/** - * The base implementation of `_.range` and `_.rangeRight` which doesn't - * coerce arguments. - * - * @private - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @param {number} step The value to increment or decrement by. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the range of numbers. - */ -function baseRange(start, end, step, fromRight) { - var index = -1, - length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), - result = Array(length); - - while (length--) { - result[fromRight ? length : ++index] = start; - start += step; - } - return result; -} - -module.exports = baseRange; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseShuffle.js": -/***/ (function(module, exports, __webpack_require__) { - -var shuffleSelf = __webpack_require__("./node_modules/lodash/_shuffleSelf.js"), - values = __webpack_require__("./node_modules/lodash/values.js"); - -/** - * The base implementation of `_.shuffle`. - * - * @private - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - */ -function baseShuffle(collection) { - return shuffleSelf(values(collection)); -} - -module.exports = baseShuffle; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseSlice.js": -/***/ (function(module, exports) { - -/** - * The base implementation of `_.slice` without an iteratee call guard. - * - * @private - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ -function baseSlice(array, start, end) { - var index = -1, - length = array.length; - - if (start < 0) { - start = -start > length ? 0 : (length + start); - } - end = end > length ? length : end; - if (end < 0) { - end += length; - } - length = start > end ? 0 : ((end - start) >>> 0); - start >>>= 0; - - var result = Array(length); - while (++index < length) { - result[index] = array[index + start]; - } - return result; -} - -module.exports = baseSlice; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseTimes.js": -/***/ (function(module, exports) { - -/** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. - * - * @private - * @param {number} n The number of times to invoke `iteratee`. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. - */ -function baseTimes(n, iteratee) { - var index = -1, - result = Array(n); - - while (++index < n) { - result[index] = iteratee(index); - } - return result; -} - -module.exports = baseTimes; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseToString.js": -/***/ (function(module, exports, __webpack_require__) { - -var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), - arrayMap = __webpack_require__("./node_modules/lodash/_arrayMap.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - isSymbol = __webpack_require__("./node_modules/lodash/isSymbol.js"); - -/** Used as references for various `Number` constants. */ -var INFINITY = 1 / 0; - -/** Used to convert symbols to primitives and strings. */ -var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolToString = symbolProto ? symbolProto.toString : undefined; - -/** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. - * - * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. - */ -function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == 'string') { - return value; - } - if (isArray(value)) { - // Recursively convert values (susceptible to call stack limits). - return arrayMap(value, baseToString) + ''; - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : ''; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; -} - -module.exports = baseToString; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseUnary.js": -/***/ (function(module, exports) { - -/** - * The base implementation of `_.unary` without support for storing metadata. - * - * @private - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - */ -function baseUnary(func) { - return function(value) { - return func(value); - }; -} - -module.exports = baseUnary; - - -/***/ }), - -/***/ "./node_modules/lodash/_baseValues.js": -/***/ (function(module, exports, __webpack_require__) { - -var arrayMap = __webpack_require__("./node_modules/lodash/_arrayMap.js"); - -/** - * The base implementation of `_.values` and `_.valuesIn` which creates an - * array of `object` property values corresponding to the property names - * of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the array of property values. - */ -function baseValues(object, props) { - return arrayMap(props, function(key) { - return object[key]; - }); -} - -module.exports = baseValues; - - -/***/ }), - -/***/ "./node_modules/lodash/_cacheHas.js": -/***/ (function(module, exports) { - -/** - * Checks if a `cache` value for `key` exists. - * - * @private - * @param {Object} cache The cache to query. - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function cacheHas(cache, key) { - return cache.has(key); -} - -module.exports = cacheHas; - - -/***/ }), - -/***/ "./node_modules/lodash/_castPath.js": -/***/ (function(module, exports, __webpack_require__) { - -var isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - isKey = __webpack_require__("./node_modules/lodash/_isKey.js"), - stringToPath = __webpack_require__("./node_modules/lodash/_stringToPath.js"), - toString = __webpack_require__("./node_modules/lodash/toString.js"); - -/** - * Casts `value` to a path array if it's not one. - * - * @private - * @param {*} value The value to inspect. - * @param {Object} [object] The object to query keys on. - * @returns {Array} Returns the cast property path array. - */ -function castPath(value, object) { - if (isArray(value)) { - return value; - } - return isKey(value, object) ? [value] : stringToPath(toString(value)); -} - -module.exports = castPath; - - -/***/ }), - -/***/ "./node_modules/lodash/_copyArray.js": -/***/ (function(module, exports) { - -/** - * Copies the values of `source` to `array`. - * - * @private - * @param {Array} source The array to copy values from. - * @param {Array} [array=[]] The array to copy values to. - * @returns {Array} Returns `array`. - */ -function copyArray(source, array) { - var index = -1, - length = source.length; - - array || (array = Array(length)); - while (++index < length) { - array[index] = source[index]; - } - return array; -} - -module.exports = copyArray; - - -/***/ }), - -/***/ "./node_modules/lodash/_coreJsData.js": -/***/ (function(module, exports, __webpack_require__) { - -var root = __webpack_require__("./node_modules/lodash/_root.js"); - -/** Used to detect overreaching core-js shims. */ -var coreJsData = root['__core-js_shared__']; - -module.exports = coreJsData; - - -/***/ }), - -/***/ "./node_modules/lodash/_createBaseEach.js": -/***/ (function(module, exports, __webpack_require__) { - -var isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"); - -/** - * Creates a `baseEach` or `baseEachRight` function. - * - * @private - * @param {Function} eachFunc The function to iterate over a collection. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ -function createBaseEach(eachFunc, fromRight) { - return function(collection, iteratee) { - if (collection == null) { - return collection; - } - if (!isArrayLike(collection)) { - return eachFunc(collection, iteratee); - } - var length = collection.length, - index = fromRight ? length : -1, - iterable = Object(collection); - - while ((fromRight ? index-- : ++index < length)) { - if (iteratee(iterable[index], index, iterable) === false) { - break; - } - } - return collection; - }; -} - -module.exports = createBaseEach; - - -/***/ }), - -/***/ "./node_modules/lodash/_createBaseFor.js": -/***/ (function(module, exports) { - -/** - * Creates a base function for methods like `_.forIn` and `_.forOwn`. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ -function createBaseFor(fromRight) { - return function(object, iteratee, keysFunc) { - var index = -1, - iterable = Object(object), - props = keysFunc(object), - length = props.length; - - while (length--) { - var key = props[fromRight ? length : ++index]; - if (iteratee(iterable[key], key, iterable) === false) { - break; - } - } - return object; - }; -} - -module.exports = createBaseFor; - - -/***/ }), - -/***/ "./node_modules/lodash/_createRange.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseRange = __webpack_require__("./node_modules/lodash/_baseRange.js"), - isIterateeCall = __webpack_require__("./node_modules/lodash/_isIterateeCall.js"), - toFinite = __webpack_require__("./node_modules/lodash/toFinite.js"); - -/** - * Creates a `_.range` or `_.rangeRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new range function. - */ -function createRange(fromRight) { - return function(start, end, step) { - if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { - end = step = undefined; - } - // Ensure the sign of `-0` is preserved. - start = toFinite(start); - if (end === undefined) { - end = start; - start = 0; - } else { - end = toFinite(end); - } - step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); - return baseRange(start, end, step, fromRight); - }; -} - -module.exports = createRange; - - -/***/ }), - -/***/ "./node_modules/lodash/_equalArrays.js": -/***/ (function(module, exports, __webpack_require__) { - -var SetCache = __webpack_require__("./node_modules/lodash/_SetCache.js"), - arraySome = __webpack_require__("./node_modules/lodash/_arraySome.js"), - cacheHas = __webpack_require__("./node_modules/lodash/_cacheHas.js"); - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - -/** - * A specialized version of `baseIsEqualDeep` for arrays with support for - * partial deep comparisons. - * - * @private - * @param {Array} array The array to compare. - * @param {Array} other The other array to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `array` and `other` objects. - * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. - */ -function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - arrLength = array.length, - othLength = other.length; - - if (arrLength != othLength && !(isPartial && othLength > arrLength)) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(array); - if (stacked && stack.get(other)) { - return stacked == other; - } - var index = -1, - result = true, - seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; - - stack.set(array, other); - stack.set(other, array); - - // Ignore non-index properties. - while (++index < arrLength) { - var arrValue = array[index], - othValue = other[index]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, arrValue, index, other, array, stack) - : customizer(arrValue, othValue, index, array, other, stack); - } - if (compared !== undefined) { - if (compared) { - continue; - } - result = false; - break; - } - // Recursively compare arrays (susceptible to call stack limits). - if (seen) { - if (!arraySome(other, function(othValue, othIndex) { - if (!cacheHas(seen, othIndex) && - (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { - return seen.push(othIndex); - } - })) { - result = false; - break; - } - } else if (!( - arrValue === othValue || - equalFunc(arrValue, othValue, bitmask, customizer, stack) - )) { - result = false; - break; - } - } - stack['delete'](array); - stack['delete'](other); - return result; -} - -module.exports = equalArrays; - - -/***/ }), - -/***/ "./node_modules/lodash/_equalByTag.js": -/***/ (function(module, exports, __webpack_require__) { - -var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), - Uint8Array = __webpack_require__("./node_modules/lodash/_Uint8Array.js"), - eq = __webpack_require__("./node_modules/lodash/eq.js"), - equalArrays = __webpack_require__("./node_modules/lodash/_equalArrays.js"), - mapToArray = __webpack_require__("./node_modules/lodash/_mapToArray.js"), - setToArray = __webpack_require__("./node_modules/lodash/_setToArray.js"); - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - -/** `Object#toString` result references. */ -var boolTag = '[object Boolean]', - dateTag = '[object Date]', - errorTag = '[object Error]', - mapTag = '[object Map]', - numberTag = '[object Number]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]'; - -var arrayBufferTag = '[object ArrayBuffer]', - dataViewTag = '[object DataView]'; - -/** Used to convert symbols to primitives and strings. */ -var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; - -/** - * A specialized version of `baseIsEqualDeep` for comparing objects of - * the same `toStringTag`. - * - * **Note:** This function only supports comparing values with tags of - * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {string} tag The `toStringTag` of the objects to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ -function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { - switch (tag) { - case dataViewTag: - if ((object.byteLength != other.byteLength) || - (object.byteOffset != other.byteOffset)) { - return false; - } - object = object.buffer; - other = other.buffer; - - case arrayBufferTag: - if ((object.byteLength != other.byteLength) || - !equalFunc(new Uint8Array(object), new Uint8Array(other))) { - return false; - } - return true; - - case boolTag: - case dateTag: - case numberTag: - // Coerce booleans to `1` or `0` and dates to milliseconds. - // Invalid dates are coerced to `NaN`. - return eq(+object, +other); - - case errorTag: - return object.name == other.name && object.message == other.message; - - case regexpTag: - case stringTag: - // Coerce regexes to strings and treat strings, primitives and objects, - // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring - // for more details. - return object == (other + ''); - - case mapTag: - var convert = mapToArray; - - case setTag: - var isPartial = bitmask & COMPARE_PARTIAL_FLAG; - convert || (convert = setToArray); - - if (object.size != other.size && !isPartial) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked) { - return stacked == other; - } - bitmask |= COMPARE_UNORDERED_FLAG; - - // Recursively compare objects (susceptible to call stack limits). - stack.set(object, other); - var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); - stack['delete'](object); - return result; - - case symbolTag: - if (symbolValueOf) { - return symbolValueOf.call(object) == symbolValueOf.call(other); - } - } - return false; -} - -module.exports = equalByTag; - - -/***/ }), - -/***/ "./node_modules/lodash/_equalObjects.js": -/***/ (function(module, exports, __webpack_require__) { - -var getAllKeys = __webpack_require__("./node_modules/lodash/_getAllKeys.js"); - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1; - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * A specialized version of `baseIsEqualDeep` for objects with support for - * partial deep comparisons. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ -function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - objProps = getAllKeys(object), - objLength = objProps.length, - othProps = getAllKeys(other), - othLength = othProps.length; - - if (objLength != othLength && !isPartial) { - return false; - } - var index = objLength; - while (index--) { - var key = objProps[index]; - if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { - return false; - } - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked && stack.get(other)) { - return stacked == other; - } - var result = true; - stack.set(object, other); - stack.set(other, object); - - var skipCtor = isPartial; - while (++index < objLength) { - key = objProps[index]; - var objValue = object[key], - othValue = other[key]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, objValue, key, other, object, stack) - : customizer(objValue, othValue, key, object, other, stack); - } - // Recursively compare objects (susceptible to call stack limits). - if (!(compared === undefined - ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) - : compared - )) { - result = false; - break; - } - skipCtor || (skipCtor = key == 'constructor'); - } - if (result && !skipCtor) { - var objCtor = object.constructor, - othCtor = other.constructor; - - // Non `Object` object instances with different constructors are not equal. - if (objCtor != othCtor && - ('constructor' in object && 'constructor' in other) && - !(typeof objCtor == 'function' && objCtor instanceof objCtor && - typeof othCtor == 'function' && othCtor instanceof othCtor)) { - result = false; - } - } - stack['delete'](object); - stack['delete'](other); - return result; -} - -module.exports = equalObjects; - - -/***/ }), - -/***/ "./node_modules/lodash/_freeGlobal.js": -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */ -var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; - -module.exports = freeGlobal; - -/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/global.js"))) - -/***/ }), - -/***/ "./node_modules/lodash/_getAllKeys.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGetAllKeys = __webpack_require__("./node_modules/lodash/_baseGetAllKeys.js"), - getSymbols = __webpack_require__("./node_modules/lodash/_getSymbols.js"), - keys = __webpack_require__("./node_modules/lodash/keys.js"); - -/** - * Creates an array of own enumerable property names and symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ -function getAllKeys(object) { - return baseGetAllKeys(object, keys, getSymbols); -} - -module.exports = getAllKeys; - - -/***/ }), - -/***/ "./node_modules/lodash/_getMapData.js": -/***/ (function(module, exports, __webpack_require__) { - -var isKeyable = __webpack_require__("./node_modules/lodash/_isKeyable.js"); - -/** - * Gets the data for `map`. - * - * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. - */ -function getMapData(map, key) { - var data = map.__data__; - return isKeyable(key) - ? data[typeof key == 'string' ? 'string' : 'hash'] - : data.map; -} - -module.exports = getMapData; - - -/***/ }), - -/***/ "./node_modules/lodash/_getMatchData.js": -/***/ (function(module, exports, __webpack_require__) { - -var isStrictComparable = __webpack_require__("./node_modules/lodash/_isStrictComparable.js"), - keys = __webpack_require__("./node_modules/lodash/keys.js"); - -/** - * Gets the property names, values, and compare flags of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the match data of `object`. - */ -function getMatchData(object) { - var result = keys(object), - length = result.length; - - while (length--) { - var key = result[length], - value = object[key]; - - result[length] = [key, value, isStrictComparable(value)]; - } - return result; -} - -module.exports = getMatchData; - - -/***/ }), - -/***/ "./node_modules/lodash/_getNative.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseIsNative = __webpack_require__("./node_modules/lodash/_baseIsNative.js"), - getValue = __webpack_require__("./node_modules/lodash/_getValue.js"); - -/** - * Gets the native function at `key` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. - */ -function getNative(object, key) { - var value = getValue(object, key); - return baseIsNative(value) ? value : undefined; -} - -module.exports = getNative; - - -/***/ }), - -/***/ "./node_modules/lodash/_getRawTag.js": -/***/ (function(module, exports, __webpack_require__) { - -var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ -var nativeObjectToString = objectProto.toString; - -/** Built-in value references. */ -var symToStringTag = Symbol ? Symbol.toStringTag : undefined; - -/** - * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the raw `toStringTag`. - */ -function getRawTag(value) { - var isOwn = hasOwnProperty.call(value, symToStringTag), - tag = value[symToStringTag]; - - try { - value[symToStringTag] = undefined; - var unmasked = true; - } catch (e) {} - - var result = nativeObjectToString.call(value); - if (unmasked) { - if (isOwn) { - value[symToStringTag] = tag; - } else { - delete value[symToStringTag]; - } - } - return result; -} - -module.exports = getRawTag; - - -/***/ }), - -/***/ "./node_modules/lodash/_getSymbols.js": -/***/ (function(module, exports, __webpack_require__) { - -var arrayFilter = __webpack_require__("./node_modules/lodash/_arrayFilter.js"), - stubArray = __webpack_require__("./node_modules/lodash/stubArray.js"); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Built-in value references. */ -var propertyIsEnumerable = objectProto.propertyIsEnumerable; - -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeGetSymbols = Object.getOwnPropertySymbols; - -/** - * Creates an array of the own enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ -var getSymbols = !nativeGetSymbols ? stubArray : function(object) { - if (object == null) { - return []; - } - object = Object(object); - return arrayFilter(nativeGetSymbols(object), function(symbol) { - return propertyIsEnumerable.call(object, symbol); - }); -}; - -module.exports = getSymbols; - - -/***/ }), - -/***/ "./node_modules/lodash/_getTag.js": -/***/ (function(module, exports, __webpack_require__) { - -var DataView = __webpack_require__("./node_modules/lodash/_DataView.js"), - Map = __webpack_require__("./node_modules/lodash/_Map.js"), - Promise = __webpack_require__("./node_modules/lodash/_Promise.js"), - Set = __webpack_require__("./node_modules/lodash/_Set.js"), - WeakMap = __webpack_require__("./node_modules/lodash/_WeakMap.js"), - baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), - toSource = __webpack_require__("./node_modules/lodash/_toSource.js"); - -/** `Object#toString` result references. */ -var mapTag = '[object Map]', - objectTag = '[object Object]', - promiseTag = '[object Promise]', - setTag = '[object Set]', - weakMapTag = '[object WeakMap]'; - -var dataViewTag = '[object DataView]'; - -/** Used to detect maps, sets, and weakmaps. */ -var dataViewCtorString = toSource(DataView), - mapCtorString = toSource(Map), - promiseCtorString = toSource(Promise), - setCtorString = toSource(Set), - weakMapCtorString = toSource(WeakMap); - -/** - * Gets the `toStringTag` of `value`. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ -var getTag = baseGetTag; - -// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. -if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || - (Map && getTag(new Map) != mapTag) || - (Promise && getTag(Promise.resolve()) != promiseTag) || - (Set && getTag(new Set) != setTag) || - (WeakMap && getTag(new WeakMap) != weakMapTag)) { - getTag = function(value) { - var result = baseGetTag(value), - Ctor = result == objectTag ? value.constructor : undefined, - ctorString = Ctor ? toSource(Ctor) : ''; - - if (ctorString) { - switch (ctorString) { - case dataViewCtorString: return dataViewTag; - case mapCtorString: return mapTag; - case promiseCtorString: return promiseTag; - case setCtorString: return setTag; - case weakMapCtorString: return weakMapTag; - } - } - return result; - }; -} - -module.exports = getTag; - - -/***/ }), - -/***/ "./node_modules/lodash/_getValue.js": -/***/ (function(module, exports) { - -/** - * Gets the value at `key` of `object`. - * - * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ -function getValue(object, key) { - return object == null ? undefined : object[key]; -} - -module.exports = getValue; - - -/***/ }), - -/***/ "./node_modules/lodash/_hasPath.js": -/***/ (function(module, exports, __webpack_require__) { - -var castPath = __webpack_require__("./node_modules/lodash/_castPath.js"), - isArguments = __webpack_require__("./node_modules/lodash/isArguments.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - isIndex = __webpack_require__("./node_modules/lodash/_isIndex.js"), - isLength = __webpack_require__("./node_modules/lodash/isLength.js"), - toKey = __webpack_require__("./node_modules/lodash/_toKey.js"); - -/** - * Checks if `path` exists on `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @param {Function} hasFunc The function to check properties. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - */ -function hasPath(object, path, hasFunc) { - path = castPath(path, object); - - var index = -1, - length = path.length, - result = false; - - while (++index < length) { - var key = toKey(path[index]); - if (!(result = object != null && hasFunc(object, key))) { - break; - } - object = object[key]; - } - if (result || ++index != length) { - return result; - } - length = object == null ? 0 : object.length; - return !!length && isLength(length) && isIndex(key, length) && - (isArray(object) || isArguments(object)); -} - -module.exports = hasPath; - - -/***/ }), - -/***/ "./node_modules/lodash/_hashClear.js": -/***/ (function(module, exports, __webpack_require__) { - -var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); - -/** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ -function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; - this.size = 0; -} - -module.exports = hashClear; - - -/***/ }), - -/***/ "./node_modules/lodash/_hashDelete.js": -/***/ (function(module, exports) { - -/** - * Removes `key` and its value from the hash. - * - * @private - * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function hashDelete(key) { - var result = this.has(key) && delete this.__data__[key]; - this.size -= result ? 1 : 0; - return result; -} - -module.exports = hashDelete; - - -/***/ }), - -/***/ "./node_modules/lodash/_hashGet.js": -/***/ (function(module, exports, __webpack_require__) { - -var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * Gets the hash value for `key`. - * - * @private - * @name get - * @memberOf Hash - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function hashGet(key) { - var data = this.__data__; - if (nativeCreate) { - var result = data[key]; - return result === HASH_UNDEFINED ? undefined : result; - } - return hasOwnProperty.call(data, key) ? data[key] : undefined; -} - -module.exports = hashGet; - - -/***/ }), - -/***/ "./node_modules/lodash/_hashHas.js": -/***/ (function(module, exports, __webpack_require__) { - -var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * Checks if a hash value for `key` exists. - * - * @private - * @name has - * @memberOf Hash - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function hashHas(key) { - var data = this.__data__; - return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); -} - -module.exports = hashHas; - - -/***/ }), - -/***/ "./node_modules/lodash/_hashSet.js": -/***/ (function(module, exports, __webpack_require__) { - -var nativeCreate = __webpack_require__("./node_modules/lodash/_nativeCreate.js"); - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; - -/** - * Sets the hash `key` to `value`. - * - * @private - * @name set - * @memberOf Hash - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. - */ -function hashSet(key, value) { - var data = this.__data__; - this.size += this.has(key) ? 0 : 1; - data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; - return this; -} - -module.exports = hashSet; - - -/***/ }), - -/***/ "./node_modules/lodash/_isFlattenable.js": -/***/ (function(module, exports, __webpack_require__) { - -var Symbol = __webpack_require__("./node_modules/lodash/_Symbol.js"), - isArguments = __webpack_require__("./node_modules/lodash/isArguments.js"), - isArray = __webpack_require__("./node_modules/lodash/isArray.js"); - -/** Built-in value references. */ -var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined; - -/** - * Checks if `value` is a flattenable `arguments` object or array. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. - */ -function isFlattenable(value) { - return isArray(value) || isArguments(value) || - !!(spreadableSymbol && value && value[spreadableSymbol]); -} - -module.exports = isFlattenable; - - -/***/ }), - -/***/ "./node_modules/lodash/_isIndex.js": -/***/ (function(module, exports) { - -/** Used as references for various `Number` constants. */ -var MAX_SAFE_INTEGER = 9007199254740991; - -/** Used to detect unsigned integer values. */ -var reIsUint = /^(?:0|[1-9]\d*)$/; - -/** - * Checks if `value` is a valid array-like index. - * - * @private - * @param {*} value The value to check. - * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. - * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. - */ -function isIndex(value, length) { - var type = typeof value; - length = length == null ? MAX_SAFE_INTEGER : length; - - return !!length && - (type == 'number' || - (type != 'symbol' && reIsUint.test(value))) && - (value > -1 && value % 1 == 0 && value < length); -} - -module.exports = isIndex; - - -/***/ }), - -/***/ "./node_modules/lodash/_isIterateeCall.js": -/***/ (function(module, exports, __webpack_require__) { - -var eq = __webpack_require__("./node_modules/lodash/eq.js"), - isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"), - isIndex = __webpack_require__("./node_modules/lodash/_isIndex.js"), - isObject = __webpack_require__("./node_modules/lodash/isObject.js"); - -/** - * Checks if the given arguments are from an iteratee call. - * - * @private - * @param {*} value The potential iteratee value argument. - * @param {*} index The potential iteratee index or key argument. - * @param {*} object The potential iteratee object argument. - * @returns {boolean} Returns `true` if the arguments are from an iteratee call, - * else `false`. - */ -function isIterateeCall(value, index, object) { - if (!isObject(object)) { - return false; - } - var type = typeof index; - if (type == 'number' - ? (isArrayLike(object) && isIndex(index, object.length)) - : (type == 'string' && index in object) - ) { - return eq(object[index], value); - } - return false; -} - -module.exports = isIterateeCall; - - -/***/ }), - -/***/ "./node_modules/lodash/_isKey.js": -/***/ (function(module, exports, __webpack_require__) { - -var isArray = __webpack_require__("./node_modules/lodash/isArray.js"), - isSymbol = __webpack_require__("./node_modules/lodash/isSymbol.js"); - -/** Used to match property names within property paths. */ -var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/; - -/** - * Checks if `value` is a property name and not a property path. - * - * @private - * @param {*} value The value to check. - * @param {Object} [object] The object to query keys on. - * @returns {boolean} Returns `true` if `value` is a property name, else `false`. - */ -function isKey(value, object) { - if (isArray(value)) { - return false; - } - var type = typeof value; - if (type == 'number' || type == 'symbol' || type == 'boolean' || - value == null || isSymbol(value)) { - return true; - } - return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || - (object != null && value in Object(object)); -} - -module.exports = isKey; - - -/***/ }), - -/***/ "./node_modules/lodash/_isKeyable.js": -/***/ (function(module, exports) { - -/** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ -function isKeyable(value) { - var type = typeof value; - return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') - ? (value !== '__proto__') - : (value === null); -} - -module.exports = isKeyable; - - -/***/ }), - -/***/ "./node_modules/lodash/_isMasked.js": -/***/ (function(module, exports, __webpack_require__) { - -var coreJsData = __webpack_require__("./node_modules/lodash/_coreJsData.js"); - -/** Used to detect methods masquerading as native. */ -var maskSrcKey = (function() { - var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); - return uid ? ('Symbol(src)_1.' + uid) : ''; -}()); - -/** - * Checks if `func` has its source masked. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. - */ -function isMasked(func) { - return !!maskSrcKey && (maskSrcKey in func); -} - -module.exports = isMasked; - - -/***/ }), - -/***/ "./node_modules/lodash/_isPrototype.js": -/***/ (function(module, exports) { - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** - * Checks if `value` is likely a prototype object. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. - */ -function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; - - return value === proto; -} - -module.exports = isPrototype; - - -/***/ }), - -/***/ "./node_modules/lodash/_isStrictComparable.js": -/***/ (function(module, exports, __webpack_require__) { - -var isObject = __webpack_require__("./node_modules/lodash/isObject.js"); - -/** - * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` if suitable for strict - * equality comparisons, else `false`. - */ -function isStrictComparable(value) { - return value === value && !isObject(value); -} - -module.exports = isStrictComparable; - - -/***/ }), - -/***/ "./node_modules/lodash/_listCacheClear.js": -/***/ (function(module, exports) { - -/** - * Removes all key-value entries from the list cache. - * - * @private - * @name clear - * @memberOf ListCache - */ -function listCacheClear() { - this.__data__ = []; - this.size = 0; -} - -module.exports = listCacheClear; - - -/***/ }), - -/***/ "./node_modules/lodash/_listCacheDelete.js": -/***/ (function(module, exports, __webpack_require__) { - -var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); - -/** Used for built-in method references. */ -var arrayProto = Array.prototype; - -/** Built-in value references. */ -var splice = arrayProto.splice; - -/** - * Removes `key` and its value from the list cache. - * - * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - return false; - } - var lastIndex = data.length - 1; - if (index == lastIndex) { - data.pop(); - } else { - splice.call(data, index, 1); - } - --this.size; - return true; -} - -module.exports = listCacheDelete; - - -/***/ }), - -/***/ "./node_modules/lodash/_listCacheGet.js": -/***/ (function(module, exports, __webpack_require__) { - -var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); - -/** - * Gets the list cache value for `key`. - * - * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - return index < 0 ? undefined : data[index][1]; -} - -module.exports = listCacheGet; - - -/***/ }), - -/***/ "./node_modules/lodash/_listCacheHas.js": -/***/ (function(module, exports, __webpack_require__) { - -var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); - -/** - * Checks if a list cache value for `key` exists. - * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1; -} - -module.exports = listCacheHas; - - -/***/ }), - -/***/ "./node_modules/lodash/_listCacheSet.js": -/***/ (function(module, exports, __webpack_require__) { - -var assocIndexOf = __webpack_require__("./node_modules/lodash/_assocIndexOf.js"); - -/** - * Sets the list cache `key` to `value`. - * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. - */ -function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - ++this.size; - data.push([key, value]); - } else { - data[index][1] = value; - } - return this; -} - -module.exports = listCacheSet; - - -/***/ }), - -/***/ "./node_modules/lodash/_mapCacheClear.js": -/***/ (function(module, exports, __webpack_require__) { - -var Hash = __webpack_require__("./node_modules/lodash/_Hash.js"), - ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"), - Map = __webpack_require__("./node_modules/lodash/_Map.js"); - -/** - * Removes all key-value entries from the map. - * - * @private - * @name clear - * @memberOf MapCache - */ -function mapCacheClear() { - this.size = 0; - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; -} - -module.exports = mapCacheClear; - - -/***/ }), - -/***/ "./node_modules/lodash/_mapCacheDelete.js": -/***/ (function(module, exports, __webpack_require__) { - -var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); - -/** - * Removes `key` and its value from the map. - * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function mapCacheDelete(key) { - var result = getMapData(this, key)['delete'](key); - this.size -= result ? 1 : 0; - return result; -} - -module.exports = mapCacheDelete; - - -/***/ }), - -/***/ "./node_modules/lodash/_mapCacheGet.js": -/***/ (function(module, exports, __webpack_require__) { - -var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); - -/** - * Gets the map value for `key`. - * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function mapCacheGet(key) { - return getMapData(this, key).get(key); -} - -module.exports = mapCacheGet; - - -/***/ }), - -/***/ "./node_modules/lodash/_mapCacheHas.js": -/***/ (function(module, exports, __webpack_require__) { - -var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); - -/** - * Checks if a map value for `key` exists. - * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function mapCacheHas(key) { - return getMapData(this, key).has(key); -} - -module.exports = mapCacheHas; - - -/***/ }), - -/***/ "./node_modules/lodash/_mapCacheSet.js": -/***/ (function(module, exports, __webpack_require__) { - -var getMapData = __webpack_require__("./node_modules/lodash/_getMapData.js"); - -/** - * Sets the map `key` to `value`. - * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. - */ -function mapCacheSet(key, value) { - var data = getMapData(this, key), - size = data.size; - - data.set(key, value); - this.size += data.size == size ? 0 : 1; - return this; -} - -module.exports = mapCacheSet; - - -/***/ }), - -/***/ "./node_modules/lodash/_mapToArray.js": -/***/ (function(module, exports) { - -/** - * Converts `map` to its key-value pairs. - * - * @private - * @param {Object} map The map to convert. - * @returns {Array} Returns the key-value pairs. - */ -function mapToArray(map) { - var index = -1, - result = Array(map.size); - - map.forEach(function(value, key) { - result[++index] = [key, value]; - }); - return result; -} - -module.exports = mapToArray; - - -/***/ }), - -/***/ "./node_modules/lodash/_matchesStrictComparable.js": -/***/ (function(module, exports) { - -/** - * A specialized version of `matchesProperty` for source values suitable - * for strict equality comparisons, i.e. `===`. - * - * @private - * @param {string} key The key of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ -function matchesStrictComparable(key, srcValue) { - return function(object) { - if (object == null) { - return false; - } - return object[key] === srcValue && - (srcValue !== undefined || (key in Object(object))); - }; -} - -module.exports = matchesStrictComparable; - - -/***/ }), - -/***/ "./node_modules/lodash/_memoizeCapped.js": -/***/ (function(module, exports, __webpack_require__) { - -var memoize = __webpack_require__("./node_modules/lodash/memoize.js"); - -/** Used as the maximum memoize cache size. */ -var MAX_MEMOIZE_SIZE = 500; - -/** - * A specialized version of `_.memoize` which clears the memoized function's - * cache when it exceeds `MAX_MEMOIZE_SIZE`. - * - * @private - * @param {Function} func The function to have its output memoized. - * @returns {Function} Returns the new memoized function. - */ -function memoizeCapped(func) { - var result = memoize(func, function(key) { - if (cache.size === MAX_MEMOIZE_SIZE) { - cache.clear(); - } - return key; - }); - - var cache = result.cache; - return result; -} - -module.exports = memoizeCapped; - - -/***/ }), - -/***/ "./node_modules/lodash/_nativeCreate.js": -/***/ (function(module, exports, __webpack_require__) { - -var getNative = __webpack_require__("./node_modules/lodash/_getNative.js"); - -/* Built-in method references that are verified to be native. */ -var nativeCreate = getNative(Object, 'create'); - -module.exports = nativeCreate; - - -/***/ }), - -/***/ "./node_modules/lodash/_nativeKeys.js": -/***/ (function(module, exports, __webpack_require__) { - -var overArg = __webpack_require__("./node_modules/lodash/_overArg.js"); - -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeKeys = overArg(Object.keys, Object); - -module.exports = nativeKeys; - - -/***/ }), - -/***/ "./node_modules/lodash/_nodeUtil.js": -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__("./node_modules/lodash/_freeGlobal.js"); - -/** Detect free variable `exports`. */ -var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; - -/** Detect free variable `module`. */ -var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; - -/** Detect the popular CommonJS extension `module.exports`. */ -var moduleExports = freeModule && freeModule.exports === freeExports; - -/** Detect free variable `process` from Node.js. */ -var freeProcess = moduleExports && freeGlobal.process; - -/** Used to access faster Node.js helpers. */ -var nodeUtil = (function() { - try { - // Use `util.types` for Node.js 10+. - var types = freeModule && freeModule.require && freeModule.require('util').types; - - if (types) { - return types; - } - - // Legacy `process.binding('util')` for Node.js < 10. - return freeProcess && freeProcess.binding && freeProcess.binding('util'); - } catch (e) {} -}()); - -module.exports = nodeUtil; - -/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/module.js")(module))) - -/***/ }), - -/***/ "./node_modules/lodash/_objectToString.js": -/***/ (function(module, exports) { - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ -var nativeObjectToString = objectProto.toString; - -/** - * Converts `value` to a string using `Object.prototype.toString`. - * - * @private - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - */ -function objectToString(value) { - return nativeObjectToString.call(value); -} - -module.exports = objectToString; - - -/***/ }), - -/***/ "./node_modules/lodash/_overArg.js": -/***/ (function(module, exports) { - -/** - * Creates a unary function that invokes `func` with its argument transformed. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. - */ -function overArg(func, transform) { - return function(arg) { - return func(transform(arg)); - }; -} - -module.exports = overArg; - - -/***/ }), - -/***/ "./node_modules/lodash/_root.js": -/***/ (function(module, exports, __webpack_require__) { - -var freeGlobal = __webpack_require__("./node_modules/lodash/_freeGlobal.js"); - -/** Detect free variable `self`. */ -var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - -/** Used as a reference to the global object. */ -var root = freeGlobal || freeSelf || Function('return this')(); - -module.exports = root; - - -/***/ }), - -/***/ "./node_modules/lodash/_setCacheAdd.js": -/***/ (function(module, exports) { - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; - -/** - * Adds `value` to the array cache. - * - * @private - * @name add - * @memberOf SetCache - * @alias push - * @param {*} value The value to cache. - * @returns {Object} Returns the cache instance. - */ -function setCacheAdd(value) { - this.__data__.set(value, HASH_UNDEFINED); - return this; -} - -module.exports = setCacheAdd; - - -/***/ }), - -/***/ "./node_modules/lodash/_setCacheHas.js": -/***/ (function(module, exports) { - -/** - * Checks if `value` is in the array cache. - * - * @private - * @name has - * @memberOf SetCache - * @param {*} value The value to search for. - * @returns {number} Returns `true` if `value` is found, else `false`. - */ -function setCacheHas(value) { - return this.__data__.has(value); -} - -module.exports = setCacheHas; - - -/***/ }), - -/***/ "./node_modules/lodash/_setToArray.js": -/***/ (function(module, exports) { - -/** - * Converts `set` to an array of its values. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the values. - */ -function setToArray(set) { - var index = -1, - result = Array(set.size); - - set.forEach(function(value) { - result[++index] = value; - }); - return result; -} - -module.exports = setToArray; - - -/***/ }), - -/***/ "./node_modules/lodash/_shuffleSelf.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseRandom = __webpack_require__("./node_modules/lodash/_baseRandom.js"); - -/** - * A specialized version of `_.shuffle` which mutates and sets the size of `array`. - * - * @private - * @param {Array} array The array to shuffle. - * @param {number} [size=array.length] The size of `array`. - * @returns {Array} Returns `array`. - */ -function shuffleSelf(array, size) { - var index = -1, - length = array.length, - lastIndex = length - 1; - - size = size === undefined ? length : size; - while (++index < size) { - var rand = baseRandom(index, lastIndex), - value = array[rand]; - - array[rand] = array[index]; - array[index] = value; - } - array.length = size; - return array; -} - -module.exports = shuffleSelf; - - -/***/ }), - -/***/ "./node_modules/lodash/_stackClear.js": -/***/ (function(module, exports, __webpack_require__) { - -var ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"); - -/** - * Removes all key-value entries from the stack. - * - * @private - * @name clear - * @memberOf Stack - */ -function stackClear() { - this.__data__ = new ListCache; - this.size = 0; -} - -module.exports = stackClear; - - -/***/ }), - -/***/ "./node_modules/lodash/_stackDelete.js": -/***/ (function(module, exports) { - -/** - * Removes `key` and its value from the stack. - * - * @private - * @name delete - * @memberOf Stack - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function stackDelete(key) { - var data = this.__data__, - result = data['delete'](key); - - this.size = data.size; - return result; -} - -module.exports = stackDelete; - - -/***/ }), - -/***/ "./node_modules/lodash/_stackGet.js": -/***/ (function(module, exports) { - -/** - * Gets the stack value for `key`. - * - * @private - * @name get - * @memberOf Stack - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function stackGet(key) { - return this.__data__.get(key); -} - -module.exports = stackGet; - - -/***/ }), - -/***/ "./node_modules/lodash/_stackHas.js": -/***/ (function(module, exports) { - -/** - * Checks if a stack value for `key` exists. - * - * @private - * @name has - * @memberOf Stack - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function stackHas(key) { - return this.__data__.has(key); -} - -module.exports = stackHas; - - -/***/ }), - -/***/ "./node_modules/lodash/_stackSet.js": -/***/ (function(module, exports, __webpack_require__) { - -var ListCache = __webpack_require__("./node_modules/lodash/_ListCache.js"), - Map = __webpack_require__("./node_modules/lodash/_Map.js"), - MapCache = __webpack_require__("./node_modules/lodash/_MapCache.js"); - -/** Used as the size to enable large array optimizations. */ -var LARGE_ARRAY_SIZE = 200; - -/** - * Sets the stack `key` to `value`. - * - * @private - * @name set - * @memberOf Stack - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the stack cache instance. - */ -function stackSet(key, value) { - var data = this.__data__; - if (data instanceof ListCache) { - var pairs = data.__data__; - if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { - pairs.push([key, value]); - this.size = ++data.size; - return this; - } - data = this.__data__ = new MapCache(pairs); - } - data.set(key, value); - this.size = data.size; - return this; -} - -module.exports = stackSet; - - -/***/ }), - -/***/ "./node_modules/lodash/_stringToPath.js": -/***/ (function(module, exports, __webpack_require__) { - -var memoizeCapped = __webpack_require__("./node_modules/lodash/_memoizeCapped.js"); - -/** Used to match property names within property paths. */ -var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; - -/** Used to match backslashes in property paths. */ -var reEscapeChar = /\\(\\)?/g; - -/** - * Converts `string` to a property path array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. - */ -var stringToPath = memoizeCapped(function(string) { - var result = []; - if (string.charCodeAt(0) === 46 /* . */) { - result.push(''); - } - string.replace(rePropName, function(match, number, quote, subString) { - result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); - }); - return result; -}); - -module.exports = stringToPath; - - -/***/ }), - -/***/ "./node_modules/lodash/_toKey.js": -/***/ (function(module, exports, __webpack_require__) { - -var isSymbol = __webpack_require__("./node_modules/lodash/isSymbol.js"); - -/** Used as references for various `Number` constants. */ -var INFINITY = 1 / 0; - -/** - * Converts `value` to a string key if it's not a string or symbol. - * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. - */ -function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; -} - -module.exports = toKey; - - -/***/ }), - -/***/ "./node_modules/lodash/_toSource.js": -/***/ (function(module, exports) { - -/** Used for built-in method references. */ -var funcProto = Function.prototype; - -/** Used to resolve the decompiled source of functions. */ -var funcToString = funcProto.toString; - -/** - * Converts `func` to its source code. - * - * @private - * @param {Function} func The function to convert. - * @returns {string} Returns the source code. - */ -function toSource(func) { - if (func != null) { - try { - return funcToString.call(func); - } catch (e) {} - try { - return (func + ''); - } catch (e) {} - } - return ''; -} - -module.exports = toSource; - - -/***/ }), - -/***/ "./node_modules/lodash/eq.js": -/***/ (function(module, exports) { - -/** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true - * - * _.eq('a', Object('a')); - * // => false - * - * _.eq(NaN, NaN); - * // => true - */ -function eq(value, other) { - return value === other || (value !== value && other !== other); -} - -module.exports = eq; - - -/***/ }), - -/***/ "./node_modules/lodash/flatMap.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseFlatten = __webpack_require__("./node_modules/lodash/_baseFlatten.js"), - map = __webpack_require__("./node_modules/lodash/map.js"); - -/** - * Creates a flattened array of values by running each element in `collection` - * thru `iteratee` and flattening the mapped results. The iteratee is invoked - * with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [n, n]; - * } - * - * _.flatMap([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ -function flatMap(collection, iteratee) { - return baseFlatten(map(collection, iteratee), 1); -} - -module.exports = flatMap; - - -/***/ }), - -/***/ "./node_modules/lodash/get.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGet = __webpack_require__("./node_modules/lodash/_baseGet.js"); - -/** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is returned in its place. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.get(object, 'a[0].b.c'); - * // => 3 - * - * _.get(object, ['a', '0', 'b', 'c']); - * // => 3 - * - * _.get(object, 'a.b.c', 'default'); - * // => 'default' - */ -function get(object, path, defaultValue) { - var result = object == null ? undefined : baseGet(object, path); - return result === undefined ? defaultValue : result; -} - -module.exports = get; - - -/***/ }), - -/***/ "./node_modules/lodash/hasIn.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseHasIn = __webpack_require__("./node_modules/lodash/_baseHasIn.js"), - hasPath = __webpack_require__("./node_modules/lodash/_hasPath.js"); - -/** - * Checks if `path` is a direct or inherited property of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.hasIn(object, 'a'); - * // => true - * - * _.hasIn(object, 'a.b'); - * // => true - * - * _.hasIn(object, ['a', 'b']); - * // => true - * - * _.hasIn(object, 'b'); - * // => false - */ -function hasIn(object, path) { - return object != null && hasPath(object, path, baseHasIn); -} - -module.exports = hasIn; - - -/***/ }), - -/***/ "./node_modules/lodash/identity.js": -/***/ (function(module, exports) { - -/** - * This method returns the first argument it receives. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Util - * @param {*} value Any value. - * @returns {*} Returns `value`. - * @example - * - * var object = { 'a': 1 }; - * - * console.log(_.identity(object) === object); - * // => true - */ -function identity(value) { - return value; -} - -module.exports = identity; - - -/***/ }), - -/***/ "./node_modules/lodash/isArguments.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseIsArguments = __webpack_require__("./node_modules/lodash/_baseIsArguments.js"), - isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** Built-in value references. */ -var propertyIsEnumerable = objectProto.propertyIsEnumerable; - -/** - * Checks if `value` is likely an `arguments` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. - * @example - * - * _.isArguments(function() { return arguments; }()); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ -var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { - return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && - !propertyIsEnumerable.call(value, 'callee'); -}; - -module.exports = isArguments; - - -/***/ }), - -/***/ "./node_modules/lodash/isArray.js": -/***/ (function(module, exports) { - -/** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false - * - * _.isArray('abc'); - * // => false - * - * _.isArray(_.noop); - * // => false - */ -var isArray = Array.isArray; - -module.exports = isArray; - - -/***/ }), - -/***/ "./node_modules/lodash/isArrayLike.js": -/***/ (function(module, exports, __webpack_require__) { - -var isFunction = __webpack_require__("./node_modules/lodash/isFunction.js"), - isLength = __webpack_require__("./node_modules/lodash/isLength.js"); - -/** - * Checks if `value` is array-like. A value is considered array-like if it's - * not a function and has a `value.length` that's an integer greater than or - * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is array-like, else `false`. - * @example - * - * _.isArrayLike([1, 2, 3]); - * // => true - * - * _.isArrayLike(document.body.children); - * // => true - * - * _.isArrayLike('abc'); - * // => true - * - * _.isArrayLike(_.noop); - * // => false - */ -function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value); -} - -module.exports = isArrayLike; - - -/***/ }), - -/***/ "./node_modules/lodash/isBuffer.js": -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__("./node_modules/lodash/_root.js"), - stubFalse = __webpack_require__("./node_modules/lodash/stubFalse.js"); - -/** Detect free variable `exports`. */ -var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; - -/** Detect free variable `module`. */ -var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; - -/** Detect the popular CommonJS extension `module.exports`. */ -var moduleExports = freeModule && freeModule.exports === freeExports; - -/** Built-in value references. */ -var Buffer = moduleExports ? root.Buffer : undefined; - -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; - -/** - * Checks if `value` is a buffer. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. - * @example - * - * _.isBuffer(new Buffer(2)); - * // => true - * - * _.isBuffer(new Uint8Array(2)); - * // => false - */ -var isBuffer = nativeIsBuffer || stubFalse; - -module.exports = isBuffer; - -/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/webpack/buildin/module.js")(module))) - -/***/ }), - -/***/ "./node_modules/lodash/isFunction.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), - isObject = __webpack_require__("./node_modules/lodash/isObject.js"); - -/** `Object#toString` result references. */ -var asyncTag = '[object AsyncFunction]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - proxyTag = '[object Proxy]'; - -/** - * Checks if `value` is classified as a `Function` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false - */ -function isFunction(value) { - if (!isObject(value)) { - return false; - } - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 9 which returns 'object' for typed arrays and other constructors. - var tag = baseGetTag(value); - return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; -} - -module.exports = isFunction; - - -/***/ }), - -/***/ "./node_modules/lodash/isLength.js": -/***/ (function(module, exports) { - -/** Used as references for various `Number` constants. */ -var MAX_SAFE_INTEGER = 9007199254740991; - -/** - * Checks if `value` is a valid array-like length. - * - * **Note:** This method is loosely based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. - * @example - * - * _.isLength(3); - * // => true - * - * _.isLength(Number.MIN_VALUE); - * // => false - * - * _.isLength(Infinity); - * // => false - * - * _.isLength('3'); - * // => false - */ -function isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; -} - -module.exports = isLength; - - -/***/ }), - -/***/ "./node_modules/lodash/isObject.js": -/***/ (function(module, exports) { - -/** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true - * - * _.isObject(null); - * // => false - */ -function isObject(value) { - var type = typeof value; - return value != null && (type == 'object' || type == 'function'); -} - -module.exports = isObject; - - -/***/ }), - -/***/ "./node_modules/lodash/isObjectLike.js": -/***/ (function(module, exports) { - -/** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example - * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); - * // => true - * - * _.isObjectLike(_.noop); - * // => false - * - * _.isObjectLike(null); - * // => false - */ -function isObjectLike(value) { - return value != null && typeof value == 'object'; -} - -module.exports = isObjectLike; - - -/***/ }), - -/***/ "./node_modules/lodash/isSymbol.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseGetTag = __webpack_require__("./node_modules/lodash/_baseGetTag.js"), - isObjectLike = __webpack_require__("./node_modules/lodash/isObjectLike.js"); - -/** `Object#toString` result references. */ -var symbolTag = '[object Symbol]'; - -/** - * Checks if `value` is classified as a `Symbol` primitive or object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. - * @example - * - * _.isSymbol(Symbol.iterator); - * // => true - * - * _.isSymbol('abc'); - * // => false - */ -function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && baseGetTag(value) == symbolTag); -} - -module.exports = isSymbol; - - -/***/ }), - -/***/ "./node_modules/lodash/isTypedArray.js": -/***/ (function(module, exports, __webpack_require__) { - -var baseIsTypedArray = __webpack_require__("./node_modules/lodash/_baseIsTypedArray.js"), - baseUnary = __webpack_require__("./node_modules/lodash/_baseUnary.js"), - nodeUtil = __webpack_require__("./node_modules/lodash/_nodeUtil.js"); - -/* Node.js helper references. */ -var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; - -/** - * Checks if `value` is classified as a typed array. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - * @example - * - * _.isTypedArray(new Uint8Array); - * // => true - * - * _.isTypedArray([]); - * // => false - */ -var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; - -module.exports = isTypedArray; - - -/***/ }), - -/***/ "./node_modules/lodash/keys.js": -/***/ (function(module, exports, __webpack_require__) { - -var arrayLikeKeys = __webpack_require__("./node_modules/lodash/_arrayLikeKeys.js"), - baseKeys = __webpack_require__("./node_modules/lodash/_baseKeys.js"), - isArrayLike = __webpack_require__("./node_modules/lodash/isArrayLike.js"); - -/** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) - * - * _.keys('hi'); - * // => ['0', '1'] - */ -function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); -} - -module.exports = keys; - - -/***/ }), - -/***/ "./node_modules/lodash/lodash.js": -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(global, module) {var __WEBPACK_AMD_DEFINE_RESULT__;/** - * @license - * Lodash - * Copyright JS Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - */ -;(function() { - - /** Used as a safe reference for `undefined` in pre-ES5 environments. */ - var undefined; - - /** Used as the semantic version number. */ - var VERSION = '4.17.10'; - - /** Used as the size to enable large array optimizations. */ - var LARGE_ARRAY_SIZE = 200; - - /** Error message constants. */ - var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.', - FUNC_ERROR_TEXT = 'Expected a function'; - - /** Used to stand-in for `undefined` hash values. */ - var HASH_UNDEFINED = '__lodash_hash_undefined__'; - - /** Used as the maximum memoize cache size. */ - var MAX_MEMOIZE_SIZE = 500; - - /** Used as the internal argument placeholder. */ - var PLACEHOLDER = '__lodash_placeholder__'; - - /** Used to compose bitmasks for cloning. */ - var CLONE_DEEP_FLAG = 1, - CLONE_FLAT_FLAG = 2, - CLONE_SYMBOLS_FLAG = 4; - - /** Used to compose bitmasks for value comparisons. */ - var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - - /** Used to compose bitmasks for function metadata. */ - var WRAP_BIND_FLAG = 1, - WRAP_BIND_KEY_FLAG = 2, - WRAP_CURRY_BOUND_FLAG = 4, - WRAP_CURRY_FLAG = 8, - WRAP_CURRY_RIGHT_FLAG = 16, - WRAP_PARTIAL_FLAG = 32, - WRAP_PARTIAL_RIGHT_FLAG = 64, - WRAP_ARY_FLAG = 128, - WRAP_REARG_FLAG = 256, - WRAP_FLIP_FLAG = 512; - - /** Used as default options for `_.truncate`. */ - var DEFAULT_TRUNC_LENGTH = 30, - DEFAULT_TRUNC_OMISSION = '...'; - - /** Used to detect hot functions by number of calls within a span of milliseconds. */ - var HOT_COUNT = 800, - HOT_SPAN = 16; - - /** Used to indicate the type of lazy iteratees. */ - var LAZY_FILTER_FLAG = 1, - LAZY_MAP_FLAG = 2, - LAZY_WHILE_FLAG = 3; - - /** Used as references for various `Number` constants. */ - var INFINITY = 1 / 0, - MAX_SAFE_INTEGER = 9007199254740991, - MAX_INTEGER = 1.7976931348623157e+308, - NAN = 0 / 0; - - /** Used as references for the maximum length and index of an array. */ - var MAX_ARRAY_LENGTH = 4294967295, - MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, - HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; - - /** Used to associate wrap methods with their bit flags. */ - var wrapFlags = [ - ['ary', WRAP_ARY_FLAG], - ['bind', WRAP_BIND_FLAG], - ['bindKey', WRAP_BIND_KEY_FLAG], - ['curry', WRAP_CURRY_FLAG], - ['curryRight', WRAP_CURRY_RIGHT_FLAG], - ['flip', WRAP_FLIP_FLAG], - ['partial', WRAP_PARTIAL_FLAG], - ['partialRight', WRAP_PARTIAL_RIGHT_FLAG], - ['rearg', WRAP_REARG_FLAG] - ]; - - /** `Object#toString` result references. */ - var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - asyncTag = '[object AsyncFunction]', - boolTag = '[object Boolean]', - dateTag = '[object Date]', - domExcTag = '[object DOMException]', - errorTag = '[object Error]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - mapTag = '[object Map]', - numberTag = '[object Number]', - nullTag = '[object Null]', - objectTag = '[object Object]', - promiseTag = '[object Promise]', - proxyTag = '[object Proxy]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]', - undefinedTag = '[object Undefined]', - weakMapTag = '[object WeakMap]', - weakSetTag = '[object WeakSet]'; - - var arrayBufferTag = '[object ArrayBuffer]', - dataViewTag = '[object DataView]', - float32Tag = '[object Float32Array]', - float64Tag = '[object Float64Array]', - int8Tag = '[object Int8Array]', - int16Tag = '[object Int16Array]', - int32Tag = '[object Int32Array]', - uint8Tag = '[object Uint8Array]', - uint8ClampedTag = '[object Uint8ClampedArray]', - uint16Tag = '[object Uint16Array]', - uint32Tag = '[object Uint32Array]'; - - /** Used to match empty string literals in compiled template source. */ - var reEmptyStringLeading = /\b__p \+= '';/g, - reEmptyStringMiddle = /\b(__p \+=) '' \+/g, - reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; - - /** Used to match HTML entities and HTML characters. */ - var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, - reUnescapedHtml = /[&<>"']/g, - reHasEscapedHtml = RegExp(reEscapedHtml.source), - reHasUnescapedHtml = RegExp(reUnescapedHtml.source); - - /** Used to match template delimiters. */ - var reEscape = /<%-([\s\S]+?)%>/g, - reEvaluate = /<%([\s\S]+?)%>/g, - reInterpolate = /<%=([\s\S]+?)%>/g; - - /** Used to match property names within property paths. */ - var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/, - rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; - - /** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). - */ - var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, - reHasRegExpChar = RegExp(reRegExpChar.source); - - /** Used to match leading and trailing whitespace. */ - var reTrim = /^\s+|\s+$/g, - reTrimStart = /^\s+/, - reTrimEnd = /\s+$/; - - /** Used to match wrap detail comments. */ - var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, - reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, - reSplitDetails = /,? & /; - - /** Used to match words composed of alphanumeric characters. */ - var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; - - /** Used to match backslashes in property paths. */ - var reEscapeChar = /\\(\\)?/g; - - /** - * Used to match - * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). - */ - var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; - - /** Used to match `RegExp` flags from their coerced string values. */ - var reFlags = /\w*$/; - - /** Used to detect bad signed hexadecimal string values. */ - var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; - - /** Used to detect binary string values. */ - var reIsBinary = /^0b[01]+$/i; - - /** Used to detect host constructors (Safari). */ - var reIsHostCtor = /^\[object .+?Constructor\]$/; - - /** Used to detect octal string values. */ - var reIsOctal = /^0o[0-7]+$/i; - - /** Used to detect unsigned integer values. */ - var reIsUint = /^(?:0|[1-9]\d*)$/; - - /** Used to match Latin Unicode letters (excluding mathematical operators). */ - var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; - - /** Used to ensure capturing order of template delimiters. */ - var reNoMatch = /($^)/; - - /** Used to match unescaped characters in compiled string literals. */ - var reUnescapedString = /['\n\r\u2028\u2029\\]/g; - - /** Used to compose unicode character classes. */ - var rsAstralRange = '\\ud800-\\udfff', - rsComboMarksRange = '\\u0300-\\u036f', - reComboHalfMarksRange = '\\ufe20-\\ufe2f', - rsComboSymbolsRange = '\\u20d0-\\u20ff', - rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, - rsDingbatRange = '\\u2700-\\u27bf', - rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', - rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', - rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', - rsPunctuationRange = '\\u2000-\\u206f', - rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000', - rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', - rsVarRange = '\\ufe0e\\ufe0f', - rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; - - /** Used to compose unicode capture groups. */ - var rsApos = "['\u2019]", - rsAstral = '[' + rsAstralRange + ']', - rsBreak = '[' + rsBreakRange + ']', - rsCombo = '[' + rsComboRange + ']', - rsDigits = '\\d+', - rsDingbat = '[' + rsDingbatRange + ']', - rsLower = '[' + rsLowerRange + ']', - rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', - rsFitz = '\\ud83c[\\udffb-\\udfff]', - rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', - rsNonAstral = '[^' + rsAstralRange + ']', - rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', - rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', - rsUpper = '[' + rsUpperRange + ']', - rsZWJ = '\\u200d'; - - /** Used to compose unicode regexes. */ - var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')', - rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')', - rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', - rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', - reOptMod = rsModifier + '?', - rsOptVar = '[' + rsVarRange + ']?', - rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', - rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', - rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', - rsSeq = rsOptVar + reOptMod + rsOptJoin, - rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq, - rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; - - /** Used to match apostrophes. */ - var reApos = RegExp(rsApos, 'g'); - - /** - * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and - * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). - */ - var reComboMark = RegExp(rsCombo, 'g'); - - /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ - var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); - - /** Used to match complex or compound words. */ - var reUnicodeWord = RegExp([ - rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')', - rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')', - rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower, - rsUpper + '+' + rsOptContrUpper, - rsOrdUpper, - rsOrdLower, - rsDigits, - rsEmoji - ].join('|'), 'g'); - - /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ - var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); - - /** Used to detect strings that need a more robust regexp to match words. */ - var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; - - /** Used to assign default `context` object properties. */ - var contextProps = [ - 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array', - 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object', - 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array', - 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', - '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout' - ]; - - /** Used to make template sourceURLs easier to identify. */ - var templateCounter = -1; - - /** Used to identify `toStringTag` values of typed arrays. */ - var typedArrayTags = {}; - typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = - typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = - typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = - typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = - typedArrayTags[uint32Tag] = true; - typedArrayTags[argsTag] = typedArrayTags[arrayTag] = - typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = - typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = - typedArrayTags[errorTag] = typedArrayTags[funcTag] = - typedArrayTags[mapTag] = typedArrayTags[numberTag] = - typedArrayTags[objectTag] = typedArrayTags[regexpTag] = - typedArrayTags[setTag] = typedArrayTags[stringTag] = - typedArrayTags[weakMapTag] = false; - - /** Used to identify `toStringTag` values supported by `_.clone`. */ - var cloneableTags = {}; - cloneableTags[argsTag] = cloneableTags[arrayTag] = - cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = - cloneableTags[boolTag] = cloneableTags[dateTag] = - cloneableTags[float32Tag] = cloneableTags[float64Tag] = - cloneableTags[int8Tag] = cloneableTags[int16Tag] = - cloneableTags[int32Tag] = cloneableTags[mapTag] = - cloneableTags[numberTag] = cloneableTags[objectTag] = - cloneableTags[regexpTag] = cloneableTags[setTag] = - cloneableTags[stringTag] = cloneableTags[symbolTag] = - cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = - cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; - cloneableTags[errorTag] = cloneableTags[funcTag] = - cloneableTags[weakMapTag] = false; - - /** Used to map Latin Unicode letters to basic Latin letters. */ - var deburredLetters = { - // Latin-1 Supplement block. - '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A', - '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a', - '\xc7': 'C', '\xe7': 'c', - '\xd0': 'D', '\xf0': 'd', - '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E', - '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e', - '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I', - '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i', - '\xd1': 'N', '\xf1': 'n', - '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O', - '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o', - '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U', - '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u', - '\xdd': 'Y', '\xfd': 'y', '\xff': 'y', - '\xc6': 'Ae', '\xe6': 'ae', - '\xde': 'Th', '\xfe': 'th', - '\xdf': 'ss', - // Latin Extended-A block. - '\u0100': 'A', '\u0102': 'A', '\u0104': 'A', - '\u0101': 'a', '\u0103': 'a', '\u0105': 'a', - '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C', - '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c', - '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd', - '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E', - '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e', - '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G', - '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g', - '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h', - '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I', - '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i', - '\u0134': 'J', '\u0135': 'j', - '\u0136': 'K', '\u0137': 'k', '\u0138': 'k', - '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L', - '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l', - '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N', - '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n', - '\u014c': 'O', '\u014e': 'O', '\u0150': 'O', - '\u014d': 'o', '\u014f': 'o', '\u0151': 'o', - '\u0154': 'R', '\u0156': 'R', '\u0158': 'R', - '\u0155': 'r', '\u0157': 'r', '\u0159': 'r', - '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S', - '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's', - '\u0162': 'T', '\u0164': 'T', '\u0166': 'T', - '\u0163': 't', '\u0165': 't', '\u0167': 't', - '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U', - '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u', - '\u0174': 'W', '\u0175': 'w', - '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y', - '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z', - '\u017a': 'z', '\u017c': 'z', '\u017e': 'z', - '\u0132': 'IJ', '\u0133': 'ij', - '\u0152': 'Oe', '\u0153': 'oe', - '\u0149': "'n", '\u017f': 's' - }; - - /** Used to map characters to HTML entities. */ - var htmlEscapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - "'": ''' - }; - - /** Used to map HTML entities to characters. */ - var htmlUnescapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - ''': "'" - }; - - /** Used to escape characters for inclusion in compiled string literals. */ - var stringEscapes = { - '\\': '\\', - "'": "'", - '\n': 'n', - '\r': 'r', - '\u2028': 'u2028', - '\u2029': 'u2029' - }; - - /** Built-in method references without a dependency on `root`. */ - var freeParseFloat = parseFloat, - freeParseInt = parseInt; - - /** Detect free variable `global` from Node.js. */ - var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; - - /** Detect free variable `self`. */ - var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - - /** Used as a reference to the global object. */ - var root = freeGlobal || freeSelf || Function('return this')(); - - /** Detect free variable `exports`. */ - var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; - - /** Detect free variable `module`. */ - var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; - - /** Detect the popular CommonJS extension `module.exports`. */ - var moduleExports = freeModule && freeModule.exports === freeExports; - - /** Detect free variable `process` from Node.js. */ - var freeProcess = moduleExports && freeGlobal.process; - - /** Used to access faster Node.js helpers. */ - var nodeUtil = (function() { - try { - // Use `util.types` for Node.js 10+. - var types = freeModule && freeModule.require && freeModule.require('util').types; - - if (types) { - return types; - } - - // Legacy `process.binding('util')` for Node.js < 10. - return freeProcess && freeProcess.binding && freeProcess.binding('util'); - } catch (e) {} - }()); - - /* Node.js helper references. */ - var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, - nodeIsDate = nodeUtil && nodeUtil.isDate, - nodeIsMap = nodeUtil && nodeUtil.isMap, - nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, - nodeIsSet = nodeUtil && nodeUtil.isSet, - nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; - - /*--------------------------------------------------------------------------*/ - - /** - * A faster alternative to `Function#apply`, this function invokes `func` - * with the `this` binding of `thisArg` and the arguments of `args`. - * - * @private - * @param {Function} func The function to invoke. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} args The arguments to invoke `func` with. - * @returns {*} Returns the result of `func`. - */ - function apply(func, thisArg, args) { - switch (args.length) { - case 0: return func.call(thisArg); - case 1: return func.call(thisArg, args[0]); - case 2: return func.call(thisArg, args[0], args[1]); - case 3: return func.call(thisArg, args[0], args[1], args[2]); - } - return func.apply(thisArg, args); - } - - /** - * A specialized version of `baseAggregator` for arrays. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform keys. - * @param {Object} accumulator The initial aggregated object. - * @returns {Function} Returns `accumulator`. - */ - function arrayAggregator(array, setter, iteratee, accumulator) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - var value = array[index]; - setter(accumulator, value, iteratee(value), array); - } - return accumulator; - } - - /** - * A specialized version of `_.forEach` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. - */ - function arrayEach(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (iteratee(array[index], index, array) === false) { - break; - } - } - return array; - } - - /** - * A specialized version of `_.forEachRight` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. - */ - function arrayEachRight(array, iteratee) { - var length = array == null ? 0 : array.length; - - while (length--) { - if (iteratee(array[length], length, array) === false) { - break; - } - } - return array; - } - - /** - * A specialized version of `_.every` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false`. - */ - function arrayEvery(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (!predicate(array[index], index, array)) { - return false; - } - } - return true; - } - - /** - * A specialized version of `_.filter` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ - function arrayFilter(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (predicate(value, index, array)) { - result[resIndex++] = value; - } - } - return result; - } - - /** - * A specialized version of `_.includes` for arrays without support for - * specifying an index to search from. - * - * @private - * @param {Array} [array] The array to inspect. - * @param {*} target The value to search for. - * @returns {boolean} Returns `true` if `target` is found, else `false`. - */ - function arrayIncludes(array, value) { - var length = array == null ? 0 : array.length; - return !!length && baseIndexOf(array, value, 0) > -1; - } - - /** - * This function is like `arrayIncludes` except that it accepts a comparator. - * - * @private - * @param {Array} [array] The array to inspect. - * @param {*} target The value to search for. - * @param {Function} comparator The comparator invoked per element. - * @returns {boolean} Returns `true` if `target` is found, else `false`. - */ - function arrayIncludesWith(array, value, comparator) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (comparator(value, array[index])) { - return true; - } - } - return false; - } - - /** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ - function arrayMap(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length, - result = Array(length); - - while (++index < length) { - result[index] = iteratee(array[index], index, array); - } - return result; - } - - /** - * Appends the elements of `values` to `array`. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. - */ - function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length; - - while (++index < length) { - array[offset + index] = values[index]; - } - return array; - } - - /** - * A specialized version of `_.reduce` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @param {boolean} [initAccum] Specify using the first element of `array` as - * the initial value. - * @returns {*} Returns the accumulated value. - */ - function arrayReduce(array, iteratee, accumulator, initAccum) { - var index = -1, - length = array == null ? 0 : array.length; - - if (initAccum && length) { - accumulator = array[++index]; - } - while (++index < length) { - accumulator = iteratee(accumulator, array[index], index, array); - } - return accumulator; - } - - /** - * A specialized version of `_.reduceRight` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @param {boolean} [initAccum] Specify using the last element of `array` as - * the initial value. - * @returns {*} Returns the accumulated value. - */ - function arrayReduceRight(array, iteratee, accumulator, initAccum) { - var length = array == null ? 0 : array.length; - if (initAccum && length) { - accumulator = array[--length]; - } - while (length--) { - accumulator = iteratee(accumulator, array[length], length, array); - } - return accumulator; - } - - /** - * A specialized version of `_.some` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ - function arraySome(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (predicate(array[index], index, array)) { - return true; - } - } - return false; - } - - /** - * Gets the size of an ASCII `string`. - * - * @private - * @param {string} string The string inspect. - * @returns {number} Returns the string size. - */ - var asciiSize = baseProperty('length'); - - /** - * Converts an ASCII `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function asciiToArray(string) { - return string.split(''); - } - - /** - * Splits an ASCII `string` into an array of its words. - * - * @private - * @param {string} The string to inspect. - * @returns {Array} Returns the words of `string`. - */ - function asciiWords(string) { - return string.match(reAsciiWord) || []; - } - - /** - * The base implementation of methods like `_.findKey` and `_.findLastKey`, - * without support for iteratee shorthands, which iterates over `collection` - * using `eachFunc`. - * - * @private - * @param {Array|Object} collection The collection to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {Function} eachFunc The function to iterate over `collection`. - * @returns {*} Returns the found element or its key, else `undefined`. - */ - function baseFindKey(collection, predicate, eachFunc) { - var result; - eachFunc(collection, function(value, key, collection) { - if (predicate(value, key, collection)) { - result = key; - return false; - } - }); - return result; - } - - /** - * The base implementation of `_.findIndex` and `_.findLastIndex` without - * support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {number} fromIndex The index to search from. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseFindIndex(array, predicate, fromIndex, fromRight) { - var length = array.length, - index = fromIndex + (fromRight ? 1 : -1); - - while ((fromRight ? index-- : ++index < length)) { - if (predicate(array[index], index, array)) { - return index; - } - } - return -1; - } - - /** - * The base implementation of `_.indexOf` without `fromIndex` bounds checks. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseIndexOf(array, value, fromIndex) { - return value === value - ? strictIndexOf(array, value, fromIndex) - : baseFindIndex(array, baseIsNaN, fromIndex); - } - - /** - * This function is like `baseIndexOf` except that it accepts a comparator. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @param {Function} comparator The comparator invoked per element. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseIndexOfWith(array, value, fromIndex, comparator) { - var index = fromIndex - 1, - length = array.length; - - while (++index < length) { - if (comparator(array[index], value)) { - return index; - } - } - return -1; - } - - /** - * The base implementation of `_.isNaN` without support for number objects. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. - */ - function baseIsNaN(value) { - return value !== value; - } - - /** - * The base implementation of `_.mean` and `_.meanBy` without support for - * iteratee shorthands. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {number} Returns the mean. - */ - function baseMean(array, iteratee) { - var length = array == null ? 0 : array.length; - return length ? (baseSum(array, iteratee) / length) : NAN; - } - - /** - * The base implementation of `_.property` without support for deep paths. - * - * @private - * @param {string} key The key of the property to get. - * @returns {Function} Returns the new accessor function. - */ - function baseProperty(key) { - return function(object) { - return object == null ? undefined : object[key]; - }; - } - - /** - * The base implementation of `_.propertyOf` without support for deep paths. - * - * @private - * @param {Object} object The object to query. - * @returns {Function} Returns the new accessor function. - */ - function basePropertyOf(object) { - return function(key) { - return object == null ? undefined : object[key]; - }; - } - - /** - * The base implementation of `_.reduce` and `_.reduceRight`, without support - * for iteratee shorthands, which iterates over `collection` using `eachFunc`. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} accumulator The initial value. - * @param {boolean} initAccum Specify using the first or last element of - * `collection` as the initial value. - * @param {Function} eachFunc The function to iterate over `collection`. - * @returns {*} Returns the accumulated value. - */ - function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { - eachFunc(collection, function(value, index, collection) { - accumulator = initAccum - ? (initAccum = false, value) - : iteratee(accumulator, value, index, collection); - }); - return accumulator; - } - - /** - * The base implementation of `_.sortBy` which uses `comparer` to define the - * sort order of `array` and replaces criteria objects with their corresponding - * values. - * - * @private - * @param {Array} array The array to sort. - * @param {Function} comparer The function to define sort order. - * @returns {Array} Returns `array`. - */ - function baseSortBy(array, comparer) { - var length = array.length; - - array.sort(comparer); - while (length--) { - array[length] = array[length].value; - } - return array; - } - - /** - * The base implementation of `_.sum` and `_.sumBy` without support for - * iteratee shorthands. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {number} Returns the sum. - */ - function baseSum(array, iteratee) { - var result, - index = -1, - length = array.length; - - while (++index < length) { - var current = iteratee(array[index]); - if (current !== undefined) { - result = result === undefined ? current : (result + current); - } - } - return result; - } - - /** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. - * - * @private - * @param {number} n The number of times to invoke `iteratee`. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. - */ - function baseTimes(n, iteratee) { - var index = -1, - result = Array(n); - - while (++index < n) { - result[index] = iteratee(index); - } - return result; - } - - /** - * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array - * of key-value pairs for `object` corresponding to the property names of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the key-value pairs. - */ - function baseToPairs(object, props) { - return arrayMap(props, function(key) { - return [key, object[key]]; - }); - } - - /** - * The base implementation of `_.unary` without support for storing metadata. - * - * @private - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - */ - function baseUnary(func) { - return function(value) { - return func(value); - }; - } - - /** - * The base implementation of `_.values` and `_.valuesIn` which creates an - * array of `object` property values corresponding to the property names - * of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the array of property values. - */ - function baseValues(object, props) { - return arrayMap(props, function(key) { - return object[key]; - }); - } - - /** - * Checks if a `cache` value for `key` exists. - * - * @private - * @param {Object} cache The cache to query. - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function cacheHas(cache, key) { - return cache.has(key); - } - - /** - * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol - * that is not found in the character symbols. - * - * @private - * @param {Array} strSymbols The string symbols to inspect. - * @param {Array} chrSymbols The character symbols to find. - * @returns {number} Returns the index of the first unmatched string symbol. - */ - function charsStartIndex(strSymbols, chrSymbols) { - var index = -1, - length = strSymbols.length; - - while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} - return index; - } - - /** - * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol - * that is not found in the character symbols. - * - * @private - * @param {Array} strSymbols The string symbols to inspect. - * @param {Array} chrSymbols The character symbols to find. - * @returns {number} Returns the index of the last unmatched string symbol. - */ - function charsEndIndex(strSymbols, chrSymbols) { - var index = strSymbols.length; - - while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} - return index; - } - - /** - * Gets the number of `placeholder` occurrences in `array`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} placeholder The placeholder to search for. - * @returns {number} Returns the placeholder count. - */ - function countHolders(array, placeholder) { - var length = array.length, - result = 0; - - while (length--) { - if (array[length] === placeholder) { - ++result; - } - } - return result; - } - - /** - * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A - * letters to basic Latin letters. - * - * @private - * @param {string} letter The matched letter to deburr. - * @returns {string} Returns the deburred letter. - */ - var deburrLetter = basePropertyOf(deburredLetters); - - /** - * Used by `_.escape` to convert characters to HTML entities. - * - * @private - * @param {string} chr The matched character to escape. - * @returns {string} Returns the escaped character. - */ - var escapeHtmlChar = basePropertyOf(htmlEscapes); - - /** - * Used by `_.template` to escape characters for inclusion in compiled string literals. - * - * @private - * @param {string} chr The matched character to escape. - * @returns {string} Returns the escaped character. - */ - function escapeStringChar(chr) { - return '\\' + stringEscapes[chr]; - } - - /** - * Gets the value at `key` of `object`. - * - * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ - function getValue(object, key) { - return object == null ? undefined : object[key]; - } - - /** - * Checks if `string` contains Unicode symbols. - * - * @private - * @param {string} string The string to inspect. - * @returns {boolean} Returns `true` if a symbol is found, else `false`. - */ - function hasUnicode(string) { - return reHasUnicode.test(string); - } - - /** - * Checks if `string` contains a word composed of Unicode symbols. - * - * @private - * @param {string} string The string to inspect. - * @returns {boolean} Returns `true` if a word is found, else `false`. - */ - function hasUnicodeWord(string) { - return reHasUnicodeWord.test(string); - } - - /** - * Converts `iterator` to an array. - * - * @private - * @param {Object} iterator The iterator to convert. - * @returns {Array} Returns the converted array. - */ - function iteratorToArray(iterator) { - var data, - result = []; - - while (!(data = iterator.next()).done) { - result.push(data.value); - } - return result; - } - - /** - * Converts `map` to its key-value pairs. - * - * @private - * @param {Object} map The map to convert. - * @returns {Array} Returns the key-value pairs. - */ - function mapToArray(map) { - var index = -1, - result = Array(map.size); - - map.forEach(function(value, key) { - result[++index] = [key, value]; - }); - return result; - } - - /** - * Creates a unary function that invokes `func` with its argument transformed. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. - */ - function overArg(func, transform) { - return function(arg) { - return func(transform(arg)); - }; - } - - /** - * Replaces all `placeholder` elements in `array` with an internal placeholder - * and returns an array of their indexes. - * - * @private - * @param {Array} array The array to modify. - * @param {*} placeholder The placeholder to replace. - * @returns {Array} Returns the new array of placeholder indexes. - */ - function replaceHolders(array, placeholder) { - var index = -1, - length = array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value === placeholder || value === PLACEHOLDER) { - array[index] = PLACEHOLDER; - result[resIndex++] = index; - } - } - return result; - } - - /** - * Gets the value at `key`, unless `key` is "__proto__". - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ - function safeGet(object, key) { - return key == '__proto__' - ? undefined - : object[key]; - } - - /** - * Converts `set` to an array of its values. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the values. - */ - function setToArray(set) { - var index = -1, - result = Array(set.size); - - set.forEach(function(value) { - result[++index] = value; - }); - return result; - } - - /** - * Converts `set` to its value-value pairs. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the value-value pairs. - */ - function setToPairs(set) { - var index = -1, - result = Array(set.size); - - set.forEach(function(value) { - result[++index] = [value, value]; - }); - return result; - } - - /** - * A specialized version of `_.indexOf` which performs strict equality - * comparisons of values, i.e. `===`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function strictIndexOf(array, value, fromIndex) { - var index = fromIndex - 1, - length = array.length; - - while (++index < length) { - if (array[index] === value) { - return index; - } - } - return -1; - } - - /** - * A specialized version of `_.lastIndexOf` which performs strict equality - * comparisons of values, i.e. `===`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function strictLastIndexOf(array, value, fromIndex) { - var index = fromIndex + 1; - while (index--) { - if (array[index] === value) { - return index; - } - } - return index; - } - - /** - * Gets the number of symbols in `string`. - * - * @private - * @param {string} string The string to inspect. - * @returns {number} Returns the string size. - */ - function stringSize(string) { - return hasUnicode(string) - ? unicodeSize(string) - : asciiSize(string); - } - - /** - * Converts `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function stringToArray(string) { - return hasUnicode(string) - ? unicodeToArray(string) - : asciiToArray(string); - } - - /** - * Used by `_.unescape` to convert HTML entities to characters. - * - * @private - * @param {string} chr The matched character to unescape. - * @returns {string} Returns the unescaped character. - */ - var unescapeHtmlChar = basePropertyOf(htmlUnescapes); - - /** - * Gets the size of a Unicode `string`. - * - * @private - * @param {string} string The string inspect. - * @returns {number} Returns the string size. - */ - function unicodeSize(string) { - var result = reUnicode.lastIndex = 0; - while (reUnicode.test(string)) { - ++result; - } - return result; - } - - /** - * Converts a Unicode `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function unicodeToArray(string) { - return string.match(reUnicode) || []; - } - - /** - * Splits a Unicode `string` into an array of its words. - * - * @private - * @param {string} The string to inspect. - * @returns {Array} Returns the words of `string`. - */ - function unicodeWords(string) { - return string.match(reUnicodeWord) || []; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Create a new pristine `lodash` function using the `context` object. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Util - * @param {Object} [context=root] The context object. - * @returns {Function} Returns a new `lodash` function. - * @example - * - * _.mixin({ 'foo': _.constant('foo') }); - * - * var lodash = _.runInContext(); - * lodash.mixin({ 'bar': lodash.constant('bar') }); - * - * _.isFunction(_.foo); - * // => true - * _.isFunction(_.bar); - * // => false - * - * lodash.isFunction(lodash.foo); - * // => false - * lodash.isFunction(lodash.bar); - * // => true - * - * // Create a suped-up `defer` in Node.js. - * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; - */ - var runInContext = (function runInContext(context) { - context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps)); - - /** Built-in constructor references. */ - var Array = context.Array, - Date = context.Date, - Error = context.Error, - Function = context.Function, - Math = context.Math, - Object = context.Object, - RegExp = context.RegExp, - String = context.String, - TypeError = context.TypeError; - - /** Used for built-in method references. */ - var arrayProto = Array.prototype, - funcProto = Function.prototype, - objectProto = Object.prototype; - - /** Used to detect overreaching core-js shims. */ - var coreJsData = context['__core-js_shared__']; - - /** Used to resolve the decompiled source of functions. */ - var funcToString = funcProto.toString; - - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; - - /** Used to generate unique IDs. */ - var idCounter = 0; - - /** Used to detect methods masquerading as native. */ - var maskSrcKey = (function() { - var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); - return uid ? ('Symbol(src)_1.' + uid) : ''; - }()); - - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ - var nativeObjectToString = objectProto.toString; - - /** Used to infer the `Object` constructor. */ - var objectCtorString = funcToString.call(Object); - - /** Used to restore the original `_` reference in `_.noConflict`. */ - var oldDash = root._; - - /** Used to detect if a method is native. */ - var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' - ); - - /** Built-in value references. */ - var Buffer = moduleExports ? context.Buffer : undefined, - Symbol = context.Symbol, - Uint8Array = context.Uint8Array, - allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined, - getPrototype = overArg(Object.getPrototypeOf, Object), - objectCreate = Object.create, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - splice = arrayProto.splice, - spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined, - symIterator = Symbol ? Symbol.iterator : undefined, - symToStringTag = Symbol ? Symbol.toStringTag : undefined; - - var defineProperty = (function() { - try { - var func = getNative(Object, 'defineProperty'); - func({}, '', {}); - return func; - } catch (e) {} - }()); - - /** Mocked built-ins. */ - var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, - ctxNow = Date && Date.now !== root.Date.now && Date.now, - ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout; - - /* Built-in method references for those with the same name as other `lodash` methods. */ - var nativeCeil = Math.ceil, - nativeFloor = Math.floor, - nativeGetSymbols = Object.getOwnPropertySymbols, - nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, - nativeIsFinite = context.isFinite, - nativeJoin = arrayProto.join, - nativeKeys = overArg(Object.keys, Object), - nativeMax = Math.max, - nativeMin = Math.min, - nativeNow = Date.now, - nativeParseInt = context.parseInt, - nativeRandom = Math.random, - nativeReverse = arrayProto.reverse; - - /* Built-in method references that are verified to be native. */ - var DataView = getNative(context, 'DataView'), - Map = getNative(context, 'Map'), - Promise = getNative(context, 'Promise'), - Set = getNative(context, 'Set'), - WeakMap = getNative(context, 'WeakMap'), - nativeCreate = getNative(Object, 'create'); - - /** Used to store function metadata. */ - var metaMap = WeakMap && new WeakMap; - - /** Used to lookup unminified function names. */ - var realNames = {}; - - /** Used to detect maps, sets, and weakmaps. */ - var dataViewCtorString = toSource(DataView), - mapCtorString = toSource(Map), - promiseCtorString = toSource(Promise), - setCtorString = toSource(Set), - weakMapCtorString = toSource(WeakMap); - - /** Used to convert symbols to primitives and strings. */ - var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined, - symbolToString = symbolProto ? symbolProto.toString : undefined; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` object which wraps `value` to enable implicit method - * chain sequences. Methods that operate on and return arrays, collections, - * and functions can be chained together. Methods that retrieve a single value - * or may return a primitive value will automatically end the chain sequence - * and return the unwrapped value. Otherwise, the value must be unwrapped - * with `_#value`. - * - * Explicit chain sequences, which must be unwrapped with `_#value`, may be - * enabled using `_.chain`. - * - * The execution of chained methods is lazy, that is, it's deferred until - * `_#value` is implicitly or explicitly called. - * - * Lazy evaluation allows several methods to support shortcut fusion. - * Shortcut fusion is an optimization to merge iteratee calls; this avoids - * the creation of intermediate arrays and can greatly reduce the number of - * iteratee executions. Sections of a chain sequence qualify for shortcut - * fusion if the section is applied to an array and iteratees accept only - * one argument. The heuristic for whether a section qualifies for shortcut - * fusion is subject to change. - * - * Chaining is supported in custom builds as long as the `_#value` method is - * directly or indirectly included in the build. - * - * In addition to lodash methods, wrappers have `Array` and `String` methods. - * - * The wrapper `Array` methods are: - * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` - * - * The wrapper `String` methods are: - * `replace` and `split` - * - * The wrapper methods that support shortcut fusion are: - * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, - * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, - * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` - * - * The chainable wrapper methods are: - * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, - * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, - * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, - * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, - * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, - * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, - * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, - * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, - * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, - * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, - * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, - * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, - * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, - * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, - * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, - * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, - * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, - * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, - * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, - * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, - * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, - * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, - * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, - * `zipObject`, `zipObjectDeep`, and `zipWith` - * - * The wrapper methods that are **not** chainable by default are: - * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, - * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, - * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, - * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, - * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, - * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, - * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, - * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, - * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, - * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, - * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, - * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, - * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, - * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, - * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, - * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, - * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, - * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, - * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, - * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, - * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, - * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, - * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, - * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, - * `upperFirst`, `value`, and `words` - * - * @name _ - * @constructor - * @category Seq - * @param {*} value The value to wrap in a `lodash` instance. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * function square(n) { - * return n * n; - * } - * - * var wrapped = _([1, 2, 3]); - * - * // Returns an unwrapped value. - * wrapped.reduce(_.add); - * // => 6 - * - * // Returns a wrapped value. - * var squares = wrapped.map(square); - * - * _.isArray(squares); - * // => false - * - * _.isArray(squares.value()); - * // => true - */ - function lodash(value) { - if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { - if (value instanceof LodashWrapper) { - return value; - } - if (hasOwnProperty.call(value, '__wrapped__')) { - return wrapperClone(value); - } - } - return new LodashWrapper(value); - } - - /** - * The base implementation of `_.create` without support for assigning - * properties to the created object. - * - * @private - * @param {Object} proto The object to inherit from. - * @returns {Object} Returns the new object. - */ - var baseCreate = (function() { - function object() {} - return function(proto) { - if (!isObject(proto)) { - return {}; - } - if (objectCreate) { - return objectCreate(proto); - } - object.prototype = proto; - var result = new object; - object.prototype = undefined; - return result; - }; - }()); - - /** - * The function whose prototype chain sequence wrappers inherit from. - * - * @private - */ - function baseLodash() { - // No operation performed. - } - - /** - * The base constructor for creating `lodash` wrapper objects. - * - * @private - * @param {*} value The value to wrap. - * @param {boolean} [chainAll] Enable explicit method chain sequences. - */ - function LodashWrapper(value, chainAll) { - this.__wrapped__ = value; - this.__actions__ = []; - this.__chain__ = !!chainAll; - this.__index__ = 0; - this.__values__ = undefined; - } - - /** - * By default, the template delimiters used by lodash are like those in - * embedded Ruby (ERB) as well as ES2015 template strings. Change the - * following template settings to use alternative delimiters. - * - * @static - * @memberOf _ - * @type {Object} - */ - lodash.templateSettings = { - - /** - * Used to detect `data` property values to be HTML-escaped. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - 'escape': reEscape, - - /** - * Used to detect code to be evaluated. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - 'evaluate': reEvaluate, - - /** - * Used to detect `data` property values to inject. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - 'interpolate': reInterpolate, - - /** - * Used to reference the data object in the template text. - * - * @memberOf _.templateSettings - * @type {string} - */ - 'variable': '', - - /** - * Used to import variables into the compiled template. - * - * @memberOf _.templateSettings - * @type {Object} - */ - 'imports': { - - /** - * A reference to the `lodash` function. - * - * @memberOf _.templateSettings.imports - * @type {Function} - */ - '_': lodash - } - }; - - // Ensure wrappers are instances of `baseLodash`. - lodash.prototype = baseLodash.prototype; - lodash.prototype.constructor = lodash; - - LodashWrapper.prototype = baseCreate(baseLodash.prototype); - LodashWrapper.prototype.constructor = LodashWrapper; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. - * - * @private - * @constructor - * @param {*} value The value to wrap. - */ - function LazyWrapper(value) { - this.__wrapped__ = value; - this.__actions__ = []; - this.__dir__ = 1; - this.__filtered__ = false; - this.__iteratees__ = []; - this.__takeCount__ = MAX_ARRAY_LENGTH; - this.__views__ = []; - } - - /** - * Creates a clone of the lazy wrapper object. - * - * @private - * @name clone - * @memberOf LazyWrapper - * @returns {Object} Returns the cloned `LazyWrapper` object. - */ - function lazyClone() { - var result = new LazyWrapper(this.__wrapped__); - result.__actions__ = copyArray(this.__actions__); - result.__dir__ = this.__dir__; - result.__filtered__ = this.__filtered__; - result.__iteratees__ = copyArray(this.__iteratees__); - result.__takeCount__ = this.__takeCount__; - result.__views__ = copyArray(this.__views__); - return result; - } - - /** - * Reverses the direction of lazy iteration. - * - * @private - * @name reverse - * @memberOf LazyWrapper - * @returns {Object} Returns the new reversed `LazyWrapper` object. - */ - function lazyReverse() { - if (this.__filtered__) { - var result = new LazyWrapper(this); - result.__dir__ = -1; - result.__filtered__ = true; - } else { - result = this.clone(); - result.__dir__ *= -1; - } - return result; - } - - /** - * Extracts the unwrapped value from its lazy wrapper. - * - * @private - * @name value - * @memberOf LazyWrapper - * @returns {*} Returns the unwrapped value. - */ - function lazyValue() { - var array = this.__wrapped__.value(), - dir = this.__dir__, - isArr = isArray(array), - isRight = dir < 0, - arrLength = isArr ? array.length : 0, - view = getView(0, arrLength, this.__views__), - start = view.start, - end = view.end, - length = end - start, - index = isRight ? end : (start - 1), - iteratees = this.__iteratees__, - iterLength = iteratees.length, - resIndex = 0, - takeCount = nativeMin(length, this.__takeCount__); - - if (!isArr || (!isRight && arrLength == length && takeCount == length)) { - return baseWrapperValue(array, this.__actions__); - } - var result = []; - - outer: - while (length-- && resIndex < takeCount) { - index += dir; - - var iterIndex = -1, - value = array[index]; - - while (++iterIndex < iterLength) { - var data = iteratees[iterIndex], - iteratee = data.iteratee, - type = data.type, - computed = iteratee(value); - - if (type == LAZY_MAP_FLAG) { - value = computed; - } else if (!computed) { - if (type == LAZY_FILTER_FLAG) { - continue outer; - } else { - break outer; - } - } - } - result[resIndex++] = value; - } - return result; - } - - // Ensure `LazyWrapper` is an instance of `baseLodash`. - LazyWrapper.prototype = baseCreate(baseLodash.prototype); - LazyWrapper.prototype.constructor = LazyWrapper; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function Hash(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } - - /** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ - function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; - this.size = 0; - } - - /** - * Removes `key` and its value from the hash. - * - * @private - * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function hashDelete(key) { - var result = this.has(key) && delete this.__data__[key]; - this.size -= result ? 1 : 0; - return result; - } - - /** - * Gets the hash value for `key`. - * - * @private - * @name get - * @memberOf Hash - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function hashGet(key) { - var data = this.__data__; - if (nativeCreate) { - var result = data[key]; - return result === HASH_UNDEFINED ? undefined : result; - } - return hasOwnProperty.call(data, key) ? data[key] : undefined; - } - - /** - * Checks if a hash value for `key` exists. - * - * @private - * @name has - * @memberOf Hash - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function hashHas(key) { - var data = this.__data__; - return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); - } - - /** - * Sets the hash `key` to `value`. - * - * @private - * @name set - * @memberOf Hash - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. - */ - function hashSet(key, value) { - var data = this.__data__; - this.size += this.has(key) ? 0 : 1; - data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; - return this; - } - - // Add methods to `Hash`. - Hash.prototype.clear = hashClear; - Hash.prototype['delete'] = hashDelete; - Hash.prototype.get = hashGet; - Hash.prototype.has = hashHas; - Hash.prototype.set = hashSet; - - /*------------------------------------------------------------------------*/ - - /** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function ListCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } - - /** - * Removes all key-value entries from the list cache. - * - * @private - * @name clear - * @memberOf ListCache - */ - function listCacheClear() { - this.__data__ = []; - this.size = 0; - } - - /** - * Removes `key` and its value from the list cache. - * - * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - return false; - } - var lastIndex = data.length - 1; - if (index == lastIndex) { - data.pop(); - } else { - splice.call(data, index, 1); - } - --this.size; - return true; - } - - /** - * Gets the list cache value for `key`. - * - * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - return index < 0 ? undefined : data[index][1]; - } - - /** - * Checks if a list cache value for `key` exists. - * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1; - } - - /** - * Sets the list cache `key` to `value`. - * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. - */ - function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - ++this.size; - data.push([key, value]); - } else { - data[index][1] = value; - } - return this; - } - - // Add methods to `ListCache`. - ListCache.prototype.clear = listCacheClear; - ListCache.prototype['delete'] = listCacheDelete; - ListCache.prototype.get = listCacheGet; - ListCache.prototype.has = listCacheHas; - ListCache.prototype.set = listCacheSet; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function MapCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } - - /** - * Removes all key-value entries from the map. - * - * @private - * @name clear - * @memberOf MapCache - */ - function mapCacheClear() { - this.size = 0; - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; - } - - /** - * Removes `key` and its value from the map. - * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function mapCacheDelete(key) { - var result = getMapData(this, key)['delete'](key); - this.size -= result ? 1 : 0; - return result; - } - - /** - * Gets the map value for `key`. - * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function mapCacheGet(key) { - return getMapData(this, key).get(key); - } - - /** - * Checks if a map value for `key` exists. - * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function mapCacheHas(key) { - return getMapData(this, key).has(key); - } - - /** - * Sets the map `key` to `value`. - * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. - */ - function mapCacheSet(key, value) { - var data = getMapData(this, key), - size = data.size; - - data.set(key, value); - this.size += data.size == size ? 0 : 1; - return this; - } - - // Add methods to `MapCache`. - MapCache.prototype.clear = mapCacheClear; - MapCache.prototype['delete'] = mapCacheDelete; - MapCache.prototype.get = mapCacheGet; - MapCache.prototype.has = mapCacheHas; - MapCache.prototype.set = mapCacheSet; - - /*------------------------------------------------------------------------*/ - - /** - * - * Creates an array cache object to store unique values. - * - * @private - * @constructor - * @param {Array} [values] The values to cache. - */ - function SetCache(values) { - var index = -1, - length = values == null ? 0 : values.length; - - this.__data__ = new MapCache; - while (++index < length) { - this.add(values[index]); - } - } - - /** - * Adds `value` to the array cache. - * - * @private - * @name add - * @memberOf SetCache - * @alias push - * @param {*} value The value to cache. - * @returns {Object} Returns the cache instance. - */ - function setCacheAdd(value) { - this.__data__.set(value, HASH_UNDEFINED); - return this; - } - - /** - * Checks if `value` is in the array cache. - * - * @private - * @name has - * @memberOf SetCache - * @param {*} value The value to search for. - * @returns {number} Returns `true` if `value` is found, else `false`. - */ - function setCacheHas(value) { - return this.__data__.has(value); - } - - // Add methods to `SetCache`. - SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; - SetCache.prototype.has = setCacheHas; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a stack cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function Stack(entries) { - var data = this.__data__ = new ListCache(entries); - this.size = data.size; - } - - /** - * Removes all key-value entries from the stack. - * - * @private - * @name clear - * @memberOf Stack - */ - function stackClear() { - this.__data__ = new ListCache; - this.size = 0; - } - - /** - * Removes `key` and its value from the stack. - * - * @private - * @name delete - * @memberOf Stack - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function stackDelete(key) { - var data = this.__data__, - result = data['delete'](key); - - this.size = data.size; - return result; - } - - /** - * Gets the stack value for `key`. - * - * @private - * @name get - * @memberOf Stack - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function stackGet(key) { - return this.__data__.get(key); - } - - /** - * Checks if a stack value for `key` exists. - * - * @private - * @name has - * @memberOf Stack - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function stackHas(key) { - return this.__data__.has(key); - } - - /** - * Sets the stack `key` to `value`. - * - * @private - * @name set - * @memberOf Stack - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the stack cache instance. - */ - function stackSet(key, value) { - var data = this.__data__; - if (data instanceof ListCache) { - var pairs = data.__data__; - if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { - pairs.push([key, value]); - this.size = ++data.size; - return this; - } - data = this.__data__ = new MapCache(pairs); - } - data.set(key, value); - this.size = data.size; - return this; - } - - // Add methods to `Stack`. - Stack.prototype.clear = stackClear; - Stack.prototype['delete'] = stackDelete; - Stack.prototype.get = stackGet; - Stack.prototype.has = stackHas; - Stack.prototype.set = stackSet; - - /*------------------------------------------------------------------------*/ - - /** - * Creates an array of the enumerable property names of the array-like `value`. - * - * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. - */ - function arrayLikeKeys(value, inherited) { - var isArr = isArray(value), - isArg = !isArr && isArguments(value), - isBuff = !isArr && !isArg && isBuffer(value), - isType = !isArr && !isArg && !isBuff && isTypedArray(value), - skipIndexes = isArr || isArg || isBuff || isType, - result = skipIndexes ? baseTimes(value.length, String) : [], - length = result.length; - - for (var key in value) { - if ((inherited || hasOwnProperty.call(value, key)) && - !(skipIndexes && ( - // Safari 9 has enumerable `arguments.length` in strict mode. - key == 'length' || - // Node.js 0.10 has enumerable non-index properties on buffers. - (isBuff && (key == 'offset' || key == 'parent')) || - // PhantomJS 2 has enumerable non-index properties on typed arrays. - (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || - // Skip index properties. - isIndex(key, length) - ))) { - result.push(key); - } - } - return result; - } - - /** - * A specialized version of `_.sample` for arrays. - * - * @private - * @param {Array} array The array to sample. - * @returns {*} Returns the random element. - */ - function arraySample(array) { - var length = array.length; - return length ? array[baseRandom(0, length - 1)] : undefined; - } - - /** - * A specialized version of `_.sampleSize` for arrays. - * - * @private - * @param {Array} array The array to sample. - * @param {number} n The number of elements to sample. - * @returns {Array} Returns the random elements. - */ - function arraySampleSize(array, n) { - return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); - } - - /** - * A specialized version of `_.shuffle` for arrays. - * - * @private - * @param {Array} array The array to shuffle. - * @returns {Array} Returns the new shuffled array. - */ - function arrayShuffle(array) { - return shuffleSelf(copyArray(array)); - } - - /** - * This function is like `assignValue` except that it doesn't assign - * `undefined` values. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function assignMergeValue(object, key, value) { - if ((value !== undefined && !eq(object[key], value)) || - (value === undefined && !(key in object))) { - baseAssignValue(object, key, value); - } - } - - /** - * Assigns `value` to `key` of `object` if the existing value is not equivalent - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function assignValue(object, key, value) { - var objValue = object[key]; - if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || - (value === undefined && !(key in object))) { - baseAssignValue(object, key, value); - } - } - - /** - * Gets the index at which the `key` is found in `array` of key-value pairs. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function assocIndexOf(array, key) { - var length = array.length; - while (length--) { - if (eq(array[length][0], key)) { - return length; - } - } - return -1; - } - - /** - * Aggregates elements of `collection` on `accumulator` with keys transformed - * by `iteratee` and values set by `setter`. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform keys. - * @param {Object} accumulator The initial aggregated object. - * @returns {Function} Returns `accumulator`. - */ - function baseAggregator(collection, setter, iteratee, accumulator) { - baseEach(collection, function(value, key, collection) { - setter(accumulator, value, iteratee(value), collection); - }); - return accumulator; - } - - /** - * The base implementation of `_.assign` without support for multiple sources - * or `customizer` functions. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. - */ - function baseAssign(object, source) { - return object && copyObject(source, keys(source), object); - } - - /** - * The base implementation of `_.assignIn` without support for multiple sources - * or `customizer` functions. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. - */ - function baseAssignIn(object, source) { - return object && copyObject(source, keysIn(source), object); - } - - /** - * The base implementation of `assignValue` and `assignMergeValue` without - * value checks. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function baseAssignValue(object, key, value) { - if (key == '__proto__' && defineProperty) { - defineProperty(object, key, { - 'configurable': true, - 'enumerable': true, - 'value': value, - 'writable': true - }); - } else { - object[key] = value; - } - } - - /** - * The base implementation of `_.at` without support for individual paths. - * - * @private - * @param {Object} object The object to iterate over. - * @param {string[]} paths The property paths to pick. - * @returns {Array} Returns the picked elements. - */ - function baseAt(object, paths) { - var index = -1, - length = paths.length, - result = Array(length), - skip = object == null; - - while (++index < length) { - result[index] = skip ? undefined : get(object, paths[index]); - } - return result; - } - - /** - * The base implementation of `_.clamp` which doesn't coerce arguments. - * - * @private - * @param {number} number The number to clamp. - * @param {number} [lower] The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the clamped number. - */ - function baseClamp(number, lower, upper) { - if (number === number) { - if (upper !== undefined) { - number = number <= upper ? number : upper; - } - if (lower !== undefined) { - number = number >= lower ? number : lower; - } - } - return number; - } - - /** - * The base implementation of `_.clone` and `_.cloneDeep` which tracks - * traversed objects. - * - * @private - * @param {*} value The value to clone. - * @param {boolean} bitmask The bitmask flags. - * 1 - Deep clone - * 2 - Flatten inherited properties - * 4 - Clone symbols - * @param {Function} [customizer] The function to customize cloning. - * @param {string} [key] The key of `value`. - * @param {Object} [object] The parent object of `value`. - * @param {Object} [stack] Tracks traversed objects and their clone counterparts. - * @returns {*} Returns the cloned value. - */ - function baseClone(value, bitmask, customizer, key, object, stack) { - var result, - isDeep = bitmask & CLONE_DEEP_FLAG, - isFlat = bitmask & CLONE_FLAT_FLAG, - isFull = bitmask & CLONE_SYMBOLS_FLAG; - - if (customizer) { - result = object ? customizer(value, key, object, stack) : customizer(value); - } - if (result !== undefined) { - return result; - } - if (!isObject(value)) { - return value; - } - var isArr = isArray(value); - if (isArr) { - result = initCloneArray(value); - if (!isDeep) { - return copyArray(value, result); - } - } else { - var tag = getTag(value), - isFunc = tag == funcTag || tag == genTag; - - if (isBuffer(value)) { - return cloneBuffer(value, isDeep); - } - if (tag == objectTag || tag == argsTag || (isFunc && !object)) { - result = (isFlat || isFunc) ? {} : initCloneObject(value); - if (!isDeep) { - return isFlat - ? copySymbolsIn(value, baseAssignIn(result, value)) - : copySymbols(value, baseAssign(result, value)); - } - } else { - if (!cloneableTags[tag]) { - return object ? value : {}; - } - result = initCloneByTag(value, tag, isDeep); - } - } - // Check for circular references and return its corresponding clone. - stack || (stack = new Stack); - var stacked = stack.get(value); - if (stacked) { - return stacked; - } - stack.set(value, result); - - if (isSet(value)) { - value.forEach(function(subValue) { - result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); - }); - - return result; - } - - if (isMap(value)) { - value.forEach(function(subValue, key) { - result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); - }); - - return result; - } - - var keysFunc = isFull - ? (isFlat ? getAllKeysIn : getAllKeys) - : (isFlat ? keysIn : keys); - - var props = isArr ? undefined : keysFunc(value); - arrayEach(props || value, function(subValue, key) { - if (props) { - key = subValue; - subValue = value[key]; - } - // Recursively populate clone (susceptible to call stack limits). - assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); - }); - return result; - } - - /** - * The base implementation of `_.conforms` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property predicates to conform to. - * @returns {Function} Returns the new spec function. - */ - function baseConforms(source) { - var props = keys(source); - return function(object) { - return baseConformsTo(object, source, props); - }; - } - - /** - * The base implementation of `_.conformsTo` which accepts `props` to check. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property predicates to conform to. - * @returns {boolean} Returns `true` if `object` conforms, else `false`. - */ - function baseConformsTo(object, source, props) { - var length = props.length; - if (object == null) { - return !length; - } - object = Object(object); - while (length--) { - var key = props[length], - predicate = source[key], - value = object[key]; - - if ((value === undefined && !(key in object)) || !predicate(value)) { - return false; - } - } - return true; - } - - /** - * The base implementation of `_.delay` and `_.defer` which accepts `args` - * to provide to `func`. - * - * @private - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @param {Array} args The arguments to provide to `func`. - * @returns {number|Object} Returns the timer id or timeout object. - */ - function baseDelay(func, wait, args) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - return setTimeout(function() { func.apply(undefined, args); }, wait); - } - - /** - * The base implementation of methods like `_.difference` without support - * for excluding multiple arrays or iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Array} values The values to exclude. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - */ - function baseDifference(array, values, iteratee, comparator) { - var index = -1, - includes = arrayIncludes, - isCommon = true, - length = array.length, - result = [], - valuesLength = values.length; - - if (!length) { - return result; - } - if (iteratee) { - values = arrayMap(values, baseUnary(iteratee)); - } - if (comparator) { - includes = arrayIncludesWith; - isCommon = false; - } - else if (values.length >= LARGE_ARRAY_SIZE) { - includes = cacheHas; - isCommon = false; - values = new SetCache(values); - } - outer: - while (++index < length) { - var value = array[index], - computed = iteratee == null ? value : iteratee(value); - - value = (comparator || value !== 0) ? value : 0; - if (isCommon && computed === computed) { - var valuesIndex = valuesLength; - while (valuesIndex--) { - if (values[valuesIndex] === computed) { - continue outer; - } - } - result.push(value); - } - else if (!includes(values, computed, comparator)) { - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.forEach` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ - var baseEach = createBaseEach(baseForOwn); - - /** - * The base implementation of `_.forEachRight` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ - var baseEachRight = createBaseEach(baseForOwnRight, true); - - /** - * The base implementation of `_.every` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false` - */ - function baseEvery(collection, predicate) { - var result = true; - baseEach(collection, function(value, index, collection) { - result = !!predicate(value, index, collection); - return result; - }); - return result; - } - - /** - * The base implementation of methods like `_.max` and `_.min` which accepts a - * `comparator` to determine the extremum value. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The iteratee invoked per iteration. - * @param {Function} comparator The comparator used to compare values. - * @returns {*} Returns the extremum value. - */ - function baseExtremum(array, iteratee, comparator) { - var index = -1, - length = array.length; - - while (++index < length) { - var value = array[index], - current = iteratee(value); - - if (current != null && (computed === undefined - ? (current === current && !isSymbol(current)) - : comparator(current, computed) - )) { - var computed = current, - result = value; - } - } - return result; - } - - /** - * The base implementation of `_.fill` without an iteratee call guard. - * - * @private - * @param {Array} array The array to fill. - * @param {*} value The value to fill `array` with. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns `array`. - */ - function baseFill(array, value, start, end) { - var length = array.length; - - start = toInteger(start); - if (start < 0) { - start = -start > length ? 0 : (length + start); - } - end = (end === undefined || end > length) ? length : toInteger(end); - if (end < 0) { - end += length; - } - end = start > end ? 0 : toLength(end); - while (start < end) { - array[start++] = value; - } - return array; - } - - /** - * The base implementation of `_.filter` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ - function baseFilter(collection, predicate) { - var result = []; - baseEach(collection, function(value, index, collection) { - if (predicate(value, index, collection)) { - result.push(value); - } - }); - return result; - } - - /** - * The base implementation of `_.flatten` with support for restricting flattening. - * - * @private - * @param {Array} array The array to flatten. - * @param {number} depth The maximum recursion depth. - * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. - * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. - * @param {Array} [result=[]] The initial result value. - * @returns {Array} Returns the new flattened array. - */ - function baseFlatten(array, depth, predicate, isStrict, result) { - var index = -1, - length = array.length; - - predicate || (predicate = isFlattenable); - result || (result = []); - - while (++index < length) { - var value = array[index]; - if (depth > 0 && predicate(value)) { - if (depth > 1) { - // Recursively flatten arrays (susceptible to call stack limits). - baseFlatten(value, depth - 1, predicate, isStrict, result); - } else { - arrayPush(result, value); - } - } else if (!isStrict) { - result[result.length] = value; - } - } - return result; - } - - /** - * The base implementation of `baseForOwn` which iterates over `object` - * properties returned by `keysFunc` and invokes `iteratee` for each property. - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ - var baseFor = createBaseFor(); - - /** - * This function is like `baseFor` except that it iterates over properties - * in the opposite order. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ - var baseForRight = createBaseFor(true); - - /** - * The base implementation of `_.forOwn` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ - function baseForOwn(object, iteratee) { - return object && baseFor(object, iteratee, keys); - } - - /** - * The base implementation of `_.forOwnRight` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ - function baseForOwnRight(object, iteratee) { - return object && baseForRight(object, iteratee, keys); - } - - /** - * The base implementation of `_.functions` which creates an array of - * `object` function property names filtered from `props`. - * - * @private - * @param {Object} object The object to inspect. - * @param {Array} props The property names to filter. - * @returns {Array} Returns the function names. - */ - function baseFunctions(object, props) { - return arrayFilter(props, function(key) { - return isFunction(object[key]); - }); - } - - /** - * The base implementation of `_.get` without support for default values. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. - */ - function baseGet(object, path) { - path = castPath(path, object); - - var index = 0, - length = path.length; - - while (object != null && index < length) { - object = object[toKey(path[index++])]; - } - return (index && index == length) ? object : undefined; - } - - /** - * The base implementation of `getAllKeys` and `getAllKeysIn` which uses - * `keysFunc` and `symbolsFunc` to get the enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Function} keysFunc The function to get the keys of `object`. - * @param {Function} symbolsFunc The function to get the symbols of `object`. - * @returns {Array} Returns the array of property names and symbols. - */ - function baseGetAllKeys(object, keysFunc, symbolsFunc) { - var result = keysFunc(object); - return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); - } - - /** - * The base implementation of `getTag` without fallbacks for buggy environments. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ - function baseGetTag(value) { - if (value == null) { - return value === undefined ? undefinedTag : nullTag; - } - return (symToStringTag && symToStringTag in Object(value)) - ? getRawTag(value) - : objectToString(value); - } - - /** - * The base implementation of `_.gt` which doesn't coerce arguments. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than `other`, - * else `false`. - */ - function baseGt(value, other) { - return value > other; - } - - /** - * The base implementation of `_.has` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ - function baseHas(object, key) { - return object != null && hasOwnProperty.call(object, key); - } - - /** - * The base implementation of `_.hasIn` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ - function baseHasIn(object, key) { - return object != null && key in Object(object); - } - - /** - * The base implementation of `_.inRange` which doesn't coerce arguments. - * - * @private - * @param {number} number The number to check. - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @returns {boolean} Returns `true` if `number` is in the range, else `false`. - */ - function baseInRange(number, start, end) { - return number >= nativeMin(start, end) && number < nativeMax(start, end); - } - - /** - * The base implementation of methods like `_.intersection`, without support - * for iteratee shorthands, that accepts an array of arrays to inspect. - * - * @private - * @param {Array} arrays The arrays to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of shared values. - */ - function baseIntersection(arrays, iteratee, comparator) { - var includes = comparator ? arrayIncludesWith : arrayIncludes, - length = arrays[0].length, - othLength = arrays.length, - othIndex = othLength, - caches = Array(othLength), - maxLength = Infinity, - result = []; - - while (othIndex--) { - var array = arrays[othIndex]; - if (othIndex && iteratee) { - array = arrayMap(array, baseUnary(iteratee)); - } - maxLength = nativeMin(array.length, maxLength); - caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120)) - ? new SetCache(othIndex && array) - : undefined; - } - array = arrays[0]; - - var index = -1, - seen = caches[0]; - - outer: - while (++index < length && result.length < maxLength) { - var value = array[index], - computed = iteratee ? iteratee(value) : value; - - value = (comparator || value !== 0) ? value : 0; - if (!(seen - ? cacheHas(seen, computed) - : includes(result, computed, comparator) - )) { - othIndex = othLength; - while (--othIndex) { - var cache = caches[othIndex]; - if (!(cache - ? cacheHas(cache, computed) - : includes(arrays[othIndex], computed, comparator)) - ) { - continue outer; - } - } - if (seen) { - seen.push(computed); - } - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.invert` and `_.invertBy` which inverts - * `object` with values transformed by `iteratee` and set by `setter`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform values. - * @param {Object} accumulator The initial inverted object. - * @returns {Function} Returns `accumulator`. - */ - function baseInverter(object, setter, iteratee, accumulator) { - baseForOwn(object, function(value, key, object) { - setter(accumulator, iteratee(value), key, object); - }); - return accumulator; - } - - /** - * The base implementation of `_.invoke` without support for individual - * method arguments. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the method to invoke. - * @param {Array} args The arguments to invoke the method with. - * @returns {*} Returns the result of the invoked method. - */ - function baseInvoke(object, path, args) { - path = castPath(path, object); - object = parent(object, path); - var func = object == null ? object : object[toKey(last(path))]; - return func == null ? undefined : apply(func, object, args); - } - - /** - * The base implementation of `_.isArguments`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - */ - function baseIsArguments(value) { - return isObjectLike(value) && baseGetTag(value) == argsTag; - } - - /** - * The base implementation of `_.isArrayBuffer` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. - */ - function baseIsArrayBuffer(value) { - return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; - } - - /** - * The base implementation of `_.isDate` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a date object, else `false`. - */ - function baseIsDate(value) { - return isObjectLike(value) && baseGetTag(value) == dateTag; - } - - /** - * The base implementation of `_.isEqual` which supports partial comparisons - * and tracks traversed objects. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {boolean} bitmask The bitmask flags. - * 1 - Unordered comparison - * 2 - Partial comparison - * @param {Function} [customizer] The function to customize comparisons. - * @param {Object} [stack] Tracks traversed `value` and `other` objects. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - */ - function baseIsEqual(value, other, bitmask, customizer, stack) { - if (value === other) { - return true; - } - if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { - return value !== value && other !== other; - } - return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); - } - - /** - * A specialized version of `baseIsEqual` for arrays and objects which performs - * deep comparisons and tracks traversed objects enabling objects with circular - * references to be compared. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} [stack] Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { - var objIsArr = isArray(object), - othIsArr = isArray(other), - objTag = objIsArr ? arrayTag : getTag(object), - othTag = othIsArr ? arrayTag : getTag(other); - - objTag = objTag == argsTag ? objectTag : objTag; - othTag = othTag == argsTag ? objectTag : othTag; - - var objIsObj = objTag == objectTag, - othIsObj = othTag == objectTag, - isSameTag = objTag == othTag; - - if (isSameTag && isBuffer(object)) { - if (!isBuffer(other)) { - return false; - } - objIsArr = true; - objIsObj = false; - } - if (isSameTag && !objIsObj) { - stack || (stack = new Stack); - return (objIsArr || isTypedArray(object)) - ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) - : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); - } - if (!(bitmask & COMPARE_PARTIAL_FLAG)) { - var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), - othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); - - if (objIsWrapped || othIsWrapped) { - var objUnwrapped = objIsWrapped ? object.value() : object, - othUnwrapped = othIsWrapped ? other.value() : other; - - stack || (stack = new Stack); - return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); - } - } - if (!isSameTag) { - return false; - } - stack || (stack = new Stack); - return equalObjects(object, other, bitmask, customizer, equalFunc, stack); - } - - /** - * The base implementation of `_.isMap` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a map, else `false`. - */ - function baseIsMap(value) { - return isObjectLike(value) && getTag(value) == mapTag; - } - - /** - * The base implementation of `_.isMatch` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Array} matchData The property names, values, and compare flags to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - */ - function baseIsMatch(object, source, matchData, customizer) { - var index = matchData.length, - length = index, - noCustomizer = !customizer; - - if (object == null) { - return !length; - } - object = Object(object); - while (index--) { - var data = matchData[index]; - if ((noCustomizer && data[2]) - ? data[1] !== object[data[0]] - : !(data[0] in object) - ) { - return false; - } - } - while (++index < length) { - data = matchData[index]; - var key = data[0], - objValue = object[key], - srcValue = data[1]; - - if (noCustomizer && data[2]) { - if (objValue === undefined && !(key in object)) { - return false; - } - } else { - var stack = new Stack; - if (customizer) { - var result = customizer(objValue, srcValue, key, object, source, stack); - } - if (!(result === undefined - ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) - : result - )) { - return false; - } - } - } - return true; - } - - /** - * The base implementation of `_.isNative` without bad shim checks. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - */ - function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false; - } - var pattern = isFunction(value) ? reIsNative : reIsHostCtor; - return pattern.test(toSource(value)); - } - - /** - * The base implementation of `_.isRegExp` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. - */ - function baseIsRegExp(value) { - return isObjectLike(value) && baseGetTag(value) == regexpTag; - } - - /** - * The base implementation of `_.isSet` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a set, else `false`. - */ - function baseIsSet(value) { - return isObjectLike(value) && getTag(value) == setTag; - } - - /** - * The base implementation of `_.isTypedArray` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - */ - function baseIsTypedArray(value) { - return isObjectLike(value) && - isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; - } - - /** - * The base implementation of `_.iteratee`. - * - * @private - * @param {*} [value=_.identity] The value to convert to an iteratee. - * @returns {Function} Returns the iteratee. - */ - function baseIteratee(value) { - // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. - // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. - if (typeof value == 'function') { - return value; - } - if (value == null) { - return identity; - } - if (typeof value == 'object') { - return isArray(value) - ? baseMatchesProperty(value[0], value[1]) - : baseMatches(value); - } - return property(value); - } - - /** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object); - } - var result = []; - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != 'constructor') { - result.push(key); - } - } - return result; - } - - /** - * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeysIn(object) { - if (!isObject(object)) { - return nativeKeysIn(object); - } - var isProto = isPrototype(object), - result = []; - - for (var key in object) { - if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { - result.push(key); - } - } - return result; - } - - /** - * The base implementation of `_.lt` which doesn't coerce arguments. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than `other`, - * else `false`. - */ - function baseLt(value, other) { - return value < other; - } - - /** - * The base implementation of `_.map` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ - function baseMap(collection, iteratee) { - var index = -1, - result = isArrayLike(collection) ? Array(collection.length) : []; - - baseEach(collection, function(value, key, collection) { - result[++index] = iteratee(value, key, collection); - }); - return result; - } - - /** - * The base implementation of `_.matches` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property values to match. - * @returns {Function} Returns the new spec function. - */ - function baseMatches(source) { - var matchData = getMatchData(source); - if (matchData.length == 1 && matchData[0][2]) { - return matchesStrictComparable(matchData[0][0], matchData[0][1]); - } - return function(object) { - return object === source || baseIsMatch(object, source, matchData); - }; - } - - /** - * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. - * - * @private - * @param {string} path The path of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ - function baseMatchesProperty(path, srcValue) { - if (isKey(path) && isStrictComparable(srcValue)) { - return matchesStrictComparable(toKey(path), srcValue); - } - return function(object) { - var objValue = get(object, path); - return (objValue === undefined && objValue === srcValue) - ? hasIn(object, path) - : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); - }; - } - - /** - * The base implementation of `_.merge` without support for multiple sources. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @param {number} srcIndex The index of `source`. - * @param {Function} [customizer] The function to customize merged values. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - */ - function baseMerge(object, source, srcIndex, customizer, stack) { - if (object === source) { - return; - } - baseFor(source, function(srcValue, key) { - if (isObject(srcValue)) { - stack || (stack = new Stack); - baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); - } - else { - var newValue = customizer - ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) - : undefined; - - if (newValue === undefined) { - newValue = srcValue; - } - assignMergeValue(object, key, newValue); - } - }, keysIn); - } - - /** - * A specialized version of `baseMerge` for arrays and objects which performs - * deep merges and tracks traversed objects enabling objects with circular - * references to be merged. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @param {string} key The key of the value to merge. - * @param {number} srcIndex The index of `source`. - * @param {Function} mergeFunc The function to merge values. - * @param {Function} [customizer] The function to customize assigned values. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - */ - function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { - var objValue = safeGet(object, key), - srcValue = safeGet(source, key), - stacked = stack.get(srcValue); - - if (stacked) { - assignMergeValue(object, key, stacked); - return; - } - var newValue = customizer - ? customizer(objValue, srcValue, (key + ''), object, source, stack) - : undefined; - - var isCommon = newValue === undefined; - - if (isCommon) { - var isArr = isArray(srcValue), - isBuff = !isArr && isBuffer(srcValue), - isTyped = !isArr && !isBuff && isTypedArray(srcValue); - - newValue = srcValue; - if (isArr || isBuff || isTyped) { - if (isArray(objValue)) { - newValue = objValue; - } - else if (isArrayLikeObject(objValue)) { - newValue = copyArray(objValue); - } - else if (isBuff) { - isCommon = false; - newValue = cloneBuffer(srcValue, true); - } - else if (isTyped) { - isCommon = false; - newValue = cloneTypedArray(srcValue, true); - } - else { - newValue = []; - } - } - else if (isPlainObject(srcValue) || isArguments(srcValue)) { - newValue = objValue; - if (isArguments(objValue)) { - newValue = toPlainObject(objValue); - } - else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) { - newValue = initCloneObject(srcValue); - } - } - else { - isCommon = false; - } - } - if (isCommon) { - // Recursively merge objects and arrays (susceptible to call stack limits). - stack.set(srcValue, newValue); - mergeFunc(newValue, srcValue, srcIndex, customizer, stack); - stack['delete'](srcValue); - } - assignMergeValue(object, key, newValue); - } - - /** - * The base implementation of `_.nth` which doesn't coerce arguments. - * - * @private - * @param {Array} array The array to query. - * @param {number} n The index of the element to return. - * @returns {*} Returns the nth element of `array`. - */ - function baseNth(array, n) { - var length = array.length; - if (!length) { - return; - } - n += n < 0 ? length : 0; - return isIndex(n, length) ? array[n] : undefined; - } - - /** - * The base implementation of `_.orderBy` without param guards. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. - * @param {string[]} orders The sort orders of `iteratees`. - * @returns {Array} Returns the new sorted array. - */ - function baseOrderBy(collection, iteratees, orders) { - var index = -1; - iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee())); - - var result = baseMap(collection, function(value, key, collection) { - var criteria = arrayMap(iteratees, function(iteratee) { - return iteratee(value); - }); - return { 'criteria': criteria, 'index': ++index, 'value': value }; - }); - - return baseSortBy(result, function(object, other) { - return compareMultiple(object, other, orders); - }); - } - - /** - * The base implementation of `_.pick` without support for individual - * property identifiers. - * - * @private - * @param {Object} object The source object. - * @param {string[]} paths The property paths to pick. - * @returns {Object} Returns the new object. - */ - function basePick(object, paths) { - return basePickBy(object, paths, function(value, path) { - return hasIn(object, path); - }); - } - - /** - * The base implementation of `_.pickBy` without support for iteratee shorthands. - * - * @private - * @param {Object} object The source object. - * @param {string[]} paths The property paths to pick. - * @param {Function} predicate The function invoked per property. - * @returns {Object} Returns the new object. - */ - function basePickBy(object, paths, predicate) { - var index = -1, - length = paths.length, - result = {}; - - while (++index < length) { - var path = paths[index], - value = baseGet(object, path); - - if (predicate(value, path)) { - baseSet(result, castPath(path, object), value); - } - } - return result; - } - - /** - * A specialized version of `baseProperty` which supports deep paths. - * - * @private - * @param {Array|string} path The path of the property to get. - * @returns {Function} Returns the new accessor function. - */ - function basePropertyDeep(path) { - return function(object) { - return baseGet(object, path); - }; - } - - /** - * The base implementation of `_.pullAllBy` without support for iteratee - * shorthands. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns `array`. - */ - function basePullAll(array, values, iteratee, comparator) { - var indexOf = comparator ? baseIndexOfWith : baseIndexOf, - index = -1, - length = values.length, - seen = array; - - if (array === values) { - values = copyArray(values); - } - if (iteratee) { - seen = arrayMap(array, baseUnary(iteratee)); - } - while (++index < length) { - var fromIndex = 0, - value = values[index], - computed = iteratee ? iteratee(value) : value; - - while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) { - if (seen !== array) { - splice.call(seen, fromIndex, 1); - } - splice.call(array, fromIndex, 1); - } - } - return array; - } - - /** - * The base implementation of `_.pullAt` without support for individual - * indexes or capturing the removed elements. - * - * @private - * @param {Array} array The array to modify. - * @param {number[]} indexes The indexes of elements to remove. - * @returns {Array} Returns `array`. - */ - function basePullAt(array, indexes) { - var length = array ? indexes.length : 0, - lastIndex = length - 1; - - while (length--) { - var index = indexes[length]; - if (length == lastIndex || index !== previous) { - var previous = index; - if (isIndex(index)) { - splice.call(array, index, 1); - } else { - baseUnset(array, index); - } - } - } - return array; - } - - /** - * The base implementation of `_.random` without support for returning - * floating-point numbers. - * - * @private - * @param {number} lower The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the random number. - */ - function baseRandom(lower, upper) { - return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); - } - - /** - * The base implementation of `_.range` and `_.rangeRight` which doesn't - * coerce arguments. - * - * @private - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @param {number} step The value to increment or decrement by. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the range of numbers. - */ - function baseRange(start, end, step, fromRight) { - var index = -1, - length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), - result = Array(length); - - while (length--) { - result[fromRight ? length : ++index] = start; - start += step; - } - return result; - } - - /** - * The base implementation of `_.repeat` which doesn't coerce arguments. - * - * @private - * @param {string} string The string to repeat. - * @param {number} n The number of times to repeat the string. - * @returns {string} Returns the repeated string. - */ - function baseRepeat(string, n) { - var result = ''; - if (!string || n < 1 || n > MAX_SAFE_INTEGER) { - return result; - } - // Leverage the exponentiation by squaring algorithm for a faster repeat. - // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. - do { - if (n % 2) { - result += string; - } - n = nativeFloor(n / 2); - if (n) { - string += string; - } - } while (n); - - return result; - } - - /** - * The base implementation of `_.rest` which doesn't validate or coerce arguments. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. - */ - function baseRest(func, start) { - return setToString(overRest(func, start, identity), func + ''); - } - - /** - * The base implementation of `_.sample`. - * - * @private - * @param {Array|Object} collection The collection to sample. - * @returns {*} Returns the random element. - */ - function baseSample(collection) { - return arraySample(values(collection)); - } - - /** - * The base implementation of `_.sampleSize` without param guards. - * - * @private - * @param {Array|Object} collection The collection to sample. - * @param {number} n The number of elements to sample. - * @returns {Array} Returns the random elements. - */ - function baseSampleSize(collection, n) { - var array = values(collection); - return shuffleSelf(array, baseClamp(n, 0, array.length)); - } - - /** - * The base implementation of `_.set`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @param {Function} [customizer] The function to customize path creation. - * @returns {Object} Returns `object`. - */ - function baseSet(object, path, value, customizer) { - if (!isObject(object)) { - return object; - } - path = castPath(path, object); - - var index = -1, - length = path.length, - lastIndex = length - 1, - nested = object; - - while (nested != null && ++index < length) { - var key = toKey(path[index]), - newValue = value; - - if (index != lastIndex) { - var objValue = nested[key]; - newValue = customizer ? customizer(objValue, key, nested) : undefined; - if (newValue === undefined) { - newValue = isObject(objValue) - ? objValue - : (isIndex(path[index + 1]) ? [] : {}); - } - } - assignValue(nested, key, newValue); - nested = nested[key]; - } - return object; - } - - /** - * The base implementation of `setData` without support for hot loop shorting. - * - * @private - * @param {Function} func The function to associate metadata with. - * @param {*} data The metadata. - * @returns {Function} Returns `func`. - */ - var baseSetData = !metaMap ? identity : function(func, data) { - metaMap.set(func, data); - return func; - }; - - /** - * The base implementation of `setToString` without support for hot loop shorting. - * - * @private - * @param {Function} func The function to modify. - * @param {Function} string The `toString` result. - * @returns {Function} Returns `func`. - */ - var baseSetToString = !defineProperty ? identity : function(func, string) { - return defineProperty(func, 'toString', { - 'configurable': true, - 'enumerable': false, - 'value': constant(string), - 'writable': true - }); - }; - - /** - * The base implementation of `_.shuffle`. - * - * @private - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - */ - function baseShuffle(collection) { - return shuffleSelf(values(collection)); - } - - /** - * The base implementation of `_.slice` without an iteratee call guard. - * - * @private - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ - function baseSlice(array, start, end) { - var index = -1, - length = array.length; - - if (start < 0) { - start = -start > length ? 0 : (length + start); - } - end = end > length ? length : end; - if (end < 0) { - end += length; - } - length = start > end ? 0 : ((end - start) >>> 0); - start >>>= 0; - - var result = Array(length); - while (++index < length) { - result[index] = array[index + start]; - } - return result; - } - - /** - * The base implementation of `_.some` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ - function baseSome(collection, predicate) { - var result; - - baseEach(collection, function(value, index, collection) { - result = predicate(value, index, collection); - return !result; - }); - return !!result; - } - - /** - * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which - * performs a binary search of `array` to determine the index at which `value` - * should be inserted into `array` in order to maintain its sort order. - * - * @private - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {boolean} [retHighest] Specify returning the highest qualified index. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - */ - function baseSortedIndex(array, value, retHighest) { - var low = 0, - high = array == null ? low : array.length; - - if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { - while (low < high) { - var mid = (low + high) >>> 1, - computed = array[mid]; - - if (computed !== null && !isSymbol(computed) && - (retHighest ? (computed <= value) : (computed < value))) { - low = mid + 1; - } else { - high = mid; - } - } - return high; - } - return baseSortedIndexBy(array, value, identity, retHighest); - } - - /** - * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` - * which invokes `iteratee` for `value` and each element of `array` to compute - * their sort ranking. The iteratee is invoked with one argument; (value). - * - * @private - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} iteratee The iteratee invoked per element. - * @param {boolean} [retHighest] Specify returning the highest qualified index. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - */ - function baseSortedIndexBy(array, value, iteratee, retHighest) { - value = iteratee(value); - - var low = 0, - high = array == null ? 0 : array.length, - valIsNaN = value !== value, - valIsNull = value === null, - valIsSymbol = isSymbol(value), - valIsUndefined = value === undefined; - - while (low < high) { - var mid = nativeFloor((low + high) / 2), - computed = iteratee(array[mid]), - othIsDefined = computed !== undefined, - othIsNull = computed === null, - othIsReflexive = computed === computed, - othIsSymbol = isSymbol(computed); - - if (valIsNaN) { - var setLow = retHighest || othIsReflexive; - } else if (valIsUndefined) { - setLow = othIsReflexive && (retHighest || othIsDefined); - } else if (valIsNull) { - setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); - } else if (valIsSymbol) { - setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); - } else if (othIsNull || othIsSymbol) { - setLow = false; - } else { - setLow = retHighest ? (computed <= value) : (computed < value); - } - if (setLow) { - low = mid + 1; - } else { - high = mid; - } - } - return nativeMin(high, MAX_ARRAY_INDEX); - } - - /** - * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without - * support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - */ - function baseSortedUniq(array, iteratee) { - var index = -1, - length = array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index], - computed = iteratee ? iteratee(value) : value; - - if (!index || !eq(computed, seen)) { - var seen = computed; - result[resIndex++] = value === 0 ? 0 : value; - } - } - return result; - } - - /** - * The base implementation of `_.toNumber` which doesn't ensure correct - * conversions of binary, hexadecimal, or octal string values. - * - * @private - * @param {*} value The value to process. - * @returns {number} Returns the number. - */ - function baseToNumber(value) { - if (typeof value == 'number') { - return value; - } - if (isSymbol(value)) { - return NAN; - } - return +value; - } - - /** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. - * - * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. - */ - function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == 'string') { - return value; - } - if (isArray(value)) { - // Recursively convert values (susceptible to call stack limits). - return arrayMap(value, baseToString) + ''; - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : ''; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; - } - - /** - * The base implementation of `_.uniqBy` without support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new duplicate free array. - */ - function baseUniq(array, iteratee, comparator) { - var index = -1, - includes = arrayIncludes, - length = array.length, - isCommon = true, - result = [], - seen = result; - - if (comparator) { - isCommon = false; - includes = arrayIncludesWith; - } - else if (length >= LARGE_ARRAY_SIZE) { - var set = iteratee ? null : createSet(array); - if (set) { - return setToArray(set); - } - isCommon = false; - includes = cacheHas; - seen = new SetCache; - } - else { - seen = iteratee ? [] : result; - } - outer: - while (++index < length) { - var value = array[index], - computed = iteratee ? iteratee(value) : value; - - value = (comparator || value !== 0) ? value : 0; - if (isCommon && computed === computed) { - var seenIndex = seen.length; - while (seenIndex--) { - if (seen[seenIndex] === computed) { - continue outer; - } - } - if (iteratee) { - seen.push(computed); - } - result.push(value); - } - else if (!includes(seen, computed, comparator)) { - if (seen !== result) { - seen.push(computed); - } - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.unset`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The property path to unset. - * @returns {boolean} Returns `true` if the property is deleted, else `false`. - */ - function baseUnset(object, path) { - path = castPath(path, object); - object = parent(object, path); - return object == null || delete object[toKey(last(path))]; - } - - /** - * The base implementation of `_.update`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to update. - * @param {Function} updater The function to produce the updated value. - * @param {Function} [customizer] The function to customize path creation. - * @returns {Object} Returns `object`. - */ - function baseUpdate(object, path, updater, customizer) { - return baseSet(object, path, updater(baseGet(object, path)), customizer); - } - - /** - * The base implementation of methods like `_.dropWhile` and `_.takeWhile` - * without support for iteratee shorthands. - * - * @private - * @param {Array} array The array to query. - * @param {Function} predicate The function invoked per iteration. - * @param {boolean} [isDrop] Specify dropping elements instead of taking them. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the slice of `array`. - */ - function baseWhile(array, predicate, isDrop, fromRight) { - var length = array.length, - index = fromRight ? length : -1; - - while ((fromRight ? index-- : ++index < length) && - predicate(array[index], index, array)) {} - - return isDrop - ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length)) - : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index)); - } - - /** - * The base implementation of `wrapperValue` which returns the result of - * performing a sequence of actions on the unwrapped `value`, where each - * successive action is supplied the return value of the previous. - * - * @private - * @param {*} value The unwrapped value. - * @param {Array} actions Actions to perform to resolve the unwrapped value. - * @returns {*} Returns the resolved value. - */ - function baseWrapperValue(value, actions) { - var result = value; - if (result instanceof LazyWrapper) { - result = result.value(); - } - return arrayReduce(actions, function(result, action) { - return action.func.apply(action.thisArg, arrayPush([result], action.args)); - }, result); - } - - /** - * The base implementation of methods like `_.xor`, without support for - * iteratee shorthands, that accepts an array of arrays to inspect. - * - * @private - * @param {Array} arrays The arrays to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of values. - */ - function baseXor(arrays, iteratee, comparator) { - var length = arrays.length; - if (length < 2) { - return length ? baseUniq(arrays[0]) : []; - } - var index = -1, - result = Array(length); - - while (++index < length) { - var array = arrays[index], - othIndex = -1; - - while (++othIndex < length) { - if (othIndex != index) { - result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator); - } - } - } - return baseUniq(baseFlatten(result, 1), iteratee, comparator); - } - - /** - * This base implementation of `_.zipObject` which assigns values using `assignFunc`. - * - * @private - * @param {Array} props The property identifiers. - * @param {Array} values The property values. - * @param {Function} assignFunc The function to assign values. - * @returns {Object} Returns the new object. - */ - function baseZipObject(props, values, assignFunc) { - var index = -1, - length = props.length, - valsLength = values.length, - result = {}; - - while (++index < length) { - var value = index < valsLength ? values[index] : undefined; - assignFunc(result, props[index], value); - } - return result; - } - - /** - * Casts `value` to an empty array if it's not an array like object. - * - * @private - * @param {*} value The value to inspect. - * @returns {Array|Object} Returns the cast array-like object. - */ - function castArrayLikeObject(value) { - return isArrayLikeObject(value) ? value : []; - } - - /** - * Casts `value` to `identity` if it's not a function. - * - * @private - * @param {*} value The value to inspect. - * @returns {Function} Returns cast function. - */ - function castFunction(value) { - return typeof value == 'function' ? value : identity; - } - - /** - * Casts `value` to a path array if it's not one. - * - * @private - * @param {*} value The value to inspect. - * @param {Object} [object] The object to query keys on. - * @returns {Array} Returns the cast property path array. - */ - function castPath(value, object) { - if (isArray(value)) { - return value; - } - return isKey(value, object) ? [value] : stringToPath(toString(value)); - } - - /** - * A `baseRest` alias which can be replaced with `identity` by module - * replacement plugins. - * - * @private - * @type {Function} - * @param {Function} func The function to apply a rest parameter to. - * @returns {Function} Returns the new function. - */ - var castRest = baseRest; - - /** - * Casts `array` to a slice if it's needed. - * - * @private - * @param {Array} array The array to inspect. - * @param {number} start The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the cast slice. - */ - function castSlice(array, start, end) { - var length = array.length; - end = end === undefined ? length : end; - return (!start && end >= length) ? array : baseSlice(array, start, end); - } - - /** - * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). - * - * @private - * @param {number|Object} id The timer id or timeout object of the timer to clear. - */ - var clearTimeout = ctxClearTimeout || function(id) { - return root.clearTimeout(id); - }; - - /** - * Creates a clone of `buffer`. - * - * @private - * @param {Buffer} buffer The buffer to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Buffer} Returns the cloned buffer. - */ - function cloneBuffer(buffer, isDeep) { - if (isDeep) { - return buffer.slice(); - } - var length = buffer.length, - result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); - - buffer.copy(result); - return result; - } - - /** - * Creates a clone of `arrayBuffer`. - * - * @private - * @param {ArrayBuffer} arrayBuffer The array buffer to clone. - * @returns {ArrayBuffer} Returns the cloned array buffer. - */ - function cloneArrayBuffer(arrayBuffer) { - var result = new arrayBuffer.constructor(arrayBuffer.byteLength); - new Uint8Array(result).set(new Uint8Array(arrayBuffer)); - return result; - } - - /** - * Creates a clone of `dataView`. - * - * @private - * @param {Object} dataView The data view to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned data view. - */ - function cloneDataView(dataView, isDeep) { - var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; - return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); - } - - /** - * Creates a clone of `regexp`. - * - * @private - * @param {Object} regexp The regexp to clone. - * @returns {Object} Returns the cloned regexp. - */ - function cloneRegExp(regexp) { - var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); - result.lastIndex = regexp.lastIndex; - return result; - } - - /** - * Creates a clone of the `symbol` object. - * - * @private - * @param {Object} symbol The symbol object to clone. - * @returns {Object} Returns the cloned symbol object. - */ - function cloneSymbol(symbol) { - return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; - } - - /** - * Creates a clone of `typedArray`. - * - * @private - * @param {Object} typedArray The typed array to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned typed array. - */ - function cloneTypedArray(typedArray, isDeep) { - var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; - return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); - } - - /** - * Compares values to sort them in ascending order. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {number} Returns the sort order indicator for `value`. - */ - function compareAscending(value, other) { - if (value !== other) { - var valIsDefined = value !== undefined, - valIsNull = value === null, - valIsReflexive = value === value, - valIsSymbol = isSymbol(value); - - var othIsDefined = other !== undefined, - othIsNull = other === null, - othIsReflexive = other === other, - othIsSymbol = isSymbol(other); - - if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || - (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) || - (valIsNull && othIsDefined && othIsReflexive) || - (!valIsDefined && othIsReflexive) || - !valIsReflexive) { - return 1; - } - if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || - (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || - (othIsNull && valIsDefined && valIsReflexive) || - (!othIsDefined && valIsReflexive) || - !othIsReflexive) { - return -1; - } - } - return 0; - } - - /** - * Used by `_.orderBy` to compare multiple properties of a value to another - * and stable sort them. - * - * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, - * specify an order of "desc" for descending or "asc" for ascending sort order - * of corresponding values. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {boolean[]|string[]} orders The order to sort by for each property. - * @returns {number} Returns the sort order indicator for `object`. - */ - function compareMultiple(object, other, orders) { - var index = -1, - objCriteria = object.criteria, - othCriteria = other.criteria, - length = objCriteria.length, - ordersLength = orders.length; - - while (++index < length) { - var result = compareAscending(objCriteria[index], othCriteria[index]); - if (result) { - if (index >= ordersLength) { - return result; - } - var order = orders[index]; - return result * (order == 'desc' ? -1 : 1); - } - } - // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications - // that causes it, under certain circumstances, to provide the same value for - // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 - // for more details. - // - // This also ensures a stable sort in V8 and other engines. - // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. - return object.index - other.index; - } - - /** - * Creates an array that is the composition of partially applied arguments, - * placeholders, and provided arguments into a single array of arguments. - * - * @private - * @param {Array} args The provided arguments. - * @param {Array} partials The arguments to prepend to those provided. - * @param {Array} holders The `partials` placeholder indexes. - * @params {boolean} [isCurried] Specify composing for a curried function. - * @returns {Array} Returns the new array of composed arguments. - */ - function composeArgs(args, partials, holders, isCurried) { - var argsIndex = -1, - argsLength = args.length, - holdersLength = holders.length, - leftIndex = -1, - leftLength = partials.length, - rangeLength = nativeMax(argsLength - holdersLength, 0), - result = Array(leftLength + rangeLength), - isUncurried = !isCurried; - - while (++leftIndex < leftLength) { - result[leftIndex] = partials[leftIndex]; - } - while (++argsIndex < holdersLength) { - if (isUncurried || argsIndex < argsLength) { - result[holders[argsIndex]] = args[argsIndex]; - } - } - while (rangeLength--) { - result[leftIndex++] = args[argsIndex++]; - } - return result; - } - - /** - * This function is like `composeArgs` except that the arguments composition - * is tailored for `_.partialRight`. - * - * @private - * @param {Array} args The provided arguments. - * @param {Array} partials The arguments to append to those provided. - * @param {Array} holders The `partials` placeholder indexes. - * @params {boolean} [isCurried] Specify composing for a curried function. - * @returns {Array} Returns the new array of composed arguments. - */ - function composeArgsRight(args, partials, holders, isCurried) { - var argsIndex = -1, - argsLength = args.length, - holdersIndex = -1, - holdersLength = holders.length, - rightIndex = -1, - rightLength = partials.length, - rangeLength = nativeMax(argsLength - holdersLength, 0), - result = Array(rangeLength + rightLength), - isUncurried = !isCurried; - - while (++argsIndex < rangeLength) { - result[argsIndex] = args[argsIndex]; - } - var offset = argsIndex; - while (++rightIndex < rightLength) { - result[offset + rightIndex] = partials[rightIndex]; - } - while (++holdersIndex < holdersLength) { - if (isUncurried || argsIndex < argsLength) { - result[offset + holders[holdersIndex]] = args[argsIndex++]; - } - } - return result; - } - - /** - * Copies the values of `source` to `array`. - * - * @private - * @param {Array} source The array to copy values from. - * @param {Array} [array=[]] The array to copy values to. - * @returns {Array} Returns `array`. - */ - function copyArray(source, array) { - var index = -1, - length = source.length; - - array || (array = Array(length)); - while (++index < length) { - array[index] = source[index]; - } - return array; - } - - /** - * Copies properties of `source` to `object`. - * - * @private - * @param {Object} source The object to copy properties from. - * @param {Array} props The property identifiers to copy. - * @param {Object} [object={}] The object to copy properties to. - * @param {Function} [customizer] The function to customize copied values. - * @returns {Object} Returns `object`. - */ - function copyObject(source, props, object, customizer) { - var isNew = !object; - object || (object = {}); - - var index = -1, - length = props.length; - - while (++index < length) { - var key = props[index]; - - var newValue = customizer - ? customizer(object[key], source[key], key, object, source) - : undefined; - - if (newValue === undefined) { - newValue = source[key]; - } - if (isNew) { - baseAssignValue(object, key, newValue); - } else { - assignValue(object, key, newValue); - } - } - return object; - } - - /** - * Copies own symbols of `source` to `object`. - * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `object`. - */ - function copySymbols(source, object) { - return copyObject(source, getSymbols(source), object); - } - - /** - * Copies own and inherited symbols of `source` to `object`. - * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `object`. - */ - function copySymbolsIn(source, object) { - return copyObject(source, getSymbolsIn(source), object); - } - - /** - * Creates a function like `_.groupBy`. - * - * @private - * @param {Function} setter The function to set accumulator values. - * @param {Function} [initializer] The accumulator object initializer. - * @returns {Function} Returns the new aggregator function. - */ - function createAggregator(setter, initializer) { - return function(collection, iteratee) { - var func = isArray(collection) ? arrayAggregator : baseAggregator, - accumulator = initializer ? initializer() : {}; - - return func(collection, setter, getIteratee(iteratee, 2), accumulator); - }; - } - - /** - * Creates a function like `_.assign`. - * - * @private - * @param {Function} assigner The function to assign values. - * @returns {Function} Returns the new assigner function. - */ - function createAssigner(assigner) { - return baseRest(function(object, sources) { - var index = -1, - length = sources.length, - customizer = length > 1 ? sources[length - 1] : undefined, - guard = length > 2 ? sources[2] : undefined; - - customizer = (assigner.length > 3 && typeof customizer == 'function') - ? (length--, customizer) - : undefined; - - if (guard && isIterateeCall(sources[0], sources[1], guard)) { - customizer = length < 3 ? undefined : customizer; - length = 1; - } - object = Object(object); - while (++index < length) { - var source = sources[index]; - if (source) { - assigner(object, source, index, customizer); - } - } - return object; - }); - } - - /** - * Creates a `baseEach` or `baseEachRight` function. - * - * @private - * @param {Function} eachFunc The function to iterate over a collection. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ - function createBaseEach(eachFunc, fromRight) { - return function(collection, iteratee) { - if (collection == null) { - return collection; - } - if (!isArrayLike(collection)) { - return eachFunc(collection, iteratee); - } - var length = collection.length, - index = fromRight ? length : -1, - iterable = Object(collection); - - while ((fromRight ? index-- : ++index < length)) { - if (iteratee(iterable[index], index, iterable) === false) { - break; - } - } - return collection; - }; - } - - /** - * Creates a base function for methods like `_.forIn` and `_.forOwn`. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ - function createBaseFor(fromRight) { - return function(object, iteratee, keysFunc) { - var index = -1, - iterable = Object(object), - props = keysFunc(object), - length = props.length; - - while (length--) { - var key = props[fromRight ? length : ++index]; - if (iteratee(iterable[key], key, iterable) === false) { - break; - } - } - return object; - }; - } - - /** - * Creates a function that wraps `func` to invoke it with the optional `this` - * binding of `thisArg`. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} [thisArg] The `this` binding of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createBind(func, bitmask, thisArg) { - var isBind = bitmask & WRAP_BIND_FLAG, - Ctor = createCtor(func); - - function wrapper() { - var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; - return fn.apply(isBind ? thisArg : this, arguments); - } - return wrapper; - } - - /** - * Creates a function like `_.lowerFirst`. - * - * @private - * @param {string} methodName The name of the `String` case method to use. - * @returns {Function} Returns the new case function. - */ - function createCaseFirst(methodName) { - return function(string) { - string = toString(string); - - var strSymbols = hasUnicode(string) - ? stringToArray(string) - : undefined; - - var chr = strSymbols - ? strSymbols[0] - : string.charAt(0); - - var trailing = strSymbols - ? castSlice(strSymbols, 1).join('') - : string.slice(1); - - return chr[methodName]() + trailing; - }; - } - - /** - * Creates a function like `_.camelCase`. - * - * @private - * @param {Function} callback The function to combine each word. - * @returns {Function} Returns the new compounder function. - */ - function createCompounder(callback) { - return function(string) { - return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); - }; - } - - /** - * Creates a function that produces an instance of `Ctor` regardless of - * whether it was invoked as part of a `new` expression or by `call` or `apply`. - * - * @private - * @param {Function} Ctor The constructor to wrap. - * @returns {Function} Returns the new wrapped function. - */ - function createCtor(Ctor) { - return function() { - // Use a `switch` statement to work with class constructors. See - // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist - // for more details. - var args = arguments; - switch (args.length) { - case 0: return new Ctor; - case 1: return new Ctor(args[0]); - case 2: return new Ctor(args[0], args[1]); - case 3: return new Ctor(args[0], args[1], args[2]); - case 4: return new Ctor(args[0], args[1], args[2], args[3]); - case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]); - case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); - case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); - } - var thisBinding = baseCreate(Ctor.prototype), - result = Ctor.apply(thisBinding, args); - - // Mimic the constructor's `return` behavior. - // See https://es5.github.io/#x13.2.2 for more details. - return isObject(result) ? result : thisBinding; - }; - } - - /** - * Creates a function that wraps `func` to enable currying. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {number} arity The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createCurry(func, bitmask, arity) { - var Ctor = createCtor(func); - - function wrapper() { - var length = arguments.length, - args = Array(length), - index = length, - placeholder = getHolder(wrapper); - - while (index--) { - args[index] = arguments[index]; - } - var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder) - ? [] - : replaceHolders(args, placeholder); - - length -= holders.length; - if (length < arity) { - return createRecurry( - func, bitmask, createHybrid, wrapper.placeholder, undefined, - args, holders, undefined, undefined, arity - length); - } - var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; - return apply(fn, this, args); - } - return wrapper; - } - - /** - * Creates a `_.find` or `_.findLast` function. - * - * @private - * @param {Function} findIndexFunc The function to find the collection index. - * @returns {Function} Returns the new find function. - */ - function createFind(findIndexFunc) { - return function(collection, predicate, fromIndex) { - var iterable = Object(collection); - if (!isArrayLike(collection)) { - var iteratee = getIteratee(predicate, 3); - collection = keys(collection); - predicate = function(key) { return iteratee(iterable[key], key, iterable); }; - } - var index = findIndexFunc(collection, predicate, fromIndex); - return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined; - }; - } - - /** - * Creates a `_.flow` or `_.flowRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new flow function. - */ - function createFlow(fromRight) { - return flatRest(function(funcs) { - var length = funcs.length, - index = length, - prereq = LodashWrapper.prototype.thru; - - if (fromRight) { - funcs.reverse(); - } - while (index--) { - var func = funcs[index]; - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - if (prereq && !wrapper && getFuncName(func) == 'wrapper') { - var wrapper = new LodashWrapper([], true); - } - } - index = wrapper ? index : length; - while (++index < length) { - func = funcs[index]; - - var funcName = getFuncName(func), - data = funcName == 'wrapper' ? getData(func) : undefined; - - if (data && isLaziable(data[0]) && - data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && - !data[4].length && data[9] == 1 - ) { - wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); - } else { - wrapper = (func.length == 1 && isLaziable(func)) - ? wrapper[funcName]() - : wrapper.thru(func); - } - } - return function() { - var args = arguments, - value = args[0]; - - if (wrapper && args.length == 1 && isArray(value)) { - return wrapper.plant(value).value(); - } - var index = 0, - result = length ? funcs[index].apply(this, args) : value; - - while (++index < length) { - result = funcs[index].call(this, result); - } - return result; - }; - }); - } - - /** - * Creates a function that wraps `func` to invoke it with optional `this` - * binding of `thisArg`, partial application, and currying. - * - * @private - * @param {Function|string} func The function or method name to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to prepend to those provided to - * the new function. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [partialsRight] The arguments to append to those provided - * to the new function. - * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { - var isAry = bitmask & WRAP_ARY_FLAG, - isBind = bitmask & WRAP_BIND_FLAG, - isBindKey = bitmask & WRAP_BIND_KEY_FLAG, - isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), - isFlip = bitmask & WRAP_FLIP_FLAG, - Ctor = isBindKey ? undefined : createCtor(func); - - function wrapper() { - var length = arguments.length, - args = Array(length), - index = length; - - while (index--) { - args[index] = arguments[index]; - } - if (isCurried) { - var placeholder = getHolder(wrapper), - holdersCount = countHolders(args, placeholder); - } - if (partials) { - args = composeArgs(args, partials, holders, isCurried); - } - if (partialsRight) { - args = composeArgsRight(args, partialsRight, holdersRight, isCurried); - } - length -= holdersCount; - if (isCurried && length < arity) { - var newHolders = replaceHolders(args, placeholder); - return createRecurry( - func, bitmask, createHybrid, wrapper.placeholder, thisArg, - args, newHolders, argPos, ary, arity - length - ); - } - var thisBinding = isBind ? thisArg : this, - fn = isBindKey ? thisBinding[func] : func; - - length = args.length; - if (argPos) { - args = reorder(args, argPos); - } else if (isFlip && length > 1) { - args.reverse(); - } - if (isAry && ary < length) { - args.length = ary; - } - if (this && this !== root && this instanceof wrapper) { - fn = Ctor || createCtor(fn); - } - return fn.apply(thisBinding, args); - } - return wrapper; - } - - /** - * Creates a function like `_.invertBy`. - * - * @private - * @param {Function} setter The function to set accumulator values. - * @param {Function} toIteratee The function to resolve iteratees. - * @returns {Function} Returns the new inverter function. - */ - function createInverter(setter, toIteratee) { - return function(object, iteratee) { - return baseInverter(object, setter, toIteratee(iteratee), {}); - }; - } - - /** - * Creates a function that performs a mathematical operation on two values. - * - * @private - * @param {Function} operator The function to perform the operation. - * @param {number} [defaultValue] The value used for `undefined` arguments. - * @returns {Function} Returns the new mathematical operation function. - */ - function createMathOperation(operator, defaultValue) { - return function(value, other) { - var result; - if (value === undefined && other === undefined) { - return defaultValue; - } - if (value !== undefined) { - result = value; - } - if (other !== undefined) { - if (result === undefined) { - return other; - } - if (typeof value == 'string' || typeof other == 'string') { - value = baseToString(value); - other = baseToString(other); - } else { - value = baseToNumber(value); - other = baseToNumber(other); - } - result = operator(value, other); - } - return result; - }; - } - - /** - * Creates a function like `_.over`. - * - * @private - * @param {Function} arrayFunc The function to iterate over iteratees. - * @returns {Function} Returns the new over function. - */ - function createOver(arrayFunc) { - return flatRest(function(iteratees) { - iteratees = arrayMap(iteratees, baseUnary(getIteratee())); - return baseRest(function(args) { - var thisArg = this; - return arrayFunc(iteratees, function(iteratee) { - return apply(iteratee, thisArg, args); - }); - }); - }); - } - - /** - * Creates the padding for `string` based on `length`. The `chars` string - * is truncated if the number of characters exceeds `length`. - * - * @private - * @param {number} length The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padding for `string`. - */ - function createPadding(length, chars) { - chars = chars === undefined ? ' ' : baseToString(chars); - - var charsLength = chars.length; - if (charsLength < 2) { - return charsLength ? baseRepeat(chars, length) : chars; - } - var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); - return hasUnicode(chars) - ? castSlice(stringToArray(result), 0, length).join('') - : result.slice(0, length); - } - - /** - * Creates a function that wraps `func` to invoke it with the `this` binding - * of `thisArg` and `partials` prepended to the arguments it receives. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} partials The arguments to prepend to those provided to - * the new function. - * @returns {Function} Returns the new wrapped function. - */ - function createPartial(func, bitmask, thisArg, partials) { - var isBind = bitmask & WRAP_BIND_FLAG, - Ctor = createCtor(func); - - function wrapper() { - var argsIndex = -1, - argsLength = arguments.length, - leftIndex = -1, - leftLength = partials.length, - args = Array(leftLength + argsLength), - fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; - - while (++leftIndex < leftLength) { - args[leftIndex] = partials[leftIndex]; - } - while (argsLength--) { - args[leftIndex++] = arguments[++argsIndex]; - } - return apply(fn, isBind ? thisArg : this, args); - } - return wrapper; - } - - /** - * Creates a `_.range` or `_.rangeRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new range function. - */ - function createRange(fromRight) { - return function(start, end, step) { - if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { - end = step = undefined; - } - // Ensure the sign of `-0` is preserved. - start = toFinite(start); - if (end === undefined) { - end = start; - start = 0; - } else { - end = toFinite(end); - } - step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); - return baseRange(start, end, step, fromRight); - }; - } - - /** - * Creates a function that performs a relational operation on two values. - * - * @private - * @param {Function} operator The function to perform the operation. - * @returns {Function} Returns the new relational operation function. - */ - function createRelationalOperation(operator) { - return function(value, other) { - if (!(typeof value == 'string' && typeof other == 'string')) { - value = toNumber(value); - other = toNumber(other); - } - return operator(value, other); - }; - } - - /** - * Creates a function that wraps `func` to continue currying. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {Function} wrapFunc The function to create the `func` wrapper. - * @param {*} placeholder The placeholder value. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to prepend to those provided to - * the new function. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { - var isCurry = bitmask & WRAP_CURRY_FLAG, - newHolders = isCurry ? holders : undefined, - newHoldersRight = isCurry ? undefined : holders, - newPartials = isCurry ? partials : undefined, - newPartialsRight = isCurry ? undefined : partials; - - bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG); - bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); - - if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { - bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); - } - var newData = [ - func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, - newHoldersRight, argPos, ary, arity - ]; - - var result = wrapFunc.apply(undefined, newData); - if (isLaziable(func)) { - setData(result, newData); - } - result.placeholder = placeholder; - return setWrapToString(result, func, bitmask); - } - - /** - * Creates a function like `_.round`. - * - * @private - * @param {string} methodName The name of the `Math` method to use when rounding. - * @returns {Function} Returns the new round function. - */ - function createRound(methodName) { - var func = Math[methodName]; - return function(number, precision) { - number = toNumber(number); - precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); - if (precision) { - // Shift with exponential notation to avoid floating-point issues. - // See [MDN](https://mdn.io/round#Examples) for more details. - var pair = (toString(number) + 'e').split('e'), - value = func(pair[0] + 'e' + (+pair[1] + precision)); - - pair = (toString(value) + 'e').split('e'); - return +(pair[0] + 'e' + (+pair[1] - precision)); - } - return func(number); - }; - } - - /** - * Creates a set object of `values`. - * - * @private - * @param {Array} values The values to add to the set. - * @returns {Object} Returns the new set. - */ - var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { - return new Set(values); - }; - - /** - * Creates a `_.toPairs` or `_.toPairsIn` function. - * - * @private - * @param {Function} keysFunc The function to get the keys of a given object. - * @returns {Function} Returns the new pairs function. - */ - function createToPairs(keysFunc) { - return function(object) { - var tag = getTag(object); - if (tag == mapTag) { - return mapToArray(object); - } - if (tag == setTag) { - return setToPairs(object); - } - return baseToPairs(object, keysFunc(object)); - }; - } - - /** - * Creates a function that either curries or invokes `func` with optional - * `this` binding and partially applied arguments. - * - * @private - * @param {Function|string} func The function or method name to wrap. - * @param {number} bitmask The bitmask flags. - * 1 - `_.bind` - * 2 - `_.bindKey` - * 4 - `_.curry` or `_.curryRight` of a bound function - * 8 - `_.curry` - * 16 - `_.curryRight` - * 32 - `_.partial` - * 64 - `_.partialRight` - * 128 - `_.rearg` - * 256 - `_.ary` - * 512 - `_.flip` - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to be partially applied. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { - var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; - if (!isBindKey && typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - var length = partials ? partials.length : 0; - if (!length) { - bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); - partials = holders = undefined; - } - ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0); - arity = arity === undefined ? arity : toInteger(arity); - length -= holders ? holders.length : 0; - - if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { - var partialsRight = partials, - holdersRight = holders; - - partials = holders = undefined; - } - var data = isBindKey ? undefined : getData(func); - - var newData = [ - func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, - argPos, ary, arity - ]; - - if (data) { - mergeData(newData, data); - } - func = newData[0]; - bitmask = newData[1]; - thisArg = newData[2]; - partials = newData[3]; - holders = newData[4]; - arity = newData[9] = newData[9] === undefined - ? (isBindKey ? 0 : func.length) - : nativeMax(newData[9] - length, 0); - - if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { - bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); - } - if (!bitmask || bitmask == WRAP_BIND_FLAG) { - var result = createBind(func, bitmask, thisArg); - } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { - result = createCurry(func, bitmask, arity); - } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { - result = createPartial(func, bitmask, thisArg, partials); - } else { - result = createHybrid.apply(undefined, newData); - } - var setter = data ? baseSetData : setData; - return setWrapToString(setter(result, newData), func, bitmask); - } - - /** - * Used by `_.defaults` to customize its `_.assignIn` use to assign properties - * of source objects to the destination object for all destination properties - * that resolve to `undefined`. - * - * @private - * @param {*} objValue The destination value. - * @param {*} srcValue The source value. - * @param {string} key The key of the property to assign. - * @param {Object} object The parent object of `objValue`. - * @returns {*} Returns the value to assign. - */ - function customDefaultsAssignIn(objValue, srcValue, key, object) { - if (objValue === undefined || - (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) { - return srcValue; - } - return objValue; - } - - /** - * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source - * objects into destination objects that are passed thru. - * - * @private - * @param {*} objValue The destination value. - * @param {*} srcValue The source value. - * @param {string} key The key of the property to merge. - * @param {Object} object The parent object of `objValue`. - * @param {Object} source The parent object of `srcValue`. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - * @returns {*} Returns the value to assign. - */ - function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { - if (isObject(objValue) && isObject(srcValue)) { - // Recursively merge objects and arrays (susceptible to call stack limits). - stack.set(srcValue, objValue); - baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack); - stack['delete'](srcValue); - } - return objValue; - } - - /** - * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain - * objects. - * - * @private - * @param {*} value The value to inspect. - * @param {string} key The key of the property to inspect. - * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. - */ - function customOmitClone(value) { - return isPlainObject(value) ? undefined : value; - } - - /** - * A specialized version of `baseIsEqualDeep` for arrays with support for - * partial deep comparisons. - * - * @private - * @param {Array} array The array to compare. - * @param {Array} other The other array to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `array` and `other` objects. - * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. - */ - function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - arrLength = array.length, - othLength = other.length; - - if (arrLength != othLength && !(isPartial && othLength > arrLength)) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(array); - if (stacked && stack.get(other)) { - return stacked == other; - } - var index = -1, - result = true, - seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; - - stack.set(array, other); - stack.set(other, array); - - // Ignore non-index properties. - while (++index < arrLength) { - var arrValue = array[index], - othValue = other[index]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, arrValue, index, other, array, stack) - : customizer(arrValue, othValue, index, array, other, stack); - } - if (compared !== undefined) { - if (compared) { - continue; - } - result = false; - break; - } - // Recursively compare arrays (susceptible to call stack limits). - if (seen) { - if (!arraySome(other, function(othValue, othIndex) { - if (!cacheHas(seen, othIndex) && - (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { - return seen.push(othIndex); - } - })) { - result = false; - break; - } - } else if (!( - arrValue === othValue || - equalFunc(arrValue, othValue, bitmask, customizer, stack) - )) { - result = false; - break; - } - } - stack['delete'](array); - stack['delete'](other); - return result; - } - - /** - * A specialized version of `baseIsEqualDeep` for comparing objects of - * the same `toStringTag`. - * - * **Note:** This function only supports comparing values with tags of - * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {string} tag The `toStringTag` of the objects to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { - switch (tag) { - case dataViewTag: - if ((object.byteLength != other.byteLength) || - (object.byteOffset != other.byteOffset)) { - return false; - } - object = object.buffer; - other = other.buffer; - - case arrayBufferTag: - if ((object.byteLength != other.byteLength) || - !equalFunc(new Uint8Array(object), new Uint8Array(other))) { - return false; - } - return true; - - case boolTag: - case dateTag: - case numberTag: - // Coerce booleans to `1` or `0` and dates to milliseconds. - // Invalid dates are coerced to `NaN`. - return eq(+object, +other); - - case errorTag: - return object.name == other.name && object.message == other.message; - - case regexpTag: - case stringTag: - // Coerce regexes to strings and treat strings, primitives and objects, - // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring - // for more details. - return object == (other + ''); - - case mapTag: - var convert = mapToArray; - - case setTag: - var isPartial = bitmask & COMPARE_PARTIAL_FLAG; - convert || (convert = setToArray); - - if (object.size != other.size && !isPartial) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked) { - return stacked == other; - } - bitmask |= COMPARE_UNORDERED_FLAG; - - // Recursively compare objects (susceptible to call stack limits). - stack.set(object, other); - var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); - stack['delete'](object); - return result; - - case symbolTag: - if (symbolValueOf) { - return symbolValueOf.call(object) == symbolValueOf.call(other); - } - } - return false; - } - - /** - * A specialized version of `baseIsEqualDeep` for objects with support for - * partial deep comparisons. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - objProps = getAllKeys(object), - objLength = objProps.length, - othProps = getAllKeys(other), - othLength = othProps.length; - - if (objLength != othLength && !isPartial) { - return false; - } - var index = objLength; - while (index--) { - var key = objProps[index]; - if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { - return false; - } - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked && stack.get(other)) { - return stacked == other; - } - var result = true; - stack.set(object, other); - stack.set(other, object); - - var skipCtor = isPartial; - while (++index < objLength) { - key = objProps[index]; - var objValue = object[key], - othValue = other[key]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, objValue, key, other, object, stack) - : customizer(objValue, othValue, key, object, other, stack); - } - // Recursively compare objects (susceptible to call stack limits). - if (!(compared === undefined - ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) - : compared - )) { - result = false; - break; - } - skipCtor || (skipCtor = key == 'constructor'); - } - if (result && !skipCtor) { - var objCtor = object.constructor, - othCtor = other.constructor; - - // Non `Object` object instances with different constructors are not equal. - if (objCtor != othCtor && - ('constructor' in object && 'constructor' in other) && - !(typeof objCtor == 'function' && objCtor instanceof objCtor && - typeof othCtor == 'function' && othCtor instanceof othCtor)) { - result = false; - } - } - stack['delete'](object); - stack['delete'](other); - return result; - } - - /** - * A specialized version of `baseRest` which flattens the rest array. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @returns {Function} Returns the new function. - */ - function flatRest(func) { - return setToString(overRest(func, undefined, flatten), func + ''); - } - - /** - * Creates an array of own enumerable property names and symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ - function getAllKeys(object) { - return baseGetAllKeys(object, keys, getSymbols); - } - - /** - * Creates an array of own and inherited enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ - function getAllKeysIn(object) { - return baseGetAllKeys(object, keysIn, getSymbolsIn); - } - - /** - * Gets metadata for `func`. - * - * @private - * @param {Function} func The function to query. - * @returns {*} Returns the metadata for `func`. - */ - var getData = !metaMap ? noop : function(func) { - return metaMap.get(func); - }; - - /** - * Gets the name of `func`. - * - * @private - * @param {Function} func The function to query. - * @returns {string} Returns the function name. - */ - function getFuncName(func) { - var result = (func.name + ''), - array = realNames[result], - length = hasOwnProperty.call(realNames, result) ? array.length : 0; - - while (length--) { - var data = array[length], - otherFunc = data.func; - if (otherFunc == null || otherFunc == func) { - return data.name; - } - } - return result; - } - - /** - * Gets the argument placeholder value for `func`. - * - * @private - * @param {Function} func The function to inspect. - * @returns {*} Returns the placeholder value. - */ - function getHolder(func) { - var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func; - return object.placeholder; - } - - /** - * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, - * this function returns the custom method, otherwise it returns `baseIteratee`. - * If arguments are provided, the chosen function is invoked with them and - * its result is returned. - * - * @private - * @param {*} [value] The value to convert to an iteratee. - * @param {number} [arity] The arity of the created iteratee. - * @returns {Function} Returns the chosen function or its result. - */ - function getIteratee() { - var result = lodash.iteratee || iteratee; - result = result === iteratee ? baseIteratee : result; - return arguments.length ? result(arguments[0], arguments[1]) : result; - } - - /** - * Gets the data for `map`. - * - * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. - */ - function getMapData(map, key) { - var data = map.__data__; - return isKeyable(key) - ? data[typeof key == 'string' ? 'string' : 'hash'] - : data.map; - } - - /** - * Gets the property names, values, and compare flags of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the match data of `object`. - */ - function getMatchData(object) { - var result = keys(object), - length = result.length; - - while (length--) { - var key = result[length], - value = object[key]; - - result[length] = [key, value, isStrictComparable(value)]; - } - return result; - } - - /** - * Gets the native function at `key` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. - */ - function getNative(object, key) { - var value = getValue(object, key); - return baseIsNative(value) ? value : undefined; - } - - /** - * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the raw `toStringTag`. - */ - function getRawTag(value) { - var isOwn = hasOwnProperty.call(value, symToStringTag), - tag = value[symToStringTag]; - - try { - value[symToStringTag] = undefined; - var unmasked = true; - } catch (e) {} - - var result = nativeObjectToString.call(value); - if (unmasked) { - if (isOwn) { - value[symToStringTag] = tag; - } else { - delete value[symToStringTag]; - } - } - return result; - } - - /** - * Creates an array of the own enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ - var getSymbols = !nativeGetSymbols ? stubArray : function(object) { - if (object == null) { - return []; - } - object = Object(object); - return arrayFilter(nativeGetSymbols(object), function(symbol) { - return propertyIsEnumerable.call(object, symbol); - }); - }; - - /** - * Creates an array of the own and inherited enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ - var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { - var result = []; - while (object) { - arrayPush(result, getSymbols(object)); - object = getPrototype(object); - } - return result; - }; - - /** - * Gets the `toStringTag` of `value`. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ - var getTag = baseGetTag; - - // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. - if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || - (Map && getTag(new Map) != mapTag) || - (Promise && getTag(Promise.resolve()) != promiseTag) || - (Set && getTag(new Set) != setTag) || - (WeakMap && getTag(new WeakMap) != weakMapTag)) { - getTag = function(value) { - var result = baseGetTag(value), - Ctor = result == objectTag ? value.constructor : undefined, - ctorString = Ctor ? toSource(Ctor) : ''; - - if (ctorString) { - switch (ctorString) { - case dataViewCtorString: return dataViewTag; - case mapCtorString: return mapTag; - case promiseCtorString: return promiseTag; - case setCtorString: return setTag; - case weakMapCtorString: return weakMapTag; - } - } - return result; - }; - } - - /** - * Gets the view, applying any `transforms` to the `start` and `end` positions. - * - * @private - * @param {number} start The start of the view. - * @param {number} end The end of the view. - * @param {Array} transforms The transformations to apply to the view. - * @returns {Object} Returns an object containing the `start` and `end` - * positions of the view. - */ - function getView(start, end, transforms) { - var index = -1, - length = transforms.length; - - while (++index < length) { - var data = transforms[index], - size = data.size; - - switch (data.type) { - case 'drop': start += size; break; - case 'dropRight': end -= size; break; - case 'take': end = nativeMin(end, start + size); break; - case 'takeRight': start = nativeMax(start, end - size); break; - } - } - return { 'start': start, 'end': end }; - } - - /** - * Extracts wrapper details from the `source` body comment. - * - * @private - * @param {string} source The source to inspect. - * @returns {Array} Returns the wrapper details. - */ - function getWrapDetails(source) { - var match = source.match(reWrapDetails); - return match ? match[1].split(reSplitDetails) : []; - } - - /** - * Checks if `path` exists on `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @param {Function} hasFunc The function to check properties. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - */ - function hasPath(object, path, hasFunc) { - path = castPath(path, object); - - var index = -1, - length = path.length, - result = false; - - while (++index < length) { - var key = toKey(path[index]); - if (!(result = object != null && hasFunc(object, key))) { - break; - } - object = object[key]; - } - if (result || ++index != length) { - return result; - } - length = object == null ? 0 : object.length; - return !!length && isLength(length) && isIndex(key, length) && - (isArray(object) || isArguments(object)); - } - - /** - * Initializes an array clone. - * - * @private - * @param {Array} array The array to clone. - * @returns {Array} Returns the initialized clone. - */ - function initCloneArray(array) { - var length = array.length, - result = new array.constructor(length); - - // Add properties assigned by `RegExp#exec`. - if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { - result.index = array.index; - result.input = array.input; - } - return result; - } - - /** - * Initializes an object clone. - * - * @private - * @param {Object} object The object to clone. - * @returns {Object} Returns the initialized clone. - */ - function initCloneObject(object) { - return (typeof object.constructor == 'function' && !isPrototype(object)) - ? baseCreate(getPrototype(object)) - : {}; - } - - /** - * Initializes an object clone based on its `toStringTag`. - * - * **Note:** This function only supports cloning values with tags of - * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. - * - * @private - * @param {Object} object The object to clone. - * @param {string} tag The `toStringTag` of the object to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the initialized clone. - */ - function initCloneByTag(object, tag, isDeep) { - var Ctor = object.constructor; - switch (tag) { - case arrayBufferTag: - return cloneArrayBuffer(object); - - case boolTag: - case dateTag: - return new Ctor(+object); - - case dataViewTag: - return cloneDataView(object, isDeep); - - case float32Tag: case float64Tag: - case int8Tag: case int16Tag: case int32Tag: - case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: - return cloneTypedArray(object, isDeep); - - case mapTag: - return new Ctor; - - case numberTag: - case stringTag: - return new Ctor(object); - - case regexpTag: - return cloneRegExp(object); - - case setTag: - return new Ctor; - - case symbolTag: - return cloneSymbol(object); - } - } - - /** - * Inserts wrapper `details` in a comment at the top of the `source` body. - * - * @private - * @param {string} source The source to modify. - * @returns {Array} details The details to insert. - * @returns {string} Returns the modified source. - */ - function insertWrapDetails(source, details) { - var length = details.length; - if (!length) { - return source; - } - var lastIndex = length - 1; - details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex]; - details = details.join(length > 2 ? ', ' : ' '); - return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n'); - } - - /** - * Checks if `value` is a flattenable `arguments` object or array. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. - */ - function isFlattenable(value) { - return isArray(value) || isArguments(value) || - !!(spreadableSymbol && value && value[spreadableSymbol]); - } - - /** - * Checks if `value` is a valid array-like index. - * - * @private - * @param {*} value The value to check. - * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. - * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. - */ - function isIndex(value, length) { - var type = typeof value; - length = length == null ? MAX_SAFE_INTEGER : length; - - return !!length && - (type == 'number' || - (type != 'symbol' && reIsUint.test(value))) && - (value > -1 && value % 1 == 0 && value < length); - } - - /** - * Checks if the given arguments are from an iteratee call. - * - * @private - * @param {*} value The potential iteratee value argument. - * @param {*} index The potential iteratee index or key argument. - * @param {*} object The potential iteratee object argument. - * @returns {boolean} Returns `true` if the arguments are from an iteratee call, - * else `false`. - */ - function isIterateeCall(value, index, object) { - if (!isObject(object)) { - return false; - } - var type = typeof index; - if (type == 'number' - ? (isArrayLike(object) && isIndex(index, object.length)) - : (type == 'string' && index in object) - ) { - return eq(object[index], value); - } - return false; - } - - /** - * Checks if `value` is a property name and not a property path. - * - * @private - * @param {*} value The value to check. - * @param {Object} [object] The object to query keys on. - * @returns {boolean} Returns `true` if `value` is a property name, else `false`. - */ - function isKey(value, object) { - if (isArray(value)) { - return false; - } - var type = typeof value; - if (type == 'number' || type == 'symbol' || type == 'boolean' || - value == null || isSymbol(value)) { - return true; - } - return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || - (object != null && value in Object(object)); - } - - /** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ - function isKeyable(value) { - var type = typeof value; - return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') - ? (value !== '__proto__') - : (value === null); - } - - /** - * Checks if `func` has a lazy counterpart. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` has a lazy counterpart, - * else `false`. - */ - function isLaziable(func) { - var funcName = getFuncName(func), - other = lodash[funcName]; - - if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { - return false; - } - if (func === other) { - return true; - } - var data = getData(other); - return !!data && func === data[0]; - } - - /** - * Checks if `func` has its source masked. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. - */ - function isMasked(func) { - return !!maskSrcKey && (maskSrcKey in func); - } - - /** - * Checks if `func` is capable of being masked. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `func` is maskable, else `false`. - */ - var isMaskable = coreJsData ? isFunction : stubFalse; - - /** - * Checks if `value` is likely a prototype object. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. - */ - function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; - - return value === proto; - } - - /** - * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` if suitable for strict - * equality comparisons, else `false`. - */ - function isStrictComparable(value) { - return value === value && !isObject(value); - } - - /** - * A specialized version of `matchesProperty` for source values suitable - * for strict equality comparisons, i.e. `===`. - * - * @private - * @param {string} key The key of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ - function matchesStrictComparable(key, srcValue) { - return function(object) { - if (object == null) { - return false; - } - return object[key] === srcValue && - (srcValue !== undefined || (key in Object(object))); - }; - } - - /** - * A specialized version of `_.memoize` which clears the memoized function's - * cache when it exceeds `MAX_MEMOIZE_SIZE`. - * - * @private - * @param {Function} func The function to have its output memoized. - * @returns {Function} Returns the new memoized function. - */ - function memoizeCapped(func) { - var result = memoize(func, function(key) { - if (cache.size === MAX_MEMOIZE_SIZE) { - cache.clear(); - } - return key; - }); - - var cache = result.cache; - return result; - } - - /** - * Merges the function metadata of `source` into `data`. - * - * Merging metadata reduces the number of wrappers used to invoke a function. - * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` - * may be applied regardless of execution order. Methods like `_.ary` and - * `_.rearg` modify function arguments, making the order in which they are - * executed important, preventing the merging of metadata. However, we make - * an exception for a safe combined case where curried functions have `_.ary` - * and or `_.rearg` applied. - * - * @private - * @param {Array} data The destination metadata. - * @param {Array} source The source metadata. - * @returns {Array} Returns `data`. - */ - function mergeData(data, source) { - var bitmask = data[1], - srcBitmask = source[1], - newBitmask = bitmask | srcBitmask, - isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); - - var isCombo = - ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) || - ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) || - ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG)); - - // Exit early if metadata can't be merged. - if (!(isCommon || isCombo)) { - return data; - } - // Use source `thisArg` if available. - if (srcBitmask & WRAP_BIND_FLAG) { - data[2] = source[2]; - // Set when currying a bound function. - newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; - } - // Compose partial arguments. - var value = source[3]; - if (value) { - var partials = data[3]; - data[3] = partials ? composeArgs(partials, value, source[4]) : value; - data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; - } - // Compose partial right arguments. - value = source[5]; - if (value) { - partials = data[5]; - data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; - data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; - } - // Use source `argPos` if available. - value = source[7]; - if (value) { - data[7] = value; - } - // Use source `ary` if it's smaller. - if (srcBitmask & WRAP_ARY_FLAG) { - data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); - } - // Use source `arity` if one is not provided. - if (data[9] == null) { - data[9] = source[9]; - } - // Use source `func` and merge bitmasks. - data[0] = source[0]; - data[1] = newBitmask; - - return data; - } - - /** - * This function is like - * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * except that it includes inherited enumerable properties. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function nativeKeysIn(object) { - var result = []; - if (object != null) { - for (var key in Object(object)) { - result.push(key); - } - } - return result; - } - - /** - * Converts `value` to a string using `Object.prototype.toString`. - * - * @private - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - */ - function objectToString(value) { - return nativeObjectToString.call(value); - } - - /** - * A specialized version of `baseRest` which transforms the rest array. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @param {Function} transform The rest array transform. - * @returns {Function} Returns the new function. - */ - function overRest(func, start, transform) { - start = nativeMax(start === undefined ? (func.length - 1) : start, 0); - return function() { - var args = arguments, - index = -1, - length = nativeMax(args.length - start, 0), - array = Array(length); - - while (++index < length) { - array[index] = args[start + index]; - } - index = -1; - var otherArgs = Array(start + 1); - while (++index < start) { - otherArgs[index] = args[index]; - } - otherArgs[start] = transform(array); - return apply(func, this, otherArgs); - }; - } - - /** - * Gets the parent value at `path` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} path The path to get the parent value of. - * @returns {*} Returns the parent value. - */ - function parent(object, path) { - return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); - } - - /** - * Reorder `array` according to the specified indexes where the element at - * the first index is assigned as the first element, the element at - * the second index is assigned as the second element, and so on. - * - * @private - * @param {Array} array The array to reorder. - * @param {Array} indexes The arranged array indexes. - * @returns {Array} Returns `array`. - */ - function reorder(array, indexes) { - var arrLength = array.length, - length = nativeMin(indexes.length, arrLength), - oldArray = copyArray(array); - - while (length--) { - var index = indexes[length]; - array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined; - } - return array; - } - - /** - * Sets metadata for `func`. - * - * **Note:** If this function becomes hot, i.e. is invoked a lot in a short - * period of time, it will trip its breaker and transition to an identity - * function to avoid garbage collection pauses in V8. See - * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) - * for more details. - * - * @private - * @param {Function} func The function to associate metadata with. - * @param {*} data The metadata. - * @returns {Function} Returns `func`. - */ - var setData = shortOut(baseSetData); - - /** - * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). - * - * @private - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @returns {number|Object} Returns the timer id or timeout object. - */ - var setTimeout = ctxSetTimeout || function(func, wait) { - return root.setTimeout(func, wait); - }; - - /** - * Sets the `toString` method of `func` to return `string`. - * - * @private - * @param {Function} func The function to modify. - * @param {Function} string The `toString` result. - * @returns {Function} Returns `func`. - */ - var setToString = shortOut(baseSetToString); - - /** - * Sets the `toString` method of `wrapper` to mimic the source of `reference` - * with wrapper details in a comment at the top of the source body. - * - * @private - * @param {Function} wrapper The function to modify. - * @param {Function} reference The reference function. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @returns {Function} Returns `wrapper`. - */ - function setWrapToString(wrapper, reference, bitmask) { - var source = (reference + ''); - return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); - } - - /** - * Creates a function that'll short out and invoke `identity` instead - * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` - * milliseconds. - * - * @private - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new shortable function. - */ - function shortOut(func) { - var count = 0, - lastCalled = 0; - - return function() { - var stamp = nativeNow(), - remaining = HOT_SPAN - (stamp - lastCalled); - - lastCalled = stamp; - if (remaining > 0) { - if (++count >= HOT_COUNT) { - return arguments[0]; - } - } else { - count = 0; - } - return func.apply(undefined, arguments); - }; - } - - /** - * A specialized version of `_.shuffle` which mutates and sets the size of `array`. - * - * @private - * @param {Array} array The array to shuffle. - * @param {number} [size=array.length] The size of `array`. - * @returns {Array} Returns `array`. - */ - function shuffleSelf(array, size) { - var index = -1, - length = array.length, - lastIndex = length - 1; - - size = size === undefined ? length : size; - while (++index < size) { - var rand = baseRandom(index, lastIndex), - value = array[rand]; - - array[rand] = array[index]; - array[index] = value; - } - array.length = size; - return array; - } - - /** - * Converts `string` to a property path array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. - */ - var stringToPath = memoizeCapped(function(string) { - var result = []; - if (string.charCodeAt(0) === 46 /* . */) { - result.push(''); - } - string.replace(rePropName, function(match, number, quote, subString) { - result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); - }); - return result; - }); - - /** - * Converts `value` to a string key if it's not a string or symbol. - * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. - */ - function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; - } - - /** - * Converts `func` to its source code. - * - * @private - * @param {Function} func The function to convert. - * @returns {string} Returns the source code. - */ - function toSource(func) { - if (func != null) { - try { - return funcToString.call(func); - } catch (e) {} - try { - return (func + ''); - } catch (e) {} - } - return ''; - } - - /** - * Updates wrapper `details` based on `bitmask` flags. - * - * @private - * @returns {Array} details The details to modify. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @returns {Array} Returns `details`. - */ - function updateWrapDetails(details, bitmask) { - arrayEach(wrapFlags, function(pair) { - var value = '_.' + pair[0]; - if ((bitmask & pair[1]) && !arrayIncludes(details, value)) { - details.push(value); - } - }); - return details.sort(); - } - - /** - * Creates a clone of `wrapper`. - * - * @private - * @param {Object} wrapper The wrapper to clone. - * @returns {Object} Returns the cloned wrapper. - */ - function wrapperClone(wrapper) { - if (wrapper instanceof LazyWrapper) { - return wrapper.clone(); - } - var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); - result.__actions__ = copyArray(wrapper.__actions__); - result.__index__ = wrapper.__index__; - result.__values__ = wrapper.__values__; - return result; - } - - /*------------------------------------------------------------------------*/ - - /** - * Creates an array of elements split into groups the length of `size`. - * If `array` can't be split evenly, the final chunk will be the remaining - * elements. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to process. - * @param {number} [size=1] The length of each chunk - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the new array of chunks. - * @example - * - * _.chunk(['a', 'b', 'c', 'd'], 2); - * // => [['a', 'b'], ['c', 'd']] - * - * _.chunk(['a', 'b', 'c', 'd'], 3); - * // => [['a', 'b', 'c'], ['d']] - */ - function chunk(array, size, guard) { - if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) { - size = 1; - } else { - size = nativeMax(toInteger(size), 0); - } - var length = array == null ? 0 : array.length; - if (!length || size < 1) { - return []; - } - var index = 0, - resIndex = 0, - result = Array(nativeCeil(length / size)); - - while (index < length) { - result[resIndex++] = baseSlice(array, index, (index += size)); - } - return result; - } - - /** - * Creates an array with all falsey values removed. The values `false`, `null`, - * `0`, `""`, `undefined`, and `NaN` are falsey. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to compact. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.compact([0, 1, false, 2, '', 3]); - * // => [1, 2, 3] - */ - function compact(array) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value) { - result[resIndex++] = value; - } - } - return result; - } - - /** - * Creates a new array concatenating `array` with any additional arrays - * and/or values. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to concatenate. - * @param {...*} [values] The values to concatenate. - * @returns {Array} Returns the new concatenated array. - * @example - * - * var array = [1]; - * var other = _.concat(array, 2, [3], [[4]]); - * - * console.log(other); - * // => [1, 2, 3, [4]] - * - * console.log(array); - * // => [1] - */ - function concat() { - var length = arguments.length; - if (!length) { - return []; - } - var args = Array(length - 1), - array = arguments[0], - index = length; - - while (index--) { - args[index - 1] = arguments[index]; - } - return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1)); - } - - /** - * Creates an array of `array` values not included in the other given arrays - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. The order and references of result values are - * determined by the first array. - * - * **Note:** Unlike `_.pullAll`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @returns {Array} Returns the new array of filtered values. - * @see _.without, _.xor - * @example - * - * _.difference([2, 1], [2, 3]); - * // => [1] - */ - var difference = baseRest(function(array, values) { - return isArrayLikeObject(array) - ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) - : []; - }); - - /** - * This method is like `_.difference` except that it accepts `iteratee` which - * is invoked for each element of `array` and `values` to generate the criterion - * by which they're compared. The order and references of result values are - * determined by the first array. The iteratee is invoked with one argument: - * (value). - * - * **Note:** Unlike `_.pullAllBy`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [1.2] - * - * // The `_.property` iteratee shorthand. - * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); - * // => [{ 'x': 2 }] - */ - var differenceBy = baseRest(function(array, values) { - var iteratee = last(values); - if (isArrayLikeObject(iteratee)) { - iteratee = undefined; - } - return isArrayLikeObject(array) - ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)) - : []; - }); - - /** - * This method is like `_.difference` except that it accepts `comparator` - * which is invoked to compare elements of `array` to `values`. The order and - * references of result values are determined by the first array. The comparator - * is invoked with two arguments: (arrVal, othVal). - * - * **Note:** Unlike `_.pullAllWith`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * - * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); - * // => [{ 'x': 2, 'y': 1 }] - */ - var differenceWith = baseRest(function(array, values) { - var comparator = last(values); - if (isArrayLikeObject(comparator)) { - comparator = undefined; - } - return isArrayLikeObject(array) - ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator) - : []; - }); - - /** - * Creates a slice of `array` with `n` elements dropped from the beginning. - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to drop. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.drop([1, 2, 3]); - * // => [2, 3] - * - * _.drop([1, 2, 3], 2); - * // => [3] - * - * _.drop([1, 2, 3], 5); - * // => [] - * - * _.drop([1, 2, 3], 0); - * // => [1, 2, 3] - */ - function drop(array, n, guard) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - return baseSlice(array, n < 0 ? 0 : n, length); - } - - /** - * Creates a slice of `array` with `n` elements dropped from the end. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to drop. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.dropRight([1, 2, 3]); - * // => [1, 2] - * - * _.dropRight([1, 2, 3], 2); - * // => [1] - * - * _.dropRight([1, 2, 3], 5); - * // => [] - * - * _.dropRight([1, 2, 3], 0); - * // => [1, 2, 3] - */ - function dropRight(array, n, guard) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - n = length - n; - return baseSlice(array, 0, n < 0 ? 0 : n); - } - - /** - * Creates a slice of `array` excluding elements dropped from the end. - * Elements are dropped until `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.dropRightWhile(users, function(o) { return !o.active; }); - * // => objects for ['barney'] - * - * // The `_.matches` iteratee shorthand. - * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); - * // => objects for ['barney', 'fred'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.dropRightWhile(users, ['active', false]); - * // => objects for ['barney'] - * - * // The `_.property` iteratee shorthand. - * _.dropRightWhile(users, 'active'); - * // => objects for ['barney', 'fred', 'pebbles'] - */ - function dropRightWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3), true, true) - : []; - } - - /** - * Creates a slice of `array` excluding elements dropped from the beginning. - * Elements are dropped until `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.dropWhile(users, function(o) { return !o.active; }); - * // => objects for ['pebbles'] - * - * // The `_.matches` iteratee shorthand. - * _.dropWhile(users, { 'user': 'barney', 'active': false }); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.dropWhile(users, ['active', false]); - * // => objects for ['pebbles'] - * - * // The `_.property` iteratee shorthand. - * _.dropWhile(users, 'active'); - * // => objects for ['barney', 'fred', 'pebbles'] - */ - function dropWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3), true) - : []; - } - - /** - * Fills elements of `array` with `value` from `start` up to, but not - * including, `end`. - * - * **Note:** This method mutates `array`. - * - * @static - * @memberOf _ - * @since 3.2.0 - * @category Array - * @param {Array} array The array to fill. - * @param {*} value The value to fill `array` with. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns `array`. - * @example - * - * var array = [1, 2, 3]; - * - * _.fill(array, 'a'); - * console.log(array); - * // => ['a', 'a', 'a'] - * - * _.fill(Array(3), 2); - * // => [2, 2, 2] - * - * _.fill([4, 6, 8, 10], '*', 1, 3); - * // => [4, '*', '*', 10] - */ - function fill(array, value, start, end) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - if (start && typeof start != 'number' && isIterateeCall(array, value, start)) { - start = 0; - end = length; - } - return baseFill(array, value, start, end); - } - - /** - * This method is like `_.find` except that it returns the index of the first - * element `predicate` returns truthy for instead of the element itself. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=0] The index to search from. - * @returns {number} Returns the index of the found element, else `-1`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.findIndex(users, function(o) { return o.user == 'barney'; }); - * // => 0 - * - * // The `_.matches` iteratee shorthand. - * _.findIndex(users, { 'user': 'fred', 'active': false }); - * // => 1 - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findIndex(users, ['active', false]); - * // => 0 - * - * // The `_.property` iteratee shorthand. - * _.findIndex(users, 'active'); - * // => 2 - */ - function findIndex(array, predicate, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = fromIndex == null ? 0 : toInteger(fromIndex); - if (index < 0) { - index = nativeMax(length + index, 0); - } - return baseFindIndex(array, getIteratee(predicate, 3), index); - } - - /** - * This method is like `_.findIndex` except that it iterates over elements - * of `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=array.length-1] The index to search from. - * @returns {number} Returns the index of the found element, else `-1`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); - * // => 2 - * - * // The `_.matches` iteratee shorthand. - * _.findLastIndex(users, { 'user': 'barney', 'active': true }); - * // => 0 - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findLastIndex(users, ['active', false]); - * // => 2 - * - * // The `_.property` iteratee shorthand. - * _.findLastIndex(users, 'active'); - * // => 0 - */ - function findLastIndex(array, predicate, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = length - 1; - if (fromIndex !== undefined) { - index = toInteger(fromIndex); - index = fromIndex < 0 - ? nativeMax(length + index, 0) - : nativeMin(index, length - 1); - } - return baseFindIndex(array, getIteratee(predicate, 3), index, true); - } - - /** - * Flattens `array` a single level deep. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to flatten. - * @returns {Array} Returns the new flattened array. - * @example - * - * _.flatten([1, [2, [3, [4]], 5]]); - * // => [1, 2, [3, [4]], 5] - */ - function flatten(array) { - var length = array == null ? 0 : array.length; - return length ? baseFlatten(array, 1) : []; - } - - /** - * Recursively flattens `array`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to flatten. - * @returns {Array} Returns the new flattened array. - * @example - * - * _.flattenDeep([1, [2, [3, [4]], 5]]); - * // => [1, 2, 3, 4, 5] - */ - function flattenDeep(array) { - var length = array == null ? 0 : array.length; - return length ? baseFlatten(array, INFINITY) : []; - } - - /** - * Recursively flatten `array` up to `depth` times. - * - * @static - * @memberOf _ - * @since 4.4.0 - * @category Array - * @param {Array} array The array to flatten. - * @param {number} [depth=1] The maximum recursion depth. - * @returns {Array} Returns the new flattened array. - * @example - * - * var array = [1, [2, [3, [4]], 5]]; - * - * _.flattenDepth(array, 1); - * // => [1, 2, [3, [4]], 5] - * - * _.flattenDepth(array, 2); - * // => [1, 2, 3, [4], 5] - */ - function flattenDepth(array, depth) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - depth = depth === undefined ? 1 : toInteger(depth); - return baseFlatten(array, depth); - } - - /** - * The inverse of `_.toPairs`; this method returns an object composed - * from key-value `pairs`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} pairs The key-value pairs. - * @returns {Object} Returns the new object. - * @example - * - * _.fromPairs([['a', 1], ['b', 2]]); - * // => { 'a': 1, 'b': 2 } - */ - function fromPairs(pairs) { - var index = -1, - length = pairs == null ? 0 : pairs.length, - result = {}; - - while (++index < length) { - var pair = pairs[index]; - result[pair[0]] = pair[1]; - } - return result; - } - - /** - * Gets the first element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @alias first - * @category Array - * @param {Array} array The array to query. - * @returns {*} Returns the first element of `array`. - * @example - * - * _.head([1, 2, 3]); - * // => 1 - * - * _.head([]); - * // => undefined - */ - function head(array) { - return (array && array.length) ? array[0] : undefined; - } - - /** - * Gets the index at which the first occurrence of `value` is found in `array` - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. If `fromIndex` is negative, it's used as the - * offset from the end of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.indexOf([1, 2, 1, 2], 2); - * // => 1 - * - * // Search from the `fromIndex`. - * _.indexOf([1, 2, 1, 2], 2, 2); - * // => 3 - */ - function indexOf(array, value, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = fromIndex == null ? 0 : toInteger(fromIndex); - if (index < 0) { - index = nativeMax(length + index, 0); - } - return baseIndexOf(array, value, index); - } - - /** - * Gets all but the last element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.initial([1, 2, 3]); - * // => [1, 2] - */ - function initial(array) { - var length = array == null ? 0 : array.length; - return length ? baseSlice(array, 0, -1) : []; - } - - /** - * Creates an array of unique values that are included in all given arrays - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. The order and references of result values are - * determined by the first array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * _.intersection([2, 1], [2, 3]); - * // => [2] - */ - var intersection = baseRest(function(arrays) { - var mapped = arrayMap(arrays, castArrayLikeObject); - return (mapped.length && mapped[0] === arrays[0]) - ? baseIntersection(mapped) - : []; - }); - - /** - * This method is like `_.intersection` except that it accepts `iteratee` - * which is invoked for each element of each `arrays` to generate the criterion - * by which they're compared. The order and references of result values are - * determined by the first array. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [2.1] - * - * // The `_.property` iteratee shorthand. - * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }] - */ - var intersectionBy = baseRest(function(arrays) { - var iteratee = last(arrays), - mapped = arrayMap(arrays, castArrayLikeObject); - - if (iteratee === last(mapped)) { - iteratee = undefined; - } else { - mapped.pop(); - } - return (mapped.length && mapped[0] === arrays[0]) - ? baseIntersection(mapped, getIteratee(iteratee, 2)) - : []; - }); - - /** - * This method is like `_.intersection` except that it accepts `comparator` - * which is invoked to compare elements of `arrays`. The order and references - * of result values are determined by the first array. The comparator is - * invoked with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.intersectionWith(objects, others, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }] - */ - var intersectionWith = baseRest(function(arrays) { - var comparator = last(arrays), - mapped = arrayMap(arrays, castArrayLikeObject); - - comparator = typeof comparator == 'function' ? comparator : undefined; - if (comparator) { - mapped.pop(); - } - return (mapped.length && mapped[0] === arrays[0]) - ? baseIntersection(mapped, undefined, comparator) - : []; - }); - - /** - * Converts all elements in `array` into a string separated by `separator`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to convert. - * @param {string} [separator=','] The element separator. - * @returns {string} Returns the joined string. - * @example - * - * _.join(['a', 'b', 'c'], '~'); - * // => 'a~b~c' - */ - function join(array, separator) { - return array == null ? '' : nativeJoin.call(array, separator); - } - - /** - * Gets the last element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @returns {*} Returns the last element of `array`. - * @example - * - * _.last([1, 2, 3]); - * // => 3 - */ - function last(array) { - var length = array == null ? 0 : array.length; - return length ? array[length - 1] : undefined; - } - - /** - * This method is like `_.indexOf` except that it iterates over elements of - * `array` from right to left. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=array.length-1] The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.lastIndexOf([1, 2, 1, 2], 2); - * // => 3 - * - * // Search from the `fromIndex`. - * _.lastIndexOf([1, 2, 1, 2], 2, 2); - * // => 1 - */ - function lastIndexOf(array, value, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = length; - if (fromIndex !== undefined) { - index = toInteger(fromIndex); - index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); - } - return value === value - ? strictLastIndexOf(array, value, index) - : baseFindIndex(array, baseIsNaN, index, true); - } - - /** - * Gets the element at index `n` of `array`. If `n` is negative, the nth - * element from the end is returned. - * - * @static - * @memberOf _ - * @since 4.11.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=0] The index of the element to return. - * @returns {*} Returns the nth element of `array`. - * @example - * - * var array = ['a', 'b', 'c', 'd']; - * - * _.nth(array, 1); - * // => 'b' - * - * _.nth(array, -2); - * // => 'c'; - */ - function nth(array, n) { - return (array && array.length) ? baseNth(array, toInteger(n)) : undefined; - } - - /** - * Removes all given values from `array` using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` - * to remove elements from an array by predicate. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {...*} [values] The values to remove. - * @returns {Array} Returns `array`. - * @example - * - * var array = ['a', 'b', 'c', 'a', 'b', 'c']; - * - * _.pull(array, 'a', 'c'); - * console.log(array); - * // => ['b', 'b'] - */ - var pull = baseRest(pullAll); - - /** - * This method is like `_.pull` except that it accepts an array of values to remove. - * - * **Note:** Unlike `_.difference`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @returns {Array} Returns `array`. - * @example - * - * var array = ['a', 'b', 'c', 'a', 'b', 'c']; - * - * _.pullAll(array, ['a', 'c']); - * console.log(array); - * // => ['b', 'b'] - */ - function pullAll(array, values) { - return (array && array.length && values && values.length) - ? basePullAll(array, values) - : array; - } - - /** - * This method is like `_.pullAll` except that it accepts `iteratee` which is - * invoked for each element of `array` and `values` to generate the criterion - * by which they're compared. The iteratee is invoked with one argument: (value). - * - * **Note:** Unlike `_.differenceBy`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns `array`. - * @example - * - * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; - * - * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); - * console.log(array); - * // => [{ 'x': 2 }] - */ - function pullAllBy(array, values, iteratee) { - return (array && array.length && values && values.length) - ? basePullAll(array, values, getIteratee(iteratee, 2)) - : array; - } - - /** - * This method is like `_.pullAll` except that it accepts `comparator` which - * is invoked to compare elements of `array` to `values`. The comparator is - * invoked with two arguments: (arrVal, othVal). - * - * **Note:** Unlike `_.differenceWith`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns `array`. - * @example - * - * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; - * - * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); - * console.log(array); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] - */ - function pullAllWith(array, values, comparator) { - return (array && array.length && values && values.length) - ? basePullAll(array, values, undefined, comparator) - : array; - } - - /** - * Removes elements from `array` corresponding to `indexes` and returns an - * array of removed elements. - * - * **Note:** Unlike `_.at`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {...(number|number[])} [indexes] The indexes of elements to remove. - * @returns {Array} Returns the new array of removed elements. - * @example - * - * var array = ['a', 'b', 'c', 'd']; - * var pulled = _.pullAt(array, [1, 3]); - * - * console.log(array); - * // => ['a', 'c'] - * - * console.log(pulled); - * // => ['b', 'd'] - */ - var pullAt = flatRest(function(array, indexes) { - var length = array == null ? 0 : array.length, - result = baseAt(array, indexes); - - basePullAt(array, arrayMap(indexes, function(index) { - return isIndex(index, length) ? +index : index; - }).sort(compareAscending)); - - return result; - }); - - /** - * Removes all elements from `array` that `predicate` returns truthy for - * and returns an array of the removed elements. The predicate is invoked - * with three arguments: (value, index, array). - * - * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` - * to pull elements from an array by value. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new array of removed elements. - * @example - * - * var array = [1, 2, 3, 4]; - * var evens = _.remove(array, function(n) { - * return n % 2 == 0; - * }); - * - * console.log(array); - * // => [1, 3] - * - * console.log(evens); - * // => [2, 4] - */ - function remove(array, predicate) { - var result = []; - if (!(array && array.length)) { - return result; - } - var index = -1, - indexes = [], - length = array.length; - - predicate = getIteratee(predicate, 3); - while (++index < length) { - var value = array[index]; - if (predicate(value, index, array)) { - result.push(value); - indexes.push(index); - } - } - basePullAt(array, indexes); - return result; - } - - /** - * Reverses `array` so that the first element becomes the last, the second - * element becomes the second to last, and so on. - * - * **Note:** This method mutates `array` and is based on - * [`Array#reverse`](https://mdn.io/Array/reverse). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @returns {Array} Returns `array`. - * @example - * - * var array = [1, 2, 3]; - * - * _.reverse(array); - * // => [3, 2, 1] - * - * console.log(array); - * // => [3, 2, 1] - */ - function reverse(array) { - return array == null ? array : nativeReverse.call(array); - } - - /** - * Creates a slice of `array` from `start` up to, but not including, `end`. - * - * **Note:** This method is used instead of - * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are - * returned. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ - function slice(array, start, end) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - if (end && typeof end != 'number' && isIterateeCall(array, start, end)) { - start = 0; - end = length; - } - else { - start = start == null ? 0 : toInteger(start); - end = end === undefined ? length : toInteger(end); - } - return baseSlice(array, start, end); - } - - /** - * Uses a binary search to determine the lowest index at which `value` - * should be inserted into `array` in order to maintain its sort order. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * _.sortedIndex([30, 50], 40); - * // => 1 - */ - function sortedIndex(array, value) { - return baseSortedIndex(array, value); - } - - /** - * This method is like `_.sortedIndex` except that it accepts `iteratee` - * which is invoked for `value` and each element of `array` to compute their - * sort ranking. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * var objects = [{ 'x': 4 }, { 'x': 5 }]; - * - * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); - * // => 0 - * - * // The `_.property` iteratee shorthand. - * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); - * // => 0 - */ - function sortedIndexBy(array, value, iteratee) { - return baseSortedIndexBy(array, value, getIteratee(iteratee, 2)); - } - - /** - * This method is like `_.indexOf` except that it performs a binary - * search on a sorted `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.sortedIndexOf([4, 5, 5, 5, 6], 5); - * // => 1 - */ - function sortedIndexOf(array, value) { - var length = array == null ? 0 : array.length; - if (length) { - var index = baseSortedIndex(array, value); - if (index < length && eq(array[index], value)) { - return index; - } - } - return -1; - } - - /** - * This method is like `_.sortedIndex` except that it returns the highest - * index at which `value` should be inserted into `array` in order to - * maintain its sort order. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * _.sortedLastIndex([4, 5, 5, 5, 6], 5); - * // => 4 - */ - function sortedLastIndex(array, value) { - return baseSortedIndex(array, value, true); - } - - /** - * This method is like `_.sortedLastIndex` except that it accepts `iteratee` - * which is invoked for `value` and each element of `array` to compute their - * sort ranking. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * var objects = [{ 'x': 4 }, { 'x': 5 }]; - * - * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); - * // => 1 - * - * // The `_.property` iteratee shorthand. - * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); - * // => 1 - */ - function sortedLastIndexBy(array, value, iteratee) { - return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true); - } - - /** - * This method is like `_.lastIndexOf` except that it performs a binary - * search on a sorted `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); - * // => 3 - */ - function sortedLastIndexOf(array, value) { - var length = array == null ? 0 : array.length; - if (length) { - var index = baseSortedIndex(array, value, true) - 1; - if (eq(array[index], value)) { - return index; - } - } - return -1; - } - - /** - * This method is like `_.uniq` except that it's designed and optimized - * for sorted arrays. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.sortedUniq([1, 1, 2]); - * // => [1, 2] - */ - function sortedUniq(array) { - return (array && array.length) - ? baseSortedUniq(array) - : []; - } - - /** - * This method is like `_.uniqBy` except that it's designed and optimized - * for sorted arrays. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); - * // => [1.1, 2.3] - */ - function sortedUniqBy(array, iteratee) { - return (array && array.length) - ? baseSortedUniq(array, getIteratee(iteratee, 2)) - : []; - } - - /** - * Gets all but the first element of `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to query. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.tail([1, 2, 3]); - * // => [2, 3] - */ - function tail(array) { - var length = array == null ? 0 : array.length; - return length ? baseSlice(array, 1, length) : []; - } - - /** - * Creates a slice of `array` with `n` elements taken from the beginning. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to take. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.take([1, 2, 3]); - * // => [1] - * - * _.take([1, 2, 3], 2); - * // => [1, 2] - * - * _.take([1, 2, 3], 5); - * // => [1, 2, 3] - * - * _.take([1, 2, 3], 0); - * // => [] - */ - function take(array, n, guard) { - if (!(array && array.length)) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - return baseSlice(array, 0, n < 0 ? 0 : n); - } - - /** - * Creates a slice of `array` with `n` elements taken from the end. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to take. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.takeRight([1, 2, 3]); - * // => [3] - * - * _.takeRight([1, 2, 3], 2); - * // => [2, 3] - * - * _.takeRight([1, 2, 3], 5); - * // => [1, 2, 3] - * - * _.takeRight([1, 2, 3], 0); - * // => [] - */ - function takeRight(array, n, guard) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - n = length - n; - return baseSlice(array, n < 0 ? 0 : n, length); - } - - /** - * Creates a slice of `array` with elements taken from the end. Elements are - * taken until `predicate` returns falsey. The predicate is invoked with - * three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.takeRightWhile(users, function(o) { return !o.active; }); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.matches` iteratee shorthand. - * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); - * // => objects for ['pebbles'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.takeRightWhile(users, ['active', false]); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.property` iteratee shorthand. - * _.takeRightWhile(users, 'active'); - * // => [] - */ - function takeRightWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3), false, true) - : []; - } - - /** - * Creates a slice of `array` with elements taken from the beginning. Elements - * are taken until `predicate` returns falsey. The predicate is invoked with - * three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.takeWhile(users, function(o) { return !o.active; }); - * // => objects for ['barney', 'fred'] - * - * // The `_.matches` iteratee shorthand. - * _.takeWhile(users, { 'user': 'barney', 'active': false }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.takeWhile(users, ['active', false]); - * // => objects for ['barney', 'fred'] - * - * // The `_.property` iteratee shorthand. - * _.takeWhile(users, 'active'); - * // => [] - */ - function takeWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3)) - : []; - } - - /** - * Creates an array of unique values, in order, from all given arrays using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of combined values. - * @example - * - * _.union([2], [1, 2]); - * // => [2, 1] - */ - var union = baseRest(function(arrays) { - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); - }); - - /** - * This method is like `_.union` except that it accepts `iteratee` which is - * invoked for each element of each `arrays` to generate the criterion by - * which uniqueness is computed. Result values are chosen from the first - * array in which the value occurs. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of combined values. - * @example - * - * _.unionBy([2.1], [1.2, 2.3], Math.floor); - * // => [2.1, 1.2] - * - * // The `_.property` iteratee shorthand. - * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - var unionBy = baseRest(function(arrays) { - var iteratee = last(arrays); - if (isArrayLikeObject(iteratee)) { - iteratee = undefined; - } - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)); - }); - - /** - * This method is like `_.union` except that it accepts `comparator` which - * is invoked to compare elements of `arrays`. Result values are chosen from - * the first array in which the value occurs. The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of combined values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.unionWith(objects, others, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] - */ - var unionWith = baseRest(function(arrays) { - var comparator = last(arrays); - comparator = typeof comparator == 'function' ? comparator : undefined; - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator); - }); - - /** - * Creates a duplicate-free version of an array, using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons, in which only the first occurrence of each element - * is kept. The order of result values is determined by the order they occur - * in the array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.uniq([2, 1, 2]); - * // => [2, 1] - */ - function uniq(array) { - return (array && array.length) ? baseUniq(array) : []; - } - - /** - * This method is like `_.uniq` except that it accepts `iteratee` which is - * invoked for each element in `array` to generate the criterion by which - * uniqueness is computed. The order of result values is determined by the - * order they occur in the array. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.uniqBy([2.1, 1.2, 2.3], Math.floor); - * // => [2.1, 1.2] - * - * // The `_.property` iteratee shorthand. - * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - function uniqBy(array, iteratee) { - return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : []; - } - - /** - * This method is like `_.uniq` except that it accepts `comparator` which - * is invoked to compare elements of `array`. The order of result values is - * determined by the order they occur in the array.The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.uniqWith(objects, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] - */ - function uniqWith(array, comparator) { - comparator = typeof comparator == 'function' ? comparator : undefined; - return (array && array.length) ? baseUniq(array, undefined, comparator) : []; - } - - /** - * This method is like `_.zip` except that it accepts an array of grouped - * elements and creates an array regrouping the elements to their pre-zip - * configuration. - * - * @static - * @memberOf _ - * @since 1.2.0 - * @category Array - * @param {Array} array The array of grouped elements to process. - * @returns {Array} Returns the new array of regrouped elements. - * @example - * - * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); - * // => [['a', 1, true], ['b', 2, false]] - * - * _.unzip(zipped); - * // => [['a', 'b'], [1, 2], [true, false]] - */ - function unzip(array) { - if (!(array && array.length)) { - return []; - } - var length = 0; - array = arrayFilter(array, function(group) { - if (isArrayLikeObject(group)) { - length = nativeMax(group.length, length); - return true; - } - }); - return baseTimes(length, function(index) { - return arrayMap(array, baseProperty(index)); - }); - } - - /** - * This method is like `_.unzip` except that it accepts `iteratee` to specify - * how regrouped values should be combined. The iteratee is invoked with the - * elements of each group: (...group). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Array - * @param {Array} array The array of grouped elements to process. - * @param {Function} [iteratee=_.identity] The function to combine - * regrouped values. - * @returns {Array} Returns the new array of regrouped elements. - * @example - * - * var zipped = _.zip([1, 2], [10, 20], [100, 200]); - * // => [[1, 10, 100], [2, 20, 200]] - * - * _.unzipWith(zipped, _.add); - * // => [3, 30, 300] - */ - function unzipWith(array, iteratee) { - if (!(array && array.length)) { - return []; - } - var result = unzip(array); - if (iteratee == null) { - return result; - } - return arrayMap(result, function(group) { - return apply(iteratee, undefined, group); - }); - } - - /** - * Creates an array excluding all given values using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * **Note:** Unlike `_.pull`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...*} [values] The values to exclude. - * @returns {Array} Returns the new array of filtered values. - * @see _.difference, _.xor - * @example - * - * _.without([2, 1, 2, 3], 1, 2); - * // => [3] - */ - var without = baseRest(function(array, values) { - return isArrayLikeObject(array) - ? baseDifference(array, values) - : []; - }); - - /** - * Creates an array of unique values that is the - * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) - * of the given arrays. The order of result values is determined by the order - * they occur in the arrays. - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of filtered values. - * @see _.difference, _.without - * @example - * - * _.xor([2, 1], [2, 3]); - * // => [1, 3] - */ - var xor = baseRest(function(arrays) { - return baseXor(arrayFilter(arrays, isArrayLikeObject)); - }); - - /** - * This method is like `_.xor` except that it accepts `iteratee` which is - * invoked for each element of each `arrays` to generate the criterion by - * which by which they're compared. The order of result values is determined - * by the order they occur in the arrays. The iteratee is invoked with one - * argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [1.2, 3.4] - * - * // The `_.property` iteratee shorthand. - * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 2 }] - */ - var xorBy = baseRest(function(arrays) { - var iteratee = last(arrays); - if (isArrayLikeObject(iteratee)) { - iteratee = undefined; - } - return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2)); - }); - - /** - * This method is like `_.xor` except that it accepts `comparator` which is - * invoked to compare elements of `arrays`. The order of result values is - * determined by the order they occur in the arrays. The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.xorWith(objects, others, _.isEqual); - * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] - */ - var xorWith = baseRest(function(arrays) { - var comparator = last(arrays); - comparator = typeof comparator == 'function' ? comparator : undefined; - return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator); - }); - - /** - * Creates an array of grouped elements, the first of which contains the - * first elements of the given arrays, the second of which contains the - * second elements of the given arrays, and so on. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to process. - * @returns {Array} Returns the new array of grouped elements. - * @example - * - * _.zip(['a', 'b'], [1, 2], [true, false]); - * // => [['a', 1, true], ['b', 2, false]] - */ - var zip = baseRest(unzip); - - /** - * This method is like `_.fromPairs` except that it accepts two arrays, - * one of property identifiers and one of corresponding values. - * - * @static - * @memberOf _ - * @since 0.4.0 - * @category Array - * @param {Array} [props=[]] The property identifiers. - * @param {Array} [values=[]] The property values. - * @returns {Object} Returns the new object. - * @example - * - * _.zipObject(['a', 'b'], [1, 2]); - * // => { 'a': 1, 'b': 2 } - */ - function zipObject(props, values) { - return baseZipObject(props || [], values || [], assignValue); - } - - /** - * This method is like `_.zipObject` except that it supports property paths. - * - * @static - * @memberOf _ - * @since 4.1.0 - * @category Array - * @param {Array} [props=[]] The property identifiers. - * @param {Array} [values=[]] The property values. - * @returns {Object} Returns the new object. - * @example - * - * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); - * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } - */ - function zipObjectDeep(props, values) { - return baseZipObject(props || [], values || [], baseSet); - } - - /** - * This method is like `_.zip` except that it accepts `iteratee` to specify - * how grouped values should be combined. The iteratee is invoked with the - * elements of each group: (...group). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Array - * @param {...Array} [arrays] The arrays to process. - * @param {Function} [iteratee=_.identity] The function to combine - * grouped values. - * @returns {Array} Returns the new array of grouped elements. - * @example - * - * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { - * return a + b + c; - * }); - * // => [111, 222] - */ - var zipWith = baseRest(function(arrays) { - var length = arrays.length, - iteratee = length > 1 ? arrays[length - 1] : undefined; - - iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined; - return unzipWith(arrays, iteratee); - }); - - /*------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` wrapper instance that wraps `value` with explicit method - * chain sequences enabled. The result of such sequences must be unwrapped - * with `_#value`. - * - * @static - * @memberOf _ - * @since 1.3.0 - * @category Seq - * @param {*} value The value to wrap. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'pebbles', 'age': 1 } - * ]; - * - * var youngest = _ - * .chain(users) - * .sortBy('age') - * .map(function(o) { - * return o.user + ' is ' + o.age; - * }) - * .head() - * .value(); - * // => 'pebbles is 1' - */ - function chain(value) { - var result = lodash(value); - result.__chain__ = true; - return result; - } - - /** - * This method invokes `interceptor` and returns `value`. The interceptor - * is invoked with one argument; (value). The purpose of this method is to - * "tap into" a method chain sequence in order to modify intermediate results. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @param {*} value The value to provide to `interceptor`. - * @param {Function} interceptor The function to invoke. - * @returns {*} Returns `value`. - * @example - * - * _([1, 2, 3]) - * .tap(function(array) { - * // Mutate input array. - * array.pop(); - * }) - * .reverse() - * .value(); - * // => [2, 1] - */ - function tap(value, interceptor) { - interceptor(value); - return value; - } - - /** - * This method is like `_.tap` except that it returns the result of `interceptor`. - * The purpose of this method is to "pass thru" values replacing intermediate - * results in a method chain sequence. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Seq - * @param {*} value The value to provide to `interceptor`. - * @param {Function} interceptor The function to invoke. - * @returns {*} Returns the result of `interceptor`. - * @example - * - * _(' abc ') - * .chain() - * .trim() - * .thru(function(value) { - * return [value]; - * }) - * .value(); - * // => ['abc'] - */ - function thru(value, interceptor) { - return interceptor(value); - } - - /** - * This method is the wrapper version of `_.at`. - * - * @name at - * @memberOf _ - * @since 1.0.0 - * @category Seq - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - * - * _(object).at(['a[0].b.c', 'a[1]']).value(); - * // => [3, 4] - */ - var wrapperAt = flatRest(function(paths) { - var length = paths.length, - start = length ? paths[0] : 0, - value = this.__wrapped__, - interceptor = function(object) { return baseAt(object, paths); }; - - if (length > 1 || this.__actions__.length || - !(value instanceof LazyWrapper) || !isIndex(start)) { - return this.thru(interceptor); - } - value = value.slice(start, +start + (length ? 1 : 0)); - value.__actions__.push({ - 'func': thru, - 'args': [interceptor], - 'thisArg': undefined - }); - return new LodashWrapper(value, this.__chain__).thru(function(array) { - if (length && !array.length) { - array.push(undefined); - } - return array; - }); - }); - - /** - * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. - * - * @name chain - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 } - * ]; - * - * // A sequence without explicit chaining. - * _(users).head(); - * // => { 'user': 'barney', 'age': 36 } - * - * // A sequence with explicit chaining. - * _(users) - * .chain() - * .head() - * .pick('user') - * .value(); - * // => { 'user': 'barney' } - */ - function wrapperChain() { - return chain(this); - } - - /** - * Executes the chain sequence and returns the wrapped result. - * - * @name commit - * @memberOf _ - * @since 3.2.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var array = [1, 2]; - * var wrapped = _(array).push(3); - * - * console.log(array); - * // => [1, 2] - * - * wrapped = wrapped.commit(); - * console.log(array); - * // => [1, 2, 3] - * - * wrapped.last(); - * // => 3 - * - * console.log(array); - * // => [1, 2, 3] - */ - function wrapperCommit() { - return new LodashWrapper(this.value(), this.__chain__); - } - - /** - * Gets the next value on a wrapped object following the - * [iterator protocol](https://mdn.io/iteration_protocols#iterator). - * - * @name next - * @memberOf _ - * @since 4.0.0 - * @category Seq - * @returns {Object} Returns the next iterator value. - * @example - * - * var wrapped = _([1, 2]); - * - * wrapped.next(); - * // => { 'done': false, 'value': 1 } - * - * wrapped.next(); - * // => { 'done': false, 'value': 2 } - * - * wrapped.next(); - * // => { 'done': true, 'value': undefined } - */ - function wrapperNext() { - if (this.__values__ === undefined) { - this.__values__ = toArray(this.value()); - } - var done = this.__index__ >= this.__values__.length, - value = done ? undefined : this.__values__[this.__index__++]; - - return { 'done': done, 'value': value }; - } - - /** - * Enables the wrapper to be iterable. - * - * @name Symbol.iterator - * @memberOf _ - * @since 4.0.0 - * @category Seq - * @returns {Object} Returns the wrapper object. - * @example - * - * var wrapped = _([1, 2]); - * - * wrapped[Symbol.iterator]() === wrapped; - * // => true - * - * Array.from(wrapped); - * // => [1, 2] - */ - function wrapperToIterator() { - return this; - } - - /** - * Creates a clone of the chain sequence planting `value` as the wrapped value. - * - * @name plant - * @memberOf _ - * @since 3.2.0 - * @category Seq - * @param {*} value The value to plant. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * function square(n) { - * return n * n; - * } - * - * var wrapped = _([1, 2]).map(square); - * var other = wrapped.plant([3, 4]); - * - * other.value(); - * // => [9, 16] - * - * wrapped.value(); - * // => [1, 4] - */ - function wrapperPlant(value) { - var result, - parent = this; - - while (parent instanceof baseLodash) { - var clone = wrapperClone(parent); - clone.__index__ = 0; - clone.__values__ = undefined; - if (result) { - previous.__wrapped__ = clone; - } else { - result = clone; - } - var previous = clone; - parent = parent.__wrapped__; - } - previous.__wrapped__ = value; - return result; - } - - /** - * This method is the wrapper version of `_.reverse`. - * - * **Note:** This method mutates the wrapped array. - * - * @name reverse - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var array = [1, 2, 3]; - * - * _(array).reverse().value() - * // => [3, 2, 1] - * - * console.log(array); - * // => [3, 2, 1] - */ - function wrapperReverse() { - var value = this.__wrapped__; - if (value instanceof LazyWrapper) { - var wrapped = value; - if (this.__actions__.length) { - wrapped = new LazyWrapper(this); - } - wrapped = wrapped.reverse(); - wrapped.__actions__.push({ - 'func': thru, - 'args': [reverse], - 'thisArg': undefined - }); - return new LodashWrapper(wrapped, this.__chain__); - } - return this.thru(reverse); - } - - /** - * Executes the chain sequence to resolve the unwrapped value. - * - * @name value - * @memberOf _ - * @since 0.1.0 - * @alias toJSON, valueOf - * @category Seq - * @returns {*} Returns the resolved unwrapped value. - * @example - * - * _([1, 2, 3]).value(); - * // => [1, 2, 3] - */ - function wrapperValue() { - return baseWrapperValue(this.__wrapped__, this.__actions__); - } - - /*------------------------------------------------------------------------*/ - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The corresponding value of - * each key is the number of times the key was returned by `iteratee`. The - * iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.countBy([6.1, 4.2, 6.3], Math.floor); - * // => { '4': 1, '6': 2 } - * - * // The `_.property` iteratee shorthand. - * _.countBy(['one', 'two', 'three'], 'length'); - * // => { '3': 2, '5': 1 } - */ - var countBy = createAggregator(function(result, value, key) { - if (hasOwnProperty.call(result, key)) { - ++result[key]; - } else { - baseAssignValue(result, key, 1); - } - }); - - /** - * Checks if `predicate` returns truthy for **all** elements of `collection`. - * Iteration is stopped once `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index|key, collection). - * - * **Note:** This method returns `true` for - * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because - * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of - * elements of empty collections. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false`. - * @example - * - * _.every([true, 1, null, 'yes'], Boolean); - * // => false - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': false } - * ]; - * - * // The `_.matches` iteratee shorthand. - * _.every(users, { 'user': 'barney', 'active': false }); - * // => false - * - * // The `_.matchesProperty` iteratee shorthand. - * _.every(users, ['active', false]); - * // => true - * - * // The `_.property` iteratee shorthand. - * _.every(users, 'active'); - * // => false - */ - function every(collection, predicate, guard) { - var func = isArray(collection) ? arrayEvery : baseEvery; - if (guard && isIterateeCall(collection, predicate, guard)) { - predicate = undefined; - } - return func(collection, getIteratee(predicate, 3)); - } - - /** - * Iterates over elements of `collection`, returning an array of all elements - * `predicate` returns truthy for. The predicate is invoked with three - * arguments: (value, index|key, collection). - * - * **Note:** Unlike `_.remove`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - * @see _.reject - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': true }, - * { 'user': 'fred', 'age': 40, 'active': false } - * ]; - * - * _.filter(users, function(o) { return !o.active; }); - * // => objects for ['fred'] - * - * // The `_.matches` iteratee shorthand. - * _.filter(users, { 'age': 36, 'active': true }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.filter(users, ['active', false]); - * // => objects for ['fred'] - * - * // The `_.property` iteratee shorthand. - * _.filter(users, 'active'); - * // => objects for ['barney'] - */ - function filter(collection, predicate) { - var func = isArray(collection) ? arrayFilter : baseFilter; - return func(collection, getIteratee(predicate, 3)); - } - - /** - * Iterates over elements of `collection`, returning the first element - * `predicate` returns truthy for. The predicate is invoked with three - * arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=0] The index to search from. - * @returns {*} Returns the matched element, else `undefined`. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': true }, - * { 'user': 'fred', 'age': 40, 'active': false }, - * { 'user': 'pebbles', 'age': 1, 'active': true } - * ]; - * - * _.find(users, function(o) { return o.age < 40; }); - * // => object for 'barney' - * - * // The `_.matches` iteratee shorthand. - * _.find(users, { 'age': 1, 'active': true }); - * // => object for 'pebbles' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.find(users, ['active', false]); - * // => object for 'fred' - * - * // The `_.property` iteratee shorthand. - * _.find(users, 'active'); - * // => object for 'barney' - */ - var find = createFind(findIndex); - - /** - * This method is like `_.find` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Collection - * @param {Array|Object} collection The collection to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=collection.length-1] The index to search from. - * @returns {*} Returns the matched element, else `undefined`. - * @example - * - * _.findLast([1, 2, 3, 4], function(n) { - * return n % 2 == 1; - * }); - * // => 3 - */ - var findLast = createFind(findLastIndex); - - /** - * Creates a flattened array of values by running each element in `collection` - * thru `iteratee` and flattening the mapped results. The iteratee is invoked - * with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [n, n]; - * } - * - * _.flatMap([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ - function flatMap(collection, iteratee) { - return baseFlatten(map(collection, iteratee), 1); - } - - /** - * This method is like `_.flatMap` except that it recursively flattens the - * mapped results. - * - * @static - * @memberOf _ - * @since 4.7.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [[[n, n]]]; - * } - * - * _.flatMapDeep([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ - function flatMapDeep(collection, iteratee) { - return baseFlatten(map(collection, iteratee), INFINITY); - } - - /** - * This method is like `_.flatMap` except that it recursively flattens the - * mapped results up to `depth` times. - * - * @static - * @memberOf _ - * @since 4.7.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {number} [depth=1] The maximum recursion depth. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [[[n, n]]]; - * } - * - * _.flatMapDepth([1, 2], duplicate, 2); - * // => [[1, 1], [2, 2]] - */ - function flatMapDepth(collection, iteratee, depth) { - depth = depth === undefined ? 1 : toInteger(depth); - return baseFlatten(map(collection, iteratee), depth); - } - - /** - * Iterates over elements of `collection` and invokes `iteratee` for each element. - * The iteratee is invoked with three arguments: (value, index|key, collection). - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * **Note:** As with other "Collections" methods, objects with a "length" - * property are iterated like arrays. To avoid this behavior use `_.forIn` - * or `_.forOwn` for object iteration. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @alias each - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - * @see _.forEachRight - * @example - * - * _.forEach([1, 2], function(value) { - * console.log(value); - * }); - * // => Logs `1` then `2`. - * - * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a' then 'b' (iteration order is not guaranteed). - */ - function forEach(collection, iteratee) { - var func = isArray(collection) ? arrayEach : baseEach; - return func(collection, getIteratee(iteratee, 3)); - } - - /** - * This method is like `_.forEach` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @alias eachRight - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - * @see _.forEach - * @example - * - * _.forEachRight([1, 2], function(value) { - * console.log(value); - * }); - * // => Logs `2` then `1`. - */ - function forEachRight(collection, iteratee) { - var func = isArray(collection) ? arrayEachRight : baseEachRight; - return func(collection, getIteratee(iteratee, 3)); - } - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The order of grouped values - * is determined by the order they occur in `collection`. The corresponding - * value of each key is an array of elements responsible for generating the - * key. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.groupBy([6.1, 4.2, 6.3], Math.floor); - * // => { '4': [4.2], '6': [6.1, 6.3] } - * - * // The `_.property` iteratee shorthand. - * _.groupBy(['one', 'two', 'three'], 'length'); - * // => { '3': ['one', 'two'], '5': ['three'] } - */ - var groupBy = createAggregator(function(result, value, key) { - if (hasOwnProperty.call(result, key)) { - result[key].push(value); - } else { - baseAssignValue(result, key, [value]); - } - }); - - /** - * Checks if `value` is in `collection`. If `collection` is a string, it's - * checked for a substring of `value`, otherwise - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * is used for equality comparisons. If `fromIndex` is negative, it's used as - * the offset from the end of `collection`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {boolean} Returns `true` if `value` is found, else `false`. - * @example - * - * _.includes([1, 2, 3], 1); - * // => true - * - * _.includes([1, 2, 3], 1, 2); - * // => false - * - * _.includes({ 'a': 1, 'b': 2 }, 1); - * // => true - * - * _.includes('abcd', 'bc'); - * // => true - */ - function includes(collection, value, fromIndex, guard) { - collection = isArrayLike(collection) ? collection : values(collection); - fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0; - - var length = collection.length; - if (fromIndex < 0) { - fromIndex = nativeMax(length + fromIndex, 0); - } - return isString(collection) - ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1) - : (!!length && baseIndexOf(collection, value, fromIndex) > -1); - } - - /** - * Invokes the method at `path` of each element in `collection`, returning - * an array of the results of each invoked method. Any additional arguments - * are provided to each invoked method. If `path` is a function, it's invoked - * for, and `this` bound to, each element in `collection`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Array|Function|string} path The path of the method to invoke or - * the function invoked per iteration. - * @param {...*} [args] The arguments to invoke each method with. - * @returns {Array} Returns the array of results. - * @example - * - * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); - * // => [[1, 5, 7], [1, 2, 3]] - * - * _.invokeMap([123, 456], String.prototype.split, ''); - * // => [['1', '2', '3'], ['4', '5', '6']] - */ - var invokeMap = baseRest(function(collection, path, args) { - var index = -1, - isFunc = typeof path == 'function', - result = isArrayLike(collection) ? Array(collection.length) : []; - - baseEach(collection, function(value) { - result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args); - }); - return result; - }); - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The corresponding value of - * each key is the last element responsible for generating the key. The - * iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * var array = [ - * { 'dir': 'left', 'code': 97 }, - * { 'dir': 'right', 'code': 100 } - * ]; - * - * _.keyBy(array, function(o) { - * return String.fromCharCode(o.code); - * }); - * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } - * - * _.keyBy(array, 'dir'); - * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } - */ - var keyBy = createAggregator(function(result, value, key) { - baseAssignValue(result, key, value); - }); - - /** - * Creates an array of values by running each element in `collection` thru - * `iteratee`. The iteratee is invoked with three arguments: - * (value, index|key, collection). - * - * Many lodash methods are guarded to work as iteratees for methods like - * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. - * - * The guarded methods are: - * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, - * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, - * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, - * `template`, `trim`, `trimEnd`, `trimStart`, and `words` - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - * @example - * - * function square(n) { - * return n * n; - * } - * - * _.map([4, 8], square); - * // => [16, 64] - * - * _.map({ 'a': 4, 'b': 8 }, square); - * // => [16, 64] (iteration order is not guaranteed) - * - * var users = [ - * { 'user': 'barney' }, - * { 'user': 'fred' } - * ]; - * - * // The `_.property` iteratee shorthand. - * _.map(users, 'user'); - * // => ['barney', 'fred'] - */ - function map(collection, iteratee) { - var func = isArray(collection) ? arrayMap : baseMap; - return func(collection, getIteratee(iteratee, 3)); - } - - /** - * This method is like `_.sortBy` except that it allows specifying the sort - * orders of the iteratees to sort by. If `orders` is unspecified, all values - * are sorted in ascending order. Otherwise, specify an order of "desc" for - * descending or "asc" for ascending sort order of corresponding values. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] - * The iteratees to sort by. - * @param {string[]} [orders] The sort orders of `iteratees`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {Array} Returns the new sorted array. - * @example - * - * var users = [ - * { 'user': 'fred', 'age': 48 }, - * { 'user': 'barney', 'age': 34 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'barney', 'age': 36 } - * ]; - * - * // Sort by `user` in ascending order and by `age` in descending order. - * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); - * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] - */ - function orderBy(collection, iteratees, orders, guard) { - if (collection == null) { - return []; - } - if (!isArray(iteratees)) { - iteratees = iteratees == null ? [] : [iteratees]; - } - orders = guard ? undefined : orders; - if (!isArray(orders)) { - orders = orders == null ? [] : [orders]; - } - return baseOrderBy(collection, iteratees, orders); - } - - /** - * Creates an array of elements split into two groups, the first of which - * contains elements `predicate` returns truthy for, the second of which - * contains elements `predicate` returns falsey for. The predicate is - * invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the array of grouped elements. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': true }, - * { 'user': 'pebbles', 'age': 1, 'active': false } - * ]; - * - * _.partition(users, function(o) { return o.active; }); - * // => objects for [['fred'], ['barney', 'pebbles']] - * - * // The `_.matches` iteratee shorthand. - * _.partition(users, { 'age': 1, 'active': false }); - * // => objects for [['pebbles'], ['barney', 'fred']] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.partition(users, ['active', false]); - * // => objects for [['barney', 'pebbles'], ['fred']] - * - * // The `_.property` iteratee shorthand. - * _.partition(users, 'active'); - * // => objects for [['fred'], ['barney', 'pebbles']] - */ - var partition = createAggregator(function(result, value, key) { - result[key ? 0 : 1].push(value); - }, function() { return [[], []]; }); - - /** - * Reduces `collection` to a value which is the accumulated result of running - * each element in `collection` thru `iteratee`, where each successive - * invocation is supplied the return value of the previous. If `accumulator` - * is not given, the first element of `collection` is used as the initial - * value. The iteratee is invoked with four arguments: - * (accumulator, value, index|key, collection). - * - * Many lodash methods are guarded to work as iteratees for methods like - * `_.reduce`, `_.reduceRight`, and `_.transform`. - * - * The guarded methods are: - * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, - * and `sortBy` - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @returns {*} Returns the accumulated value. - * @see _.reduceRight - * @example - * - * _.reduce([1, 2], function(sum, n) { - * return sum + n; - * }, 0); - * // => 3 - * - * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { - * (result[value] || (result[value] = [])).push(key); - * return result; - * }, {}); - * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) - */ - function reduce(collection, iteratee, accumulator) { - var func = isArray(collection) ? arrayReduce : baseReduce, - initAccum = arguments.length < 3; - - return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach); - } - - /** - * This method is like `_.reduce` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @returns {*} Returns the accumulated value. - * @see _.reduce - * @example - * - * var array = [[0, 1], [2, 3], [4, 5]]; - * - * _.reduceRight(array, function(flattened, other) { - * return flattened.concat(other); - * }, []); - * // => [4, 5, 2, 3, 0, 1] - */ - function reduceRight(collection, iteratee, accumulator) { - var func = isArray(collection) ? arrayReduceRight : baseReduce, - initAccum = arguments.length < 3; - - return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight); - } - - /** - * The opposite of `_.filter`; this method returns the elements of `collection` - * that `predicate` does **not** return truthy for. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - * @see _.filter - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': true } - * ]; - * - * _.reject(users, function(o) { return !o.active; }); - * // => objects for ['fred'] - * - * // The `_.matches` iteratee shorthand. - * _.reject(users, { 'age': 40, 'active': true }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.reject(users, ['active', false]); - * // => objects for ['fred'] - * - * // The `_.property` iteratee shorthand. - * _.reject(users, 'active'); - * // => objects for ['barney'] - */ - function reject(collection, predicate) { - var func = isArray(collection) ? arrayFilter : baseFilter; - return func(collection, negate(getIteratee(predicate, 3))); - } - - /** - * Gets a random element from `collection`. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Collection - * @param {Array|Object} collection The collection to sample. - * @returns {*} Returns the random element. - * @example - * - * _.sample([1, 2, 3, 4]); - * // => 2 - */ - function sample(collection) { - var func = isArray(collection) ? arraySample : baseSample; - return func(collection); - } - - /** - * Gets `n` random elements at unique keys from `collection` up to the - * size of `collection`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to sample. - * @param {number} [n=1] The number of elements to sample. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the random elements. - * @example - * - * _.sampleSize([1, 2, 3], 2); - * // => [3, 1] - * - * _.sampleSize([1, 2, 3], 4); - * // => [2, 3, 1] - */ - function sampleSize(collection, n, guard) { - if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) { - n = 1; - } else { - n = toInteger(n); - } - var func = isArray(collection) ? arraySampleSize : baseSampleSize; - return func(collection, n); - } - - /** - * Creates an array of shuffled values, using a version of the - * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - * @example - * - * _.shuffle([1, 2, 3, 4]); - * // => [4, 1, 3, 2] - */ - function shuffle(collection) { - var func = isArray(collection) ? arrayShuffle : baseShuffle; - return func(collection); - } - - /** - * Gets the size of `collection` by returning its length for array-like - * values or the number of own enumerable string keyed properties for objects. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. - * @returns {number} Returns the collection size. - * @example - * - * _.size([1, 2, 3]); - * // => 3 - * - * _.size({ 'a': 1, 'b': 2 }); - * // => 2 - * - * _.size('pebbles'); - * // => 7 - */ - function size(collection) { - if (collection == null) { - return 0; - } - if (isArrayLike(collection)) { - return isString(collection) ? stringSize(collection) : collection.length; - } - var tag = getTag(collection); - if (tag == mapTag || tag == setTag) { - return collection.size; - } - return baseKeys(collection).length; - } - - /** - * Checks if `predicate` returns truthy for **any** element of `collection`. - * Iteration is stopped once `predicate` returns truthy. The predicate is - * invoked with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - * @example - * - * _.some([null, 0, 'yes', false], Boolean); - * // => true - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false } - * ]; - * - * // The `_.matches` iteratee shorthand. - * _.some(users, { 'user': 'barney', 'active': false }); - * // => false - * - * // The `_.matchesProperty` iteratee shorthand. - * _.some(users, ['active', false]); - * // => true - * - * // The `_.property` iteratee shorthand. - * _.some(users, 'active'); - * // => true - */ - function some(collection, predicate, guard) { - var func = isArray(collection) ? arraySome : baseSome; - if (guard && isIterateeCall(collection, predicate, guard)) { - predicate = undefined; - } - return func(collection, getIteratee(predicate, 3)); - } - - /** - * Creates an array of elements, sorted in ascending order by the results of - * running each element in a collection thru each iteratee. This method - * performs a stable sort, that is, it preserves the original sort order of - * equal elements. The iteratees are invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {...(Function|Function[])} [iteratees=[_.identity]] - * The iteratees to sort by. - * @returns {Array} Returns the new sorted array. - * @example - * - * var users = [ - * { 'user': 'fred', 'age': 48 }, - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'barney', 'age': 34 } - * ]; - * - * _.sortBy(users, [function(o) { return o.user; }]); - * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] - * - * _.sortBy(users, ['user', 'age']); - * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]] - */ - var sortBy = baseRest(function(collection, iteratees) { - if (collection == null) { - return []; - } - var length = iteratees.length; - if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { - iteratees = []; - } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { - iteratees = [iteratees[0]]; - } - return baseOrderBy(collection, baseFlatten(iteratees, 1), []); - }); - - /*------------------------------------------------------------------------*/ - - /** - * Gets the timestamp of the number of milliseconds that have elapsed since - * the Unix epoch (1 January 1970 00:00:00 UTC). - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Date - * @returns {number} Returns the timestamp. - * @example - * - * _.defer(function(stamp) { - * console.log(_.now() - stamp); - * }, _.now()); - * // => Logs the number of milliseconds it took for the deferred invocation. - */ - var now = ctxNow || function() { - return root.Date.now(); - }; - - /*------------------------------------------------------------------------*/ - - /** - * The opposite of `_.before`; this method creates a function that invokes - * `func` once it's called `n` or more times. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {number} n The number of calls before `func` is invoked. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var saves = ['profile', 'settings']; - * - * var done = _.after(saves.length, function() { - * console.log('done saving!'); - * }); - * - * _.forEach(saves, function(type) { - * asyncSave({ 'type': type, 'complete': done }); - * }); - * // => Logs 'done saving!' after the two async saves have completed. - */ - function after(n, func) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - n = toInteger(n); - return function() { - if (--n < 1) { - return func.apply(this, arguments); - } - }; - } - - /** - * Creates a function that invokes `func`, with up to `n` arguments, - * ignoring any additional arguments. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to cap arguments for. - * @param {number} [n=func.length] The arity cap. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new capped function. - * @example - * - * _.map(['6', '8', '10'], _.ary(parseInt, 1)); - * // => [6, 8, 10] - */ - function ary(func, n, guard) { - n = guard ? undefined : n; - n = (func && n == null) ? func.length : n; - return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n); - } - - /** - * Creates a function that invokes `func`, with the `this` binding and arguments - * of the created function, while it's called less than `n` times. Subsequent - * calls to the created function return the result of the last `func` invocation. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {number} n The number of calls at which `func` is no longer invoked. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * jQuery(element).on('click', _.before(5, addContactToList)); - * // => Allows adding up to 4 contacts to the list. - */ - function before(n, func) { - var result; - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - n = toInteger(n); - return function() { - if (--n > 0) { - result = func.apply(this, arguments); - } - if (n <= 1) { - func = undefined; - } - return result; - }; - } - - /** - * Creates a function that invokes `func` with the `this` binding of `thisArg` - * and `partials` prepended to the arguments it receives. - * - * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, - * may be used as a placeholder for partially applied arguments. - * - * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" - * property of bound functions. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to bind. - * @param {*} thisArg The `this` binding of `func`. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * function greet(greeting, punctuation) { - * return greeting + ' ' + this.user + punctuation; - * } - * - * var object = { 'user': 'fred' }; - * - * var bound = _.bind(greet, object, 'hi'); - * bound('!'); - * // => 'hi fred!' - * - * // Bound with placeholders. - * var bound = _.bind(greet, object, _, '!'); - * bound('hi'); - * // => 'hi fred!' - */ - var bind = baseRest(function(func, thisArg, partials) { - var bitmask = WRAP_BIND_FLAG; - if (partials.length) { - var holders = replaceHolders(partials, getHolder(bind)); - bitmask |= WRAP_PARTIAL_FLAG; - } - return createWrap(func, bitmask, thisArg, partials, holders); - }); - - /** - * Creates a function that invokes the method at `object[key]` with `partials` - * prepended to the arguments it receives. - * - * This method differs from `_.bind` by allowing bound functions to reference - * methods that may be redefined or don't yet exist. See - * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) - * for more details. - * - * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * @static - * @memberOf _ - * @since 0.10.0 - * @category Function - * @param {Object} object The object to invoke the method on. - * @param {string} key The key of the method. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var object = { - * 'user': 'fred', - * 'greet': function(greeting, punctuation) { - * return greeting + ' ' + this.user + punctuation; - * } - * }; - * - * var bound = _.bindKey(object, 'greet', 'hi'); - * bound('!'); - * // => 'hi fred!' - * - * object.greet = function(greeting, punctuation) { - * return greeting + 'ya ' + this.user + punctuation; - * }; - * - * bound('!'); - * // => 'hiya fred!' - * - * // Bound with placeholders. - * var bound = _.bindKey(object, 'greet', _, '!'); - * bound('hi'); - * // => 'hiya fred!' - */ - var bindKey = baseRest(function(object, key, partials) { - var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; - if (partials.length) { - var holders = replaceHolders(partials, getHolder(bindKey)); - bitmask |= WRAP_PARTIAL_FLAG; - } - return createWrap(key, bitmask, object, partials, holders); - }); - - /** - * Creates a function that accepts arguments of `func` and either invokes - * `func` returning its result, if at least `arity` number of arguments have - * been provided, or returns a function that accepts the remaining `func` - * arguments, and so on. The arity of `func` may be specified if `func.length` - * is not sufficient. - * - * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, - * may be used as a placeholder for provided arguments. - * - * **Note:** This method doesn't set the "length" property of curried functions. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Function - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new curried function. - * @example - * - * var abc = function(a, b, c) { - * return [a, b, c]; - * }; - * - * var curried = _.curry(abc); - * - * curried(1)(2)(3); - * // => [1, 2, 3] - * - * curried(1, 2)(3); - * // => [1, 2, 3] - * - * curried(1, 2, 3); - * // => [1, 2, 3] - * - * // Curried with placeholders. - * curried(1)(_, 3)(2); - * // => [1, 2, 3] - */ - function curry(func, arity, guard) { - arity = guard ? undefined : arity; - var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity); - result.placeholder = curry.placeholder; - return result; - } - - /** - * This method is like `_.curry` except that arguments are applied to `func` - * in the manner of `_.partialRight` instead of `_.partial`. - * - * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for provided arguments. - * - * **Note:** This method doesn't set the "length" property of curried functions. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new curried function. - * @example - * - * var abc = function(a, b, c) { - * return [a, b, c]; - * }; - * - * var curried = _.curryRight(abc); - * - * curried(3)(2)(1); - * // => [1, 2, 3] - * - * curried(2, 3)(1); - * // => [1, 2, 3] - * - * curried(1, 2, 3); - * // => [1, 2, 3] - * - * // Curried with placeholders. - * curried(3)(1, _)(2); - * // => [1, 2, 3] - */ - function curryRight(func, arity, guard) { - arity = guard ? undefined : arity; - var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity); - result.placeholder = curryRight.placeholder; - return result; - } - - /** - * Creates a debounced function that delays invoking `func` until after `wait` - * milliseconds have elapsed since the last time the debounced function was - * invoked. The debounced function comes with a `cancel` method to cancel - * delayed `func` invocations and a `flush` method to immediately invoke them. - * Provide `options` to indicate whether `func` should be invoked on the - * leading and/or trailing edge of the `wait` timeout. The `func` is invoked - * with the last arguments provided to the debounced function. Subsequent - * calls to the debounced function return the result of the last `func` - * invocation. - * - * **Note:** If `leading` and `trailing` options are `true`, `func` is - * invoked on the trailing edge of the timeout only if the debounced function - * is invoked more than once during the `wait` timeout. - * - * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred - * until to the next tick, similar to `setTimeout` with a timeout of `0`. - * - * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) - * for details over the differences between `_.debounce` and `_.throttle`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to debounce. - * @param {number} [wait=0] The number of milliseconds to delay. - * @param {Object} [options={}] The options object. - * @param {boolean} [options.leading=false] - * Specify invoking on the leading edge of the timeout. - * @param {number} [options.maxWait] - * The maximum time `func` is allowed to be delayed before it's invoked. - * @param {boolean} [options.trailing=true] - * Specify invoking on the trailing edge of the timeout. - * @returns {Function} Returns the new debounced function. - * @example - * - * // Avoid costly calculations while the window size is in flux. - * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); - * - * // Invoke `sendMail` when clicked, debouncing subsequent calls. - * jQuery(element).on('click', _.debounce(sendMail, 300, { - * 'leading': true, - * 'trailing': false - * })); - * - * // Ensure `batchLog` is invoked once after 1 second of debounced calls. - * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); - * var source = new EventSource('/stream'); - * jQuery(source).on('message', debounced); - * - * // Cancel the trailing debounced invocation. - * jQuery(window).on('popstate', debounced.cancel); - */ - function debounce(func, wait, options) { - var lastArgs, - lastThis, - maxWait, - result, - timerId, - lastCallTime, - lastInvokeTime = 0, - leading = false, - maxing = false, - trailing = true; - - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - wait = toNumber(wait) || 0; - if (isObject(options)) { - leading = !!options.leading; - maxing = 'maxWait' in options; - maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; - trailing = 'trailing' in options ? !!options.trailing : trailing; - } - - function invokeFunc(time) { - var args = lastArgs, - thisArg = lastThis; - - lastArgs = lastThis = undefined; - lastInvokeTime = time; - result = func.apply(thisArg, args); - return result; - } - - function leadingEdge(time) { - // Reset any `maxWait` timer. - lastInvokeTime = time; - // Start the timer for the trailing edge. - timerId = setTimeout(timerExpired, wait); - // Invoke the leading edge. - return leading ? invokeFunc(time) : result; - } - - function remainingWait(time) { - var timeSinceLastCall = time - lastCallTime, - timeSinceLastInvoke = time - lastInvokeTime, - timeWaiting = wait - timeSinceLastCall; - - return maxing - ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) - : timeWaiting; - } - - function shouldInvoke(time) { - var timeSinceLastCall = time - lastCallTime, - timeSinceLastInvoke = time - lastInvokeTime; - - // Either this is the first call, activity has stopped and we're at the - // trailing edge, the system time has gone backwards and we're treating - // it as the trailing edge, or we've hit the `maxWait` limit. - return (lastCallTime === undefined || (timeSinceLastCall >= wait) || - (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); - } - - function timerExpired() { - var time = now(); - if (shouldInvoke(time)) { - return trailingEdge(time); - } - // Restart the timer. - timerId = setTimeout(timerExpired, remainingWait(time)); - } - - function trailingEdge(time) { - timerId = undefined; - - // Only invoke if we have `lastArgs` which means `func` has been - // debounced at least once. - if (trailing && lastArgs) { - return invokeFunc(time); - } - lastArgs = lastThis = undefined; - return result; - } - - function cancel() { - if (timerId !== undefined) { - clearTimeout(timerId); - } - lastInvokeTime = 0; - lastArgs = lastCallTime = lastThis = timerId = undefined; - } - - function flush() { - return timerId === undefined ? result : trailingEdge(now()); - } - - function debounced() { - var time = now(), - isInvoking = shouldInvoke(time); - - lastArgs = arguments; - lastThis = this; - lastCallTime = time; - - if (isInvoking) { - if (timerId === undefined) { - return leadingEdge(lastCallTime); - } - if (maxing) { - // Handle invocations in a tight loop. - timerId = setTimeout(timerExpired, wait); - return invokeFunc(lastCallTime); - } - } - if (timerId === undefined) { - timerId = setTimeout(timerExpired, wait); - } - return result; - } - debounced.cancel = cancel; - debounced.flush = flush; - return debounced; - } - - /** - * Defers invoking the `func` until the current call stack has cleared. Any - * additional arguments are provided to `func` when it's invoked. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to defer. - * @param {...*} [args] The arguments to invoke `func` with. - * @returns {number} Returns the timer id. - * @example - * - * _.defer(function(text) { - * console.log(text); - * }, 'deferred'); - * // => Logs 'deferred' after one millisecond. - */ - var defer = baseRest(function(func, args) { - return baseDelay(func, 1, args); - }); - - /** - * Invokes `func` after `wait` milliseconds. Any additional arguments are - * provided to `func` when it's invoked. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @param {...*} [args] The arguments to invoke `func` with. - * @returns {number} Returns the timer id. - * @example - * - * _.delay(function(text) { - * console.log(text); - * }, 1000, 'later'); - * // => Logs 'later' after one second. - */ - var delay = baseRest(function(func, wait, args) { - return baseDelay(func, toNumber(wait) || 0, args); - }); - - /** - * Creates a function that invokes `func` with arguments reversed. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to flip arguments for. - * @returns {Function} Returns the new flipped function. - * @example - * - * var flipped = _.flip(function() { - * return _.toArray(arguments); - * }); - * - * flipped('a', 'b', 'c', 'd'); - * // => ['d', 'c', 'b', 'a'] - */ - function flip(func) { - return createWrap(func, WRAP_FLIP_FLAG); - } - - /** - * Creates a function that memoizes the result of `func`. If `resolver` is - * provided, it determines the cache key for storing the result based on the - * arguments provided to the memoized function. By default, the first argument - * provided to the memoized function is used as the map cache key. The `func` - * is invoked with the `this` binding of the memoized function. - * - * **Note:** The cache is exposed as the `cache` property on the memoized - * function. Its creation may be customized by replacing the `_.memoize.Cache` - * constructor with one whose instances implement the - * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) - * method interface of `clear`, `delete`, `get`, `has`, and `set`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] The function to resolve the cache key. - * @returns {Function} Returns the new memoized function. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * var other = { 'c': 3, 'd': 4 }; - * - * var values = _.memoize(_.values); - * values(object); - * // => [1, 2] - * - * values(other); - * // => [3, 4] - * - * object.a = 2; - * values(object); - * // => [1, 2] - * - * // Modify the result cache. - * values.cache.set(object, ['a', 'b']); - * values(object); - * // => ['a', 'b'] - * - * // Replace `_.memoize.Cache`. - * _.memoize.Cache = WeakMap; - */ - function memoize(func, resolver) { - if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { - throw new TypeError(FUNC_ERROR_TEXT); - } - var memoized = function() { - var args = arguments, - key = resolver ? resolver.apply(this, args) : args[0], - cache = memoized.cache; - - if (cache.has(key)) { - return cache.get(key); - } - var result = func.apply(this, args); - memoized.cache = cache.set(key, result) || cache; - return result; - }; - memoized.cache = new (memoize.Cache || MapCache); - return memoized; - } - - // Expose `MapCache`. - memoize.Cache = MapCache; - - /** - * Creates a function that negates the result of the predicate `func`. The - * `func` predicate is invoked with the `this` binding and arguments of the - * created function. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} predicate The predicate to negate. - * @returns {Function} Returns the new negated function. - * @example - * - * function isEven(n) { - * return n % 2 == 0; - * } - * - * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); - * // => [1, 3, 5] - */ - function negate(predicate) { - if (typeof predicate != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - return function() { - var args = arguments; - switch (args.length) { - case 0: return !predicate.call(this); - case 1: return !predicate.call(this, args[0]); - case 2: return !predicate.call(this, args[0], args[1]); - case 3: return !predicate.call(this, args[0], args[1], args[2]); - } - return !predicate.apply(this, args); - }; - } - - /** - * Creates a function that is restricted to invoking `func` once. Repeat calls - * to the function return the value of the first invocation. The `func` is - * invoked with the `this` binding and arguments of the created function. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var initialize = _.once(createApplication); - * initialize(); - * initialize(); - * // => `createApplication` is invoked once - */ - function once(func) { - return before(2, func); - } - - /** - * Creates a function that invokes `func` with its arguments transformed. - * - * @static - * @since 4.0.0 - * @memberOf _ - * @category Function - * @param {Function} func The function to wrap. - * @param {...(Function|Function[])} [transforms=[_.identity]] - * The argument transforms. - * @returns {Function} Returns the new function. - * @example - * - * function doubled(n) { - * return n * 2; - * } - * - * function square(n) { - * return n * n; - * } - * - * var func = _.overArgs(function(x, y) { - * return [x, y]; - * }, [square, doubled]); - * - * func(9, 3); - * // => [81, 6] - * - * func(10, 5); - * // => [100, 10] - */ - var overArgs = castRest(function(func, transforms) { - transforms = (transforms.length == 1 && isArray(transforms[0])) - ? arrayMap(transforms[0], baseUnary(getIteratee())) - : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())); - - var funcsLength = transforms.length; - return baseRest(function(args) { - var index = -1, - length = nativeMin(args.length, funcsLength); - - while (++index < length) { - args[index] = transforms[index].call(this, args[index]); - } - return apply(func, this, args); - }); - }); - - /** - * Creates a function that invokes `func` with `partials` prepended to the - * arguments it receives. This method is like `_.bind` except it does **not** - * alter the `this` binding. - * - * The `_.partial.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * **Note:** This method doesn't set the "length" property of partially - * applied functions. - * - * @static - * @memberOf _ - * @since 0.2.0 - * @category Function - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * function greet(greeting, name) { - * return greeting + ' ' + name; - * } - * - * var sayHelloTo = _.partial(greet, 'hello'); - * sayHelloTo('fred'); - * // => 'hello fred' - * - * // Partially applied with placeholders. - * var greetFred = _.partial(greet, _, 'fred'); - * greetFred('hi'); - * // => 'hi fred' - */ - var partial = baseRest(function(func, partials) { - var holders = replaceHolders(partials, getHolder(partial)); - return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders); - }); - - /** - * This method is like `_.partial` except that partially applied arguments - * are appended to the arguments it receives. - * - * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * **Note:** This method doesn't set the "length" property of partially - * applied functions. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Function - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * function greet(greeting, name) { - * return greeting + ' ' + name; - * } - * - * var greetFred = _.partialRight(greet, 'fred'); - * greetFred('hi'); - * // => 'hi fred' - * - * // Partially applied with placeholders. - * var sayHelloTo = _.partialRight(greet, 'hello', _); - * sayHelloTo('fred'); - * // => 'hello fred' - */ - var partialRight = baseRest(function(func, partials) { - var holders = replaceHolders(partials, getHolder(partialRight)); - return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders); - }); - - /** - * Creates a function that invokes `func` with arguments arranged according - * to the specified `indexes` where the argument value at the first index is - * provided as the first argument, the argument value at the second index is - * provided as the second argument, and so on. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to rearrange arguments for. - * @param {...(number|number[])} indexes The arranged argument indexes. - * @returns {Function} Returns the new function. - * @example - * - * var rearged = _.rearg(function(a, b, c) { - * return [a, b, c]; - * }, [2, 0, 1]); - * - * rearged('b', 'c', 'a') - * // => ['a', 'b', 'c'] - */ - var rearg = flatRest(function(func, indexes) { - return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes); - }); - - /** - * Creates a function that invokes `func` with the `this` binding of the - * created function and arguments from `start` and beyond provided as - * an array. - * - * **Note:** This method is based on the - * [rest parameter](https://mdn.io/rest_parameters). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. - * @example - * - * var say = _.rest(function(what, names) { - * return what + ' ' + _.initial(names).join(', ') + - * (_.size(names) > 1 ? ', & ' : '') + _.last(names); - * }); - * - * say('hello', 'fred', 'barney', 'pebbles'); - * // => 'hello fred, barney, & pebbles' - */ - function rest(func, start) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - start = start === undefined ? start : toInteger(start); - return baseRest(func, start); - } - - /** - * Creates a function that invokes `func` with the `this` binding of the - * create function and an array of arguments much like - * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). - * - * **Note:** This method is based on the - * [spread operator](https://mdn.io/spread_operator). - * - * @static - * @memberOf _ - * @since 3.2.0 - * @category Function - * @param {Function} func The function to spread arguments over. - * @param {number} [start=0] The start position of the spread. - * @returns {Function} Returns the new function. - * @example - * - * var say = _.spread(function(who, what) { - * return who + ' says ' + what; - * }); - * - * say(['fred', 'hello']); - * // => 'fred says hello' - * - * var numbers = Promise.all([ - * Promise.resolve(40), - * Promise.resolve(36) - * ]); - * - * numbers.then(_.spread(function(x, y) { - * return x + y; - * })); - * // => a Promise of 76 - */ - function spread(func, start) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - start = start == null ? 0 : nativeMax(toInteger(start), 0); - return baseRest(function(args) { - var array = args[start], - otherArgs = castSlice(args, 0, start); - - if (array) { - arrayPush(otherArgs, array); - } - return apply(func, this, otherArgs); - }); - } - - /** - * Creates a throttled function that only invokes `func` at most once per - * every `wait` milliseconds. The throttled function comes with a `cancel` - * method to cancel delayed `func` invocations and a `flush` method to - * immediately invoke them. Provide `options` to indicate whether `func` - * should be invoked on the leading and/or trailing edge of the `wait` - * timeout. The `func` is invoked with the last arguments provided to the - * throttled function. Subsequent calls to the throttled function return the - * result of the last `func` invocation. - * - * **Note:** If `leading` and `trailing` options are `true`, `func` is - * invoked on the trailing edge of the timeout only if the throttled function - * is invoked more than once during the `wait` timeout. - * - * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred - * until to the next tick, similar to `setTimeout` with a timeout of `0`. - * - * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) - * for details over the differences between `_.throttle` and `_.debounce`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to throttle. - * @param {number} [wait=0] The number of milliseconds to throttle invocations to. - * @param {Object} [options={}] The options object. - * @param {boolean} [options.leading=true] - * Specify invoking on the leading edge of the timeout. - * @param {boolean} [options.trailing=true] - * Specify invoking on the trailing edge of the timeout. - * @returns {Function} Returns the new throttled function. - * @example - * - * // Avoid excessively updating the position while scrolling. - * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); - * - * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. - * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); - * jQuery(element).on('click', throttled); - * - * // Cancel the trailing throttled invocation. - * jQuery(window).on('popstate', throttled.cancel); - */ - function throttle(func, wait, options) { - var leading = true, - trailing = true; - - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - if (isObject(options)) { - leading = 'leading' in options ? !!options.leading : leading; - trailing = 'trailing' in options ? !!options.trailing : trailing; - } - return debounce(func, wait, { - 'leading': leading, - 'maxWait': wait, - 'trailing': trailing - }); - } - - /** - * Creates a function that accepts up to one argument, ignoring any - * additional arguments. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - * @example - * - * _.map(['6', '8', '10'], _.unary(parseInt)); - * // => [6, 8, 10] - */ - function unary(func) { - return ary(func, 1); - } - - /** - * Creates a function that provides `value` to `wrapper` as its first - * argument. Any additional arguments provided to the function are appended - * to those provided to the `wrapper`. The wrapper is invoked with the `this` - * binding of the created function. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {*} value The value to wrap. - * @param {Function} [wrapper=identity] The wrapper function. - * @returns {Function} Returns the new function. - * @example - * - * var p = _.wrap(_.escape, function(func, text) { - * return '

' + func(text) + '

'; - * }); - * - * p('fred, barney, & pebbles'); - * // => '

fred, barney, & pebbles

' - */ - function wrap(value, wrapper) { - return partial(castFunction(wrapper), value); - } - - /*------------------------------------------------------------------------*/ - - /** - * Casts `value` as an array if it's not one. - * - * @static - * @memberOf _ - * @since 4.4.0 - * @category Lang - * @param {*} value The value to inspect. - * @returns {Array} Returns the cast array. - * @example - * - * _.castArray(1); - * // => [1] - * - * _.castArray({ 'a': 1 }); - * // => [{ 'a': 1 }] - * - * _.castArray('abc'); - * // => ['abc'] - * - * _.castArray(null); - * // => [null] - * - * _.castArray(undefined); - * // => [undefined] - * - * _.castArray(); - * // => [] - * - * var array = [1, 2, 3]; - * console.log(_.castArray(array) === array); - * // => true - */ - function castArray() { - if (!arguments.length) { - return []; - } - var value = arguments[0]; - return isArray(value) ? value : [value]; - } - - /** - * Creates a shallow clone of `value`. - * - * **Note:** This method is loosely based on the - * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) - * and supports cloning arrays, array buffers, booleans, date objects, maps, - * numbers, `Object` objects, regexes, sets, strings, symbols, and typed - * arrays. The own enumerable properties of `arguments` objects are cloned - * as plain objects. An empty object is returned for uncloneable values such - * as error objects, functions, DOM nodes, and WeakMaps. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to clone. - * @returns {*} Returns the cloned value. - * @see _.cloneDeep - * @example - * - * var objects = [{ 'a': 1 }, { 'b': 2 }]; - * - * var shallow = _.clone(objects); - * console.log(shallow[0] === objects[0]); - * // => true - */ - function clone(value) { - return baseClone(value, CLONE_SYMBOLS_FLAG); - } - - /** - * This method is like `_.clone` except that it accepts `customizer` which - * is invoked to produce the cloned value. If `customizer` returns `undefined`, - * cloning is handled by the method instead. The `customizer` is invoked with - * up to four arguments; (value [, index|key, object, stack]). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to clone. - * @param {Function} [customizer] The function to customize cloning. - * @returns {*} Returns the cloned value. - * @see _.cloneDeepWith - * @example - * - * function customizer(value) { - * if (_.isElement(value)) { - * return value.cloneNode(false); - * } - * } - * - * var el = _.cloneWith(document.body, customizer); - * - * console.log(el === document.body); - * // => false - * console.log(el.nodeName); - * // => 'BODY' - * console.log(el.childNodes.length); - * // => 0 - */ - function cloneWith(value, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return baseClone(value, CLONE_SYMBOLS_FLAG, customizer); - } - - /** - * This method is like `_.clone` except that it recursively clones `value`. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Lang - * @param {*} value The value to recursively clone. - * @returns {*} Returns the deep cloned value. - * @see _.clone - * @example - * - * var objects = [{ 'a': 1 }, { 'b': 2 }]; - * - * var deep = _.cloneDeep(objects); - * console.log(deep[0] === objects[0]); - * // => false - */ - function cloneDeep(value) { - return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG); - } - - /** - * This method is like `_.cloneWith` except that it recursively clones `value`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to recursively clone. - * @param {Function} [customizer] The function to customize cloning. - * @returns {*} Returns the deep cloned value. - * @see _.cloneWith - * @example - * - * function customizer(value) { - * if (_.isElement(value)) { - * return value.cloneNode(true); - * } - * } - * - * var el = _.cloneDeepWith(document.body, customizer); - * - * console.log(el === document.body); - * // => false - * console.log(el.nodeName); - * // => 'BODY' - * console.log(el.childNodes.length); - * // => 20 - */ - function cloneDeepWith(value, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); - } - - /** - * Checks if `object` conforms to `source` by invoking the predicate - * properties of `source` with the corresponding property values of `object`. - * - * **Note:** This method is equivalent to `_.conforms` when `source` is - * partially applied. - * - * @static - * @memberOf _ - * @since 4.14.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property predicates to conform to. - * @returns {boolean} Returns `true` if `object` conforms, else `false`. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * - * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); - * // => true - * - * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); - * // => false - */ - function conformsTo(object, source) { - return source == null || baseConformsTo(object, source, keys(source)); - } - - /** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true - * - * _.eq('a', Object('a')); - * // => false - * - * _.eq(NaN, NaN); - * // => true - */ - function eq(value, other) { - return value === other || (value !== value && other !== other); - } - - /** - * Checks if `value` is greater than `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than `other`, - * else `false`. - * @see _.lt - * @example - * - * _.gt(3, 1); - * // => true - * - * _.gt(3, 3); - * // => false - * - * _.gt(1, 3); - * // => false - */ - var gt = createRelationalOperation(baseGt); - - /** - * Checks if `value` is greater than or equal to `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than or equal to - * `other`, else `false`. - * @see _.lte - * @example - * - * _.gte(3, 1); - * // => true - * - * _.gte(3, 3); - * // => true - * - * _.gte(1, 3); - * // => false - */ - var gte = createRelationalOperation(function(value, other) { - return value >= other; - }); - - /** - * Checks if `value` is likely an `arguments` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. - * @example - * - * _.isArguments(function() { return arguments; }()); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ - var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { - return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && - !propertyIsEnumerable.call(value, 'callee'); - }; - - /** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false - * - * _.isArray('abc'); - * // => false - * - * _.isArray(_.noop); - * // => false - */ - var isArray = Array.isArray; - - /** - * Checks if `value` is classified as an `ArrayBuffer` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. - * @example - * - * _.isArrayBuffer(new ArrayBuffer(2)); - * // => true - * - * _.isArrayBuffer(new Array(2)); - * // => false - */ - var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer; - - /** - * Checks if `value` is array-like. A value is considered array-like if it's - * not a function and has a `value.length` that's an integer greater than or - * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is array-like, else `false`. - * @example - * - * _.isArrayLike([1, 2, 3]); - * // => true - * - * _.isArrayLike(document.body.children); - * // => true - * - * _.isArrayLike('abc'); - * // => true - * - * _.isArrayLike(_.noop); - * // => false - */ - function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value); - } - - /** - * This method is like `_.isArrayLike` except that it also checks if `value` - * is an object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array-like object, - * else `false`. - * @example - * - * _.isArrayLikeObject([1, 2, 3]); - * // => true - * - * _.isArrayLikeObject(document.body.children); - * // => true - * - * _.isArrayLikeObject('abc'); - * // => false - * - * _.isArrayLikeObject(_.noop); - * // => false - */ - function isArrayLikeObject(value) { - return isObjectLike(value) && isArrayLike(value); - } - - /** - * Checks if `value` is classified as a boolean primitive or object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. - * @example - * - * _.isBoolean(false); - * // => true - * - * _.isBoolean(null); - * // => false - */ - function isBoolean(value) { - return value === true || value === false || - (isObjectLike(value) && baseGetTag(value) == boolTag); - } - - /** - * Checks if `value` is a buffer. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. - * @example - * - * _.isBuffer(new Buffer(2)); - * // => true - * - * _.isBuffer(new Uint8Array(2)); - * // => false - */ - var isBuffer = nativeIsBuffer || stubFalse; - - /** - * Checks if `value` is classified as a `Date` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a date object, else `false`. - * @example - * - * _.isDate(new Date); - * // => true - * - * _.isDate('Mon April 23 2012'); - * // => false - */ - var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate; - - /** - * Checks if `value` is likely a DOM element. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. - * @example - * - * _.isElement(document.body); - * // => true - * - * _.isElement(''); - * // => false - */ - function isElement(value) { - return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); - } - - /** - * Checks if `value` is an empty object, collection, map, or set. - * - * Objects are considered empty if they have no own enumerable string keyed - * properties. - * - * Array-like values such as `arguments` objects, arrays, buffers, strings, or - * jQuery-like collections are considered empty if they have a `length` of `0`. - * Similarly, maps and sets are considered empty if they have a `size` of `0`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is empty, else `false`. - * @example - * - * _.isEmpty(null); - * // => true - * - * _.isEmpty(true); - * // => true - * - * _.isEmpty(1); - * // => true - * - * _.isEmpty([1, 2, 3]); - * // => false - * - * _.isEmpty({ 'a': 1 }); - * // => false - */ - function isEmpty(value) { - if (value == null) { - return true; - } - if (isArrayLike(value) && - (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || - isBuffer(value) || isTypedArray(value) || isArguments(value))) { - return !value.length; - } - var tag = getTag(value); - if (tag == mapTag || tag == setTag) { - return !value.size; - } - if (isPrototype(value)) { - return !baseKeys(value).length; - } - for (var key in value) { - if (hasOwnProperty.call(value, key)) { - return false; - } - } - return true; - } - - /** - * Performs a deep comparison between two values to determine if they are - * equivalent. - * - * **Note:** This method supports comparing arrays, array buffers, booleans, - * date objects, error objects, maps, numbers, `Object` objects, regexes, - * sets, strings, symbols, and typed arrays. `Object` objects are compared - * by their own, not inherited, enumerable properties. Functions and DOM - * nodes are compared by strict equality, i.e. `===`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.isEqual(object, other); - * // => true - * - * object === other; - * // => false - */ - function isEqual(value, other) { - return baseIsEqual(value, other); - } - - /** - * This method is like `_.isEqual` except that it accepts `customizer` which - * is invoked to compare values. If `customizer` returns `undefined`, comparisons - * are handled by the method instead. The `customizer` is invoked with up to - * six arguments: (objValue, othValue [, index|key, object, other, stack]). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * function isGreeting(value) { - * return /^h(?:i|ello)$/.test(value); - * } - * - * function customizer(objValue, othValue) { - * if (isGreeting(objValue) && isGreeting(othValue)) { - * return true; - * } - * } - * - * var array = ['hello', 'goodbye']; - * var other = ['hi', 'goodbye']; - * - * _.isEqualWith(array, other, customizer); - * // => true - */ - function isEqualWith(value, other, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - var result = customizer ? customizer(value, other) : undefined; - return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result; - } - - /** - * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, - * `SyntaxError`, `TypeError`, or `URIError` object. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an error object, else `false`. - * @example - * - * _.isError(new Error); - * // => true - * - * _.isError(Error); - * // => false - */ - function isError(value) { - if (!isObjectLike(value)) { - return false; - } - var tag = baseGetTag(value); - return tag == errorTag || tag == domExcTag || - (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value)); - } - - /** - * Checks if `value` is a finite primitive number. - * - * **Note:** This method is based on - * [`Number.isFinite`](https://mdn.io/Number/isFinite). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. - * @example - * - * _.isFinite(3); - * // => true - * - * _.isFinite(Number.MIN_VALUE); - * // => true - * - * _.isFinite(Infinity); - * // => false - * - * _.isFinite('3'); - * // => false - */ - function isFinite(value) { - return typeof value == 'number' && nativeIsFinite(value); - } - - /** - * Checks if `value` is classified as a `Function` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false - */ - function isFunction(value) { - if (!isObject(value)) { - return false; - } - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 9 which returns 'object' for typed arrays and other constructors. - var tag = baseGetTag(value); - return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; - } - - /** - * Checks if `value` is an integer. - * - * **Note:** This method is based on - * [`Number.isInteger`](https://mdn.io/Number/isInteger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an integer, else `false`. - * @example - * - * _.isInteger(3); - * // => true - * - * _.isInteger(Number.MIN_VALUE); - * // => false - * - * _.isInteger(Infinity); - * // => false - * - * _.isInteger('3'); - * // => false - */ - function isInteger(value) { - return typeof value == 'number' && value == toInteger(value); - } - - /** - * Checks if `value` is a valid array-like length. - * - * **Note:** This method is loosely based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. - * @example - * - * _.isLength(3); - * // => true - * - * _.isLength(Number.MIN_VALUE); - * // => false - * - * _.isLength(Infinity); - * // => false - * - * _.isLength('3'); - * // => false - */ - function isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; - } - - /** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true - * - * _.isObject(null); - * // => false - */ - function isObject(value) { - var type = typeof value; - return value != null && (type == 'object' || type == 'function'); - } - - /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example - * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); - * // => true - * - * _.isObjectLike(_.noop); - * // => false - * - * _.isObjectLike(null); - * // => false - */ - function isObjectLike(value) { - return value != null && typeof value == 'object'; - } - - /** - * Checks if `value` is classified as a `Map` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a map, else `false`. - * @example - * - * _.isMap(new Map); - * // => true - * - * _.isMap(new WeakMap); - * // => false - */ - var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; - - /** - * Performs a partial deep comparison between `object` and `source` to - * determine if `object` contains equivalent property values. - * - * **Note:** This method is equivalent to `_.matches` when `source` is - * partially applied. - * - * Partial comparisons will match empty array and empty object `source` - * values against any array or object value, respectively. See `_.isEqual` - * for a list of supported value comparisons. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * - * _.isMatch(object, { 'b': 2 }); - * // => true - * - * _.isMatch(object, { 'b': 1 }); - * // => false - */ - function isMatch(object, source) { - return object === source || baseIsMatch(object, source, getMatchData(source)); - } - - /** - * This method is like `_.isMatch` except that it accepts `customizer` which - * is invoked to compare values. If `customizer` returns `undefined`, comparisons - * are handled by the method instead. The `customizer` is invoked with five - * arguments: (objValue, srcValue, index|key, object, source). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - * @example - * - * function isGreeting(value) { - * return /^h(?:i|ello)$/.test(value); - * } - * - * function customizer(objValue, srcValue) { - * if (isGreeting(objValue) && isGreeting(srcValue)) { - * return true; - * } - * } - * - * var object = { 'greeting': 'hello' }; - * var source = { 'greeting': 'hi' }; - * - * _.isMatchWith(object, source, customizer); - * // => true - */ - function isMatchWith(object, source, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return baseIsMatch(object, source, getMatchData(source), customizer); - } - - /** - * Checks if `value` is `NaN`. - * - * **Note:** This method is based on - * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as - * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for - * `undefined` and other non-number values. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. - * @example - * - * _.isNaN(NaN); - * // => true - * - * _.isNaN(new Number(NaN)); - * // => true - * - * isNaN(undefined); - * // => true - * - * _.isNaN(undefined); - * // => false - */ - function isNaN(value) { - // An `NaN` primitive is the only value that is not equal to itself. - // Perform the `toStringTag` check first to avoid errors with some - // ActiveX objects in IE. - return isNumber(value) && value != +value; - } - - /** - * Checks if `value` is a pristine native function. - * - * **Note:** This method can't reliably detect native functions in the presence - * of the core-js package because core-js circumvents this kind of detection. - * Despite multiple requests, the core-js maintainer has made it clear: any - * attempt to fix the detection will be obstructed. As a result, we're left - * with little choice but to throw an error. Unfortunately, this also affects - * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), - * which rely on core-js. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - * @example - * - * _.isNative(Array.prototype.push); - * // => true - * - * _.isNative(_); - * // => false - */ - function isNative(value) { - if (isMaskable(value)) { - throw new Error(CORE_ERROR_TEXT); - } - return baseIsNative(value); - } - - /** - * Checks if `value` is `null`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `null`, else `false`. - * @example - * - * _.isNull(null); - * // => true - * - * _.isNull(void 0); - * // => false - */ - function isNull(value) { - return value === null; - } - - /** - * Checks if `value` is `null` or `undefined`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is nullish, else `false`. - * @example - * - * _.isNil(null); - * // => true - * - * _.isNil(void 0); - * // => true - * - * _.isNil(NaN); - * // => false - */ - function isNil(value) { - return value == null; - } - - /** - * Checks if `value` is classified as a `Number` primitive or object. - * - * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are - * classified as numbers, use the `_.isFinite` method. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a number, else `false`. - * @example - * - * _.isNumber(3); - * // => true - * - * _.isNumber(Number.MIN_VALUE); - * // => true - * - * _.isNumber(Infinity); - * // => true - * - * _.isNumber('3'); - * // => false - */ - function isNumber(value) { - return typeof value == 'number' || - (isObjectLike(value) && baseGetTag(value) == numberTag); - } - - /** - * Checks if `value` is a plain object, that is, an object created by the - * `Object` constructor or one with a `[[Prototype]]` of `null`. - * - * @static - * @memberOf _ - * @since 0.8.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * _.isPlainObject(new Foo); - * // => false - * - * _.isPlainObject([1, 2, 3]); - * // => false - * - * _.isPlainObject({ 'x': 0, 'y': 0 }); - * // => true - * - * _.isPlainObject(Object.create(null)); - * // => true - */ - function isPlainObject(value) { - if (!isObjectLike(value) || baseGetTag(value) != objectTag) { - return false; - } - var proto = getPrototype(value); - if (proto === null) { - return true; - } - var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; - return typeof Ctor == 'function' && Ctor instanceof Ctor && - funcToString.call(Ctor) == objectCtorString; - } - - /** - * Checks if `value` is classified as a `RegExp` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. - * @example - * - * _.isRegExp(/abc/); - * // => true - * - * _.isRegExp('/abc/'); - * // => false - */ - var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp; - - /** - * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 - * double precision number which isn't the result of a rounded unsafe integer. - * - * **Note:** This method is based on - * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. - * @example - * - * _.isSafeInteger(3); - * // => true - * - * _.isSafeInteger(Number.MIN_VALUE); - * // => false - * - * _.isSafeInteger(Infinity); - * // => false - * - * _.isSafeInteger('3'); - * // => false - */ - function isSafeInteger(value) { - return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; - } - - /** - * Checks if `value` is classified as a `Set` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a set, else `false`. - * @example - * - * _.isSet(new Set); - * // => true - * - * _.isSet(new WeakSet); - * // => false - */ - var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; - - /** - * Checks if `value` is classified as a `String` primitive or object. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a string, else `false`. - * @example - * - * _.isString('abc'); - * // => true - * - * _.isString(1); - * // => false - */ - function isString(value) { - return typeof value == 'string' || - (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); - } - - /** - * Checks if `value` is classified as a `Symbol` primitive or object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. - * @example - * - * _.isSymbol(Symbol.iterator); - * // => true - * - * _.isSymbol('abc'); - * // => false - */ - function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && baseGetTag(value) == symbolTag); - } - - /** - * Checks if `value` is classified as a typed array. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - * @example - * - * _.isTypedArray(new Uint8Array); - * // => true - * - * _.isTypedArray([]); - * // => false - */ - var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; - - /** - * Checks if `value` is `undefined`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. - * @example - * - * _.isUndefined(void 0); - * // => true - * - * _.isUndefined(null); - * // => false - */ - function isUndefined(value) { - return value === undefined; - } - - /** - * Checks if `value` is classified as a `WeakMap` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. - * @example - * - * _.isWeakMap(new WeakMap); - * // => true - * - * _.isWeakMap(new Map); - * // => false - */ - function isWeakMap(value) { - return isObjectLike(value) && getTag(value) == weakMapTag; - } - - /** - * Checks if `value` is classified as a `WeakSet` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. - * @example - * - * _.isWeakSet(new WeakSet); - * // => true - * - * _.isWeakSet(new Set); - * // => false - */ - function isWeakSet(value) { - return isObjectLike(value) && baseGetTag(value) == weakSetTag; - } - - /** - * Checks if `value` is less than `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than `other`, - * else `false`. - * @see _.gt - * @example - * - * _.lt(1, 3); - * // => true - * - * _.lt(3, 3); - * // => false - * - * _.lt(3, 1); - * // => false - */ - var lt = createRelationalOperation(baseLt); - - /** - * Checks if `value` is less than or equal to `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than or equal to - * `other`, else `false`. - * @see _.gte - * @example - * - * _.lte(1, 3); - * // => true - * - * _.lte(3, 3); - * // => true - * - * _.lte(3, 1); - * // => false - */ - var lte = createRelationalOperation(function(value, other) { - return value <= other; - }); - - /** - * Converts `value` to an array. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to convert. - * @returns {Array} Returns the converted array. - * @example - * - * _.toArray({ 'a': 1, 'b': 2 }); - * // => [1, 2] - * - * _.toArray('abc'); - * // => ['a', 'b', 'c'] - * - * _.toArray(1); - * // => [] - * - * _.toArray(null); - * // => [] - */ - function toArray(value) { - if (!value) { - return []; - } - if (isArrayLike(value)) { - return isString(value) ? stringToArray(value) : copyArray(value); - } - if (symIterator && value[symIterator]) { - return iteratorToArray(value[symIterator]()); - } - var tag = getTag(value), - func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values); - - return func(value); - } - - /** - * Converts `value` to a finite number. - * - * @static - * @memberOf _ - * @since 4.12.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted number. - * @example - * - * _.toFinite(3.2); - * // => 3.2 - * - * _.toFinite(Number.MIN_VALUE); - * // => 5e-324 - * - * _.toFinite(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toFinite('3.2'); - * // => 3.2 - */ - function toFinite(value) { - if (!value) { - return value === 0 ? value : 0; - } - value = toNumber(value); - if (value === INFINITY || value === -INFINITY) { - var sign = (value < 0 ? -1 : 1); - return sign * MAX_INTEGER; - } - return value === value ? value : 0; - } - - /** - * Converts `value` to an integer. - * - * **Note:** This method is loosely based on - * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toInteger(3.2); - * // => 3 - * - * _.toInteger(Number.MIN_VALUE); - * // => 0 - * - * _.toInteger(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toInteger('3.2'); - * // => 3 - */ - function toInteger(value) { - var result = toFinite(value), - remainder = result % 1; - - return result === result ? (remainder ? result - remainder : result) : 0; - } - - /** - * Converts `value` to an integer suitable for use as the length of an - * array-like object. - * - * **Note:** This method is based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toLength(3.2); - * // => 3 - * - * _.toLength(Number.MIN_VALUE); - * // => 0 - * - * _.toLength(Infinity); - * // => 4294967295 - * - * _.toLength('3.2'); - * // => 3 - */ - function toLength(value) { - return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0; - } - - /** - * Converts `value` to a number. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to process. - * @returns {number} Returns the number. - * @example - * - * _.toNumber(3.2); - * // => 3.2 - * - * _.toNumber(Number.MIN_VALUE); - * // => 5e-324 - * - * _.toNumber(Infinity); - * // => Infinity - * - * _.toNumber('3.2'); - * // => 3.2 - */ - function toNumber(value) { - if (typeof value == 'number') { - return value; - } - if (isSymbol(value)) { - return NAN; - } - if (isObject(value)) { - var other = typeof value.valueOf == 'function' ? value.valueOf() : value; - value = isObject(other) ? (other + '') : other; - } - if (typeof value != 'string') { - return value === 0 ? value : +value; - } - value = value.replace(reTrim, ''); - var isBinary = reIsBinary.test(value); - return (isBinary || reIsOctal.test(value)) - ? freeParseInt(value.slice(2), isBinary ? 2 : 8) - : (reIsBadHex.test(value) ? NAN : +value); - } - - /** - * Converts `value` to a plain object flattening inherited enumerable string - * keyed properties of `value` to own properties of the plain object. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {Object} Returns the converted plain object. - * @example - * - * function Foo() { - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.assign({ 'a': 1 }, new Foo); - * // => { 'a': 1, 'b': 2 } - * - * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); - * // => { 'a': 1, 'b': 2, 'c': 3 } - */ - function toPlainObject(value) { - return copyObject(value, keysIn(value)); - } - - /** - * Converts `value` to a safe integer. A safe integer can be compared and - * represented correctly. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toSafeInteger(3.2); - * // => 3 - * - * _.toSafeInteger(Number.MIN_VALUE); - * // => 0 - * - * _.toSafeInteger(Infinity); - * // => 9007199254740991 - * - * _.toSafeInteger('3.2'); - * // => 3 - */ - function toSafeInteger(value) { - return value - ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) - : (value === 0 ? value : 0); - } - - /** - * Converts `value` to a string. An empty string is returned for `null` - * and `undefined` values. The sign of `-0` is preserved. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.toString(null); - * // => '' - * - * _.toString(-0); - * // => '-0' - * - * _.toString([1, 2, 3]); - * // => '1,2,3' - */ - function toString(value) { - return value == null ? '' : baseToString(value); - } - - /*------------------------------------------------------------------------*/ - - /** - * Assigns own enumerable string keyed properties of source objects to the - * destination object. Source objects are applied from left to right. - * Subsequent sources overwrite property assignments of previous sources. - * - * **Note:** This method mutates `object` and is loosely based on - * [`Object.assign`](https://mdn.io/Object/assign). - * - * @static - * @memberOf _ - * @since 0.10.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.assignIn - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * function Bar() { - * this.c = 3; - * } - * - * Foo.prototype.b = 2; - * Bar.prototype.d = 4; - * - * _.assign({ 'a': 0 }, new Foo, new Bar); - * // => { 'a': 1, 'c': 3 } - */ - var assign = createAssigner(function(object, source) { - if (isPrototype(source) || isArrayLike(source)) { - copyObject(source, keys(source), object); - return; - } - for (var key in source) { - if (hasOwnProperty.call(source, key)) { - assignValue(object, key, source[key]); - } - } - }); - - /** - * This method is like `_.assign` except that it iterates over own and - * inherited source properties. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias extend - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.assign - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * function Bar() { - * this.c = 3; - * } - * - * Foo.prototype.b = 2; - * Bar.prototype.d = 4; - * - * _.assignIn({ 'a': 0 }, new Foo, new Bar); - * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } - */ - var assignIn = createAssigner(function(object, source) { - copyObject(source, keysIn(source), object); - }); - - /** - * This method is like `_.assignIn` except that it accepts `customizer` - * which is invoked to produce the assigned values. If `customizer` returns - * `undefined`, assignment is handled by the method instead. The `customizer` - * is invoked with five arguments: (objValue, srcValue, key, object, source). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias extendWith - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @see _.assignWith - * @example - * - * function customizer(objValue, srcValue) { - * return _.isUndefined(objValue) ? srcValue : objValue; - * } - * - * var defaults = _.partialRight(_.assignInWith, customizer); - * - * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var assignInWith = createAssigner(function(object, source, srcIndex, customizer) { - copyObject(source, keysIn(source), object, customizer); - }); - - /** - * This method is like `_.assign` except that it accepts `customizer` - * which is invoked to produce the assigned values. If `customizer` returns - * `undefined`, assignment is handled by the method instead. The `customizer` - * is invoked with five arguments: (objValue, srcValue, key, object, source). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @see _.assignInWith - * @example - * - * function customizer(objValue, srcValue) { - * return _.isUndefined(objValue) ? srcValue : objValue; - * } - * - * var defaults = _.partialRight(_.assignWith, customizer); - * - * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var assignWith = createAssigner(function(object, source, srcIndex, customizer) { - copyObject(source, keys(source), object, customizer); - }); - - /** - * Creates an array of values corresponding to `paths` of `object`. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Array} Returns the picked values. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - * - * _.at(object, ['a[0].b.c', 'a[1]']); - * // => [3, 4] - */ - var at = flatRest(baseAt); - - /** - * Creates an object that inherits from the `prototype` object. If a - * `properties` object is given, its own enumerable string keyed properties - * are assigned to the created object. - * - * @static - * @memberOf _ - * @since 2.3.0 - * @category Object - * @param {Object} prototype The object to inherit from. - * @param {Object} [properties] The properties to assign to the object. - * @returns {Object} Returns the new object. - * @example - * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * function Circle() { - * Shape.call(this); - * } - * - * Circle.prototype = _.create(Shape.prototype, { - * 'constructor': Circle - * }); - * - * var circle = new Circle; - * circle instanceof Circle; - * // => true - * - * circle instanceof Shape; - * // => true - */ - function create(prototype, properties) { - var result = baseCreate(prototype); - return properties == null ? result : baseAssign(result, properties); - } - - /** - * Assigns own and inherited enumerable string keyed properties of source - * objects to the destination object for all destination properties that - * resolve to `undefined`. Source objects are applied from left to right. - * Once a property is set, additional values of the same property are ignored. - * - * **Note:** This method mutates `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.defaultsDeep - * @example - * - * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var defaults = baseRest(function(object, sources) { - object = Object(object); - - var index = -1; - var length = sources.length; - var guard = length > 2 ? sources[2] : undefined; - - if (guard && isIterateeCall(sources[0], sources[1], guard)) { - length = 1; - } - - while (++index < length) { - var source = sources[index]; - var props = keysIn(source); - var propsIndex = -1; - var propsLength = props.length; - - while (++propsIndex < propsLength) { - var key = props[propsIndex]; - var value = object[key]; - - if (value === undefined || - (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) { - object[key] = source[key]; - } - } - } - - return object; - }); - - /** - * This method is like `_.defaults` except that it recursively assigns - * default properties. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 3.10.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.defaults - * @example - * - * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); - * // => { 'a': { 'b': 2, 'c': 3 } } - */ - var defaultsDeep = baseRest(function(args) { - args.push(undefined, customDefaultsMerge); - return apply(mergeWith, undefined, args); - }); - - /** - * This method is like `_.find` except that it returns the key of the first - * element `predicate` returns truthy for instead of the element itself. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Object - * @param {Object} object The object to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {string|undefined} Returns the key of the matched element, - * else `undefined`. - * @example - * - * var users = { - * 'barney': { 'age': 36, 'active': true }, - * 'fred': { 'age': 40, 'active': false }, - * 'pebbles': { 'age': 1, 'active': true } - * }; - * - * _.findKey(users, function(o) { return o.age < 40; }); - * // => 'barney' (iteration order is not guaranteed) - * - * // The `_.matches` iteratee shorthand. - * _.findKey(users, { 'age': 1, 'active': true }); - * // => 'pebbles' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findKey(users, ['active', false]); - * // => 'fred' - * - * // The `_.property` iteratee shorthand. - * _.findKey(users, 'active'); - * // => 'barney' - */ - function findKey(object, predicate) { - return baseFindKey(object, getIteratee(predicate, 3), baseForOwn); - } - - /** - * This method is like `_.findKey` except that it iterates over elements of - * a collection in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {string|undefined} Returns the key of the matched element, - * else `undefined`. - * @example - * - * var users = { - * 'barney': { 'age': 36, 'active': true }, - * 'fred': { 'age': 40, 'active': false }, - * 'pebbles': { 'age': 1, 'active': true } - * }; - * - * _.findLastKey(users, function(o) { return o.age < 40; }); - * // => returns 'pebbles' assuming `_.findKey` returns 'barney' - * - * // The `_.matches` iteratee shorthand. - * _.findLastKey(users, { 'age': 36, 'active': true }); - * // => 'barney' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findLastKey(users, ['active', false]); - * // => 'fred' - * - * // The `_.property` iteratee shorthand. - * _.findLastKey(users, 'active'); - * // => 'pebbles' - */ - function findLastKey(object, predicate) { - return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight); - } - - /** - * Iterates over own and inherited enumerable string keyed properties of an - * object and invokes `iteratee` for each property. The iteratee is invoked - * with three arguments: (value, key, object). Iteratee functions may exit - * iteration early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 0.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forInRight - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forIn(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). - */ - function forIn(object, iteratee) { - return object == null - ? object - : baseFor(object, getIteratee(iteratee, 3), keysIn); - } - - /** - * This method is like `_.forIn` except that it iterates over properties of - * `object` in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forIn - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forInRight(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. - */ - function forInRight(object, iteratee) { - return object == null - ? object - : baseForRight(object, getIteratee(iteratee, 3), keysIn); - } - - /** - * Iterates over own enumerable string keyed properties of an object and - * invokes `iteratee` for each property. The iteratee is invoked with three - * arguments: (value, key, object). Iteratee functions may exit iteration - * early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 0.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forOwnRight - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forOwn(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a' then 'b' (iteration order is not guaranteed). - */ - function forOwn(object, iteratee) { - return object && baseForOwn(object, getIteratee(iteratee, 3)); - } - - /** - * This method is like `_.forOwn` except that it iterates over properties of - * `object` in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forOwn - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forOwnRight(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. - */ - function forOwnRight(object, iteratee) { - return object && baseForOwnRight(object, getIteratee(iteratee, 3)); - } - - /** - * Creates an array of function property names from own enumerable properties - * of `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to inspect. - * @returns {Array} Returns the function names. - * @see _.functionsIn - * @example - * - * function Foo() { - * this.a = _.constant('a'); - * this.b = _.constant('b'); - * } - * - * Foo.prototype.c = _.constant('c'); - * - * _.functions(new Foo); - * // => ['a', 'b'] - */ - function functions(object) { - return object == null ? [] : baseFunctions(object, keys(object)); - } - - /** - * Creates an array of function property names from own and inherited - * enumerable properties of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to inspect. - * @returns {Array} Returns the function names. - * @see _.functions - * @example - * - * function Foo() { - * this.a = _.constant('a'); - * this.b = _.constant('b'); - * } - * - * Foo.prototype.c = _.constant('c'); - * - * _.functionsIn(new Foo); - * // => ['a', 'b', 'c'] - */ - function functionsIn(object) { - return object == null ? [] : baseFunctions(object, keysIn(object)); - } - - /** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is returned in its place. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.get(object, 'a[0].b.c'); - * // => 3 - * - * _.get(object, ['a', '0', 'b', 'c']); - * // => 3 - * - * _.get(object, 'a.b.c', 'default'); - * // => 'default' - */ - function get(object, path, defaultValue) { - var result = object == null ? undefined : baseGet(object, path); - return result === undefined ? defaultValue : result; - } - - /** - * Checks if `path` is a direct property of `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = { 'a': { 'b': 2 } }; - * var other = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.has(object, 'a'); - * // => true - * - * _.has(object, 'a.b'); - * // => true - * - * _.has(object, ['a', 'b']); - * // => true - * - * _.has(other, 'a'); - * // => false - */ - function has(object, path) { - return object != null && hasPath(object, path, baseHas); - } - - /** - * Checks if `path` is a direct or inherited property of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.hasIn(object, 'a'); - * // => true - * - * _.hasIn(object, 'a.b'); - * // => true - * - * _.hasIn(object, ['a', 'b']); - * // => true - * - * _.hasIn(object, 'b'); - * // => false - */ - function hasIn(object, path) { - return object != null && hasPath(object, path, baseHasIn); - } - - /** - * Creates an object composed of the inverted keys and values of `object`. - * If `object` contains duplicate values, subsequent values overwrite - * property assignments of previous values. - * - * @static - * @memberOf _ - * @since 0.7.0 - * @category Object - * @param {Object} object The object to invert. - * @returns {Object} Returns the new inverted object. - * @example - * - * var object = { 'a': 1, 'b': 2, 'c': 1 }; - * - * _.invert(object); - * // => { '1': 'c', '2': 'b' } - */ - var invert = createInverter(function(result, value, key) { - if (value != null && - typeof value.toString != 'function') { - value = nativeObjectToString.call(value); - } - - result[value] = key; - }, constant(identity)); - - /** - * This method is like `_.invert` except that the inverted object is generated - * from the results of running each element of `object` thru `iteratee`. The - * corresponding inverted value of each inverted key is an array of keys - * responsible for generating the inverted value. The iteratee is invoked - * with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.1.0 - * @category Object - * @param {Object} object The object to invert. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Object} Returns the new inverted object. - * @example - * - * var object = { 'a': 1, 'b': 2, 'c': 1 }; - * - * _.invertBy(object); - * // => { '1': ['a', 'c'], '2': ['b'] } - * - * _.invertBy(object, function(value) { - * return 'group' + value; - * }); - * // => { 'group1': ['a', 'c'], 'group2': ['b'] } - */ - var invertBy = createInverter(function(result, value, key) { - if (value != null && - typeof value.toString != 'function') { - value = nativeObjectToString.call(value); - } - - if (hasOwnProperty.call(result, value)) { - result[value].push(key); - } else { - result[value] = [key]; - } - }, getIteratee); - - /** - * Invokes the method at `path` of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the method to invoke. - * @param {...*} [args] The arguments to invoke the method with. - * @returns {*} Returns the result of the invoked method. - * @example - * - * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; - * - * _.invoke(object, 'a[0].b.c.slice', 1, 3); - * // => [2, 3] - */ - var invoke = baseRest(baseInvoke); - - /** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) - * - * _.keys('hi'); - * // => ['0', '1'] - */ - function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); - } - - /** - * Creates an array of the own and inherited enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keysIn(new Foo); - * // => ['a', 'b', 'c'] (iteration order is not guaranteed) - */ - function keysIn(object) { - return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); - } - - /** - * The opposite of `_.mapValues`; this method creates an object with the - * same values as `object` and keys generated by running each own enumerable - * string keyed property of `object` thru `iteratee`. The iteratee is invoked - * with three arguments: (value, key, object). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns the new mapped object. - * @see _.mapValues - * @example - * - * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { - * return key + value; - * }); - * // => { 'a1': 1, 'b2': 2 } - */ - function mapKeys(object, iteratee) { - var result = {}; - iteratee = getIteratee(iteratee, 3); - - baseForOwn(object, function(value, key, object) { - baseAssignValue(result, iteratee(value, key, object), value); - }); - return result; - } - - /** - * Creates an object with the same keys as `object` and values generated - * by running each own enumerable string keyed property of `object` thru - * `iteratee`. The iteratee is invoked with three arguments: - * (value, key, object). - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns the new mapped object. - * @see _.mapKeys - * @example - * - * var users = { - * 'fred': { 'user': 'fred', 'age': 40 }, - * 'pebbles': { 'user': 'pebbles', 'age': 1 } - * }; - * - * _.mapValues(users, function(o) { return o.age; }); - * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) - * - * // The `_.property` iteratee shorthand. - * _.mapValues(users, 'age'); - * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) - */ - function mapValues(object, iteratee) { - var result = {}; - iteratee = getIteratee(iteratee, 3); - - baseForOwn(object, function(value, key, object) { - baseAssignValue(result, key, iteratee(value, key, object)); - }); - return result; - } - - /** - * This method is like `_.assign` except that it recursively merges own and - * inherited enumerable string keyed properties of source objects into the - * destination object. Source properties that resolve to `undefined` are - * skipped if a destination value exists. Array and plain object properties - * are merged recursively. Other objects and value types are overridden by - * assignment. Source objects are applied from left to right. Subsequent - * sources overwrite property assignments of previous sources. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @example - * - * var object = { - * 'a': [{ 'b': 2 }, { 'd': 4 }] - * }; - * - * var other = { - * 'a': [{ 'c': 3 }, { 'e': 5 }] - * }; - * - * _.merge(object, other); - * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } - */ - var merge = createAssigner(function(object, source, srcIndex) { - baseMerge(object, source, srcIndex); - }); - - /** - * This method is like `_.merge` except that it accepts `customizer` which - * is invoked to produce the merged values of the destination and source - * properties. If `customizer` returns `undefined`, merging is handled by the - * method instead. The `customizer` is invoked with six arguments: - * (objValue, srcValue, key, object, source, stack). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} customizer The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * function customizer(objValue, srcValue) { - * if (_.isArray(objValue)) { - * return objValue.concat(srcValue); - * } - * } - * - * var object = { 'a': [1], 'b': [2] }; - * var other = { 'a': [3], 'b': [4] }; - * - * _.mergeWith(object, other, customizer); - * // => { 'a': [1, 3], 'b': [2, 4] } - */ - var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { - baseMerge(object, source, srcIndex, customizer); - }); - - /** - * The opposite of `_.pick`; this method creates an object composed of the - * own and inherited enumerable property paths of `object` that are not omitted. - * - * **Note:** This method is considerably slower than `_.pick`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [paths] The property paths to omit. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.omit(object, ['a', 'c']); - * // => { 'b': '2' } - */ - var omit = flatRest(function(object, paths) { - var result = {}; - if (object == null) { - return result; - } - var isDeep = false; - paths = arrayMap(paths, function(path) { - path = castPath(path, object); - isDeep || (isDeep = path.length > 1); - return path; - }); - copyObject(object, getAllKeysIn(object), result); - if (isDeep) { - result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone); - } - var length = paths.length; - while (length--) { - baseUnset(result, paths[length]); - } - return result; - }); - - /** - * The opposite of `_.pickBy`; this method creates an object composed of - * the own and inherited enumerable string keyed properties of `object` that - * `predicate` doesn't return truthy for. The predicate is invoked with two - * arguments: (value, key). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The source object. - * @param {Function} [predicate=_.identity] The function invoked per property. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.omitBy(object, _.isNumber); - * // => { 'b': '2' } - */ - function omitBy(object, predicate) { - return pickBy(object, negate(getIteratee(predicate))); - } - - /** - * Creates an object composed of the picked `object` properties. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.pick(object, ['a', 'c']); - * // => { 'a': 1, 'c': 3 } - */ - var pick = flatRest(function(object, paths) { - return object == null ? {} : basePick(object, paths); - }); - - /** - * Creates an object composed of the `object` properties `predicate` returns - * truthy for. The predicate is invoked with two arguments: (value, key). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The source object. - * @param {Function} [predicate=_.identity] The function invoked per property. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.pickBy(object, _.isNumber); - * // => { 'a': 1, 'c': 3 } - */ - function pickBy(object, predicate) { - if (object == null) { - return {}; - } - var props = arrayMap(getAllKeysIn(object), function(prop) { - return [prop]; - }); - predicate = getIteratee(predicate); - return basePickBy(object, props, function(value, path) { - return predicate(value, path[0]); - }); - } - - /** - * This method is like `_.get` except that if the resolved value is a - * function it's invoked with the `this` binding of its parent object and - * its result is returned. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to resolve. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; - * - * _.result(object, 'a[0].b.c1'); - * // => 3 - * - * _.result(object, 'a[0].b.c2'); - * // => 4 - * - * _.result(object, 'a[0].b.c3', 'default'); - * // => 'default' - * - * _.result(object, 'a[0].b.c3', _.constant('default')); - * // => 'default' - */ - function result(object, path, defaultValue) { - path = castPath(path, object); - - var index = -1, - length = path.length; - - // Ensure the loop is entered when path is empty. - if (!length) { - length = 1; - object = undefined; - } - while (++index < length) { - var value = object == null ? undefined : object[toKey(path[index])]; - if (value === undefined) { - index = length; - value = defaultValue; - } - object = isFunction(value) ? value.call(object) : value; - } - return object; - } - - /** - * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, - * it's created. Arrays are created for missing index properties while objects - * are created for all other missing properties. Use `_.setWith` to customize - * `path` creation. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @returns {Object} Returns `object`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.set(object, 'a[0].b.c', 4); - * console.log(object.a[0].b.c); - * // => 4 - * - * _.set(object, ['x', '0', 'y', 'z'], 5); - * console.log(object.x[0].y.z); - * // => 5 - */ - function set(object, path, value) { - return object == null ? object : baseSet(object, path, value); - } - - /** - * This method is like `_.set` except that it accepts `customizer` which is - * invoked to produce the objects of `path`. If `customizer` returns `undefined` - * path creation is handled by the method instead. The `customizer` is invoked - * with three arguments: (nsValue, key, nsObject). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * var object = {}; - * - * _.setWith(object, '[0][1]', 'a', Object); - * // => { '0': { '1': 'a' } } - */ - function setWith(object, path, value, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return object == null ? object : baseSet(object, path, value, customizer); - } - - /** - * Creates an array of own enumerable string keyed-value pairs for `object` - * which can be consumed by `_.fromPairs`. If `object` is a map or set, its - * entries are returned. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias entries - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the key-value pairs. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.toPairs(new Foo); - * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) - */ - var toPairs = createToPairs(keys); - - /** - * Creates an array of own and inherited enumerable string keyed-value pairs - * for `object` which can be consumed by `_.fromPairs`. If `object` is a map - * or set, its entries are returned. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias entriesIn - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the key-value pairs. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.toPairsIn(new Foo); - * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) - */ - var toPairsIn = createToPairs(keysIn); - - /** - * An alternative to `_.reduce`; this method transforms `object` to a new - * `accumulator` object which is the result of running each of its own - * enumerable string keyed properties thru `iteratee`, with each invocation - * potentially mutating the `accumulator` object. If `accumulator` is not - * provided, a new object with the same `[[Prototype]]` will be used. The - * iteratee is invoked with four arguments: (accumulator, value, key, object). - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 1.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The custom accumulator value. - * @returns {*} Returns the accumulated value. - * @example - * - * _.transform([2, 3, 4], function(result, n) { - * result.push(n *= n); - * return n % 2 == 0; - * }, []); - * // => [4, 9] - * - * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { - * (result[value] || (result[value] = [])).push(key); - * }, {}); - * // => { '1': ['a', 'c'], '2': ['b'] } - */ - function transform(object, iteratee, accumulator) { - var isArr = isArray(object), - isArrLike = isArr || isBuffer(object) || isTypedArray(object); - - iteratee = getIteratee(iteratee, 4); - if (accumulator == null) { - var Ctor = object && object.constructor; - if (isArrLike) { - accumulator = isArr ? new Ctor : []; - } - else if (isObject(object)) { - accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; - } - else { - accumulator = {}; - } - } - (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) { - return iteratee(accumulator, value, index, object); - }); - return accumulator; - } - - /** - * Removes the property at `path` of `object`. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to unset. - * @returns {boolean} Returns `true` if the property is deleted, else `false`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 7 } }] }; - * _.unset(object, 'a[0].b.c'); - * // => true - * - * console.log(object); - * // => { 'a': [{ 'b': {} }] }; - * - * _.unset(object, ['a', '0', 'b', 'c']); - * // => true - * - * console.log(object); - * // => { 'a': [{ 'b': {} }] }; - */ - function unset(object, path) { - return object == null ? true : baseUnset(object, path); - } - - /** - * This method is like `_.set` except that accepts `updater` to produce the - * value to set. Use `_.updateWith` to customize `path` creation. The `updater` - * is invoked with one argument: (value). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {Function} updater The function to produce the updated value. - * @returns {Object} Returns `object`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.update(object, 'a[0].b.c', function(n) { return n * n; }); - * console.log(object.a[0].b.c); - * // => 9 - * - * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); - * console.log(object.x[0].y.z); - * // => 0 - */ - function update(object, path, updater) { - return object == null ? object : baseUpdate(object, path, castFunction(updater)); - } - - /** - * This method is like `_.update` except that it accepts `customizer` which is - * invoked to produce the objects of `path`. If `customizer` returns `undefined` - * path creation is handled by the method instead. The `customizer` is invoked - * with three arguments: (nsValue, key, nsObject). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {Function} updater The function to produce the updated value. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * var object = {}; - * - * _.updateWith(object, '[0][1]', _.constant('a'), Object); - * // => { '0': { '1': 'a' } } - */ - function updateWith(object, path, updater, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer); - } - - /** - * Creates an array of the own enumerable string keyed property values of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.values(new Foo); - * // => [1, 2] (iteration order is not guaranteed) - * - * _.values('hi'); - * // => ['h', 'i'] - */ - function values(object) { - return object == null ? [] : baseValues(object, keys(object)); - } - - /** - * Creates an array of the own and inherited enumerable string keyed property - * values of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.valuesIn(new Foo); - * // => [1, 2, 3] (iteration order is not guaranteed) - */ - function valuesIn(object) { - return object == null ? [] : baseValues(object, keysIn(object)); - } - - /*------------------------------------------------------------------------*/ - - /** - * Clamps `number` within the inclusive `lower` and `upper` bounds. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Number - * @param {number} number The number to clamp. - * @param {number} [lower] The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the clamped number. - * @example - * - * _.clamp(-10, -5, 5); - * // => -5 - * - * _.clamp(10, -5, 5); - * // => 5 - */ - function clamp(number, lower, upper) { - if (upper === undefined) { - upper = lower; - lower = undefined; - } - if (upper !== undefined) { - upper = toNumber(upper); - upper = upper === upper ? upper : 0; - } - if (lower !== undefined) { - lower = toNumber(lower); - lower = lower === lower ? lower : 0; - } - return baseClamp(toNumber(number), lower, upper); - } - - /** - * Checks if `n` is between `start` and up to, but not including, `end`. If - * `end` is not specified, it's set to `start` with `start` then set to `0`. - * If `start` is greater than `end` the params are swapped to support - * negative ranges. - * - * @static - * @memberOf _ - * @since 3.3.0 - * @category Number - * @param {number} number The number to check. - * @param {number} [start=0] The start of the range. - * @param {number} end The end of the range. - * @returns {boolean} Returns `true` if `number` is in the range, else `false`. - * @see _.range, _.rangeRight - * @example - * - * _.inRange(3, 2, 4); - * // => true - * - * _.inRange(4, 8); - * // => true - * - * _.inRange(4, 2); - * // => false - * - * _.inRange(2, 2); - * // => false - * - * _.inRange(1.2, 2); - * // => true - * - * _.inRange(5.2, 4); - * // => false - * - * _.inRange(-3, -2, -6); - * // => true - */ - function inRange(number, start, end) { - start = toFinite(start); - if (end === undefined) { - end = start; - start = 0; - } else { - end = toFinite(end); - } - number = toNumber(number); - return baseInRange(number, start, end); - } - - /** - * Produces a random number between the inclusive `lower` and `upper` bounds. - * If only one argument is provided a number between `0` and the given number - * is returned. If `floating` is `true`, or either `lower` or `upper` are - * floats, a floating-point number is returned instead of an integer. - * - * **Note:** JavaScript follows the IEEE-754 standard for resolving - * floating-point values which can produce unexpected results. - * - * @static - * @memberOf _ - * @since 0.7.0 - * @category Number - * @param {number} [lower=0] The lower bound. - * @param {number} [upper=1] The upper bound. - * @param {boolean} [floating] Specify returning a floating-point number. - * @returns {number} Returns the random number. - * @example - * - * _.random(0, 5); - * // => an integer between 0 and 5 - * - * _.random(5); - * // => also an integer between 0 and 5 - * - * _.random(5, true); - * // => a floating-point number between 0 and 5 - * - * _.random(1.2, 5.2); - * // => a floating-point number between 1.2 and 5.2 - */ - function random(lower, upper, floating) { - if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) { - upper = floating = undefined; - } - if (floating === undefined) { - if (typeof upper == 'boolean') { - floating = upper; - upper = undefined; - } - else if (typeof lower == 'boolean') { - floating = lower; - lower = undefined; - } - } - if (lower === undefined && upper === undefined) { - lower = 0; - upper = 1; - } - else { - lower = toFinite(lower); - if (upper === undefined) { - upper = lower; - lower = 0; - } else { - upper = toFinite(upper); - } - } - if (lower > upper) { - var temp = lower; - lower = upper; - upper = temp; - } - if (floating || lower % 1 || upper % 1) { - var rand = nativeRandom(); - return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper); - } - return baseRandom(lower, upper); - } - - /*------------------------------------------------------------------------*/ - - /** - * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the camel cased string. - * @example - * - * _.camelCase('Foo Bar'); - * // => 'fooBar' - * - * _.camelCase('--foo-bar--'); - * // => 'fooBar' - * - * _.camelCase('__FOO_BAR__'); - * // => 'fooBar' - */ - var camelCase = createCompounder(function(result, word, index) { - word = word.toLowerCase(); - return result + (index ? capitalize(word) : word); - }); - - /** - * Converts the first character of `string` to upper case and the remaining - * to lower case. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to capitalize. - * @returns {string} Returns the capitalized string. - * @example - * - * _.capitalize('FRED'); - * // => 'Fred' - */ - function capitalize(string) { - return upperFirst(toString(string).toLowerCase()); - } - - /** - * Deburrs `string` by converting - * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) - * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) - * letters to basic Latin letters and removing - * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to deburr. - * @returns {string} Returns the deburred string. - * @example - * - * _.deburr('déjà vu'); - * // => 'deja vu' - */ - function deburr(string) { - string = toString(string); - return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ''); - } - - /** - * Checks if `string` ends with the given target string. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to inspect. - * @param {string} [target] The string to search for. - * @param {number} [position=string.length] The position to search up to. - * @returns {boolean} Returns `true` if `string` ends with `target`, - * else `false`. - * @example - * - * _.endsWith('abc', 'c'); - * // => true - * - * _.endsWith('abc', 'b'); - * // => false - * - * _.endsWith('abc', 'b', 2); - * // => true - */ - function endsWith(string, target, position) { - string = toString(string); - target = baseToString(target); - - var length = string.length; - position = position === undefined - ? length - : baseClamp(toInteger(position), 0, length); - - var end = position; - position -= target.length; - return position >= 0 && string.slice(position, end) == target; - } - - /** - * Converts the characters "&", "<", ">", '"', and "'" in `string` to their - * corresponding HTML entities. - * - * **Note:** No other characters are escaped. To escape additional - * characters use a third-party library like [_he_](https://mths.be/he). - * - * Though the ">" character is escaped for symmetry, characters like - * ">" and "/" don't need escaping in HTML and have no special meaning - * unless they're part of a tag or unquoted attribute value. See - * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) - * (under "semi-related fun fact") for more details. - * - * When working with HTML you should always - * [quote attribute values](http://wonko.com/post/html-escaping) to reduce - * XSS vectors. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category String - * @param {string} [string=''] The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escape('fred, barney, & pebbles'); - * // => 'fred, barney, & pebbles' - */ - function escape(string) { - string = toString(string); - return (string && reHasUnescapedHtml.test(string)) - ? string.replace(reUnescapedHtml, escapeHtmlChar) - : string; - } - - /** - * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", - * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escapeRegExp('[lodash](https://lodash.com/)'); - * // => '\[lodash\]\(https://lodash\.com/\)' - */ - function escapeRegExp(string) { - string = toString(string); - return (string && reHasRegExpChar.test(string)) - ? string.replace(reRegExpChar, '\\$&') - : string; - } - - /** - * Converts `string` to - * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the kebab cased string. - * @example - * - * _.kebabCase('Foo Bar'); - * // => 'foo-bar' - * - * _.kebabCase('fooBar'); - * // => 'foo-bar' - * - * _.kebabCase('__FOO_BAR__'); - * // => 'foo-bar' - */ - var kebabCase = createCompounder(function(result, word, index) { - return result + (index ? '-' : '') + word.toLowerCase(); - }); - - /** - * Converts `string`, as space separated words, to lower case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the lower cased string. - * @example - * - * _.lowerCase('--Foo-Bar--'); - * // => 'foo bar' - * - * _.lowerCase('fooBar'); - * // => 'foo bar' - * - * _.lowerCase('__FOO_BAR__'); - * // => 'foo bar' - */ - var lowerCase = createCompounder(function(result, word, index) { - return result + (index ? ' ' : '') + word.toLowerCase(); - }); - - /** - * Converts the first character of `string` to lower case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.lowerFirst('Fred'); - * // => 'fred' - * - * _.lowerFirst('FRED'); - * // => 'fRED' - */ - var lowerFirst = createCaseFirst('toLowerCase'); - - /** - * Pads `string` on the left and right sides if it's shorter than `length`. - * Padding characters are truncated if they can't be evenly divided by `length`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.pad('abc', 8); - * // => ' abc ' - * - * _.pad('abc', 8, '_-'); - * // => '_-abc_-_' - * - * _.pad('abc', 3); - * // => 'abc' - */ - function pad(string, length, chars) { - string = toString(string); - length = toInteger(length); - - var strLength = length ? stringSize(string) : 0; - if (!length || strLength >= length) { - return string; - } - var mid = (length - strLength) / 2; - return ( - createPadding(nativeFloor(mid), chars) + - string + - createPadding(nativeCeil(mid), chars) - ); - } - - /** - * Pads `string` on the right side if it's shorter than `length`. Padding - * characters are truncated if they exceed `length`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.padEnd('abc', 6); - * // => 'abc ' - * - * _.padEnd('abc', 6, '_-'); - * // => 'abc_-_' - * - * _.padEnd('abc', 3); - * // => 'abc' - */ - function padEnd(string, length, chars) { - string = toString(string); - length = toInteger(length); - - var strLength = length ? stringSize(string) : 0; - return (length && strLength < length) - ? (string + createPadding(length - strLength, chars)) - : string; - } - - /** - * Pads `string` on the left side if it's shorter than `length`. Padding - * characters are truncated if they exceed `length`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.padStart('abc', 6); - * // => ' abc' - * - * _.padStart('abc', 6, '_-'); - * // => '_-_abc' - * - * _.padStart('abc', 3); - * // => 'abc' - */ - function padStart(string, length, chars) { - string = toString(string); - length = toInteger(length); - - var strLength = length ? stringSize(string) : 0; - return (length && strLength < length) - ? (createPadding(length - strLength, chars) + string) - : string; - } - - /** - * Converts `string` to an integer of the specified radix. If `radix` is - * `undefined` or `0`, a `radix` of `10` is used unless `value` is a - * hexadecimal, in which case a `radix` of `16` is used. - * - * **Note:** This method aligns with the - * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category String - * @param {string} string The string to convert. - * @param {number} [radix=10] The radix to interpret `value` by. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {number} Returns the converted integer. - * @example - * - * _.parseInt('08'); - * // => 8 - * - * _.map(['6', '08', '10'], _.parseInt); - * // => [6, 8, 10] - */ - function parseInt(string, radix, guard) { - if (guard || radix == null) { - radix = 0; - } else if (radix) { - radix = +radix; - } - return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0); - } - - /** - * Repeats the given string `n` times. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to repeat. - * @param {number} [n=1] The number of times to repeat the string. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {string} Returns the repeated string. - * @example - * - * _.repeat('*', 3); - * // => '***' - * - * _.repeat('abc', 2); - * // => 'abcabc' - * - * _.repeat('abc', 0); - * // => '' - */ - function repeat(string, n, guard) { - if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) { - n = 1; - } else { - n = toInteger(n); - } - return baseRepeat(toString(string), n); - } - - /** - * Replaces matches for `pattern` in `string` with `replacement`. - * - * **Note:** This method is based on - * [`String#replace`](https://mdn.io/String/replace). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to modify. - * @param {RegExp|string} pattern The pattern to replace. - * @param {Function|string} replacement The match replacement. - * @returns {string} Returns the modified string. - * @example - * - * _.replace('Hi Fred', 'Fred', 'Barney'); - * // => 'Hi Barney' - */ - function replace() { - var args = arguments, - string = toString(args[0]); - - return args.length < 3 ? string : string.replace(args[1], args[2]); - } - - /** - * Converts `string` to - * [snake case](https://en.wikipedia.org/wiki/Snake_case). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the snake cased string. - * @example - * - * _.snakeCase('Foo Bar'); - * // => 'foo_bar' - * - * _.snakeCase('fooBar'); - * // => 'foo_bar' - * - * _.snakeCase('--FOO-BAR--'); - * // => 'foo_bar' - */ - var snakeCase = createCompounder(function(result, word, index) { - return result + (index ? '_' : '') + word.toLowerCase(); - }); - - /** - * Splits `string` by `separator`. - * - * **Note:** This method is based on - * [`String#split`](https://mdn.io/String/split). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to split. - * @param {RegExp|string} separator The separator pattern to split by. - * @param {number} [limit] The length to truncate results to. - * @returns {Array} Returns the string segments. - * @example - * - * _.split('a-b-c', '-', 2); - * // => ['a', 'b'] - */ - function split(string, separator, limit) { - if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) { - separator = limit = undefined; - } - limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0; - if (!limit) { - return []; - } - string = toString(string); - if (string && ( - typeof separator == 'string' || - (separator != null && !isRegExp(separator)) - )) { - separator = baseToString(separator); - if (!separator && hasUnicode(string)) { - return castSlice(stringToArray(string), 0, limit); - } - } - return string.split(separator, limit); - } - - /** - * Converts `string` to - * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). - * - * @static - * @memberOf _ - * @since 3.1.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the start cased string. - * @example - * - * _.startCase('--foo-bar--'); - * // => 'Foo Bar' - * - * _.startCase('fooBar'); - * // => 'Foo Bar' - * - * _.startCase('__FOO_BAR__'); - * // => 'FOO BAR' - */ - var startCase = createCompounder(function(result, word, index) { - return result + (index ? ' ' : '') + upperFirst(word); - }); - - /** - * Checks if `string` starts with the given target string. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to inspect. - * @param {string} [target] The string to search for. - * @param {number} [position=0] The position to search from. - * @returns {boolean} Returns `true` if `string` starts with `target`, - * else `false`. - * @example - * - * _.startsWith('abc', 'a'); - * // => true - * - * _.startsWith('abc', 'b'); - * // => false - * - * _.startsWith('abc', 'b', 1); - * // => true - */ - function startsWith(string, target, position) { - string = toString(string); - position = position == null - ? 0 - : baseClamp(toInteger(position), 0, string.length); - - target = baseToString(target); - return string.slice(position, position + target.length) == target; - } - - /** - * Creates a compiled template function that can interpolate data properties - * in "interpolate" delimiters, HTML-escape interpolated data properties in - * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data - * properties may be accessed as free variables in the template. If a setting - * object is given, it takes precedence over `_.templateSettings` values. - * - * **Note:** In the development build `_.template` utilizes - * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) - * for easier debugging. - * - * For more information on precompiling templates see - * [lodash's custom builds documentation](https://lodash.com/custom-builds). - * - * For more information on Chrome extension sandboxes see - * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category String - * @param {string} [string=''] The template string. - * @param {Object} [options={}] The options object. - * @param {RegExp} [options.escape=_.templateSettings.escape] - * The HTML "escape" delimiter. - * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] - * The "evaluate" delimiter. - * @param {Object} [options.imports=_.templateSettings.imports] - * An object to import into the template as free variables. - * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] - * The "interpolate" delimiter. - * @param {string} [options.sourceURL='lodash.templateSources[n]'] - * The sourceURL of the compiled template. - * @param {string} [options.variable='obj'] - * The data object variable name. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the compiled template function. - * @example - * - * // Use the "interpolate" delimiter to create a compiled template. - * var compiled = _.template('hello <%= user %>!'); - * compiled({ 'user': 'fred' }); - * // => 'hello fred!' - * - * // Use the HTML "escape" delimiter to escape data property values. - * var compiled = _.template('<%- value %>'); - * compiled({ 'value': ' + + + \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index a55ab15..dbb2ea5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2354,6 +2354,11 @@ "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==", "dev": true }, + "body-parse": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/body-parse/-/body-parse-0.1.0.tgz", + "integrity": "sha512-k0PDF7vZZpspXlwoM8ywh9PIHZokooS0Rek4M8Vekoro7XuuaWVhjgTpdzIRrfKj5oLQahwjn621/4kG4d91xw==" + }, "body-parser": { "version": "1.18.2", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz", @@ -2520,6 +2525,11 @@ "electron-to-chromium": "^1.2.7" } }, + "bson": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/bson/-/bson-1.1.0.tgz", + "integrity": "sha512-9Aeai9TacfNtWXOYarkFJRW2CWo+dRon+fuLZYJmvLV3+MiUp0bEI6IAZfXEIg7/Pl/7IWlLaDnhzTsD81etQA==" + }, "buffer": { "version": "4.9.1", "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", @@ -3745,8 +3755,7 @@ "ejs": { "version": "2.6.1", "resolved": "https://registry.npmjs.org/ejs/-/ejs-2.6.1.tgz", - "integrity": "sha512-0xy4A/twfrRCnkhfk8ErDi5DqdAsAqeGxht4xkCUrsvhhbQNs7E+4jV0CN7+NKIY0aHE72+XvqtBIXzD31ZbXQ==", - "dev": true + "integrity": "sha512-0xy4A/twfrRCnkhfk8ErDi5DqdAsAqeGxht4xkCUrsvhhbQNs7E+4jV0CN7+NKIY0aHE72+XvqtBIXzD31ZbXQ==" }, "electron-to-chromium": { "version": "1.3.48", @@ -7295,6 +7304,12 @@ "readable-stream": "^2.0.1" } }, + "memory-pager": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/memory-pager/-/memory-pager-1.1.0.tgz", + "integrity": "sha512-Mf9OHV/Y7h6YWDxTzX/b4ZZ4oh9NSXblQL8dtPCOomOtZciEHxePR78+uHFLLlsk01A6jVHhHsQZZ/WcIPpnzg==", + "optional": true + }, "merge-descriptors": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", @@ -7506,6 +7521,26 @@ "minimist": "0.0.8" } }, + "mongodb": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/mongodb/-/mongodb-3.1.6.tgz", + "integrity": "sha512-E5QJuXQoMlT7KyCYqNNMfAkhfQD79AT4F8Xd+6x37OX+8BL17GyXyWvfm6wuyx4wnzCCPoCSLeMeUN2S7dU9yw==", + "requires": { + "mongodb-core": "3.1.5", + "safe-buffer": "^5.1.2" + } + }, + "mongodb-core": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/mongodb-core/-/mongodb-core-3.1.5.tgz", + "integrity": "sha512-emT/tM4ZBinqd6RZok+EzDdtN4LjYJIckv71qQVOEFmvXgT5cperZegVmTgox/1cx4XQu6LJ5ZuIwipP/eKdQg==", + "requires": { + "bson": "^1.1.0", + "require_optional": "^1.0.1", + "safe-buffer": "^5.1.2", + "saslprep": "^1.0.0" + } + }, "move-concurrently": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz", @@ -9401,6 +9436,22 @@ "resolve-from": "^1.0.0" } }, + "require_optional": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/require_optional/-/require_optional-1.0.1.tgz", + "integrity": "sha512-qhM/y57enGWHAe3v/NcwML6a3/vfESLe/sGM2dII+gEO0BpKRUkWZow/tyloNqJyN6kXSl3RyyM8Ll5D/sJP8g==", + "requires": { + "resolve-from": "^2.0.0", + "semver": "^5.1.0" + }, + "dependencies": { + "resolve-from": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-2.0.0.tgz", + "integrity": "sha1-lICrIOlP+h2egKgEx+oUdhGWa1c=" + } + } + }, "resolve": { "version": "1.7.1", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz", @@ -9611,8 +9662,7 @@ "safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", - "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", - "dev": true + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" }, "safe-regex": { "version": "1.1.0", @@ -9629,6 +9679,15 @@ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", "dev": true }, + "saslprep": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/saslprep/-/saslprep-1.0.2.tgz", + "integrity": "sha512-4cDsYuAjXssUSjxHKRe4DTZC0agDwsCqcMqtJAQPzC74nJ7LfAJflAtC1Zed5hMzEQKj82d3tuzqdGNRsLJ4Gw==", + "optional": true, + "requires": { + "sparse-bitfield": "^3.0.3" + } + }, "sax": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", @@ -9680,8 +9739,7 @@ "semver": { "version": "5.5.0", "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", - "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==", - "dev": true + "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==" }, "send": { "version": "0.16.2", @@ -10008,6 +10066,15 @@ "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", "dev": true }, + "sparse-bitfield": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/sparse-bitfield/-/sparse-bitfield-3.0.3.tgz", + "integrity": "sha1-/0rm5oZWBWuks+eSqzM004JzyhE=", + "optional": true, + "requires": { + "memory-pager": "^1.0.2" + } + }, "spdx-correct": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.0.0.tgz", diff --git a/package.json b/package.json index e03c976..a8c566a 100644 --- a/package.json +++ b/package.json @@ -16,8 +16,11 @@ "license": "ISC", "dependencies": { "adsr-envelope": "^1.0.0", + "body-parse": "^0.1.0", "codemirror": "^5.38.0", + "ejs": "^2.6.1", "lodash": "^4.17.10", + "mongodb": "^3.1.6", "ohm-js": "^0.14.0", "stereo-panner-node": "^1.4.0", "tonal": "^1.1.3", diff --git a/src/editor.js b/src/editor.js index 5cea06a..d78ec93 100644 --- a/src/editor.js +++ b/src/editor.js @@ -33,7 +33,7 @@ play @synth `; const editor = CodeMirror(document.querySelector('#editor'), { - value: existingCode || defaultCode, + value: window.slangPatch || existingCode || defaultCode, mode: 'slang', theme: 'duotone-light', indentWithTabs: true, @@ -65,6 +65,7 @@ function clearError() { const $run = document.querySelector('[data-run]'); const $stop = document.querySelector('[data-stop]'); const $status = document.querySelector('[data-status]'); +const $url = document.querySelector('[data-url]'); function status(str) { $status.textContent = str; @@ -94,9 +95,35 @@ function run() { // save the scene to localStorage window.localStorage.setItem('code', value); } +function createUrl() { + const value = editor.getValue(); + // The /save route of our express server is + // expecting a JSON blob containing a `text` field. + fetch('/save', { + method: 'POST', + mode: 'cors', + cache: 'default', + body: JSON.stringify({ text: value }), + headers: { + 'Content-Type': 'application/json', + 'Access-Control-Request-Method': 'post', + 'Access-Control-Allow-Credentials': 'true', + }, + }) + .then(response => response.text()) + .then((text) => { + // Redirect the browser to the newly created patch. + window.location.pathname = `/${text}`; + }) + .catch((e) => { + console.error(e); + displayError('Oh no! There’s a problem with the server. Try again in a bit.'); + }); +} $run.addEventListener('click', run); $stop.addEventListener('click', stop); +$url.addEventListener('click', createUrl); // ------------------------------ EDITOR ------------------------------ diff --git a/src/static/css/editor.css b/src/static/css/editor.css index 250111f..980858b 100644 --- a/src/static/css/editor.css +++ b/src/static/css/editor.css @@ -131,6 +131,10 @@ footer a:hover { background-color: #fb5e39; } +.button.blue { + background-color: #28bed3; +} + .button.gray { background-color: gray; } diff --git a/src/static/editor.html b/src/static/editor.html index d271967..2b421ab 100644 --- a/src/static/editor.html +++ b/src/static/editor.html @@ -15,6 +15,7 @@
Run
Stop
+
Create URL
Stopped
From 85d3626e5c5cdba49cf0b482c15b70a73ff3bfa4 Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Fri, 5 Oct 2018 09:41:06 -0500 Subject: [PATCH 15/16] Integrating save backend, although, this throws an error while saving --- backend/helpers.js | 27 ----- backend/server.js | 120 ------------------- package-lock.json | 172 ++++++++++++++------------- package.json | 1 + packing/helpers.js | 27 +++++ packing/server.js | 110 ++++++++++++++++- {backend => packing}/views/patch.ejs | 0 7 files changed, 225 insertions(+), 232 deletions(-) delete mode 100644 backend/helpers.js delete mode 100644 backend/server.js create mode 100644 packing/helpers.js rename {backend => packing}/views/patch.ejs (100%) diff --git a/backend/helpers.js b/backend/helpers.js deleted file mode 100644 index 9dda2d9..0000000 --- a/backend/helpers.js +++ /dev/null @@ -1,27 +0,0 @@ -// Returns a number between the min and max. -function randomRange(min, max){ - return Math.floor(Math.random() * (max - min + 1)) + min; -} - -// Creates an alphanumeric string 6 characters long. -// This is long enough to avoid random collisions without -// being totally obnoxious to look at. -function createHash() { - var newHash = ''; - - for (var i = 0; i < 6; i++) { - var digit; - if (Math.random() < 0.5){ - digit = String(randomRange(0,9)); - } else { - digit = String.fromCharCode(randomRange(97,122)); - } - newHash = newHash + digit; - } - return newHash; -} - -module.exports = { - createHash: createHash, - randomRange: randomRange, -}; \ No newline at end of file diff --git a/backend/server.js b/backend/server.js deleted file mode 100644 index 17168ee..0000000 --- a/backend/server.js +++ /dev/null @@ -1,120 +0,0 @@ -/* - DISCLAIMER: my vps is running an old version of node. - Does that ever happen to you? I'm writing this mostly - in old school ES5 to avoid having to upgrade right now. - If you contribute anything to this file... please be - kind. I'll upgrade eventually. - ¯\_(ツ)_/¯ -*/ - -const express = require('express'); -const bodyParser = require('body-parser'); -const MongoClient = require('mongodb').MongoClient; -const helpers = require('./helpers'); -const path = require('path'); - -const PORT = process.env.PORT || 8000; - -const app = express(); - -// We're serving static assets out of /public -app.use(express.static('public')); -// We are going to send JSON blobs so let's have -// bodyParser get the data ready for us. -app.use(bodyParser.json()); -// Using EJS to build the patch page. -app.set('view engine', 'ejs'); -// Point to the views folder -app.set('views', path.join(__dirname, './views')); - -// Connect to the database, add our routes, then start the server. -MongoClient.connect('mongodb://127.0.0.1:27017/slang', function(err, db) { - if (err) { - console.log('Oh no! The mongo database failed to start.'); - console.error(err); - return process.exit(1); - } - - // Load a saved patch, if one exists. - - app.get('/:id', function (req, res) { - const patches = db.collection('patches'); - patches.find({ _id: req.params.id }).toArray(function (err, items) { - if (err || !items.length) { - // Let's be clever and present a "not found" error - // inside of the text editor itself. - return res.render('patch', { - patch: { - text: '# Whoops! We couldn’t a patch at this URL.\n' - + '# You get the 404 womp womp patch instead.\n' - + '\n' - + '@notFoundLeft (adsr (osc tri)) + (pan -1)\n' - + '@notFoundRight (adsr (osc tri)) + (pan 1)\n' - + '\n' - + 'play @notFoundLeft\n' - + ' (rhythm [8n 8n 8n 8n 8n r1n r32n])\n' - + ' (notes [c5 b4 a#4 a4 g#4])\n' - + '\n' - + 'play @notFoundRight\n' - + ' (rhythm [r32n 8n 8n 8n 8n 8n r1n])\n' - + ' (notes (transpose -5 [c5 b4 a#4 a4 g#4]))', - }, - }); - } - - const patch = items[0]; - // We're using a string literal to dump out the text, so - // to avoid XSS let's remove any backticks present in the - // string itself. - patch.text = patch.text.replace(/\`/g, ''); - res.render('patch', { patch: patch }); - }); - }); - - // Save a new patch. - - // There are lots of ways we could do this, but here's what we're - // going to do and some rationale behind it: the client will send - // a POST to the /save route with the text they want to save, we'll - // respond by sending the ID as text, and the client will then - // redirect itself to the new URL, hitting the `/:id` route above. - - // We could just as well take the response on the client and display - // it as a URL that the user can copy, but because the URL represents - // the text *at the moment it was saved*, I don't want them to - // generate it, continue typing, and assume that their patch will - // update in some way. Redirecting to the new URL reinforces the fact - // that it's a one-time save. - - app.post('/save', function (req, res) { - const text = req.body.text; - - // Need to set some limits so you don't blow up my database! - if (!text || text.length > 10000) { - res.statusCode = '400'; - return res.send(':('); - } - - const patches = db.collection('patches'); - - // In theory there can be ID collisions, and in practice that - // does happen occasionally when you have a system like this - // doing ~1000+ saves per day, but we're not going to worry - // about that right now. - const id = helpers.createHash(); - patches.insert({ _id: id, text: text }, function (err, item) { - if (err) { - res.statusCode = 400; - return res.send('error'); - } - // return the URL - return res.send(id); - }); - }); - - // Start the server. - app.listen(PORT, function () { - console.log('Slang is running on port', (process.env.PORT || 8000), 'at', Date()); - }); -}); - diff --git a/package-lock.json b/package-lock.json index dbb2ea5..7fdb8f0 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2360,37 +2360,34 @@ "integrity": "sha512-k0PDF7vZZpspXlwoM8ywh9PIHZokooS0Rek4M8Vekoro7XuuaWVhjgTpdzIRrfKj5oLQahwjn621/4kG4d91xw==" }, "body-parser": { - "version": "1.18.2", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz", - "integrity": "sha1-h2eKGdhLR9hZuDGZvVm84iKxBFQ=", - "dev": true, + "version": "1.18.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.3.tgz", + "integrity": "sha1-WykhmP/dVTs6DyDe0FkrlWlVyLQ=", "requires": { "bytes": "3.0.0", "content-type": "~1.0.4", "debug": "2.6.9", - "depd": "~1.1.1", - "http-errors": "~1.6.2", - "iconv-lite": "0.4.19", + "depd": "~1.1.2", + "http-errors": "~1.6.3", + "iconv-lite": "0.4.23", "on-finished": "~2.3.0", - "qs": "6.5.1", - "raw-body": "2.3.2", - "type-is": "~1.6.15" + "qs": "6.5.2", + "raw-body": "2.3.3", + "type-is": "~1.6.16" }, "dependencies": { "debug": { "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "dev": true, "requires": { "ms": "2.0.0" } }, - "iconv-lite": { - "version": "0.4.19", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", - "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==", - "dev": true + "qs": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz", + "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==" } } }, @@ -2568,8 +2565,7 @@ "bytes": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz", - "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=", - "dev": true + "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=" }, "cacache": { "version": "10.0.4", @@ -3157,8 +3153,7 @@ "content-type": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", - "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==", - "dev": true + "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==" }, "convert-source-map": { "version": "1.5.1", @@ -3577,8 +3572,7 @@ "depd": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", - "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=", - "dev": true + "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=" }, "des.js": { "version": "1.0.0", @@ -3749,8 +3743,7 @@ "ee-first": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", - "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=", - "dev": true + "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=" }, "ejs": { "version": "2.6.1", @@ -4310,6 +4303,24 @@ "vary": "~1.1.2" }, "dependencies": { + "body-parser": { + "version": "1.18.2", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz", + "integrity": "sha1-h2eKGdhLR9hZuDGZvVm84iKxBFQ=", + "dev": true, + "requires": { + "bytes": "3.0.0", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "~1.1.1", + "http-errors": "~1.6.2", + "iconv-lite": "0.4.19", + "on-finished": "~2.3.0", + "qs": "6.5.1", + "raw-body": "2.3.2", + "type-is": "~1.6.15" + } + }, "debug": { "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", @@ -4319,6 +4330,50 @@ "ms": "2.0.0" } }, + "iconv-lite": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", + "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==", + "dev": true + }, + "raw-body": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.2.tgz", + "integrity": "sha1-vNYMd9Prk83gBQKVw/N5OJvIj4k=", + "dev": true, + "requires": { + "bytes": "3.0.0", + "http-errors": "1.6.2", + "iconv-lite": "0.4.19", + "unpipe": "1.0.0" + }, + "dependencies": { + "depd": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz", + "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k=", + "dev": true + }, + "http-errors": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz", + "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=", + "dev": true, + "requires": { + "depd": "1.1.1", + "inherits": "2.0.3", + "setprototypeof": "1.0.3", + "statuses": ">= 1.3.1 < 2" + } + }, + "setprototypeof": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz", + "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ=", + "dev": true + } + } + }, "safe-buffer": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", @@ -5841,7 +5896,6 @@ "version": "1.6.3", "resolved": "http://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", - "dev": true, "requires": { "depd": "~1.1.2", "inherits": "2.0.3", @@ -5859,7 +5913,6 @@ "version": "0.4.23", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.23.tgz", "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==", - "dev": true, "requires": { "safer-buffer": ">= 2.1.2 < 3" } @@ -7197,8 +7250,7 @@ "media-typer": { "version": "0.3.0", "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", - "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=", - "dev": true + "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=" }, "mem": { "version": "1.1.0", @@ -7368,14 +7420,12 @@ "mime-db": { "version": "1.36.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.36.0.tgz", - "integrity": "sha512-L+xvyD9MkoYMXb1jAmzI/lWYAxAMCPvIBSWur0PZ5nOf5euahRLVqH//FKW9mWp2lkqUgYiXPgkzfMUFi4zVDw==", - "dev": true + "integrity": "sha512-L+xvyD9MkoYMXb1jAmzI/lWYAxAMCPvIBSWur0PZ5nOf5euahRLVqH//FKW9mWp2lkqUgYiXPgkzfMUFi4zVDw==" }, "mime-types": { "version": "2.1.20", "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.20.tgz", "integrity": "sha512-HrkrPaP9vGuWbLK1B1FfgAkbqNjIuy4eHlIYnFi7kamZyLLrGlo2mpcx0bBmNpKqBtYtAfGbodDddIgddSJC2A==", - "dev": true, "requires": { "mime-db": "~1.36.0" } @@ -7558,8 +7608,7 @@ "ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", - "dev": true + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" }, "multimatch": { "version": "2.1.0", @@ -7903,7 +7952,6 @@ "version": "2.3.0", "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz", "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", - "dev": true, "requires": { "ee-first": "1.1.1" } @@ -9071,47 +9119,14 @@ "dev": true }, "raw-body": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.2.tgz", - "integrity": "sha1-vNYMd9Prk83gBQKVw/N5OJvIj4k=", - "dev": true, + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.3.tgz", + "integrity": "sha512-9esiElv1BrZoI3rCDuOuKCBRbuApGGaDPQfjSflGxdy4oyzqghxu6klEkkVIvBje+FF0BX9coEv8KqW6X/7njw==", "requires": { "bytes": "3.0.0", - "http-errors": "1.6.2", - "iconv-lite": "0.4.19", + "http-errors": "1.6.3", + "iconv-lite": "0.4.23", "unpipe": "1.0.0" - }, - "dependencies": { - "depd": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz", - "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k=", - "dev": true - }, - "http-errors": { - "version": "1.6.2", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz", - "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=", - "dev": true, - "requires": { - "depd": "1.1.1", - "inherits": "2.0.3", - "setprototypeof": "1.0.3", - "statuses": ">= 1.3.1 < 2" - } - }, - "iconv-lite": { - "version": "0.4.19", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", - "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==", - "dev": true - }, - "setprototypeof": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz", - "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ=", - "dev": true - } } }, "raw-loader": { @@ -9676,8 +9691,7 @@ "safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", - "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", - "dev": true + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" }, "saslprep": { "version": "1.0.2", @@ -9835,8 +9849,7 @@ "setprototypeof": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", - "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==", - "dev": true + "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==" }, "sha.js": { "version": "2.4.11", @@ -10155,8 +10168,7 @@ "statuses": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", - "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==", - "dev": true + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" }, "stereo-panner-node": { "version": "1.4.0", @@ -10740,7 +10752,6 @@ "version": "1.6.16", "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz", "integrity": "sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==", - "dev": true, "requires": { "media-typer": "0.3.0", "mime-types": "~2.1.18" @@ -10896,8 +10907,7 @@ "unpipe": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", - "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=", - "dev": true + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=" }, "unset-value": { "version": "1.0.0", diff --git a/package.json b/package.json index a8c566a..582e164 100644 --- a/package.json +++ b/package.json @@ -17,6 +17,7 @@ "dependencies": { "adsr-envelope": "^1.0.0", "body-parse": "^0.1.0", + "body-parser": "^1.18.3", "codemirror": "^5.38.0", "ejs": "^2.6.1", "lodash": "^4.17.10", diff --git a/packing/helpers.js b/packing/helpers.js new file mode 100644 index 0000000..52e051f --- /dev/null +++ b/packing/helpers.js @@ -0,0 +1,27 @@ +// Returns a number between the min and max. +function randomRange(min, max) { + return Math.floor(Math.random() * ((max - min) + 1)) + min; +} + +// Creates an alphanumeric string 6 characters long. +// This is long enough to avoid random collisions without +// being totally obnoxious to look at. +function createHash() { + let newHash = ''; + + for (let i = 0; i < 6; i += 1) { + let digit = 0; + if (Math.random() < 0.5) { + digit = String(randomRange(0, 9)); + } else { + digit = String.fromCharCode(randomRange(97, 122)); + } + newHash += digit; + } + return newHash; +} + +module.exports = { + createHash, + randomRange, +}; diff --git a/packing/server.js b/packing/server.js index 61b50a6..11bccf5 100644 --- a/packing/server.js +++ b/packing/server.js @@ -4,6 +4,9 @@ const express = require('express'); const webpack = require('webpack'); const devMiddlewareFn = require('webpack-dev-middleware'); const webpackConfig = require('./webpack.config.js'); +const bodyParser = require('body-parser'); +const { MongoClient } = require('mongodb'); +const helpers = require('./helpers'); // default port where dev server listens for incoming traffic const port = 5555; @@ -16,8 +19,9 @@ const devMiddleware = devMiddlewareFn(compiler, { quiet: true, }); -// handle fallback for HTML5 history API -// app.use(require('connect-history-api-fallback')()); +// We are going to send JSON blobs so let's have +// bodyParser get the data ready for us. +app.use(bodyParser.json()); // serve webpack bundle output app.use(devMiddleware); @@ -26,6 +30,11 @@ app.use(devMiddleware); const staticPath = path.posix.join('/'); app.use(staticPath, express.static('./dist')); +// Using EJS to build the patch page. +app.set('view engine', 'ejs'); +// Point to the views folder +app.set('views', path.join(__dirname, './views')); + const uri = `http://localhost:${port}`; console.log('> Starting dev server...'); @@ -38,6 +47,99 @@ devMiddleware.waitUntilValid(() => { } }); -const server = app.listen(port); +// TODO: Mongo.connect() is not a function error and redirects to a HTML URL +// Connect to the database, add our routes, then start the server. +MongoClient.connect('mongodb://127.0.0.1:27017/slang', (error, db) => { + if (error) { + console.log('Oh no! The mongo database failed to start.'); + console.error(error); + return process.exit(1); + } + + // Load a saved patch, if one exists. + + app.get('/:id', (req, res) => { + const patches = db.collection('patches'); + patches.find({ _id: req.params.id }).toArray((err, items) => { + if (err || !items.length) { + // Let's be clever and present a "not found" error + // inside of the text editor itself. + return res.render('patch', { + patch: { + text: '# Whoops! We couldn’t a patch at this URL.\n' + + '# You get the 404 womp womp patch instead.\n' + + '\n' + + '@notFoundLeft (adsr (osc tri)) + (pan -1)\n' + + '@notFoundRight (adsr (osc tri)) + (pan 1)\n' + + '\n' + + 'play @notFoundLeft\n' + + ' (rhythm [8n 8n 8n 8n 8n r1n r32n])\n' + + ' (notes [c5 b4 a#4 a4 g#4])\n' + + '\n' + + 'play @notFoundRight\n' + + ' (rhythm [r32n 8n 8n 8n 8n 8n r1n])\n' + + ' (notes (transpose -5 [c5 b4 a#4 a4 g#4]))', + }, + }); + } + + const patch = items[0]; + // We're using a string literal to dump out the text, so + // to avoid XSS let's remove any backticks present in the + // string itself. + patch.text = patch.text.replace(/`/g, ''); + res.render('patch', { patch }); + return true; + }); + }); + + // Save a new patch. + + // There are lots of ways we could do this, but here's what we're + // going to do and some rationale behind it: the client will send + // a POST to the /save route with the text they want to save, we'll + // respond by sending the ID as text, and the client will then + // redirect itself to the new URL, hitting the `/:id` route above. + + // We could just as well take the response on the client and display + // it as a URL that the user can copy, but because the URL represents + // the text *at the moment it was saved*, I don't want them to + // generate it, continue typing, and assume that their patch will + // update in some way. Redirecting to the new URL reinforces the fact + // that it's a one-time save. -module.exports = server; + app.post('/save', (req, res) => { + const { text } = req.body; + + // Need to set some limits so you don't blow up my database! + if (!text || text.length > 10000) { + res.statusCode = '400'; + return res.send(':('); + } + + const patches = db.collection('patches'); + + // In theory there can be ID collisions, and in practice that + // does happen occasionally when you have a system like this + // doing ~1000+ saves per day, but we're not going to worry + // about that right now. + const id = helpers.createHash(); + patches.insert({ _id: id, text }, (err) => { + if (err) { + res.statusCode = 400; + return res.send('error'); + } + // return the URL + return res.send(id); + }); + + return true; + }); + + // Start the server. + app.listen(port, () => { + console.log('Slang is running on port', (process.env.PORT || 8000), 'at', Date()); + }); + + return true; +}); diff --git a/backend/views/patch.ejs b/packing/views/patch.ejs similarity index 100% rename from backend/views/patch.ejs rename to packing/views/patch.ejs From d044fe8bb83e39c87410032b562953ef9de7cbdf Mon Sep 17 00:00:00 2001 From: Pedro Carrazco Date: Fri, 5 Oct 2018 16:57:52 -0500 Subject: [PATCH 16/16] Integrating Mongo DB actions to the server Hashes with expiration date (2 days) Reorganization of files --- .eslintrc | 3 +- package-lock.json | 5 -- package.json | 3 +- packing/helpers.js | 27 -------- packing/views/patch.ejs | 62 ----------------- server/helpers.js | 34 ++++++++++ server/mongo/mongo.config.js | 8 +++ server/mongodb.js | 9 +++ {packing => server}/server.js | 123 +++++++++++++++++++--------------- server/views/patch.ejs | 36 ++++++++++ src/static/editor.html | 4 +- 11 files changed, 161 insertions(+), 153 deletions(-) delete mode 100644 packing/helpers.js delete mode 100644 packing/views/patch.ejs create mode 100644 server/helpers.js create mode 100644 server/mongo/mongo.config.js create mode 100644 server/mongodb.js rename {packing => server}/server.js (54%) create mode 100644 server/views/patch.ejs diff --git a/.eslintrc b/.eslintrc index 2906401..2420cfa 100644 --- a/.eslintrc +++ b/.eslintrc @@ -31,7 +31,8 @@ { "devDependencies": [ "dist/*.js", - "packing/*.js" + "packing/*.js", + "server/**/*.js" ] } ] diff --git a/package-lock.json b/package-lock.json index 7fdb8f0..cdf99a3 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2354,11 +2354,6 @@ "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==", "dev": true }, - "body-parse": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/body-parse/-/body-parse-0.1.0.tgz", - "integrity": "sha512-k0PDF7vZZpspXlwoM8ywh9PIHZokooS0Rek4M8Vekoro7XuuaWVhjgTpdzIRrfKj5oLQahwjn621/4kG4d91xw==" - }, "body-parser": { "version": "1.18.3", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.3.tgz", diff --git a/package.json b/package.json index 582e164..88ef280 100644 --- a/package.json +++ b/package.json @@ -7,7 +7,7 @@ "prestart": "npm run lint", "start": "echo 'STARTING' && npm run dev:webpack && npm run dev:server", "dev:webpack": "webpack --config packing/webpack.config.js --progress --hide-modules", - "dev:server": "node packing/server.js", + "dev:server": "node server/server.js", "lint": "echo 'LINTING' && eslint --ext .js src packing && echo 'Syntax is ok...'", "prebuild": "npm run lint", "build": "echo 'BUILDING' && webpack --config packing/webpack.prod.js" @@ -16,7 +16,6 @@ "license": "ISC", "dependencies": { "adsr-envelope": "^1.0.0", - "body-parse": "^0.1.0", "body-parser": "^1.18.3", "codemirror": "^5.38.0", "ejs": "^2.6.1", diff --git a/packing/helpers.js b/packing/helpers.js deleted file mode 100644 index 52e051f..0000000 --- a/packing/helpers.js +++ /dev/null @@ -1,27 +0,0 @@ -// Returns a number between the min and max. -function randomRange(min, max) { - return Math.floor(Math.random() * ((max - min) + 1)) + min; -} - -// Creates an alphanumeric string 6 characters long. -// This is long enough to avoid random collisions without -// being totally obnoxious to look at. -function createHash() { - let newHash = ''; - - for (let i = 0; i < 6; i += 1) { - let digit = 0; - if (Math.random() < 0.5) { - digit = String(randomRange(0, 9)); - } else { - digit = String.fromCharCode(randomRange(97, 122)); - } - newHash += digit; - } - return newHash; -} - -module.exports = { - createHash, - randomRange, -}; diff --git a/packing/views/patch.ejs b/packing/views/patch.ejs deleted file mode 100644 index 2e93d83..0000000 --- a/packing/views/patch.ejs +++ /dev/null @@ -1,62 +0,0 @@ - - - - - - - - -
-
-
Run
-
Stop
-
-
-
Stopped
-
-
-
Create URL
- Docs -
-
-
- - - - - \ No newline at end of file diff --git a/server/helpers.js b/server/helpers.js new file mode 100644 index 0000000..70359e9 --- /dev/null +++ b/server/helpers.js @@ -0,0 +1,34 @@ +// Returns a number between the min and max. +function randomRange(min, max) { + return Math.floor(Math.random() * ((max - min) + 1)) + min; +} + +/** + * Returns an encoded version of the current date using the + * provided key or the default one. + * @param {string} k - Optional encode key + * @returns {array} + */ +function createHash(k) { + // Current numerical date is never duplicated + // Use k parameter as key, of not set, use the default key + const key = typeof k === 'string' + ? k + : '1234567890qwertyuiopasdfghjklzQWERTYUIOPASDFGHJKLZXCVBNM+_-.~'; + const r = key.length; + // Date is the raw hash + let n = new Date().getTime(); + let c = ''; + + // Encode the date acording to provided key + while (n > 0) { + c = key.charAt(n % r) + c; + n = Math.floor(n / r); + } + return c; +} + +module.exports = { + createHash, + randomRange, +}; diff --git a/server/mongo/mongo.config.js b/server/mongo/mongo.config.js new file mode 100644 index 0000000..afd75b0 --- /dev/null +++ b/server/mongo/mongo.config.js @@ -0,0 +1,8 @@ +module.exports = { + HOST: '127.0.0.1', + PORT: 27017, + NAME: 'slang', + USER: 'slang', + PASS: '5l4ng+R0x', + AUTH: null, +}; diff --git a/server/mongodb.js b/server/mongodb.js new file mode 100644 index 0000000..6ac745e --- /dev/null +++ b/server/mongodb.js @@ -0,0 +1,9 @@ +const mongoose = require('mongoose'); +const MongoConfig = require('./mongo/mongo.config.js'); + +mongoose.Promise = global.Promise; + +const uri = `mongodb://${MongoConfig.HOST}:${MongoConfig.PORT}/${MongoConfig.NAME}`; +const db = mongoose.createConnection(uri); + +module.exports = db; diff --git a/packing/server.js b/server/server.js similarity index 54% rename from packing/server.js rename to server/server.js index 11bccf5..85e51af 100644 --- a/packing/server.js +++ b/server/server.js @@ -2,11 +2,13 @@ const opn = require('opn'); const path = require('path'); const express = require('express'); const webpack = require('webpack'); +const { MongoClient } = require('mongodb'); const devMiddlewareFn = require('webpack-dev-middleware'); -const webpackConfig = require('./webpack.config.js'); const bodyParser = require('body-parser'); -const { MongoClient } = require('mongodb'); + +const webpackConfig = require('../packing/webpack.config.js'); const helpers = require('./helpers'); +const MongoConfig = require('./mongo/mongo.config.js'); // default port where dev server listens for incoming traffic const port = 5555; @@ -18,6 +20,19 @@ const devMiddleware = devMiddlewareFn(compiler, { publicPath: webpackConfig.output.publicPath, quiet: true, }); +const notFoundPatch = `# Whoops! We couldn’t a patch at this URL. +# You get the 404 womp womp patch instead. + +@notFoundLeft (adsr (osc tri)) + (pan -1) +@notFoundRight (adsr (osc tri)) + (pan 1) + +play @notFoundLeft + (rhythm [8n 8n 8n 8n 8n r1n r32n]) + (notes [c5 b4 a#4 a4 g#4]) + +play @notFoundRight + (rhythm [r32n 8n 8n 8n 8n 8n r1n]) + (notes (transpose -5 [c5 b4 a#4 a4 g#4]))'`; // We are going to send JSON blobs so let's have // bodyParser get the data ready for us. @@ -47,49 +62,43 @@ devMiddleware.waitUntilValid(() => { } }); -// TODO: Mongo.connect() is not a function error and redirects to a HTML URL // Connect to the database, add our routes, then start the server. -MongoClient.connect('mongodb://127.0.0.1:27017/slang', (error, db) => { - if (error) { +MongoClient.connect(`mongodb://${MongoConfig.HOST}:${MongoConfig.PORT}`, (err, client) => { + if (err) { console.log('Oh no! The mongo database failed to start.'); - console.error(error); - return process.exit(1); + console.error(err); + return; } - // Load a saved patch, if one exists. + const db = client.db(MongoConfig.NAME); + const patches = db.collection('Patch'); + + async function cleanup() { + await patches.deleteMany({ + $or: [ + { exp: { $exists: false } }, + { exp: { $lte: new Date().getTime() } }, + ], + }, (cleanupErr, data) => { + if (cleanupErr === null && data.result.n) console.log(`--- Cleanup: ${data.result.n} Patches removed`); + }); + } - app.get('/:id', (req, res) => { - const patches = db.collection('patches'); - patches.find({ _id: req.params.id }).toArray((err, items) => { - if (err || !items.length) { - // Let's be clever and present a "not found" error - // inside of the text editor itself. - return res.render('patch', { - patch: { - text: '# Whoops! We couldn’t a patch at this URL.\n' - + '# You get the 404 womp womp patch instead.\n' - + '\n' - + '@notFoundLeft (adsr (osc tri)) + (pan -1)\n' - + '@notFoundRight (adsr (osc tri)) + (pan 1)\n' - + '\n' - + 'play @notFoundLeft\n' - + ' (rhythm [8n 8n 8n 8n 8n r1n r32n])\n' - + ' (notes [c5 b4 a#4 a4 g#4])\n' - + '\n' - + 'play @notFoundRight\n' - + ' (rhythm [r32n 8n 8n 8n 8n 8n r1n])\n' - + ' (notes (transpose -5 [c5 b4 a#4 a4 g#4]))', - }, - }); - } + // Load a saved patch, if one exists. + app.get('/:hash', async (req, res) => { + console.log(`--- Looking for: ${req.params.hash}`); + patches.find({ hash: req.params.hash }).toArray((findErr, items) => { + const message = findErr || !items.length ? 'Not Found' : 'Found!'; + console.log(`--- ${req.params.hash} ${message}`); + // Let's be clever and present a "not found" error + // inside of the text editor itself. + let text = findErr || !items.length ? notFoundPatch : items[0].text; - const patch = items[0]; // We're using a string literal to dump out the text, so // to avoid XSS let's remove any backticks present in the // string itself. - patch.text = patch.text.replace(/`/g, ''); - res.render('patch', { patch }); - return true; + text = text.replace(/`/g, ''); + res.render('patch', { patch: text }); }); }); @@ -108,38 +117,44 @@ MongoClient.connect('mongodb://127.0.0.1:27017/slang', (error, db) => { // update in some way. Redirecting to the new URL reinforces the fact // that it's a one-time save. - app.post('/save', (req, res) => { + app.post('/save', async (req, res) => { + // Cleanup before saving + await cleanup(); const { text } = req.body; + const lifeSpan = 2; // Delete hashs after 2 days + const exp = new Date().getTime() + (lifeSpan * 60 * 60 * 24 * 1000); + console.log('--- Saving...'); // Need to set some limits so you don't blow up my database! if (!text || text.length > 10000) { res.statusCode = '400'; - return res.send(':('); + res.send(':('); + return; } - const patches = db.collection('patches'); - - // In theory there can be ID collisions, and in practice that - // does happen occasionally when you have a system like this - // doing ~1000+ saves per day, but we're not going to worry - // about that right now. - const id = helpers.createHash(); - patches.insert({ _id: id, text }, (err) => { - if (err) { - res.statusCode = 400; - return res.send('error'); + // No collitions anymore + const hash = helpers.createHash(); + + await patches.insertOne({ hash, text, exp }, (saveErr) => { + if (saveErr) { + res.statusCode = 500; + res.send('Error while saving your Patch'); } - // return the URL - return res.send(id); + console.log(`--- ${hash} Saved!`); + res.send(hash); }); + }); - return true; + app.get('/list/all', async (req, res) => { + // Insert some documents + await patches.find({}).toArray((testErr, docs) => { + console.log('--- All hashes listed'); + res.send(docs); + }); }); // Start the server. app.listen(port, () => { console.log('Slang is running on port', (process.env.PORT || 8000), 'at', Date()); }); - - return true; }); diff --git a/server/views/patch.ejs b/server/views/patch.ejs new file mode 100644 index 0000000..13c4262 --- /dev/null +++ b/server/views/patch.ejs @@ -0,0 +1,36 @@ + + + + + + + + +
+
+
Run
+
Stop
+
+
+
Stopped
+
+
+
Create URL
+ Docs +
+
+
+ + + + + \ No newline at end of file diff --git a/src/static/editor.html b/src/static/editor.html index 2b421ab..27a60bc 100644 --- a/src/static/editor.html +++ b/src/static/editor.html @@ -9,18 +9,18 @@
×
- +
Run
Stop
-
Create URL
Stopped
+
Create URL
Docs