diff --git a/_locales/bg/messages.json b/_locales/bg/messages.json index 62cd67b6..5a2ea41a 100644 --- a/_locales/bg/messages.json +++ b/_locales/bg/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Проблеми", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Цвят на фона", @@ -665,8 +665,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "Проблеми, намерени от CSSLint при следните правила:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Проблеми, намерени от stylelint при следните правила:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Значка на иконката на лентата", @@ -764,4 +764,4 @@ "message": "Пресъздайте стила на Мрежата със Стайлус, разширението за стилове. То ви позволява лесно да инсталиране теми за много сайтове.", "description": "Extension description" } -} \ No newline at end of file +} diff --git a/_locales/cs/messages.json b/_locales/cs/messages.json index fa45927b..759179b2 100644 --- a/_locales/cs/messages.json +++ b/_locales/cs/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Problémy", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Barva pozadí", @@ -653,8 +653,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "Problémy nalezené aplikací CSSLint s těmito povolenými pravidly:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Problémy nalezené aplikací stylelint s těmito povolenými pravidly:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Ikona tlačítka na panelu", @@ -752,4 +752,4 @@ "message": "Změňte vzhled webů pomocí správce uživatelských stylů. Stylus umožňuje snadnou instalaci vzhledů a modifikací pro spoustu webů.", "description": "Extension description" } -} \ No newline at end of file +} diff --git a/_locales/de/messages.json b/_locales/de/messages.json index 5c4a1e94..195760bf 100644 --- a/_locales/de/messages.json +++ b/_locales/de/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Probleme", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Hintergrundfarbe", @@ -633,8 +633,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "Die von CSSLint gefunden Fehler haben die folgenden Einstellungen:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Die von stylelint gefunden Fehler haben die folgenden Einstellungen:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Badge auf dem Toolbar-Icon", @@ -728,4 +728,4 @@ "message": "Gestalte das Web neu mit Stylus, dem Style Manager. Stylus ermöglicht dir ganz einfach Themes und Designs für viele populäre Websites zu installieren.", "description": "Extension description" } -} \ No newline at end of file +} diff --git a/_locales/en/messages.json b/_locales/en/messages.json index 9e524310..06856b2b 100644 --- a/_locales/en/messages.json +++ b/_locales/en/messages.json @@ -339,11 +339,11 @@ }, "issues": { "message": "Issues", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "issuesHelp": { - "message": "The issues found by CSSLint with these rules enabled:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "The issues found by stylelint with these rules enabled:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "manageFilters": { "message": "Filters", diff --git a/_locales/es/messages.json b/_locales/es/messages.json index 5d6e131f..713f97a1 100644 --- a/_locales/es/messages.json +++ b/_locales/es/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Problemas", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Color de fondo", @@ -657,8 +657,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "Problemas encontrados por CSSLint con estas reglas aplicadas:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Problemas encontrados por stylelint con estas reglas aplicadas:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Distintivo en el icono de barra de herramientas", diff --git a/_locales/et/messages.json b/_locales/et/messages.json index 1aa851ca..386fda0a 100644 --- a/_locales/et/messages.json +++ b/_locales/et/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Vead", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Taustavärv", @@ -653,8 +653,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "CSSLint poolt leitud vead nende lubatud reeglitega:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "stylelint poolt leitud vead nende lubatud reeglitega:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Number tööriistaribaikoonil", diff --git a/_locales/ja/messages.json b/_locales/ja/messages.json index 799371d6..bc87a044 100644 --- a/_locales/ja/messages.json +++ b/_locales/ja/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "問題点", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "背景色", @@ -649,8 +649,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "これらのルールを有効にして CSSLint で見つかった問題:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "これらのルールを有効にして stylelint で見つかった問題:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "ツールバーアイコンのバッジ", diff --git a/_locales/nl/messages.json b/_locales/nl/messages.json index 0f06ade9..47dd5dda 100644 --- a/_locales/nl/messages.json +++ b/_locales/nl/messages.json @@ -13,7 +13,7 @@ }, "issues": { "message": "Problemen", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "cm_tabSize": { "message": "Tabgrootte", @@ -345,8 +345,8 @@ "description": "Label for the button to check all styles for updates" }, "issuesHelp": { - "message": "De door CSSLint gevonden problemen, CSSLint, met deze ingeschakelde regels:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "De door stylelint gevonden problemen, stylelint, met deze ingeschakelde regels:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "confirmNo": { "message": "Nee", @@ -396,4 +396,4 @@ "message": "Voorzie het web van een ander uiterlijk met Stylus, een gebruikersstijlbeheerder. Stylus stelt u in staat om eenvoudig thema's en stijlen te installeren voor vele populaire websites.", "description": "Extension description" } -} \ No newline at end of file +} diff --git a/_locales/pl/messages.json b/_locales/pl/messages.json index b05817e7..6db9faec 100644 --- a/_locales/pl/messages.json +++ b/_locales/pl/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Problemy", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Kolor tła", @@ -657,8 +657,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "Problemy znalezione przez CSSLint z tymi włączonymi regułami:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Problemy znalezione przez stylelint z tymi włączonymi regułami:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Emblemat na ikonie paska narzędzi", diff --git a/_locales/ru/messages.json b/_locales/ru/messages.json index 5dd8f36e..b6221834 100644 --- a/_locales/ru/messages.json +++ b/_locales/ru/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "Проблемы", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "Цвет фона", @@ -657,8 +657,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "Проблемы и предупреждения по версии CSSLint с данными включенными правилами:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Проблемы и предупреждения по версии stylelint с данными включенными правилами:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "Бейдж на пиктограмме в тулбаре", diff --git a/_locales/sr/messages.json b/_locales/sr/messages.json index b55e7ad9..c6b754f5 100644 --- a/_locales/sr/messages.json +++ b/_locales/sr/messages.json @@ -13,7 +13,7 @@ }, "issues": { "message": "Проблеми", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "cm_tabSize": { "message": "Величина картице", @@ -357,8 +357,8 @@ "description": "Label for the button to check all styles for updates" }, "issuesHelp": { - "message": "Проблем пронађен од стране CSSLint са овим омогућеним правилима:", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "Проблем пронађен од стране stylelint са овим омогућеним правилима:", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "confirmNo": { "message": "Не", diff --git a/_locales/zh_CN/messages.json b/_locales/zh_CN/messages.json index e9b7cef5..e9e9b80d 100644 --- a/_locales/zh_CN/messages.json +++ b/_locales/zh_CN/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "问题", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "背景颜色", @@ -657,8 +657,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "CSSLint 在已启用的这些规则中找到问题：", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "stylelint 在已启用的这些规则中找到问题：", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "样式计数器", diff --git a/_locales/zh_TW/messages.json b/_locales/zh_TW/messages.json index 63ea9087..f6cb2703 100644 --- a/_locales/zh_TW/messages.json +++ b/_locales/zh_TW/messages.json @@ -29,7 +29,7 @@ }, "issues": { "message": "問題", - "description": "Label for the CSSLint issues block on the style edit page" + "description": "Label for the stylelint issues block on the style edit page" }, "optionsBadgeNormal": { "message": "背景顏色", @@ -661,8 +661,8 @@ "description": "Go to Options UI" }, "issuesHelp": { - "message": "由CSSLint發現啟用這些規則會產生衝突", - "description": "Help popup message for the CSSLint issues block on the style edit page" + "message": "由stylelint發現啟用這些規則會產生衝突", + "description": "Help popup message for the stylelint issues block on the style edit page" }, "optionsCustomizeBadge": { "message": "在工具列圖示上的徽章", diff --git a/edit.html b/edit.html index 4684b534..569eb95b 100644 --- a/edit.html +++ b/edit.html @@ -34,9 +34,10 @@ - - + + + diff --git a/edit/edit.css b/edit/edit.css index 450acf51..49ff5fcd 100644 --- a/edit/edit.css +++ b/edit/edit.css @@ -24,6 +24,10 @@ body { margin-top: 1rem; margin-left: 1.7rem; } +section { + box-sizing: border-box; + width: 100%; +} .aligned { display: table-row; } @@ -397,6 +401,9 @@ body[data-match-highlight="selection"] .CodeMirror-selection-highlight-scrollbar pointer-events: all; opacity: 1.0; } +#help-popup .rules { + padding: 0 15px; +} /************ lint ************/ #lint { @@ -410,6 +417,7 @@ body[data-match-highlight="selection"] .CodeMirror-selection-highlight-scrollbar border-spacing: 0; margin-bottom: 1rem; line-height: 1.0; + width: 245px; } #lint table:last-child { margin-bottom: 0; @@ -440,6 +448,10 @@ body[data-match-highlight="selection"] .CodeMirror-selection-highlight-scrollbar } #lint td[role="message"] { text-align: left; + max-width: 140px; + text-overflow: ellipsis; + white-space: pre; + overflow: hidden; } /************ CSS beautifier ************/ @@ -552,6 +564,12 @@ body[data-match-highlight="selection"] .CodeMirror-selection-highlight-scrollbar margin-top: 1em; max-height: 30vh; } + #lint table { + width: 100%; + } + #lint td[role="message"] { + max-width: none; + } #sections { padding-left: 0; } diff --git a/edit/edit.js b/edit/edit.js index fd656ecb..519f6940 100644 --- a/edit/edit.js +++ b/edit/edit.js @@ -1,5 +1,5 @@ /* eslint brace-style: 0, operator-linebreak: 0 */ -/* global CodeMirror exports parserlib CSSLint */ +/* global CodeMirror parserlib */ 'use strict'; let styleId = null; @@ -639,7 +639,6 @@ function addSection(event, section) { sections.appendChild(div); cm = setupCodeMirror(codeElement); } - div.CodeMirror = cm; setCleanSection(div); return div; @@ -1051,7 +1050,7 @@ function getEditorInSight(nearbyElement) { function updateLintReport(cm, delay) { if (delay === 0) { - // immediately show pending csslint messages in onbeforeunload and save + // immediately show pending stylelint messages in onbeforeunload and save update(cm); return; } @@ -1083,7 +1082,8 @@ function updateLintReport(cm, delay) { const info = mark.__annotation; const isActiveLine = info.from.line === cm.getCursor().line; const pos = isActiveLine ? 'cursor' : (info.from.line + ',' + info.from.ch); - let message = escapeHtml(info.message.replace(/ at line \d.+$/, '')); + const rule = info.message.substring(info.message.lastIndexOf('('), info.message.length); + let message = escapeHtml(info.message.replace(rule, '')); if (message.length > 100) { message = message.substr(0, 100) + '...'; } @@ -1091,14 +1091,16 @@ function updateLintReport(cm, delay) { delete oldMarkers[pos]; } newMarkers[pos] = message; - return '' + - '' + - info.severity + '' + - '' + (info.from.line + 1) + '' + - ':' + - '' + (info.from.ch + 1) + '' + - '' + message + ''; - }).join('') + ''; + return ` + + ${info.severity} + + ${info.from.line + 1} + : + ${info.from.ch + 1} + ${message} + ` + }) + ''; scopedState.markedLast = newMarkers; fixedOldIssues |= scopedState.reportDisplayed && Object.keys(oldMarkers).length > 0; if (scopedState.html !== html) { @@ -1181,13 +1183,10 @@ function toggleLintReport() { } function beautify(event) { - if (exports.css_beautify) { // thanks to csslint's definition of 'exports' - doBeautify(); - } else { - const script = document.head.appendChild(document.createElement('script')); - script.src = 'vendor-overwrites/beautify/beautify-css-mod.js'; - script.onload = doBeautify; - } + const script = document.head.appendChild(document.createElement('script')); + script.src = 'vendor-overwrites/beautify/beautify-css-mod.js'; + script.onload = doBeautify; + function doBeautify() { const tabs = prefs.get('editor.indentWithTabs'); const options = prefs.get('editor.beautify'); @@ -1231,7 +1230,7 @@ function beautify(event) { [].concat.apply([], cm.doc.sel.ranges.map(r => [Object.assign({}, r.anchor), Object.assign({}, r.head)])); const text = cm.getValue(); - const newText = exports.css_beautify(text, options); + const newText = css_beautify(text, options); if (newText !== text) { if (!cm.beautifyChange || !cm.beautifyChange[cm.changeGeneration()]) { // clear the list if last change wasn't a css-beautify @@ -1352,7 +1351,8 @@ function initWithStyle({style, codeIsUpdated}) { const cm = sectionDiv.CodeMirror; setTimeout(() => { cm.setOption('lint', CodeMirror.defaults.lint); - updateLintReport(cm, 0); + // update lint issue table after a short delay + updateLintReport(cm, 200); }, prefs.get('editor.lintDelay')); } } @@ -1866,11 +1866,18 @@ function showKeyMapHelp() { } function showLintHelp() { - showHelp(t('issues'), t('issuesHelp') + '' - ); + let content = t('issuesHelp') + ''); } function showRegExpTester(event, section = getSectionForChild(this)) { diff --git a/vendor-overwrites/codemirror/addon/lint/stylelint-config.js b/vendor-overwrites/codemirror/addon/lint/stylelint-config.js new file mode 100644 index 00000000..a9f736c9 --- /dev/null +++ b/vendor-overwrites/codemirror/addon/lint/stylelint-config.js @@ -0,0 +1,165 @@ +const stylelintConfig = { + // 'sugarss' is a indent-based syntax like Sass or Stylus + // ref: https://github.com/postcss/postcss#syntaxes + syntax: 'sugarss', + + rules: { + // ** recommended rules ** + // ref: https://github.com/stylelint/stylelint-config-recommended/blob/master/index.js + 'at-rule-no-unknown': true, + 'block-no-empty': true, + 'color-no-invalid-hex': true, + 'comment-no-empty': true, + 'declaration-block-no-duplicate-properties': [ true, { + 'ignore': ['consecutive-duplicates-with-different-values'] + }], + 'declaration-block-no-redundant-longhand-properties': true, + 'declaration-block-no-shorthand-property-overrides': true, + 'font-family-no-duplicate-names': true, + 'function-calc-no-unspaced-operator': true, + 'function-linear-gradient-no-nonstandard-direction': true, + 'keyframe-declaration-no-important': true, + 'media-feature-name-no-unknown': true, + 'no-empty-source': true, + 'no-extra-semicolons': true, + 'no-invalid-double-slash-comments': true, + 'property-no-unknown': true, + 'selector-pseudo-class-no-unknown': true, + 'selector-pseudo-element-no-unknown': true, + 'selector-type-no-unknown': true, + 'shorthand-property-no-redundant-values': true, + 'string-no-newline': true, + 'unit-no-unknown': true + + // ** stylistic rules ** + /* + 'at-rule-empty-line-before': [ + 'always', + { + 'except': [ + 'blockless-after-same-name-blockless', + 'first-nested' + ], + 'ignore': [ + 'after-comment' + ] + } + ], + 'at-rule-name-case': 'lower', + 'at-rule-name-space-after': 'always-single-line', + 'at-rule-semicolon-newline-after': 'always', + 'block-closing-brace-empty-line-before': 'never', + 'block-closing-brace-newline-after': 'always', + 'block-closing-brace-newline-before': 'always-multi-line', + 'block-closing-brace-space-before': 'always-single-line', + 'block-opening-brace-newline-after': 'always-multi-line', + 'block-opening-brace-space-after': 'always-single-line', + 'block-opening-brace-space-before': 'always', + 'color-hex-case': 'lower', + 'color-hex-length': 'short', + 'comment-empty-line-before': [ + 'always', + { + 'except': [ + 'first-nested' + ], + 'ignore': [ + 'stylelint-commands' + ] + } + ], + 'comment-whitespace-inside': 'always', + 'custom-property-empty-line-before': [ + 'always', + { + 'except': [ + 'after-custom-property', + 'first-nested' + ], + 'ignore': [ + 'after-comment', + 'inside-single-line-block' + ] + } + ], + 'declaration-bang-space-after': 'never', + 'declaration-bang-space-before': 'always', + 'declaration-block-semicolon-newline-after': 'always-multi-line', + 'declaration-block-semicolon-space-after': 'always-single-line', + 'declaration-block-semicolon-space-before': 'never', + 'declaration-block-single-line-max-declarations': 1, + 'declaration-block-trailing-semicolon': 'always', + 'declaration-colon-newline-after': 'always-multi-line', + 'declaration-colon-space-after': 'always-single-line', + 'declaration-colon-space-before': 'never', + 'declaration-empty-line-before': [ + 'always', + { + 'except': [ + 'after-declaration', + 'first-nested' + ], + 'ignore': [ + 'after-comment', + 'inside-single-line-block' + ] + } + ], + 'function-comma-newline-after': 'always-multi-line', + 'function-comma-space-after': 'always-single-line', + 'function-comma-space-before': 'never', + 'function-max-empty-lines': 0, + 'function-name-case': 'lower', + 'function-parentheses-newline-inside': 'always-multi-line', + 'function-parentheses-space-inside': 'never-single-line', + 'function-whitespace-after': 'always', + 'indentation': 2, + 'length-zero-no-unit': true, + 'max-empty-lines': 1, + 'media-feature-colon-space-after': 'always', + 'media-feature-colon-space-before': 'never', + 'media-feature-name-case': 'lower', + 'media-feature-parentheses-space-inside': 'never', + 'media-feature-range-operator-space-after': 'always', + 'media-feature-range-operator-space-before': 'always', + 'media-query-list-comma-newline-after': 'always-multi-line', + 'media-query-list-comma-space-after': 'always-single-line', + 'media-query-list-comma-space-before': 'never', + 'no-eol-whitespace': true, + 'no-missing-end-of-source-newline': true, + 'number-leading-zero': 'always', + 'number-no-trailing-zeros': true, + 'property-case': 'lower', + 'rule-empty-line-before': [ + 'always-multi-line', + { + 'except': [ + 'first-nested' + ], + 'ignore': [ + 'after-comment' + ] + } + ], + 'selector-attribute-brackets-space-inside': 'never', + 'selector-attribute-operator-space-after': 'never', + 'selector-attribute-operator-space-before': 'never', + 'selector-combinator-space-after': 'always', + 'selector-combinator-space-before': 'always', + 'selector-descendant-combinator-no-non-space': true, + 'selector-list-comma-newline-after': 'always', + 'selector-list-comma-space-before': 'never', + 'selector-max-empty-lines': 0, + 'selector-pseudo-class-case': 'lower', + 'selector-pseudo-class-parentheses-space-inside': 'never', + 'selector-pseudo-element-case': 'lower', + 'selector-pseudo-element-colon-notation': 'double', + 'selector-type-case': 'lower', + 'unit-case': 'lower', + 'value-list-comma-newline-after': 'always-multi-line', + 'value-list-comma-space-after': 'always-single-line', + 'value-list-comma-space-before': 'never', + 'value-list-max-empty-lines': 0 + */ + } +}; diff --git a/vendor-overwrites/codemirror/addon/lint/stylelint.js b/vendor-overwrites/codemirror/addon/lint/stylelint.js new file mode 100644 index 00000000..7ddc45c2 --- /dev/null +++ b/vendor-overwrites/codemirror/addon/lint/stylelint.js @@ -0,0 +1,49 @@ +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: http://codemirror.net/LICENSE + +// Depends on stylelint.js from https://github.com/... + +// declare global: StyleLint + +(function(mod) { + if (typeof exports == 'object' && typeof module == 'object') // CommonJS + mod(require('../../lib/codemirror')); + else if (typeof define == 'function' && define.amd) // AMD + define(['../../lib/codemirror'], mod); + else // Plain browser env + mod(CodeMirror); +})(function(CodeMirror) { +'use strict'; + +CodeMirror.registerHelper('lint', 'css', text => { + let found = []; + const stylelint = require('stylelint').lint; + + if (!stylelint) { + return found; + } + + return stylelint({ + code: text, + // stylelintConfig stored in stylelint-config.js & loaded by edit.html + config: stylelintConfig + }).then(output => { + const warnings = output.results.length ? output.results[0].warnings : [], + len = warnings.length; + let i, warning; + if (len) { + for (i = 0; i < len; i++) { + warning = warnings[i]; + found.push({ + from: CodeMirror.Pos(warning.line - 1, warning.column - 1), + to: CodeMirror.Pos(warning.line - 1, warning.column), + message: warning.text, + severity : warning.severity + }); + } + } + return found; + }); +}); + +}); diff --git a/vendor-overwrites/stylelint/stylelint-bundle.js b/vendor-overwrites/stylelint/stylelint-bundle.js new file mode 100644 index 00000000..3ec106cf --- /dev/null +++ b/vendor-overwrites/stylelint/stylelint-bundle.js @@ -0,0 +1,101439 @@ +require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o + * @license MIT + */ +function compare(a, b) { + if (a === b) { + return 0; + } + + var x = a.length; + var y = b.length; + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i]; + y = b[i]; + break; + } + } + + if (x < y) { + return -1; + } + if (y < x) { + return 1; + } + return 0; +} +function isBuffer(b) { + if (global.Buffer && typeof global.Buffer.isBuffer === 'function') { + return global.Buffer.isBuffer(b); + } + return !!(b != null && b._isBuffer); +} + +// based on node assert, original notice: + +// http://wiki.commonjs.org/wiki/Unit_Testing/1.0 +// +// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! +// +// Originally from narwhal.js (http://narwhaljs.org) +// Copyright (c) 2009 Thomas Robinson <280north.com> +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the 'Software'), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +var util = require('util/'); +var hasOwn = Object.prototype.hasOwnProperty; +var pSlice = Array.prototype.slice; +var functionsHaveNames = (function () { + return function foo() {}.name === 'foo'; +}()); +function pToString (obj) { + return Object.prototype.toString.call(obj); +} +function isView(arrbuf) { + if (isBuffer(arrbuf)) { + return false; + } + if (typeof global.ArrayBuffer !== 'function') { + return false; + } + if (typeof ArrayBuffer.isView === 'function') { + return ArrayBuffer.isView(arrbuf); + } + if (!arrbuf) { + return false; + } + if (arrbuf instanceof DataView) { + return true; + } + if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) { + return true; + } + return false; +} +// 1. The assert module provides functions that throw +// AssertionError's when particular conditions are not met. The +// assert module must conform to the following interface. + +var assert = module.exports = ok; + +// 2. The AssertionError is defined in assert. +// new assert.AssertionError({ message: message, +// actual: actual, +// expected: expected }) + +var regex = /\s*function\s+([^\(\s]*)\s*/; +// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js +function getName(func) { + if (!util.isFunction(func)) { + return; + } + if (functionsHaveNames) { + return func.name; + } + var str = func.toString(); + var match = str.match(regex); + return match && match[1]; +} +assert.AssertionError = function AssertionError(options) { + this.name = 'AssertionError'; + this.actual = options.actual; + this.expected = options.expected; + this.operator = options.operator; + if (options.message) { + this.message = options.message; + this.generatedMessage = false; + } else { + this.message = getMessage(this); + this.generatedMessage = true; + } + var stackStartFunction = options.stackStartFunction || fail; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, stackStartFunction); + } else { + // non v8 browsers so we can have a stacktrace + var err = new Error(); + if (err.stack) { + var out = err.stack; + + // try to strip useless frames + var fn_name = getName(stackStartFunction); + var idx = out.indexOf('\n' + fn_name); + if (idx >= 0) { + // once we have located the function frame + // we need to strip out everything before it (and its line) + var next_line = out.indexOf('\n', idx + 1); + out = out.substring(next_line + 1); + } + + this.stack = out; + } + } +}; + +// assert.AssertionError instanceof Error +util.inherits(assert.AssertionError, Error); + +function truncate(s, n) { + if (typeof s === 'string') { + return s.length < n ? s : s.slice(0, n); + } else { + return s; + } +} +function inspect(something) { + if (functionsHaveNames || !util.isFunction(something)) { + return util.inspect(something); + } + var rawname = getName(something); + var name = rawname ? ': ' + rawname : ''; + return '[Function' + name + ']'; +} +function getMessage(self) { + return truncate(inspect(self.actual), 128) + ' ' + + self.operator + ' ' + + truncate(inspect(self.expected), 128); +} + +// At present only the three keys mentioned above are used and +// understood by the spec. Implementations or sub modules can pass +// other keys to the AssertionError's constructor - they will be +// ignored. + +// 3. All of the following functions must throw an AssertionError +// when a corresponding condition is not met, with a message that +// may be undefined if not provided. All assertion methods provide +// both the actual and expected values to the assertion error for +// display purposes. + +function fail(actual, expected, message, operator, stackStartFunction) { + throw new assert.AssertionError({ + message: message, + actual: actual, + expected: expected, + operator: operator, + stackStartFunction: stackStartFunction + }); +} + +// EXTENSION! allows for well behaved errors defined elsewhere. +assert.fail = fail; + +// 4. Pure assertion tests whether a value is truthy, as determined +// by !!guard. +// assert.ok(guard, message_opt); +// This statement is equivalent to assert.equal(true, !!guard, +// message_opt);. To test strictly for the value true, use +// assert.strictEqual(true, guard, message_opt);. + +function ok(value, message) { + if (!value) fail(value, true, message, '==', assert.ok); +} +assert.ok = ok; + +// 5. The equality assertion tests shallow, coercive equality with +// ==. +// assert.equal(actual, expected, message_opt); + +assert.equal = function equal(actual, expected, message) { + if (actual != expected) fail(actual, expected, message, '==', assert.equal); +}; + +// 6. The non-equality assertion tests for whether two objects are not equal +// with != assert.notEqual(actual, expected, message_opt); + +assert.notEqual = function notEqual(actual, expected, message) { + if (actual == expected) { + fail(actual, expected, message, '!=', assert.notEqual); + } +}; + +// 7. The equivalence assertion tests a deep equality relation. +// assert.deepEqual(actual, expected, message_opt); + +assert.deepEqual = function deepEqual(actual, expected, message) { + if (!_deepEqual(actual, expected, false)) { + fail(actual, expected, message, 'deepEqual', assert.deepEqual); + } +}; + +assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) { + if (!_deepEqual(actual, expected, true)) { + fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual); + } +}; + +function _deepEqual(actual, expected, strict, memos) { + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + } else if (isBuffer(actual) && isBuffer(expected)) { + return compare(actual, expected) === 0; + + // 7.2. If the expected value is a Date object, the actual value is + // equivalent if it is also a Date object that refers to the same time. + } else if (util.isDate(actual) && util.isDate(expected)) { + return actual.getTime() === expected.getTime(); + + // 7.3 If the expected value is a RegExp object, the actual value is + // equivalent if it is also a RegExp object with the same source and + // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). + } else if (util.isRegExp(actual) && util.isRegExp(expected)) { + return actual.source === expected.source && + actual.global === expected.global && + actual.multiline === expected.multiline && + actual.lastIndex === expected.lastIndex && + actual.ignoreCase === expected.ignoreCase; + + // 7.4. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if ((actual === null || typeof actual !== 'object') && + (expected === null || typeof expected !== 'object')) { + return strict ? actual === expected : actual == expected; + + // If both values are instances of typed arrays, wrap their underlying + // ArrayBuffers in a Buffer each to increase performance + // This optimization requires the arrays to have the same type as checked by + // Object.prototype.toString (aka pToString). Never perform binary + // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their + // bit patterns are not identical. + } else if (isView(actual) && isView(expected) && + pToString(actual) === pToString(expected) && + !(actual instanceof Float32Array || + actual instanceof Float64Array)) { + return compare(new Uint8Array(actual.buffer), + new Uint8Array(expected.buffer)) === 0; + + // 7.5 For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else if (isBuffer(actual) !== isBuffer(expected)) { + return false; + } else { + memos = memos || {actual: [], expected: []}; + + var actualIndex = memos.actual.indexOf(actual); + if (actualIndex !== -1) { + if (actualIndex === memos.expected.indexOf(expected)) { + return true; + } + } + + memos.actual.push(actual); + memos.expected.push(expected); + + return objEquiv(actual, expected, strict, memos); + } +} + +function isArguments(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +} + +function objEquiv(a, b, strict, actualVisitedObjects) { + if (a === null || a === undefined || b === null || b === undefined) + return false; + // if one is a primitive, the other must be same + if (util.isPrimitive(a) || util.isPrimitive(b)) + return a === b; + if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) + return false; + var aIsArgs = isArguments(a); + var bIsArgs = isArguments(b); + if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) + return false; + if (aIsArgs) { + a = pSlice.call(a); + b = pSlice.call(b); + return _deepEqual(a, b, strict); + } + var ka = objectKeys(a); + var kb = objectKeys(b); + var key, i; + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length !== kb.length) + return false; + //the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + //~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] !== kb[i]) + return false; + } + //equivalent values for every corresponding key, and + //~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects)) + return false; + } + return true; +} + +// 8. The non-equivalence assertion tests for any deep inequality. +// assert.notDeepEqual(actual, expected, message_opt); + +assert.notDeepEqual = function notDeepEqual(actual, expected, message) { + if (_deepEqual(actual, expected, false)) { + fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); + } +}; + +assert.notDeepStrictEqual = notDeepStrictEqual; +function notDeepStrictEqual(actual, expected, message) { + if (_deepEqual(actual, expected, true)) { + fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual); + } +} + + +// 9. The strict equality assertion tests strict equality, as determined by ===. +// assert.strictEqual(actual, expected, message_opt); + +assert.strictEqual = function strictEqual(actual, expected, message) { + if (actual !== expected) { + fail(actual, expected, message, '===', assert.strictEqual); + } +}; + +// 10. The strict non-equality assertion tests for strict inequality, as +// determined by !==. assert.notStrictEqual(actual, expected, message_opt); + +assert.notStrictEqual = function notStrictEqual(actual, expected, message) { + if (actual === expected) { + fail(actual, expected, message, '!==', assert.notStrictEqual); + } +}; + +function expectedException(actual, expected) { + if (!actual || !expected) { + return false; + } + + if (Object.prototype.toString.call(expected) == '[object RegExp]') { + return expected.test(actual); + } + + try { + if (actual instanceof expected) { + return true; + } + } catch (e) { + // Ignore. The instanceof check doesn't work for arrow functions. + } + + if (Error.isPrototypeOf(expected)) { + return false; + } + + return expected.call({}, actual) === true; +} + +function _tryBlock(block) { + var error; + try { + block(); + } catch (e) { + error = e; + } + return error; +} + +function _throws(shouldThrow, block, expected, message) { + var actual; + + if (typeof block !== 'function') { + throw new TypeError('"block" argument must be a function'); + } + + if (typeof expected === 'string') { + message = expected; + expected = null; + } + + actual = _tryBlock(block); + + message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + + (message ? ' ' + message : '.'); + + if (shouldThrow && !actual) { + fail(actual, expected, 'Missing expected exception' + message); + } + + var userProvidedMessage = typeof message === 'string'; + var isUnwantedException = !shouldThrow && util.isError(actual); + var isUnexpectedException = !shouldThrow && actual && !expected; + + if ((isUnwantedException && + userProvidedMessage && + expectedException(actual, expected)) || + isUnexpectedException) { + fail(actual, expected, 'Got unwanted exception' + message); + } + + if ((shouldThrow && actual && expected && + !expectedException(actual, expected)) || (!shouldThrow && actual)) { + throw actual; + } +} + +// 11. Expected to throw an error: +// assert.throws(block, Error_opt, message_opt); + +assert.throws = function(block, /*optional*/error, /*optional*/message) { + _throws(true, block, error, message); +}; + +// EXTENSION! This is annoying to write outside this module. +assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) { + _throws(false, block, error, message); +}; + +assert.ifError = function(err) { if (err) throw err; }; + +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + if (hasOwn.call(obj, key)) keys.push(key); + } + return keys; +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"util/":42}],3:[function(require,module,exports){ +'use strict' + +exports.byteLength = byteLength +exports.toByteArray = toByteArray +exports.fromByteArray = fromByteArray + +var lookup = [] +var revLookup = [] +var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + +var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i +} + +revLookup['-'.charCodeAt(0)] = 62 +revLookup['_'.charCodeAt(0)] = 63 + +function placeHoldersCount (b64) { + var len = b64.length + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 bytes + // this is just a cheap hack to not do indexOf twice + return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0 +} + +function byteLength (b64) { + // base64 is 4/3 + up to two characters of the original data + return (b64.length * 3 / 4) - placeHoldersCount(b64) +} + +function toByteArray (b64) { + var i, l, tmp, placeHolders, arr + var len = b64.length + placeHolders = placeHoldersCount(b64) + + arr = new Arr((len * 3 / 4) - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? len - 4 : len + + var L = 0 + + for (i = 0; i < l; i += 4) { + tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)] + arr[L++] = (tmp >> 16) & 0xFF + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + if (placeHolders === 2) { + tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4) + arr[L++] = tmp & 0xFF + } else if (placeHolders === 1) { + tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2) + arr[L++] = (tmp >> 8) & 0xFF + arr[L++] = tmp & 0xFF + } + + return arr +} + +function tripletToBase64 (num) { + return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] +} + +function encodeChunk (uint8, start, end) { + var tmp + var output = [] + for (var i = start; i < end; i += 3) { + tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output.push(tripletToBase64(tmp)) + } + return output.join('') +} + +function fromByteArray (uint8) { + var tmp + var len = uint8.length + var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes + var output = '' + var parts = [] + var maxChunkLength = 16383 // must be multiple of 3 + + // go through the array every three bytes, we'll deal with trailing stuff later + for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { + parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + if (extraBytes === 1) { + tmp = uint8[len - 1] + output += lookup[tmp >> 2] + output += lookup[(tmp << 4) & 0x3F] + output += '==' + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + (uint8[len - 1]) + output += lookup[tmp >> 10] + output += lookup[(tmp >> 4) & 0x3F] + output += lookup[(tmp << 2) & 0x3F] + output += '=' + } + + parts.push(output) + + return parts.join('') +} + +},{}],4:[function(require,module,exports){ +arguments[4][1][0].apply(exports,arguments) +},{"dup":1}],5:[function(require,module,exports){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + +'use strict' + +var base64 = require('base64-js') +var ieee754 = require('ieee754') + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 + +var K_MAX_LENGTH = 0x7fffffff +exports.kMaxLength = K_MAX_LENGTH + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Print warning and recommend using `buffer` v4.x which has an Object + * implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * We report that the browser does not support typed arrays if the are not subclassable + * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` + * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support + * for __proto__ and has a buggy typed array implementation. + */ +Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() + +if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && + typeof console.error === 'function') { + console.error( + 'This browser lacks typed array (Uint8Array) support which is required by ' + + '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' + ) +} + +function typedArraySupport () { + // Can typed array instances can be augmented? + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 + } catch (e) { + return false + } +} + +function createBuffer (length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('Invalid typed array length') + } + // Return an augmented `Uint8Array` instance + var buf = new Uint8Array(length) + buf.__proto__ = Buffer.prototype + return buf +} + +/** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of + * `Uint8Array`, so the returned instances will have all the node `Buffer` methods + * and the `Uint8Array` methods. Square bracket notation works as expected -- it + * returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ + +function Buffer (arg, encodingOrOffset, length) { + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new Error( + 'If encoding is specified then the first argument must be a string' + ) + } + return allocUnsafe(arg) + } + return from(arg, encodingOrOffset, length) +} + +// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 +if (typeof Symbol !== 'undefined' && Symbol.species && + Buffer[Symbol.species] === Buffer) { + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true, + enumerable: false, + writable: false + }) +} + +Buffer.poolSize = 8192 // not used by this implementation + +function from (value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('"value" argument must not be a number') + } + + if (isArrayBuffer(value)) { + return fromArrayBuffer(value, encodingOrOffset, length) + } + + if (typeof value === 'string') { + return fromString(value, encodingOrOffset) + } + + return fromObject(value) +} + +/** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError + * if value is a number. + * Buffer.from(str[, encoding]) + * Buffer.from(array) + * Buffer.from(buffer) + * Buffer.from(arrayBuffer[, byteOffset[, length]]) + **/ +Buffer.from = function (value, encodingOrOffset, length) { + return from(value, encodingOrOffset, length) +} + +// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: +// https://github.com/feross/buffer/pull/148 +Buffer.prototype.__proto__ = Uint8Array.prototype +Buffer.__proto__ = Uint8Array + +function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be a number') + } else if (size < 0) { + throw new RangeError('"size" argument must not be negative') + } +} + +function alloc (size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(size) + } + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpretted as a start offset. + return typeof encoding === 'string' + ? createBuffer(size).fill(fill, encoding) + : createBuffer(size).fill(fill) + } + return createBuffer(size) +} + +/** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ +Buffer.alloc = function (size, fill, encoding) { + return alloc(size, fill, encoding) +} + +function allocUnsafe (size) { + assertSize(size) + return createBuffer(size < 0 ? 0 : checked(size) | 0) +} + +/** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ +Buffer.allocUnsafe = function (size) { + return allocUnsafe(size) +} +/** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ +Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(size) +} + +function fromString (string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('"encoding" must be a valid string encoding') + } + + var length = byteLength(string, encoding) | 0 + var buf = createBuffer(length) + + var actual = buf.write(string, encoding) + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + buf = buf.slice(0, actual) + } + + return buf +} + +function fromArrayLike (array) { + var length = array.length < 0 ? 0 : checked(array.length) | 0 + var buf = createBuffer(length) + for (var i = 0; i < length; i += 1) { + buf[i] = array[i] & 255 + } + return buf +} + +function fromArrayBuffer (array, byteOffset, length) { + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('\'offset\' is out of bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('\'length\' is out of bounds') + } + + var buf + if (byteOffset === undefined && length === undefined) { + buf = new Uint8Array(array) + } else if (length === undefined) { + buf = new Uint8Array(array, byteOffset) + } else { + buf = new Uint8Array(array, byteOffset, length) + } + + // Return an augmented `Uint8Array` instance + buf.__proto__ = Buffer.prototype + return buf +} + +function fromObject (obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0 + var buf = createBuffer(len) + + if (buf.length === 0) { + return buf + } + + obj.copy(buf, 0, 0, len) + return buf + } + + if (obj) { + if (isArrayBufferView(obj) || 'length' in obj) { + if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { + return createBuffer(0) + } + return fromArrayLike(obj) + } + + if (obj.type === 'Buffer' && Array.isArray(obj.data)) { + return fromArrayLike(obj.data) + } + } + + throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') +} + +function checked (length) { + // Note: cannot use `length < K_MAX_LENGTH` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= K_MAX_LENGTH) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (length) { + if (+length != length) { // eslint-disable-line eqeqeq + length = 0 + } + return Buffer.alloc(+length) +} + +Buffer.isBuffer = function isBuffer (b) { + return b != null && b._isBuffer === true +} + +Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i] + y = b[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'latin1': + case 'binary': + case 'base64': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + + if (list.length === 0) { + return Buffer.alloc(0) + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; ++i) { + length += list[i].length + } + } + + var buffer = Buffer.allocUnsafe(length) + var pos = 0 + for (i = 0; i < list.length; ++i) { + var buf = list[i] + if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + buf.copy(buffer, pos) + pos += buf.length + } + return buffer +} + +function byteLength (string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length + } + if (isArrayBufferView(string) || isArrayBuffer(string)) { + return string.byteLength + } + if (typeof string !== 'string') { + string = '' + string + } + + var len = string.length + if (len === 0) return 0 + + // Use a for loop to avoid recursion + var loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'latin1': + case 'binary': + return len + case 'utf8': + case 'utf-8': + case undefined: + return utf8ToBytes(string).length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return len * 2 + case 'hex': + return len >>> 1 + case 'base64': + return base64ToBytes(string).length + default: + if (loweredCase) return utf8ToBytes(string).length // assume utf8 + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} +Buffer.byteLength = byteLength + +function slowToString (encoding, start, end) { + var loweredCase = false + + // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + if (start === undefined || start < 0) { + start = 0 + } + // Return early if start > this.length. Done here to prevent potential uint32 + // coercion fail below. + if (start > this.length) { + return '' + } + + if (end === undefined || end > this.length) { + end = this.length + } + + if (end <= 0) { + return '' + } + + // Force coersion to uint32. This will also coerce falsey/NaN values to 0. + end >>>= 0 + start >>>= 0 + + if (end <= start) { + return '' + } + + if (!encoding) encoding = 'utf8' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'latin1': + case 'binary': + return latin1Slice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) +// to detect a Buffer instance. It's not possible to use `instanceof Buffer` +// reliably in a browserify context because there could be multiple different +// copies of the 'buffer' package in use. This method works even for Buffer +// instances that were created from another copy of the `buffer` package. +// See: https://github.com/feross/buffer/issues/154 +Buffer.prototype._isBuffer = true + +function swap (b, n, m) { + var i = b[n] + b[n] = b[m] + b[m] = i +} + +Buffer.prototype.swap16 = function swap16 () { + var len = this.length + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits') + } + for (var i = 0; i < len; i += 2) { + swap(this, i, i + 1) + } + return this +} + +Buffer.prototype.swap32 = function swap32 () { + var len = this.length + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits') + } + for (var i = 0; i < len; i += 4) { + swap(this, i, i + 3) + swap(this, i + 1, i + 2) + } + return this +} + +Buffer.prototype.swap64 = function swap64 () { + var len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this +} + +Buffer.prototype.toString = function toString () { + var length = this.length + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) +} + +Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function inspect () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' +} + +Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (!Buffer.isBuffer(target)) { + throw new TypeError('Argument must be a Buffer') + } + + if (start === undefined) { + start = 0 + } + if (end === undefined) { + end = target ? target.length : 0 + } + if (thisStart === undefined) { + thisStart = 0 + } + if (thisEnd === undefined) { + thisEnd = this.length + } + + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError('out of range index') + } + + if (thisStart >= thisEnd && start >= end) { + return 0 + } + if (thisStart >= thisEnd) { + return -1 + } + if (start >= end) { + return 1 + } + + start >>>= 0 + end >>>= 0 + thisStart >>>= 0 + thisEnd >>>= 0 + + if (this === target) return 0 + + var x = thisEnd - thisStart + var y = end - start + var len = Math.min(x, y) + + var thisCopy = this.slice(thisStart, thisEnd) + var targetCopy = target.slice(start, end) + + for (var i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i] + y = targetCopy[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, +// OR the last index of `val` in `buffer` at offset <= `byteOffset`. +// +// Arguments: +// - buffer - a Buffer to search +// - val - a string, Buffer, or number +// - byteOffset - an index into `buffer`; will be clamped to an int32 +// - encoding - an optional encoding, relevant is val is a string +// - dir - true for indexOf, false for lastIndexOf +function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { + // Empty buffer means no match + if (buffer.length === 0) return -1 + + // Normalize byteOffset + if (typeof byteOffset === 'string') { + encoding = byteOffset + byteOffset = 0 + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000 + } + byteOffset = +byteOffset // Coerce to Number. + if (numberIsNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : (buffer.length - 1) + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset + if (byteOffset >= buffer.length) { + if (dir) return -1 + else byteOffset = buffer.length - 1 + } else if (byteOffset < 0) { + if (dir) byteOffset = 0 + else return -1 + } + + // Normalize val + if (typeof val === 'string') { + val = Buffer.from(val, encoding) + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1 + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir) + } else if (typeof val === 'number') { + val = val & 0xFF // Search for a byte value [0-255] + if (typeof Uint8Array.prototype.indexOf === 'function') { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) + } + } + return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) + } + + throw new TypeError('val must be string, number or Buffer') +} + +function arrayIndexOf (arr, val, byteOffset, encoding, dir) { + var indexSize = 1 + var arrLength = arr.length + var valLength = val.length + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase() + if (encoding === 'ucs2' || encoding === 'ucs-2' || + encoding === 'utf16le' || encoding === 'utf-16le') { + if (arr.length < 2 || val.length < 2) { + return -1 + } + indexSize = 2 + arrLength /= 2 + valLength /= 2 + byteOffset /= 2 + } + } + + function read (buf, i) { + if (indexSize === 1) { + return buf[i] + } else { + return buf.readUInt16BE(i * indexSize) + } + } + + var i + if (dir) { + var foundIndex = -1 + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize + } else { + if (foundIndex !== -1) i -= i - foundIndex + foundIndex = -1 + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength + for (i = byteOffset; i >= 0; i--) { + var found = true + for (var j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false + break + } + } + if (found) return i + } + } + + return -1 +} + +Buffer.prototype.includes = function includes (val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1 +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true) +} + +Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (numberIsNaN(parsed)) return i + buf[offset + i] = parsed + } + return i +} + +function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) +} + +function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) +} + +function latin1Write (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) +} + +function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) +} + +function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) +} + +Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset >>> 0 + if (isFinite(length)) { + length = length >>> 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + } else { + throw new Error( + 'Buffer.write(string, encoding, offset[, length]) is no longer supported' + ) + } + + var remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('Attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + var loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + return asciiWrite(this, string, offset, length) + + case 'latin1': + case 'binary': + return latin1Write(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + end = Math.min(buf.length, end) + var res = [] + + var i = start + while (i < end) { + var firstByte = buf[i] + var codePoint = null + var bytesPerSequence = (firstByte > 0xEF) ? 4 + : (firstByte > 0xDF) ? 3 + : (firstByte > 0xBF) ? 2 + : 1 + + if (i + bytesPerSequence <= end) { + var secondByte, thirdByte, fourthByte, tempCodePoint + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte + } + break + case 2: + secondByte = buf[i + 1] + if ((secondByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) + if (tempCodePoint > 0x7F) { + codePoint = tempCodePoint + } + } + break + case 3: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) + if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { + codePoint = tempCodePoint + } + } + break + case 4: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + fourthByte = buf[i + 3] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) + if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { + codePoint = tempCodePoint + } + } + } + } + + if (codePoint === null) { + // we did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xFFFD + bytesPerSequence = 1 + } else if (codePoint > 0xFFFF) { + // encode to utf16 (surrogate pair dance) + codePoint -= 0x10000 + res.push(codePoint >>> 10 & 0x3FF | 0xD800) + codePoint = 0xDC00 | codePoint & 0x3FF + } + + res.push(codePoint) + i += bytesPerSequence + } + + return decodeCodePointsArray(res) +} + +// Based on http://stackoverflow.com/a/22747272/680742, the browser with +// the lowest limit is Chrome, with 0x10000 args. +// We go 1 magnitude less, for safety +var MAX_ARGUMENTS_LENGTH = 0x1000 + +function decodeCodePointsArray (codePoints) { + var len = codePoints.length + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints) // avoid extra slice() + } + + // Decode in chunks to avoid "call stack size exceeded". + var res = '' + var i = 0 + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ) + } + return res +} + +function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret +} + +function latin1Slice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; ++i) { + out += toHex(buf[i]) + } + return out +} + +function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) + } + return res +} + +Buffer.prototype.slice = function slice (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + var newBuf = this.subarray(start, end) + // Return an augmented `Uint8Array` instance + newBuf.__proto__ = Buffer.prototype + return newBuf +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val +} + +Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + var val = this[offset + --byteLength] + var mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val +} + +Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var i = byteLength + var mul = 1 + var val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + offset = offset >>> 0 + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') + if (offset + ext > buf.length) throw new RangeError('Index out of range') +} + +Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var mul = 1 + var i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + byteLength = byteLength >>> 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var i = byteLength - 1 + var mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + return offset + 2 +} + +Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + return offset + 2 +} + +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + return offset + 4 +} + +Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + return offset + 4 +} + +Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + var limit = Math.pow(2, (8 * byteLength) - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = 0 + var mul = 1 + var sub = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + var limit = Math.pow(2, (8 * byteLength) - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = byteLength - 1 + var mul = 1 + var sub = 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (value < 0) value = 0xff + value + 1 + this[offset] = (value & 0xff) + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError('Index out of range') + if (offset < 0) throw new RangeError('Index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + value = +value + offset = offset >>> 0 + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + var len = end - start + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000) { + // ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start] + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + targetStart + ) + } + + return len +} + +// Usage: +// buffer.fill(number[, offset[, end]]) +// buffer.fill(buffer[, offset[, end]]) +// buffer.fill(string[, offset[, end]][, encoding]) +Buffer.prototype.fill = function fill (val, start, end, encoding) { + // Handle string cases: + if (typeof val === 'string') { + if (typeof start === 'string') { + encoding = start + start = 0 + end = this.length + } else if (typeof end === 'string') { + encoding = end + end = this.length + } + if (val.length === 1) { + var code = val.charCodeAt(0) + if (code < 256) { + val = code + } + } + if (encoding !== undefined && typeof encoding !== 'string') { + throw new TypeError('encoding must be a string') + } + if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + } else if (typeof val === 'number') { + val = val & 255 + } + + // Invalid ranges are not set to a default, so can range check early. + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError('Out of range index') + } + + if (end <= start) { + return this + } + + start = start >>> 0 + end = end === undefined ? this.length : end >>> 0 + + if (!val) val = 0 + + var i + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val + } + } else { + var bytes = Buffer.isBuffer(val) + ? val + : new Buffer(val, encoding) + var len = bytes.length + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len] + } + } + + return this +} + +// HELPER FUNCTIONS +// ================ + +var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = str.trim().replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) +} + +function utf8ToBytes (string, units) { + units = units || Infinity + var codePoint + var length = string.length + var leadSurrogate = null + var bytes = [] + + for (var i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } + + // valid lead + leadSurrogate = codePoint + + continue + } + + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } + + // valid surrogate pair + codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + } + + leadSurrogate = null + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes +} + +function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str, units) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) +} + +function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; ++i) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i +} + +// ArrayBuffers from another context (i.e. an iframe) do not pass the `instanceof` check +// but they should be treated as valid. See: https://github.com/feross/buffer/issues/166 +function isArrayBuffer (obj) { + return obj instanceof ArrayBuffer || + (obj != null && obj.constructor != null && obj.constructor.name === 'ArrayBuffer' && + typeof obj.byteLength === 'number') +} + +// Node 0.10 supports `ArrayBuffer` but lacks `ArrayBuffer.isView` +function isArrayBufferView (obj) { + return (typeof ArrayBuffer.isView === 'function') && ArrayBuffer.isView(obj) +} + +function numberIsNaN (obj) { + return obj !== obj // eslint-disable-line no-self-compare +} + +},{"base64-js":3,"ieee754":9}],6:[function(require,module,exports){ +module.exports={ + "O_RDONLY": 0, + "O_WRONLY": 1, + "O_RDWR": 2, + "S_IFMT": 61440, + "S_IFREG": 32768, + "S_IFDIR": 16384, + "S_IFCHR": 8192, + "S_IFBLK": 24576, + "S_IFIFO": 4096, + "S_IFLNK": 40960, + "S_IFSOCK": 49152, + "O_CREAT": 512, + "O_EXCL": 2048, + "O_NOCTTY": 131072, + "O_TRUNC": 1024, + "O_APPEND": 8, + "O_DIRECTORY": 1048576, + "O_NOFOLLOW": 256, + "O_SYNC": 128, + "O_SYMLINK": 2097152, + "O_NONBLOCK": 4, + "S_IRWXU": 448, + "S_IRUSR": 256, + "S_IWUSR": 128, + "S_IXUSR": 64, + "S_IRWXG": 56, + "S_IRGRP": 32, + "S_IWGRP": 16, + "S_IXGRP": 8, + "S_IRWXO": 7, + "S_IROTH": 4, + "S_IWOTH": 2, + "S_IXOTH": 1, + "E2BIG": 7, + "EACCES": 13, + "EADDRINUSE": 48, + "EADDRNOTAVAIL": 49, + "EAFNOSUPPORT": 47, + "EAGAIN": 35, + "EALREADY": 37, + "EBADF": 9, + "EBADMSG": 94, + "EBUSY": 16, + "ECANCELED": 89, + "ECHILD": 10, + "ECONNABORTED": 53, + "ECONNREFUSED": 61, + "ECONNRESET": 54, + "EDEADLK": 11, + "EDESTADDRREQ": 39, + "EDOM": 33, + "EDQUOT": 69, + "EEXIST": 17, + "EFAULT": 14, + "EFBIG": 27, + "EHOSTUNREACH": 65, + "EIDRM": 90, + "EILSEQ": 92, + "EINPROGRESS": 36, + "EINTR": 4, + "EINVAL": 22, + "EIO": 5, + "EISCONN": 56, + "EISDIR": 21, + "ELOOP": 62, + "EMFILE": 24, + "EMLINK": 31, + "EMSGSIZE": 40, + "EMULTIHOP": 95, + "ENAMETOOLONG": 63, + "ENETDOWN": 50, + "ENETRESET": 52, + "ENETUNREACH": 51, + "ENFILE": 23, + "ENOBUFS": 55, + "ENODATA": 96, + "ENODEV": 19, + "ENOENT": 2, + "ENOEXEC": 8, + "ENOLCK": 77, + "ENOLINK": 97, + "ENOMEM": 12, + "ENOMSG": 91, + "ENOPROTOOPT": 42, + "ENOSPC": 28, + "ENOSR": 98, + "ENOSTR": 99, + "ENOSYS": 78, + "ENOTCONN": 57, + "ENOTDIR": 20, + "ENOTEMPTY": 66, + "ENOTSOCK": 38, + "ENOTSUP": 45, + "ENOTTY": 25, + "ENXIO": 6, + "EOPNOTSUPP": 102, + "EOVERFLOW": 84, + "EPERM": 1, + "EPIPE": 32, + "EPROTO": 100, + "EPROTONOSUPPORT": 43, + "EPROTOTYPE": 41, + "ERANGE": 34, + "EROFS": 30, + "ESPIPE": 29, + "ESRCH": 3, + "ESTALE": 70, + "ETIME": 101, + "ETIMEDOUT": 60, + "ETXTBSY": 26, + "EWOULDBLOCK": 35, + "EXDEV": 18, + "SIGHUP": 1, + "SIGINT": 2, + "SIGQUIT": 3, + "SIGILL": 4, + "SIGTRAP": 5, + "SIGABRT": 6, + "SIGIOT": 6, + "SIGBUS": 10, + "SIGFPE": 8, + "SIGKILL": 9, + "SIGUSR1": 30, + "SIGSEGV": 11, + "SIGUSR2": 31, + "SIGPIPE": 13, + "SIGALRM": 14, + "SIGTERM": 15, + "SIGCHLD": 20, + "SIGCONT": 19, + "SIGSTOP": 17, + "SIGTSTP": 18, + "SIGTTIN": 21, + "SIGTTOU": 22, + "SIGURG": 16, + "SIGXCPU": 24, + "SIGXFSZ": 25, + "SIGVTALRM": 26, + "SIGPROF": 27, + "SIGWINCH": 28, + "SIGIO": 23, + "SIGSYS": 12, + "SSL_OP_ALL": 2147486719, + "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION": 262144, + "SSL_OP_CIPHER_SERVER_PREFERENCE": 4194304, + "SSL_OP_CISCO_ANYCONNECT": 32768, + "SSL_OP_COOKIE_EXCHANGE": 8192, + "SSL_OP_CRYPTOPRO_TLSEXT_BUG": 2147483648, + "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS": 2048, + "SSL_OP_EPHEMERAL_RSA": 0, + "SSL_OP_LEGACY_SERVER_CONNECT": 4, + "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER": 32, + "SSL_OP_MICROSOFT_SESS_ID_BUG": 1, + "SSL_OP_MSIE_SSLV2_RSA_PADDING": 0, + "SSL_OP_NETSCAPE_CA_DN_BUG": 536870912, + "SSL_OP_NETSCAPE_CHALLENGE_BUG": 2, + "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG": 1073741824, + "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG": 8, + "SSL_OP_NO_COMPRESSION": 131072, + "SSL_OP_NO_QUERY_MTU": 4096, + "SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION": 65536, + "SSL_OP_NO_SSLv2": 16777216, + "SSL_OP_NO_SSLv3": 33554432, + "SSL_OP_NO_TICKET": 16384, + "SSL_OP_NO_TLSv1": 67108864, + "SSL_OP_NO_TLSv1_1": 268435456, + "SSL_OP_NO_TLSv1_2": 134217728, + "SSL_OP_PKCS1_CHECK_1": 0, + "SSL_OP_PKCS1_CHECK_2": 0, + "SSL_OP_SINGLE_DH_USE": 1048576, + "SSL_OP_SINGLE_ECDH_USE": 524288, + "SSL_OP_SSLEAY_080_CLIENT_DH_BUG": 128, + "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG": 0, + "SSL_OP_TLS_BLOCK_PADDING_BUG": 512, + "SSL_OP_TLS_D5_BUG": 256, + "SSL_OP_TLS_ROLLBACK_BUG": 8388608, + "ENGINE_METHOD_DSA": 2, + "ENGINE_METHOD_DH": 4, + "ENGINE_METHOD_RAND": 8, + "ENGINE_METHOD_ECDH": 16, + "ENGINE_METHOD_ECDSA": 32, + "ENGINE_METHOD_CIPHERS": 64, + "ENGINE_METHOD_DIGESTS": 128, + "ENGINE_METHOD_STORE": 256, + "ENGINE_METHOD_PKEY_METHS": 512, + "ENGINE_METHOD_PKEY_ASN1_METHS": 1024, + "ENGINE_METHOD_ALL": 65535, + "ENGINE_METHOD_NONE": 0, + "DH_CHECK_P_NOT_SAFE_PRIME": 2, + "DH_CHECK_P_NOT_PRIME": 1, + "DH_UNABLE_TO_CHECK_GENERATOR": 4, + "DH_NOT_SUITABLE_GENERATOR": 8, + "NPN_ENABLED": 1, + "RSA_PKCS1_PADDING": 1, + "RSA_SSLV23_PADDING": 2, + "RSA_NO_PADDING": 3, + "RSA_PKCS1_OAEP_PADDING": 4, + "RSA_X931_PADDING": 5, + "RSA_PKCS1_PSS_PADDING": 6, + "POINT_CONVERSION_COMPRESSED": 2, + "POINT_CONVERSION_UNCOMPRESSED": 4, + "POINT_CONVERSION_HYBRID": 6, + "F_OK": 0, + "R_OK": 4, + "W_OK": 2, + "X_OK": 1, + "UV_UDP_REUSEADDR": 4 +} + +},{}],7:[function(require,module,exports){ +(function (Buffer){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. + +function isArray(arg) { + if (Array.isArray) { + return Array.isArray(arg); + } + return objectToString(arg) === '[object Array]'; +} +exports.isArray = isArray; + +function isBoolean(arg) { + return typeof arg === 'boolean'; +} +exports.isBoolean = isBoolean; + +function isNull(arg) { + return arg === null; +} +exports.isNull = isNull; + +function isNullOrUndefined(arg) { + return arg == null; +} +exports.isNullOrUndefined = isNullOrUndefined; + +function isNumber(arg) { + return typeof arg === 'number'; +} +exports.isNumber = isNumber; + +function isString(arg) { + return typeof arg === 'string'; +} +exports.isString = isString; + +function isSymbol(arg) { + return typeof arg === 'symbol'; +} +exports.isSymbol = isSymbol; + +function isUndefined(arg) { + return arg === void 0; +} +exports.isUndefined = isUndefined; + +function isRegExp(re) { + return objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; + +function isError(e) { + return (objectToString(e) === '[object Error]' || e instanceof Error); +} +exports.isError = isError; + +function isFunction(arg) { + return typeof arg === 'function'; +} +exports.isFunction = isFunction; + +function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; +} +exports.isPrimitive = isPrimitive; + +exports.isBuffer = Buffer.isBuffer; + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + +}).call(this,{"isBuffer":require("../../is-buffer/index.js")}) +},{"../../is-buffer/index.js":11}],8:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; +} +module.exports = EventEmitter; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +EventEmitter.defaultMaxListeners = 10; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; +}; + +EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } else { + // At least give some kind of context to the user + var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); + err.context = er; + throw err; + } + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + args = Array.prototype.slice.call(arguments, 1); + handler.apply(this, args); + } + } else if (isObject(handler)) { + args = Array.prototype.slice.call(arguments, 1); + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; +}; + +EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; +}; + +// emits a 'removeListener' event iff the listener was removed +EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; +}; + +EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else if (listeners) { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; +}; + +EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; +}; + +EventEmitter.prototype.listenerCount = function(type) { + if (this._events) { + var evlistener = this._events[type]; + + if (isFunction(evlistener)) + return 1; + else if (evlistener) + return evlistener.length; + } + return 0; +}; + +EventEmitter.listenerCount = function(emitter, type) { + return emitter.listenerCount(type); +}; + +function isFunction(arg) { + return typeof arg === 'function'; +} + +function isNumber(arg) { + return typeof arg === 'number'; +} + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} + +function isUndefined(arg) { + return arg === void 0; +} + +},{}],9:[function(require,module,exports){ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} + +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 +} + +},{}],10:[function(require,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 + } +} + +},{}],11:[function(require,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)) +} + +},{}],12:[function(require,module,exports){ +var toString = {}.toString; + +module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; +}; + +},{}],13:[function(require,module,exports){ +exports.endianness = function () { return 'LE' }; + +exports.hostname = function () { + if (typeof location !== 'undefined') { + return location.hostname + } + else return ''; +}; + +exports.loadavg = function () { return [] }; + +exports.uptime = function () { return 0 }; + +exports.freemem = function () { + return Number.MAX_VALUE; +}; + +exports.totalmem = function () { + return Number.MAX_VALUE; +}; + +exports.cpus = function () { return [] }; + +exports.type = function () { return 'Browser' }; + +exports.release = function () { + if (typeof navigator !== 'undefined') { + return navigator.appVersion; + } + return ''; +}; + +exports.networkInterfaces += exports.getNetworkInterfaces += function () { return {} }; + +exports.arch = function () { return 'javascript' }; + +exports.platform = function () { return 'browser' }; + +exports.tmpdir = exports.tmpDir = function () { + return '/tmp'; +}; + +exports.EOL = '\n'; + +},{}],14:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// resolves . and .. elements in a path array with directory names there +// must be no slashes, empty elements, or device names (c:\) in the array +// (so also no leading and trailing slashes - it does not distinguish +// relative and absolute paths) +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Split a filename into [root, dir, basename, ext], unix version +// 'root' is just a slash, or nothing. +var splitPathRe = + /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; +var splitPath = function(filename) { + return splitPathRe.exec(filename).slice(1); +}; + +// path.resolve([from ...], to) +// posix version +exports.resolve = function() { + var resolvedPath = '', + resolvedAbsolute = false; + + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : process.cwd(); + + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +}; + +// path.normalize(path) +// posix version +exports.normalize = function(path) { + var isAbsolute = exports.isAbsolute(path), + trailingSlash = substr(path, -1) === '/'; + + // Normalize the path + path = normalizeArray(filter(path.split('/'), function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + + return (isAbsolute ? '/' : '') + path; +}; + +// posix version +exports.isAbsolute = function(path) { + return path.charAt(0) === '/'; +}; + +// posix version +exports.join = function() { + var paths = Array.prototype.slice.call(arguments, 0); + return exports.normalize(filter(paths, function(p, index) { + if (typeof p !== 'string') { + throw new TypeError('Arguments to path.join must be strings'); + } + return p; + }).join('/')); +}; + + +// path.relative(from, to) +// posix version +exports.relative = function(from, to) { + from = exports.resolve(from).substr(1); + to = exports.resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + + return outputParts.join('/'); +}; + +exports.sep = '/'; +exports.delimiter = ':'; + +exports.dirname = function(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; +}; + + +exports.basename = function(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + return f; +}; + + +exports.extname = function(path) { + return splitPath(path)[3]; +}; + +function filter (xs, f) { + if (xs.filter) return xs.filter(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + if (f(xs[i], i, xs)) res.push(xs[i]); + } + return res; +} + +// String.prototype.substr - negative index don't work in IE8 +var substr = 'ab'.substr(-1) === 'b' + ? function (str, start, len) { return str.substr(start, len) } + : function (str, start, len) { + if (start < 0) start = str.length + start; + return str.substr(start, len); + } +; + +}).call(this,require('_process')) +},{"_process":16}],15:[function(require,module,exports){ +(function (process){ +'use strict'; + +if (!process.version || + process.version.indexOf('v0.') === 0 || + process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { + module.exports = nextTick; +} else { + module.exports = process.nextTick; +} + +function nextTick(fn, arg1, arg2, arg3) { + if (typeof fn !== 'function') { + throw new TypeError('"callback" argument must be a function'); + } + var len = arguments.length; + var args, i; + switch (len) { + case 0: + case 1: + return process.nextTick(fn); + case 2: + return process.nextTick(function afterTickOne() { + fn.call(null, arg1); + }); + case 3: + return process.nextTick(function afterTickTwo() { + fn.call(null, arg1, arg2); + }); + case 4: + return process.nextTick(function afterTickThree() { + fn.call(null, arg1, arg2, arg3); + }); + default: + args = new Array(len - 1); + i = 0; + while (i < args.length) { + args[i++] = arguments[i]; + } + return process.nextTick(function afterTick() { + fn.apply(null, args); + }); + } +} + +}).call(this,require('_process')) +},{"_process":16}],16:[function(require,module,exports){ +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],17:[function(require,module,exports){ +(function (global){ +/*! https://mths.be/punycode v1.4.1 by @mathias */ +;(function(root) { + + /** Detect free variables */ + var freeExports = typeof exports == 'object' && exports && + !exports.nodeType && exports; + var freeModule = typeof module == 'object' && module && + !module.nodeType && module; + var freeGlobal = typeof global == 'object' && global; + if ( + freeGlobal.global === freeGlobal || + freeGlobal.window === freeGlobal || + freeGlobal.self === freeGlobal + ) { + root = freeGlobal; + } + + /** + * The `punycode` object. + * @name punycode + * @type Object + */ + var punycode, + + /** Highest positive signed 32-bit float value */ + maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 + + /** Bootstring parameters */ + base = 36, + tMin = 1, + tMax = 26, + skew = 38, + damp = 700, + initialBias = 72, + initialN = 128, // 0x80 + delimiter = '-', // '\x2D' + + /** Regular expressions */ + regexPunycode = /^xn--/, + regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars + regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators + + /** Error messages */ + errors = { + 'overflow': 'Overflow: input needs wider integers to process', + 'not-basic': 'Illegal input >= 0x80 (not a basic code point)', + 'invalid-input': 'Invalid input' + }, + + /** Convenience shortcuts */ + baseMinusTMin = base - tMin, + floor = Math.floor, + stringFromCharCode = String.fromCharCode, + + /** Temporary variable */ + key; + + /*--------------------------------------------------------------------------*/ + + /** + * A generic error utility function. + * @private + * @param {String} type The error type. + * @returns {Error} Throws a `RangeError` with the applicable error message. + */ + function error(type) { + throw new RangeError(errors[type]); + } + + /** + * A generic `Array#map` utility function. + * @private + * @param {Array} array The array to iterate over. + * @param {Function} callback The function that gets called for every array + * item. + * @returns {Array} A new array of values returned by the callback function. + */ + function map(array, fn) { + var length = array.length; + var result = []; + while (length--) { + result[length] = fn(array[length]); + } + return result; + } + + /** + * A simple `Array#map`-like wrapper to work with domain name strings or email + * addresses. + * @private + * @param {String} domain The domain name or email address. + * @param {Function} callback The function that gets called for every + * character. + * @returns {Array} A new string of characters returned by the callback + * function. + */ + function mapDomain(string, fn) { + var parts = string.split('@'); + var result = ''; + if (parts.length > 1) { + // In email addresses, only the domain name should be punycoded. Leave + // the local part (i.e. everything up to `@`) intact. + result = parts[0] + '@'; + string = parts[1]; + } + // Avoid `split(regex)` for IE8 compatibility. See #17. + string = string.replace(regexSeparators, '\x2E'); + var labels = string.split('.'); + var encoded = map(labels, fn).join('.'); + return result + encoded; + } + + /** + * Creates an array containing the numeric code points of each Unicode + * character in the string. While JavaScript uses UCS-2 internally, + * this function will convert a pair of surrogate halves (each of which + * UCS-2 exposes as separate characters) into a single code point, + * matching UTF-16. + * @see `punycode.ucs2.encode` + * @see + * @memberOf punycode.ucs2 + * @name decode + * @param {String} string The Unicode input string (UCS-2). + * @returns {Array} The new array of code points. + */ + function ucs2decode(string) { + var output = [], + counter = 0, + length = string.length, + value, + extra; + while (counter < length) { + value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // high surrogate, and there is a next character + extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { // low surrogate + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // unmatched surrogate; only append this code unit, in case the next + // code unit is the high surrogate of a surrogate pair + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; + } + + /** + * Creates a string based on an array of numeric code points. + * @see `punycode.ucs2.decode` + * @memberOf punycode.ucs2 + * @name encode + * @param {Array} codePoints The array of numeric code points. + * @returns {String} The new Unicode string (UCS-2). + */ + function ucs2encode(array) { + return map(array, function(value) { + var output = ''; + if (value > 0xFFFF) { + value -= 0x10000; + output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); + value = 0xDC00 | value & 0x3FF; + } + output += stringFromCharCode(value); + return output; + }).join(''); + } + + /** + * Converts a basic code point into a digit/integer. + * @see `digitToBasic()` + * @private + * @param {Number} codePoint The basic numeric code point value. + * @returns {Number} The numeric value of a basic code point (for use in + * representing integers) in the range `0` to `base - 1`, or `base` if + * the code point does not represent a value. + */ + function basicToDigit(codePoint) { + if (codePoint - 48 < 10) { + return codePoint - 22; + } + if (codePoint - 65 < 26) { + return codePoint - 65; + } + if (codePoint - 97 < 26) { + return codePoint - 97; + } + return base; + } + + /** + * Converts a digit/integer into a basic code point. + * @see `basicToDigit()` + * @private + * @param {Number} digit The numeric value of a basic code point. + * @returns {Number} The basic code point whose value (when used for + * representing integers) is `digit`, which needs to be in the range + * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is + * used; else, the lowercase form is used. The behavior is undefined + * if `flag` is non-zero and `digit` has no uppercase form. + */ + function digitToBasic(digit, flag) { + // 0..25 map to ASCII a..z or A..Z + // 26..35 map to ASCII 0..9 + return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); + } + + /** + * Bias adaptation function as per section 3.4 of RFC 3492. + * https://tools.ietf.org/html/rfc3492#section-3.4 + * @private + */ + function adapt(delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); + } + + /** + * Converts a Punycode string of ASCII-only symbols to a string of Unicode + * symbols. + * @memberOf punycode + * @param {String} input The Punycode string of ASCII-only symbols. + * @returns {String} The resulting string of Unicode symbols. + */ + function decode(input) { + // Don't use UCS-2 + var output = [], + inputLength = input.length, + out, + i = 0, + n = initialN, + bias = initialBias, + basic, + j, + index, + oldi, + w, + k, + digit, + t, + /** Cached calculation results */ + baseMinusT; + + // Handle the basic code points: let `basic` be the number of input code + // points before the last delimiter, or `0` if there is none, then copy + // the first basic code points to the output. + + basic = input.lastIndexOf(delimiter); + if (basic < 0) { + basic = 0; + } + + for (j = 0; j < basic; ++j) { + // if it's not a basic code point + if (input.charCodeAt(j) >= 0x80) { + error('not-basic'); + } + output.push(input.charCodeAt(j)); + } + + // Main decoding loop: start just after the last delimiter if any basic code + // points were copied; start at the beginning otherwise. + + for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { + + // `index` is the index of the next character to be consumed. + // Decode a generalized variable-length integer into `delta`, + // which gets added to `i`. The overflow checking is easier + // if we increase `i` as we go, then subtract off its starting + // value at the end to obtain `delta`. + for (oldi = i, w = 1, k = base; /* no condition */; k += base) { + + if (index >= inputLength) { + error('invalid-input'); + } + + digit = basicToDigit(input.charCodeAt(index++)); + + if (digit >= base || digit > floor((maxInt - i) / w)) { + error('overflow'); + } + + i += digit * w; + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + + if (digit < t) { + break; + } + + baseMinusT = base - t; + if (w > floor(maxInt / baseMinusT)) { + error('overflow'); + } + + w *= baseMinusT; + + } + + out = output.length + 1; + bias = adapt(i - oldi, out, oldi == 0); + + // `i` was supposed to wrap around from `out` to `0`, + // incrementing `n` each time, so we'll fix that now: + if (floor(i / out) > maxInt - n) { + error('overflow'); + } + + n += floor(i / out); + i %= out; + + // Insert `n` at position `i` of the output + output.splice(i++, 0, n); + + } + + return ucs2encode(output); + } + + /** + * Converts a string of Unicode symbols (e.g. a domain name label) to a + * Punycode string of ASCII-only symbols. + * @memberOf punycode + * @param {String} input The string of Unicode symbols. + * @returns {String} The resulting Punycode string of ASCII-only symbols. + */ + function encode(input) { + var n, + delta, + handledCPCount, + basicLength, + bias, + j, + m, + q, + k, + t, + currentValue, + output = [], + /** `inputLength` will hold the number of code points in `input`. */ + inputLength, + /** Cached calculation results */ + handledCPCountPlusOne, + baseMinusT, + qMinusT; + + // Convert the input in UCS-2 to Unicode + input = ucs2decode(input); + + // Cache the length + inputLength = input.length; + + // Initialize the state + n = initialN; + delta = 0; + bias = initialBias; + + // Handle the basic code points + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue < 0x80) { + output.push(stringFromCharCode(currentValue)); + } + } + + handledCPCount = basicLength = output.length; + + // `handledCPCount` is the number of code points that have been handled; + // `basicLength` is the number of basic code points. + + // Finish the basic string - if it is not empty - with a delimiter + if (basicLength) { + output.push(delimiter); + } + + // Main encoding loop: + while (handledCPCount < inputLength) { + + // All non-basic code points < n have been handled already. Find the next + // larger one: + for (m = maxInt, j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + + // Increase `delta` enough to advance the decoder's state to , + // but guard against overflow + handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error('overflow'); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + + if (currentValue < n && ++delta > maxInt) { + error('overflow'); + } + + if (currentValue == n) { + // Represent delta as a generalized variable-length integer + for (q = delta, k = base; /* no condition */; k += base) { + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + if (q < t) { + break; + } + qMinusT = q - t; + baseMinusT = base - t; + output.push( + stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) + ); + q = floor(qMinusT / baseMinusT); + } + + output.push(stringFromCharCode(digitToBasic(q, 0))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + + ++delta; + ++n; + + } + return output.join(''); + } + + /** + * Converts a Punycode string representing a domain name or an email address + * to Unicode. Only the Punycoded parts of the input will be converted, i.e. + * it doesn't matter if you call it on a string that has already been + * converted to Unicode. + * @memberOf punycode + * @param {String} input The Punycoded domain name or email address to + * convert to Unicode. + * @returns {String} The Unicode representation of the given Punycode + * string. + */ + function toUnicode(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) + ? decode(string.slice(4).toLowerCase()) + : string; + }); + } + + /** + * Converts a Unicode string representing a domain name or an email address to + * Punycode. Only the non-ASCII parts of the domain name will be converted, + * i.e. it doesn't matter if you call it with a domain that's already in + * ASCII. + * @memberOf punycode + * @param {String} input The domain name or email address to convert, as a + * Unicode string. + * @returns {String} The Punycode representation of the given domain name or + * email address. + */ + function toASCII(input) { + return mapDomain(input, function(string) { + return regexNonASCII.test(string) + ? 'xn--' + encode(string) + : string; + }); + } + + /*--------------------------------------------------------------------------*/ + + /** Define the public API */ + punycode = { + /** + * A string representing the current Punycode.js version number. + * @memberOf punycode + * @type String + */ + 'version': '1.4.1', + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see + * @memberOf punycode + * @type Object + */ + 'ucs2': { + 'decode': ucs2decode, + 'encode': ucs2encode + }, + 'decode': decode, + 'encode': encode, + 'toASCII': toASCII, + 'toUnicode': toUnicode + }; + + /** Expose `punycode` */ + // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + if ( + typeof define == 'function' && + typeof define.amd == 'object' && + define.amd + ) { + define('punycode', function() { + return punycode; + }); + } else if (freeExports && freeModule) { + if (module.exports == freeExports) { + // in Node.js, io.js, or RingoJS v0.8.0+ + freeModule.exports = punycode; + } else { + // in Narwhal or RingoJS v0.7.0- + for (key in punycode) { + punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]); + } + } + } else { + // in Rhino or a web browser + root.punycode = punycode; + } + +}(this)); + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],18:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +'use strict'; + +// If obj.hasOwnProperty has been overridden, then calling +// obj.hasOwnProperty(prop) will break. +// See: https://github.com/joyent/node/issues/1707 +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +module.exports = function(qs, sep, eq, options) { + sep = sep || '&'; + eq = eq || '='; + var obj = {}; + + if (typeof qs !== 'string' || qs.length === 0) { + return obj; + } + + var regexp = /\+/g; + qs = qs.split(sep); + + var maxKeys = 1000; + if (options && typeof options.maxKeys === 'number') { + maxKeys = options.maxKeys; + } + + var len = qs.length; + // maxKeys <= 0 means that we should not limit keys count + if (maxKeys > 0 && len > maxKeys) { + len = maxKeys; + } + + for (var i = 0; i < len; ++i) { + var x = qs[i].replace(regexp, '%20'), + idx = x.indexOf(eq), + kstr, vstr, k, v; + + if (idx >= 0) { + kstr = x.substr(0, idx); + vstr = x.substr(idx + 1); + } else { + kstr = x; + vstr = ''; + } + + k = decodeURIComponent(kstr); + v = decodeURIComponent(vstr); + + if (!hasOwnProperty(obj, k)) { + obj[k] = v; + } else if (isArray(obj[k])) { + obj[k].push(v); + } else { + obj[k] = [obj[k], v]; + } + } + + return obj; +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + +},{}],19:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +'use strict'; + +var stringifyPrimitive = function(v) { + switch (typeof v) { + case 'string': + return v; + + case 'boolean': + return v ? 'true' : 'false'; + + case 'number': + return isFinite(v) ? v : ''; + + default: + return ''; + } +}; + +module.exports = function(obj, sep, eq, name) { + sep = sep || '&'; + eq = eq || '='; + if (obj === null) { + obj = undefined; + } + + if (typeof obj === 'object') { + return map(objectKeys(obj), function(k) { + var ks = encodeURIComponent(stringifyPrimitive(k)) + eq; + if (isArray(obj[k])) { + return map(obj[k], function(v) { + return ks + encodeURIComponent(stringifyPrimitive(v)); + }).join(sep); + } else { + return ks + encodeURIComponent(stringifyPrimitive(obj[k])); + } + }).join(sep); + + } + + if (!name) return ''; + return encodeURIComponent(stringifyPrimitive(name)) + eq + + encodeURIComponent(stringifyPrimitive(obj)); +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + +function map (xs, f) { + if (xs.map) return xs.map(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + res.push(f(xs[i], i)); + } + return res; +} + +var objectKeys = Object.keys || function (obj) { + var res = []; + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key); + } + return res; +}; + +},{}],20:[function(require,module,exports){ +'use strict'; + +exports.decode = exports.parse = require('./decode'); +exports.encode = exports.stringify = require('./encode'); + +},{"./decode":18,"./encode":19}],21:[function(require,module,exports){ +module.exports = require('./lib/_stream_duplex.js'); + +},{"./lib/_stream_duplex.js":22}],22:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a duplex stream is just a stream that is both readable and writable. +// Since JS doesn't have multiple prototypal inheritance, this class +// prototypally inherits from Readable, and then parasitically from +// Writable. + +'use strict'; + +/**/ + +var processNextTick = require('process-nextick-args'); +/**/ + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + keys.push(key); + }return keys; +}; +/**/ + +module.exports = Duplex; + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var Readable = require('./_stream_readable'); +var Writable = require('./_stream_writable'); + +util.inherits(Duplex, Readable); + +var keys = objectKeys(Writable.prototype); +for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; +} + +function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + + Readable.call(this, options); + Writable.call(this, options); + + if (options && options.readable === false) this.readable = false; + + if (options && options.writable === false) this.writable = false; + + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; + + this.once('end', onend); +} + +// the no-half-open enforcer +function onend() { + // if we allow half-open state, or if the writable side ended, + // then we're ok. + if (this.allowHalfOpen || this._writableState.ended) return; + + // no more data can be written. + // But allow more writes to happen in this tick. + processNextTick(onEndNT, this); +} + +function onEndNT(self) { + self.end(); +} + +Object.defineProperty(Duplex.prototype, 'destroyed', { + get: function () { + if (this._readableState === undefined || this._writableState === undefined) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (this._readableState === undefined || this._writableState === undefined) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } +}); + +Duplex.prototype._destroy = function (err, cb) { + this.push(null); + this.end(); + + processNextTick(cb, err); +}; + +function forEach(xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} +},{"./_stream_readable":24,"./_stream_writable":26,"core-util-is":7,"inherits":10,"process-nextick-args":15}],23:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + +'use strict'; + +module.exports = PassThrough; + +var Transform = require('./_stream_transform'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(PassThrough, Transform); + +function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + + Transform.call(this, options); +} + +PassThrough.prototype._transform = function (chunk, encoding, cb) { + cb(null, chunk); +}; +},{"./_stream_transform":25,"core-util-is":7,"inherits":10}],24:[function(require,module,exports){ +(function (process,global){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +'use strict'; + +/**/ + +var processNextTick = require('process-nextick-args'); +/**/ + +module.exports = Readable; + +/**/ +var isArray = require('isarray'); +/**/ + +/**/ +var Duplex; +/**/ + +Readable.ReadableState = ReadableState; + +/**/ +var EE = require('events').EventEmitter; + +var EElistenerCount = function (emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +/**/ +var Stream = require('./internal/streams/stream'); +/**/ + +// TODO(bmeurer): Change this back to const once hole checks are +// properly optimized away early in Ignition+TurboFan. +/**/ +var Buffer = require('safe-buffer').Buffer; +var OurUint8Array = global.Uint8Array || function () {}; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} +/**/ + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +/**/ +var debugUtil = require('util'); +var debug = void 0; +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function () {}; +} +/**/ + +var BufferList = require('./internal/streams/BufferList'); +var destroyImpl = require('./internal/streams/destroy'); +var StringDecoder; + +util.inherits(Readable, Stream); + +var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; + +function prependListener(emitter, event, fn) { + // Sadly this is not cacheable as some libraries bundle their own + // event emitter implementation with them. + if (typeof emitter.prependListener === 'function') { + return emitter.prependListener(event, fn); + } else { + // This is a hack to make sure that our error handler is attached before any + // userland ones. NEVER DO THIS. This is here only because this code needs + // to continue to work with older versions of Node.js that do not include + // the prependListener() method. The goal is to eventually remove this hack. + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; + } +} + +function ReadableState(options, stream) { + Duplex = Duplex || require('./_stream_duplex'); + + options = options || {}; + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + var hwm = options.highWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = Math.floor(this.highWaterMark); + + // A linked list is used to store data chunks instead of an array because the + // linked list can remove elements from the beginning faster than + // array.shift() + this.buffer = new BufferList(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the event 'readable'/'data' is emitted + // immediately, or on a later tick. We set this to true at first, because + // any actions that shouldn't happen until "later" should generally also + // not happen before the first read call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + + // has it been destroyed + this.destroyed = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + Duplex = Duplex || require('./_stream_duplex'); + + if (!(this instanceof Readable)) return new Readable(options); + + this._readableState = new ReadableState(options, this); + + // legacy + this.readable = true; + + if (options) { + if (typeof options.read === 'function') this._read = options.read; + + if (typeof options.destroy === 'function') this._destroy = options.destroy; + } + + Stream.call(this); +} + +Object.defineProperty(Readable.prototype, 'destroyed', { + get: function () { + if (this._readableState === undefined) { + return false; + } + return this._readableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._readableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + } +}); + +Readable.prototype.destroy = destroyImpl.destroy; +Readable.prototype._undestroy = destroyImpl.undestroy; +Readable.prototype._destroy = function (err, cb) { + this.push(null); + cb(err); +}; + +// Manually shove something into the read() buffer. +// This returns true if the highWaterMark has not been hit yet, +// similar to how Writable.write() returns true if you should +// write() some more. +Readable.prototype.push = function (chunk, encoding) { + var state = this._readableState; + var skipChunkCheck; + + if (!state.objectMode) { + if (typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = Buffer.from(chunk, encoding); + encoding = ''; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + + return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function (chunk) { + return readableAddChunk(this, chunk, null, true, false); +}; + +function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { + var state = stream._readableState; + if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { + chunk = _uint8ArrayToBuffer(chunk); + } + + if (addToFront) { + if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); + } else if (state.ended) { + stream.emit('error', new Error('stream.push() after EOF')); + } else { + state.reading = false; + if (state.decoder && !encoding) { + chunk = state.decoder.write(chunk); + if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); + } else { + addChunk(stream, state, chunk, false); + } + } + } else if (!addToFront) { + state.reading = false; + } + } + + return needMoreData(state); +} + +function addChunk(stream, state, chunk, addToFront) { + if (state.flowing && state.length === 0 && !state.sync) { + stream.emit('data', chunk); + stream.read(0); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); + + if (state.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state); +} + +function chunkInvalid(state, chunk) { + var er; + if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; +} + +// if it's past the high water mark, we can push in some more. +// Also, if we have no data yet, we can stand some +// more bytes. This is to work around cases where hwm=0, +// such as the repl. Also, if the push() triggered a +// readable event, and the user called read(largeNumber) such that +// needReadable was set, then we ought to push more, so that another +// 'readable' event will be triggered. +function needMoreData(state) { + return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); +} + +Readable.prototype.isPaused = function () { + return this._readableState.flowing === false; +}; + +// backwards compatibility. +Readable.prototype.setEncoding = function (enc) { + if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; + return this; +}; + +// Don't raise the hwm > 8MB +var MAX_HWM = 0x800000; +function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + // Get the next highest power of 2 to prevent increasing hwm excessively in + // tiny amounts + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; +} + +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function howMuchToRead(n, state) { + if (n <= 0 || state.length === 0 && state.ended) return 0; + if (state.objectMode) return 1; + if (n !== n) { + // Only flow one buffer at a time + if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; + } + // If we're asking for more than the current hwm, then raise the hwm. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + if (n <= state.length) return n; + // Don't have enough + if (!state.ended) { + state.needReadable = true; + return 0; + } + return state.length; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function (n) { + debug('read', n); + n = parseInt(n, 10); + var state = this._readableState; + var nOrig = n; + + if (n !== 0) state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); + return null; + } + + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); + } + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } else if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (!state.reading) n = howMuchToRead(nOrig, state); + } + + var ret; + if (n > 0) ret = fromList(n, state);else ret = null; + + if (ret === null) { + state.needReadable = true; + n = 0; + } else { + state.length -= n; + } + + if (state.length === 0) { + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (!state.ended) state.needReadable = true; + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended) endReadable(this); + } + + if (ret !== null) this.emit('data', ret); + + return ret; +}; + +function onEofChunk(stream, state) { + if (state.ended) return; + if (state.decoder) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + + // emit 'readable' now to make sure it gets picked up. + emitReadable(stream); +} + +// Don't emit readable right away in sync mode, because this can trigger +// another read() call => stack overflow. This way, it might trigger +// a nextTick recursion warning, but that's not so bad. +function emitReadable(stream) { + var state = stream._readableState; + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream); + } +} + +function emitReadable_(stream) { + debug('emit readable'); + stream.emit('readable'); + flow(stream); +} + +// at this point, the user has presumably seen the 'readable' event, +// and called read() to consume some data. that may have triggered +// in turn another _read(n) call, in which case reading = true if +// it's in progress. +// However, if we're not ended, or reading, and the length < hwm, +// then go ahead and try to read some more preemptively. +function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + processNextTick(maybeReadMore_, stream, state); + } +} + +function maybeReadMore_(stream, state) { + var len = state.length; + while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break;else len = state.length; + } + state.readingMore = false; +} + +// abstract method. to be overridden in specific implementation classes. +// call cb(er, data) where data is <= n in length. +// for virtual (non-string, non-buffer) streams, "length" is somewhat +// arbitrary, and perhaps not very meaningful. +Readable.prototype._read = function (n) { + this.emit('error', new Error('_read() is not implemented')); +}; + +Readable.prototype.pipe = function (dest, pipeOpts) { + var src = this; + var state = this._readableState; + + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); + + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; + + var endFn = doEnd ? onend : unpipe; + if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable, unpipeInfo) { + debug('onunpipe'); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + + var cleanedUp = false; + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', unpipe); + src.removeListener('data', ondata); + + cleanedUp = true; + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + + // If the user pushes more data while we're writing to dest then we'll end up + // in ondata again. However, we only want to increase awaitDrain once because + // dest will only emit one 'drain' event for the multiple writes. + // => Introduce a guard on increasing awaitDrain. + var increasedAwaitDrain = false; + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + increasedAwaitDrain = false; + var ret = dest.write(chunk); + if (false === ret && !increasedAwaitDrain) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + // => Check whether `dest` is still a piping destination. + if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { + debug('false write response, pause', src._readableState.awaitDrain); + src._readableState.awaitDrain++; + increasedAwaitDrain = true; + } + src.pause(); + } + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); + } + + // Make sure our error handler is attached before userland ones. + prependListener(dest, 'error', onerror); + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + + function unpipe() { + debug('unpipe'); + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); + } + + return dest; +}; + +function pipeOnDrain(src) { + return function () { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) state.awaitDrain--; + if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { + state.flowing = true; + flow(src); + } + }; +} + +Readable.prototype.unpipe = function (dest) { + var state = this._readableState; + var unpipeInfo = { hasUnpiped: false }; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) return this; + + if (!dest) dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) dest.emit('unpipe', this, unpipeInfo); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + + for (var i = 0; i < len; i++) { + dests[i].emit('unpipe', this, unpipeInfo); + }return this; + } + + // try to find the right one. + var index = indexOf(state.pipes, dest); + if (index === -1) return this; + + state.pipes.splice(index, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) state.pipes = state.pipes[0]; + + dest.emit('unpipe', this, unpipeInfo); + + return this; +}; + +// set up data events if they are asked for +// Ensure readable listeners eventually get something +Readable.prototype.on = function (ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + + if (ev === 'data') { + // Start flowing on next tick if stream isn't explicitly paused + if (this._readableState.flowing !== false) this.resume(); + } else if (ev === 'readable') { + var state = this._readableState; + if (!state.endEmitted && !state.readableListening) { + state.readableListening = state.needReadable = true; + state.emittedReadable = false; + if (!state.reading) { + processNextTick(nReadingNextTick, this); + } else if (state.length) { + emitReadable(this); + } + } + } + + return res; +}; +Readable.prototype.addListener = Readable.prototype.on; + +function nReadingNextTick(self) { + debug('readable nexttick read 0'); + self.read(0); +} + +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. +Readable.prototype.resume = function () { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + state.flowing = true; + resume(this, state); + } + return this; +}; + +function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + processNextTick(resume_, stream, state); + } +} + +function resume_(stream, state) { + if (!state.reading) { + debug('resume read 0'); + stream.read(0); + } + + state.resumeScheduled = false; + state.awaitDrain = 0; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); +} + +Readable.prototype.pause = function () { + debug('call pause flowing=%j', this._readableState.flowing); + if (false !== this._readableState.flowing) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); + } + return this; +}; + +function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + while (state.flowing && stream.read() !== null) {} +} + +// wrap an old-style stream as the async data source. +// This is *not* part of the readable stream interface. +// It is an ugly unfortunate mess of history. +Readable.prototype.wrap = function (stream) { + var state = this._readableState; + var paused = false; + + var self = this; + stream.on('end', function () { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) self.push(chunk); + } + + self.push(null); + }); + + stream.on('data', function (chunk) { + debug('wrapped data'); + if (state.decoder) chunk = state.decoder.write(chunk); + + // don't skip over falsy values in objectMode + if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; + + var ret = self.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = function (method) { + return function () { + return stream[method].apply(stream, arguments); + }; + }(i); + } + } + + // proxy certain important events. + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n])); + } + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + self._read = function (n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + + return self; +}; + +// exposed for testing purposes only. +Readable._fromList = fromList; + +// Pluck off n bytes from an array of buffers. +// Length is the combined lengths of all the buffers in the list. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function fromList(n, state) { + // nothing buffered + if (state.length === 0) return null; + + var ret; + if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { + // read it all, truncate the list + if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); + state.buffer.clear(); + } else { + // read part of list + ret = fromListPartial(n, state.buffer, state.decoder); + } + + return ret; +} + +// Extracts only enough buffered data to satisfy the amount requested. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function fromListPartial(n, list, hasStrings) { + var ret; + if (n < list.head.data.length) { + // slice is the same for buffers and strings + ret = list.head.data.slice(0, n); + list.head.data = list.head.data.slice(n); + } else if (n === list.head.data.length) { + // first chunk is a perfect match + ret = list.shift(); + } else { + // result spans more than one buffer + ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); + } + return ret; +} + +// Copies a specified amount of characters from the list of buffered data +// chunks. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function copyFromBufferString(n, list) { + var p = list.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str;else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) list.head = p.next;else list.head = list.tail = null; + } else { + list.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; +} + +// Copies a specified amount of bytes from the list of buffered data chunks. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function copyFromBuffer(n, list) { + var ret = Buffer.allocUnsafe(n); + var p = list.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) list.head = p.next;else list.head = list.tail = null; + } else { + list.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; +} + +function endReadable(stream) { + var state = stream._readableState; + + // If we get here before consuming all the bytes, then that is a + // bug in node. Should never happen. + if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); + + if (!state.endEmitted) { + state.ended = true; + processNextTick(endReadableNT, state, stream); + } +} + +function endReadableNT(state, stream) { + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + } +} + +function forEach(xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +function indexOf(xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"./_stream_duplex":22,"./internal/streams/BufferList":27,"./internal/streams/destroy":28,"./internal/streams/stream":29,"_process":16,"core-util-is":7,"events":8,"inherits":10,"isarray":12,"process-nextick-args":15,"safe-buffer":34,"string_decoder/":36,"util":4}],25:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + +'use strict'; + +module.exports = Transform; + +var Duplex = require('./_stream_duplex'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(Transform, Duplex); + +function TransformState(stream) { + this.afterTransform = function (er, data) { + return afterTransform(stream, er, data); + }; + + this.needTransform = false; + this.transforming = false; + this.writecb = null; + this.writechunk = null; + this.writeencoding = null; +} + +function afterTransform(stream, er, data) { + var ts = stream._transformState; + ts.transforming = false; + + var cb = ts.writecb; + + if (!cb) { + return stream.emit('error', new Error('write callback called multiple times')); + } + + ts.writechunk = null; + ts.writecb = null; + + if (data !== null && data !== undefined) stream.push(data); + + cb(er); + + var rs = stream._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + stream._read(rs.highWaterMark); + } +} + +function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + + Duplex.call(this, options); + + this._transformState = new TransformState(this); + + var stream = this; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + + if (options) { + if (typeof options.transform === 'function') this._transform = options.transform; + + if (typeof options.flush === 'function') this._flush = options.flush; + } + + // When the writable side finishes, then flush out anything remaining. + this.once('prefinish', function () { + if (typeof this._flush === 'function') this._flush(function (er, data) { + done(stream, er, data); + });else done(stream); + }); +} + +Transform.prototype.push = function (chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function (chunk, encoding, cb) { + throw new Error('_transform() is not implemented'); +}; + +Transform.prototype._write = function (chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function (n) { + var ts = this._transformState; + + if (ts.writechunk !== null && ts.writecb && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; + +Transform.prototype._destroy = function (err, cb) { + var _this = this; + + Duplex.prototype._destroy.call(this, err, function (err2) { + cb(err2); + _this.emit('close'); + }); +}; + +function done(stream, er, data) { + if (er) return stream.emit('error', er); + + if (data !== null && data !== undefined) stream.push(data); + + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + var ws = stream._writableState; + var ts = stream._transformState; + + if (ws.length) throw new Error('Calling transform done when ws.length != 0'); + + if (ts.transforming) throw new Error('Calling transform done when still transforming'); + + return stream.push(null); +} +},{"./_stream_duplex":22,"core-util-is":7,"inherits":10}],26:[function(require,module,exports){ +(function (process,global){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// A bit simpler than readable streams. +// Implement an async ._write(chunk, encoding, cb), and it'll handle all +// the drain event emission and buffering. + +'use strict'; + +/**/ + +var processNextTick = require('process-nextick-args'); +/**/ + +module.exports = Writable; + +/* */ +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; +} + +// It seems a linked list but it is not +// there will be only 2 of these for each stream +function CorkedRequest(state) { + var _this = this; + + this.next = null; + this.entry = null; + this.finish = function () { + onCorkedFinish(_this, state); + }; +} +/* */ + +/**/ +var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick; +/**/ + +/**/ +var Duplex; +/**/ + +Writable.WritableState = WritableState; + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +/**/ +var internalUtil = { + deprecate: require('util-deprecate') +}; +/**/ + +/**/ +var Stream = require('./internal/streams/stream'); +/**/ + +/**/ +var Buffer = require('safe-buffer').Buffer; +var OurUint8Array = global.Uint8Array || function () {}; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} +/**/ + +var destroyImpl = require('./internal/streams/destroy'); + +util.inherits(Writable, Stream); + +function nop() {} + +function WritableState(options, stream) { + Duplex = Duplex || require('./_stream_duplex'); + + options = options || {}; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + var hwm = options.highWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = Math.floor(this.highWaterMark); + + // if _final has been called + this.finalCalled = false; + + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // has it been destroyed + this.destroyed = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function (er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + + this.bufferedRequest = null; + this.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; + + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; + + // count buffered requests + this.bufferedRequestCount = 0; + + // allocate the first CorkedRequest, there is always + // one allocated and free to use, and we maintain at most two + this.corkedRequestsFree = new CorkedRequest(this); +} + +WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; +}; + +(function () { + try { + Object.defineProperty(WritableState.prototype, 'buffer', { + get: internalUtil.deprecate(function () { + return this.getBuffer(); + }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') + }); + } catch (_) {} +})(); + +// Test _writableState for inheritance to account for Duplex streams, +// whose prototype chain only points to Readable. +var realHasInstance; +if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function (object) { + if (realHasInstance.call(this, object)) return true; + + return object && object._writableState instanceof WritableState; + } + }); +} else { + realHasInstance = function (object) { + return object instanceof this; + }; +} + +function Writable(options) { + Duplex = Duplex || require('./_stream_duplex'); + + // Writable ctor is applied to Duplexes, too. + // `realHasInstance` is necessary because using plain `instanceof` + // would return false, as no `_writableState` property is attached. + + // Trying to use the custom `instanceof` for Writable here will also break the + // Node.js LazyTransform implementation, which has a non-trivial getter for + // `_writableState` that would lead to infinite recursion. + if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { + return new Writable(options); + } + + this._writableState = new WritableState(options, this); + + // legacy. + this.writable = true; + + if (options) { + if (typeof options.write === 'function') this._write = options.write; + + if (typeof options.writev === 'function') this._writev = options.writev; + + if (typeof options.destroy === 'function') this._destroy = options.destroy; + + if (typeof options.final === 'function') this._final = options.final; + } + + Stream.call(this); +} + +// Otherwise people can pipe Writable streams, which is just wrong. +Writable.prototype.pipe = function () { + this.emit('error', new Error('Cannot pipe, not readable')); +}; + +function writeAfterEnd(stream, cb) { + var er = new Error('write after end'); + // TODO: defer error events consistently everywhere, not just the cb + stream.emit('error', er); + processNextTick(cb, er); +} + +// Checks that a user-supplied chunk is valid, especially for the particular +// mode the stream is in. Currently this means that `null` is never accepted +// and undefined/non-string values are only allowed in object mode. +function validChunk(stream, state, chunk, cb) { + var valid = true; + var er = false; + + if (chunk === null) { + er = new TypeError('May not write null values to stream'); + } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + if (er) { + stream.emit('error', er); + processNextTick(cb, er); + valid = false; + } + return valid; +} + +Writable.prototype.write = function (chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + var isBuf = _isUint8Array(chunk) && !state.objectMode; + + if (isBuf && !Buffer.isBuffer(chunk)) { + chunk = _uint8ArrayToBuffer(chunk); + } + + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; + + if (typeof cb !== 'function') cb = nop; + + if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); + } + + return ret; +}; + +Writable.prototype.cork = function () { + var state = this._writableState; + + state.corked++; +}; + +Writable.prototype.uncork = function () { + var state = this._writableState; + + if (state.corked) { + state.corked--; + + if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); + } +}; + +Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + // node::ParseEncoding() requires lower case. + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); + this._writableState.defaultEncoding = encoding; + return this; +}; + +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { + chunk = Buffer.from(chunk, encoding); + } + return chunk; +} + +// if we're already writing something, then just put this +// in the queue, and wait our turn. Otherwise, call _write +// If we return false, then we need a drain event, so set that flag. +function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state, chunk, encoding); + if (chunk !== newChunk) { + isBuf = true; + encoding = 'buffer'; + chunk = newChunk; + } + } + var len = state.objectMode ? 1 : chunk.length; + + state.length += len; + + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + + if (state.writing || state.corked) { + var last = state.lastBufferedRequest; + state.lastBufferedRequest = { + chunk: chunk, + encoding: encoding, + isBuf: isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; + } + state.bufferedRequestCount += 1; + } else { + doWrite(stream, state, false, len, chunk, encoding, cb); + } + + return ret; +} + +function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); + state.sync = false; +} + +function onwriteError(stream, state, sync, er, cb) { + --state.pendingcb; + + if (sync) { + // defer the callback if we are being called synchronously + // to avoid piling up things on the stack + processNextTick(cb, er); + // this can emit finish, and it will always happen + // after error + processNextTick(finishMaybe, stream, state); + stream._writableState.errorEmitted = true; + stream.emit('error', er); + } else { + // the caller expect this to happen before if + // it is async + cb(er); + stream._writableState.errorEmitted = true; + stream.emit('error', er); + // this can emit finish, but finish must + // always follow error + finishMaybe(stream, state); + } +} + +function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; +} + +function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + + onwriteStateUpdate(state); + + if (er) onwriteError(stream, state, sync, er, cb);else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(state); + + if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { + clearBuffer(stream, state); + } + + if (sync) { + /**/ + asyncWrite(afterWrite, stream, state, finished, cb); + /**/ + } else { + afterWrite(stream, state, finished, cb); + } + } +} + +function afterWrite(stream, state, finished, cb) { + if (!finished) onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); +} + +// Must force callback to be called on nextTick, so that we don't +// emit 'drain' before the write() consumer gets the 'false' return +// value, and has a chance to attach a 'drain' listener. +function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } +} + +// if there's something in the buffer waiting, then process it +function clearBuffer(stream, state) { + state.bufferProcessing = true; + var entry = state.bufferedRequest; + + if (stream._writev && entry && entry.next) { + // Fast case, write everything using _writev() + var l = state.bufferedRequestCount; + var buffer = new Array(l); + var holder = state.corkedRequestsFree; + holder.entry = entry; + + var count = 0; + var allBuffers = true; + while (entry) { + buffer[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer.allBuffers = allBuffers; + + doWrite(stream, state, true, state.length, buffer, '', holder.finish); + + // doWrite is almost always async, defer these to save a bit of time + // as the hot path ends with doWrite + state.pendingcb++; + state.lastBufferedRequest = null; + if (holder.next) { + state.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state.corkedRequestsFree = new CorkedRequest(state); + } + } else { + // Slow case, write chunks one-by-one + while (entry) { + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + + doWrite(stream, state, false, len, chunk, encoding, cb); + entry = entry.next; + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + break; + } + } + + if (entry === null) state.lastBufferedRequest = null; + } + + state.bufferedRequestCount = 0; + state.bufferedRequest = entry; + state.bufferProcessing = false; +} + +Writable.prototype._write = function (chunk, encoding, cb) { + cb(new Error('_write() is not implemented')); +}; + +Writable.prototype._writev = null; + +Writable.prototype.end = function (chunk, encoding, cb) { + var state = this._writableState; + + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); + } + + // ignore unnecessary end() calls. + if (!state.ending && !state.finished) endWritable(this, state, cb); +}; + +function needFinish(state) { + return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; +} +function callFinal(stream, state) { + stream._final(function (err) { + state.pendingcb--; + if (err) { + stream.emit('error', err); + } + state.prefinished = true; + stream.emit('prefinish'); + finishMaybe(stream, state); + }); +} +function prefinish(stream, state) { + if (!state.prefinished && !state.finalCalled) { + if (typeof stream._final === 'function') { + state.pendingcb++; + state.finalCalled = true; + processNextTick(callFinal, stream, state); + } else { + state.prefinished = true; + stream.emit('prefinish'); + } + } +} + +function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + prefinish(stream, state); + if (state.pendingcb === 0) { + state.finished = true; + stream.emit('finish'); + } + } + return need; +} + +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) processNextTick(cb);else stream.once('finish', cb); + } + state.ended = true; + stream.writable = false; +} + +function onCorkedFinish(corkReq, state, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state.pendingcb--; + cb(err); + entry = entry.next; + } + if (state.corkedRequestsFree) { + state.corkedRequestsFree.next = corkReq; + } else { + state.corkedRequestsFree = corkReq; + } +} + +Object.defineProperty(Writable.prototype, 'destroyed', { + get: function () { + if (this._writableState === undefined) { + return false; + } + return this._writableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._writableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._writableState.destroyed = value; + } +}); + +Writable.prototype.destroy = destroyImpl.destroy; +Writable.prototype._undestroy = destroyImpl.undestroy; +Writable.prototype._destroy = function (err, cb) { + this.end(); + cb(err); +}; +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"./_stream_duplex":22,"./internal/streams/destroy":28,"./internal/streams/stream":29,"_process":16,"core-util-is":7,"inherits":10,"process-nextick-args":15,"safe-buffer":34,"util-deprecate":39}],27:[function(require,module,exports){ +'use strict'; + +/**/ + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Buffer = require('safe-buffer').Buffer; +/**/ + +function copyBuffer(src, target, offset) { + src.copy(target, offset); +} + +module.exports = function () { + function BufferList() { + _classCallCheck(this, BufferList); + + this.head = null; + this.tail = null; + this.length = 0; + } + + BufferList.prototype.push = function push(v) { + var entry = { data: v, next: null }; + if (this.length > 0) this.tail.next = entry;else this.head = entry; + this.tail = entry; + ++this.length; + }; + + BufferList.prototype.unshift = function unshift(v) { + var entry = { data: v, next: this.head }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + }; + + BufferList.prototype.shift = function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; + --this.length; + return ret; + }; + + BufferList.prototype.clear = function clear() { + this.head = this.tail = null; + this.length = 0; + }; + + BufferList.prototype.join = function join(s) { + if (this.length === 0) return ''; + var p = this.head; + var ret = '' + p.data; + while (p = p.next) { + ret += s + p.data; + }return ret; + }; + + BufferList.prototype.concat = function concat(n) { + if (this.length === 0) return Buffer.alloc(0); + if (this.length === 1) return this.head.data; + var ret = Buffer.allocUnsafe(n >>> 0); + var p = this.head; + var i = 0; + while (p) { + copyBuffer(p.data, ret, i); + i += p.data.length; + p = p.next; + } + return ret; + }; + + return BufferList; +}(); +},{"safe-buffer":34}],28:[function(require,module,exports){ +'use strict'; + +/**/ + +var processNextTick = require('process-nextick-args'); +/**/ + +// undocumented cb() API, needed for core, not for public API +function destroy(err, cb) { + var _this = this; + + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { + processNextTick(emitErrorNT, this, err); + } + return; + } + + // we set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks + + if (this._readableState) { + this._readableState.destroyed = true; + } + + // if this is a duplex stream mark the writable part as destroyed as well + if (this._writableState) { + this._writableState.destroyed = true; + } + + this._destroy(err || null, function (err) { + if (!cb && err) { + processNextTick(emitErrorNT, _this, err); + if (_this._writableState) { + _this._writableState.errorEmitted = true; + } + } else if (cb) { + cb(err); + } + }); +} + +function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } +} + +function emitErrorNT(self, err) { + self.emit('error', err); +} + +module.exports = { + destroy: destroy, + undestroy: undestroy +}; +},{"process-nextick-args":15}],29:[function(require,module,exports){ +module.exports = require('events').EventEmitter; + +},{"events":8}],30:[function(require,module,exports){ +module.exports = require('./readable').PassThrough + +},{"./readable":31}],31:[function(require,module,exports){ +exports = module.exports = require('./lib/_stream_readable.js'); +exports.Stream = exports; +exports.Readable = exports; +exports.Writable = require('./lib/_stream_writable.js'); +exports.Duplex = require('./lib/_stream_duplex.js'); +exports.Transform = require('./lib/_stream_transform.js'); +exports.PassThrough = require('./lib/_stream_passthrough.js'); + +},{"./lib/_stream_duplex.js":22,"./lib/_stream_passthrough.js":23,"./lib/_stream_readable.js":24,"./lib/_stream_transform.js":25,"./lib/_stream_writable.js":26}],32:[function(require,module,exports){ +module.exports = require('./readable').Transform + +},{"./readable":31}],33:[function(require,module,exports){ +module.exports = require('./lib/_stream_writable.js'); + +},{"./lib/_stream_writable.js":26}],34:[function(require,module,exports){ +/* eslint-disable node/no-deprecated-api */ +var buffer = require('buffer') +var Buffer = buffer.Buffer + +// alternative to using Object.keys for old browsers +function copyProps (src, dst) { + for (var key in src) { + dst[key] = src[key] + } +} +if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer +} else { + // Copy properties from require('buffer') + copyProps(buffer, exports) + exports.Buffer = SafeBuffer +} + +function SafeBuffer (arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length) +} + +// Copy static methods from Buffer +copyProps(Buffer, SafeBuffer) + +SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number') + } + return Buffer(arg, encodingOrOffset, length) +} + +SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + var buf = Buffer(size) + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + } else { + buf.fill(0) + } + return buf +} + +SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return Buffer(size) +} + +SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return buffer.SlowBuffer(size) +} + +},{"buffer":5}],35:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +module.exports = Stream; + +var EE = require('events').EventEmitter; +var inherits = require('inherits'); + +inherits(Stream, EE); +Stream.Readable = require('readable-stream/readable.js'); +Stream.Writable = require('readable-stream/writable.js'); +Stream.Duplex = require('readable-stream/duplex.js'); +Stream.Transform = require('readable-stream/transform.js'); +Stream.PassThrough = require('readable-stream/passthrough.js'); + +// Backwards-compat with node 0.4.x +Stream.Stream = Stream; + + + +// old-style streams. Note that the pipe method (the only relevant +// part of this class) is overridden in the Readable class. + +function Stream() { + EE.call(this); +} + +Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +}; + +},{"events":8,"inherits":10,"readable-stream/duplex.js":21,"readable-stream/passthrough.js":30,"readable-stream/readable.js":31,"readable-stream/transform.js":32,"readable-stream/writable.js":33}],36:[function(require,module,exports){ +'use strict'; + +var Buffer = require('safe-buffer').Buffer; + +var isEncoding = Buffer.isEncoding || function (encoding) { + encoding = '' + encoding; + switch (encoding && encoding.toLowerCase()) { + case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw': + return true; + default: + return false; + } +}; + +function _normalizeEncoding(enc) { + if (!enc) return 'utf8'; + var retried; + while (true) { + switch (enc) { + case 'utf8': + case 'utf-8': + return 'utf8'; + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return 'utf16le'; + case 'latin1': + case 'binary': + return 'latin1'; + case 'base64': + case 'ascii': + case 'hex': + return enc; + default: + if (retried) return; // undefined + enc = ('' + enc).toLowerCase(); + retried = true; + } + } +}; + +// Do not cache `Buffer.isEncoding` when checking encoding names as some +// modules monkey-patch it to support additional encodings +function normalizeEncoding(enc) { + var nenc = _normalizeEncoding(enc); + if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); + return nenc || enc; +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. +exports.StringDecoder = StringDecoder; +function StringDecoder(encoding) { + this.encoding = normalizeEncoding(encoding); + var nb; + switch (this.encoding) { + case 'utf16le': + this.text = utf16Text; + this.end = utf16End; + nb = 4; + break; + case 'utf8': + this.fillLast = utf8FillLast; + nb = 4; + break; + case 'base64': + this.text = base64Text; + this.end = base64End; + nb = 3; + break; + default: + this.write = simpleWrite; + this.end = simpleEnd; + return; + } + this.lastNeed = 0; + this.lastTotal = 0; + this.lastChar = Buffer.allocUnsafe(nb); +} + +StringDecoder.prototype.write = function (buf) { + if (buf.length === 0) return ''; + var r; + var i; + if (this.lastNeed) { + r = this.fillLast(buf); + if (r === undefined) return ''; + i = this.lastNeed; + this.lastNeed = 0; + } else { + i = 0; + } + if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); + return r || ''; +}; + +StringDecoder.prototype.end = utf8End; + +// Returns only complete characters in a Buffer +StringDecoder.prototype.text = utf8Text; + +// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer +StringDecoder.prototype.fillLast = function (buf) { + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); + this.lastNeed -= buf.length; +}; + +// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a +// continuation byte. +function utf8CheckByte(byte) { + if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; + return -1; +} + +// Checks at most 3 bytes at the end of a Buffer in order to detect an +// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) +// needed to complete the UTF-8 character (if applicable) are returned. +function utf8CheckIncomplete(self, buf, i) { + var j = buf.length - 1; + if (j < i) return 0; + var nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 1; + return nb; + } + if (--j < i) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 2; + return nb; + } + if (--j < i) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) { + if (nb === 2) nb = 0;else self.lastNeed = nb - 3; + } + return nb; + } + return 0; +} + +// Validates as many continuation bytes for a multi-byte UTF-8 character as +// needed or are available. If we see a non-continuation byte where we expect +// one, we "replace" the validated continuation bytes we've seen so far with +// UTF-8 replacement characters ('\ufffd'), to match v8's UTF-8 decoding +// behavior. The continuation byte check is included three times in the case +// where all of the continuation bytes for a character exist in the same buffer. +// It is also done this way as a slight performance increase instead of using a +// loop. +function utf8CheckExtraBytes(self, buf, p) { + if ((buf[0] & 0xC0) !== 0x80) { + self.lastNeed = 0; + return '\ufffd'.repeat(p); + } + if (self.lastNeed > 1 && buf.length > 1) { + if ((buf[1] & 0xC0) !== 0x80) { + self.lastNeed = 1; + return '\ufffd'.repeat(p + 1); + } + if (self.lastNeed > 2 && buf.length > 2) { + if ((buf[2] & 0xC0) !== 0x80) { + self.lastNeed = 2; + return '\ufffd'.repeat(p + 2); + } + } + } +} + +// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. +function utf8FillLast(buf) { + var p = this.lastTotal - this.lastNeed; + var r = utf8CheckExtraBytes(this, buf, p); + if (r !== undefined) return r; + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, p, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, p, 0, buf.length); + this.lastNeed -= buf.length; +} + +// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a +// partial character, the character's bytes are buffered until the required +// number of bytes are available. +function utf8Text(buf, i) { + var total = utf8CheckIncomplete(this, buf, i); + if (!this.lastNeed) return buf.toString('utf8', i); + this.lastTotal = total; + var end = buf.length - (total - this.lastNeed); + buf.copy(this.lastChar, 0, end); + return buf.toString('utf8', i, end); +} + +// For UTF-8, a replacement character for each buffered byte of a (partial) +// character needs to be added to the output. +function utf8End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + '\ufffd'.repeat(this.lastTotal - this.lastNeed); + return r; +} + +// UTF-16LE typically needs two bytes per character, but even if we have an even +// number of bytes available, we need to check if we end on a leading/high +// surrogate. In that case, we need to wait for the next two bytes in order to +// decode the last character properly. +function utf16Text(buf, i) { + if ((buf.length - i) % 2 === 0) { + var r = buf.toString('utf16le', i); + if (r) { + var c = r.charCodeAt(r.length - 1); + if (c >= 0xD800 && c <= 0xDBFF) { + this.lastNeed = 2; + this.lastTotal = 4; + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + return r.slice(0, -1); + } + } + return r; + } + this.lastNeed = 1; + this.lastTotal = 2; + this.lastChar[0] = buf[buf.length - 1]; + return buf.toString('utf16le', i, buf.length - 1); +} + +// For UTF-16LE we do not explicitly append special replacement characters if we +// end on a partial character, we simply let v8 handle that. +function utf16End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) { + var end = this.lastTotal - this.lastNeed; + return r + this.lastChar.toString('utf16le', 0, end); + } + return r; +} + +function base64Text(buf, i) { + var n = (buf.length - i) % 3; + if (n === 0) return buf.toString('base64', i); + this.lastNeed = 3 - n; + this.lastTotal = 3; + if (n === 1) { + this.lastChar[0] = buf[buf.length - 1]; + } else { + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + } + return buf.toString('base64', i, buf.length - n); +} + +function base64End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); + return r; +} + +// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) +function simpleWrite(buf) { + return buf.toString(this.encoding); +} + +function simpleEnd(buf) { + return buf && buf.length ? this.write(buf) : ''; +} +},{"safe-buffer":34}],37:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +'use strict'; + +var punycode = require('punycode'); +var util = require('./util'); + +exports.parse = urlParse; +exports.resolve = urlResolve; +exports.resolveObject = urlResolveObject; +exports.format = urlFormat; + +exports.Url = Url; + +function Url() { + this.protocol = null; + this.slashes = null; + this.auth = null; + this.host = null; + this.port = null; + this.hostname = null; + this.hash = null; + this.search = null; + this.query = null; + this.pathname = null; + this.path = null; + this.href = null; +} + +// Reference: RFC 3986, RFC 1808, RFC 2396 + +// define these here so at least they only have to be +// compiled once on the first module load. +var protocolPattern = /^([a-z0-9.+-]+:)/i, + portPattern = /:[0-9]*$/, + + // Special case for a simple path URL + simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/, + + // RFC 2396: characters reserved for delimiting URLs. + // We actually just auto-escape these. + delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'], + + // RFC 2396: characters not allowed for various reasons. + unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims), + + // Allowed by RFCs, but cause of XSS attacks. Always escape these. + autoEscape = ['\''].concat(unwise), + // Characters that are never ever allowed in a hostname. + // Note that any invalid chars are also handled, but these + // are the ones that are *expected* to be seen, so we fast-path + // them. + nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape), + hostEndingChars = ['/', '?', '#'], + hostnameMaxLen = 255, + hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/, + hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, + // protocols that can allow "unsafe" and "unwise" chars. + unsafeProtocol = { + 'javascript': true, + 'javascript:': true + }, + // protocols that never have a hostname. + hostlessProtocol = { + 'javascript': true, + 'javascript:': true + }, + // protocols that always contain a // bit. + slashedProtocol = { + 'http': true, + 'https': true, + 'ftp': true, + 'gopher': true, + 'file': true, + 'http:': true, + 'https:': true, + 'ftp:': true, + 'gopher:': true, + 'file:': true + }, + querystring = require('querystring'); + +function urlParse(url, parseQueryString, slashesDenoteHost) { + if (url && util.isObject(url) && url instanceof Url) return url; + + var u = new Url; + u.parse(url, parseQueryString, slashesDenoteHost); + return u; +} + +Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) { + if (!util.isString(url)) { + throw new TypeError("Parameter 'url' must be a string, not " + typeof url); + } + + // Copy chrome, IE, opera backslash-handling behavior. + // Back slashes before the query string get converted to forward slashes + // See: https://code.google.com/p/chromium/issues/detail?id=25916 + var queryIndex = url.indexOf('?'), + splitter = + (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#', + uSplit = url.split(splitter), + slashRegex = /\\/g; + uSplit[0] = uSplit[0].replace(slashRegex, '/'); + url = uSplit.join(splitter); + + var rest = url; + + // trim before proceeding. + // This is to support parse stuff like " http://foo.com \n" + rest = rest.trim(); + + if (!slashesDenoteHost && url.split('#').length === 1) { + // Try fast path regexp + var simplePath = simplePathPattern.exec(rest); + if (simplePath) { + this.path = rest; + this.href = rest; + this.pathname = simplePath[1]; + if (simplePath[2]) { + this.search = simplePath[2]; + if (parseQueryString) { + this.query = querystring.parse(this.search.substr(1)); + } else { + this.query = this.search.substr(1); + } + } else if (parseQueryString) { + this.search = ''; + this.query = {}; + } + return this; + } + } + + var proto = protocolPattern.exec(rest); + if (proto) { + proto = proto[0]; + var lowerProto = proto.toLowerCase(); + this.protocol = lowerProto; + rest = rest.substr(proto.length); + } + + // figure out if it's got a host + // user@server is *always* interpreted as a hostname, and url + // resolution will treat //foo/bar as host=foo,path=bar because that's + // how the browser resolves relative URLs. + if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) { + var slashes = rest.substr(0, 2) === '//'; + if (slashes && !(proto && hostlessProtocol[proto])) { + rest = rest.substr(2); + this.slashes = true; + } + } + + if (!hostlessProtocol[proto] && + (slashes || (proto && !slashedProtocol[proto]))) { + + // there's a hostname. + // the first instance of /, ?, ;, or # ends the host. + // + // If there is an @ in the hostname, then non-host chars *are* allowed + // to the left of the last @ sign, unless some host-ending character + // comes *before* the @-sign. + // URLs are obnoxious. + // + // ex: + // http://a@b@c/ => user:a@b host:c + // http://a@b?@c => user:a host:c path:/?@c + + // v0.12 TODO(isaacs): This is not quite how Chrome does things. + // Review our test case against browsers more comprehensively. + + // find the first instance of any hostEndingChars + var hostEnd = -1; + for (var i = 0; i < hostEndingChars.length; i++) { + var hec = rest.indexOf(hostEndingChars[i]); + if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) + hostEnd = hec; + } + + // at this point, either we have an explicit point where the + // auth portion cannot go past, or the last @ char is the decider. + var auth, atSign; + if (hostEnd === -1) { + // atSign can be anywhere. + atSign = rest.lastIndexOf('@'); + } else { + // atSign must be in auth portion. + // http://a@b/c@d => host:b auth:a path:/c@d + atSign = rest.lastIndexOf('@', hostEnd); + } + + // Now we have a portion which is definitely the auth. + // Pull that off. + if (atSign !== -1) { + auth = rest.slice(0, atSign); + rest = rest.slice(atSign + 1); + this.auth = decodeURIComponent(auth); + } + + // the host is the remaining to the left of the first non-host char + hostEnd = -1; + for (var i = 0; i < nonHostChars.length; i++) { + var hec = rest.indexOf(nonHostChars[i]); + if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) + hostEnd = hec; + } + // if we still have not hit it, then the entire thing is a host. + if (hostEnd === -1) + hostEnd = rest.length; + + this.host = rest.slice(0, hostEnd); + rest = rest.slice(hostEnd); + + // pull out port. + this.parseHost(); + + // we've indicated that there is a hostname, + // so even if it's empty, it has to be present. + this.hostname = this.hostname || ''; + + // if hostname begins with [ and ends with ] + // assume that it's an IPv6 address. + var ipv6Hostname = this.hostname[0] === '[' && + this.hostname[this.hostname.length - 1] === ']'; + + // validate a little. + if (!ipv6Hostname) { + var hostparts = this.hostname.split(/\./); + for (var i = 0, l = hostparts.length; i < l; i++) { + var part = hostparts[i]; + if (!part) continue; + if (!part.match(hostnamePartPattern)) { + var newpart = ''; + for (var j = 0, k = part.length; j < k; j++) { + if (part.charCodeAt(j) > 127) { + // we replace non-ASCII char with a temporary placeholder + // we need this to make sure size of hostname is not + // broken by replacing non-ASCII by nothing + newpart += 'x'; + } else { + newpart += part[j]; + } + } + // we test again with ASCII char only + if (!newpart.match(hostnamePartPattern)) { + var validParts = hostparts.slice(0, i); + var notHost = hostparts.slice(i + 1); + var bit = part.match(hostnamePartStart); + if (bit) { + validParts.push(bit[1]); + notHost.unshift(bit[2]); + } + if (notHost.length) { + rest = '/' + notHost.join('.') + rest; + } + this.hostname = validParts.join('.'); + break; + } + } + } + } + + if (this.hostname.length > hostnameMaxLen) { + this.hostname = ''; + } else { + // hostnames are always lower case. + this.hostname = this.hostname.toLowerCase(); + } + + if (!ipv6Hostname) { + // IDNA Support: Returns a punycoded representation of "domain". + // It only converts parts of the domain name that + // have non-ASCII characters, i.e. it doesn't matter if + // you call it with a domain that already is ASCII-only. + this.hostname = punycode.toASCII(this.hostname); + } + + var p = this.port ? ':' + this.port : ''; + var h = this.hostname || ''; + this.host = h + p; + this.href += this.host; + + // strip [ and ] from the hostname + // the host field still retains them, though + if (ipv6Hostname) { + this.hostname = this.hostname.substr(1, this.hostname.length - 2); + if (rest[0] !== '/') { + rest = '/' + rest; + } + } + } + + // now rest is set to the post-host stuff. + // chop off any delim chars. + if (!unsafeProtocol[lowerProto]) { + + // First, make 100% sure that any "autoEscape" chars get + // escaped, even if encodeURIComponent doesn't think they + // need to be. + for (var i = 0, l = autoEscape.length; i < l; i++) { + var ae = autoEscape[i]; + if (rest.indexOf(ae) === -1) + continue; + var esc = encodeURIComponent(ae); + if (esc === ae) { + esc = escape(ae); + } + rest = rest.split(ae).join(esc); + } + } + + + // chop off from the tail first. + var hash = rest.indexOf('#'); + if (hash !== -1) { + // got a fragment string. + this.hash = rest.substr(hash); + rest = rest.slice(0, hash); + } + var qm = rest.indexOf('?'); + if (qm !== -1) { + this.search = rest.substr(qm); + this.query = rest.substr(qm + 1); + if (parseQueryString) { + this.query = querystring.parse(this.query); + } + rest = rest.slice(0, qm); + } else if (parseQueryString) { + // no query string, but parseQueryString still requested + this.search = ''; + this.query = {}; + } + if (rest) this.pathname = rest; + if (slashedProtocol[lowerProto] && + this.hostname && !this.pathname) { + this.pathname = '/'; + } + + //to support http.request + if (this.pathname || this.search) { + var p = this.pathname || ''; + var s = this.search || ''; + this.path = p + s; + } + + // finally, reconstruct the href based on what has been validated. + this.href = this.format(); + return this; +}; + +// format a parsed object into a url string +function urlFormat(obj) { + // ensure it's an object, and not a string url. + // If it's an obj, this is a no-op. + // this way, you can call url_format() on strings + // to clean up potentially wonky urls. + if (util.isString(obj)) obj = urlParse(obj); + if (!(obj instanceof Url)) return Url.prototype.format.call(obj); + return obj.format(); +} + +Url.prototype.format = function() { + var auth = this.auth || ''; + if (auth) { + auth = encodeURIComponent(auth); + auth = auth.replace(/%3A/i, ':'); + auth += '@'; + } + + var protocol = this.protocol || '', + pathname = this.pathname || '', + hash = this.hash || '', + host = false, + query = ''; + + if (this.host) { + host = auth + this.host; + } else if (this.hostname) { + host = auth + (this.hostname.indexOf(':') === -1 ? + this.hostname : + '[' + this.hostname + ']'); + if (this.port) { + host += ':' + this.port; + } + } + + if (this.query && + util.isObject(this.query) && + Object.keys(this.query).length) { + query = querystring.stringify(this.query); + } + + var search = this.search || (query && ('?' + query)) || ''; + + if (protocol && protocol.substr(-1) !== ':') protocol += ':'; + + // only the slashedProtocols get the //. Not mailto:, xmpp:, etc. + // unless they had them to begin with. + if (this.slashes || + (!protocol || slashedProtocol[protocol]) && host !== false) { + host = '//' + (host || ''); + if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname; + } else if (!host) { + host = ''; + } + + if (hash && hash.charAt(0) !== '#') hash = '#' + hash; + if (search && search.charAt(0) !== '?') search = '?' + search; + + pathname = pathname.replace(/[?#]/g, function(match) { + return encodeURIComponent(match); + }); + search = search.replace('#', '%23'); + + return protocol + host + pathname + search + hash; +}; + +function urlResolve(source, relative) { + return urlParse(source, false, true).resolve(relative); +} + +Url.prototype.resolve = function(relative) { + return this.resolveObject(urlParse(relative, false, true)).format(); +}; + +function urlResolveObject(source, relative) { + if (!source) return relative; + return urlParse(source, false, true).resolveObject(relative); +} + +Url.prototype.resolveObject = function(relative) { + if (util.isString(relative)) { + var rel = new Url(); + rel.parse(relative, false, true); + relative = rel; + } + + var result = new Url(); + var tkeys = Object.keys(this); + for (var tk = 0; tk < tkeys.length; tk++) { + var tkey = tkeys[tk]; + result[tkey] = this[tkey]; + } + + // hash is always overridden, no matter what. + // even href="" will remove it. + result.hash = relative.hash; + + // if the relative url is empty, then there's nothing left to do here. + if (relative.href === '') { + result.href = result.format(); + return result; + } + + // hrefs like //foo/bar always cut to the protocol. + if (relative.slashes && !relative.protocol) { + // take everything except the protocol from relative + var rkeys = Object.keys(relative); + for (var rk = 0; rk < rkeys.length; rk++) { + var rkey = rkeys[rk]; + if (rkey !== 'protocol') + result[rkey] = relative[rkey]; + } + + //urlParse appends trailing / to urls like http://www.example.com + if (slashedProtocol[result.protocol] && + result.hostname && !result.pathname) { + result.path = result.pathname = '/'; + } + + result.href = result.format(); + return result; + } + + if (relative.protocol && relative.protocol !== result.protocol) { + // if it's a known url protocol, then changing + // the protocol does weird things + // first, if it's not file:, then we MUST have a host, + // and if there was a path + // to begin with, then we MUST have a path. + // if it is file:, then the host is dropped, + // because that's known to be hostless. + // anything else is assumed to be absolute. + if (!slashedProtocol[relative.protocol]) { + var keys = Object.keys(relative); + for (var v = 0; v < keys.length; v++) { + var k = keys[v]; + result[k] = relative[k]; + } + result.href = result.format(); + return result; + } + + result.protocol = relative.protocol; + if (!relative.host && !hostlessProtocol[relative.protocol]) { + var relPath = (relative.pathname || '').split('/'); + while (relPath.length && !(relative.host = relPath.shift())); + if (!relative.host) relative.host = ''; + if (!relative.hostname) relative.hostname = ''; + if (relPath[0] !== '') relPath.unshift(''); + if (relPath.length < 2) relPath.unshift(''); + result.pathname = relPath.join('/'); + } else { + result.pathname = relative.pathname; + } + result.search = relative.search; + result.query = relative.query; + result.host = relative.host || ''; + result.auth = relative.auth; + result.hostname = relative.hostname || relative.host; + result.port = relative.port; + // to support http.request + if (result.pathname || result.search) { + var p = result.pathname || ''; + var s = result.search || ''; + result.path = p + s; + } + result.slashes = result.slashes || relative.slashes; + result.href = result.format(); + return result; + } + + var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'), + isRelAbs = ( + relative.host || + relative.pathname && relative.pathname.charAt(0) === '/' + ), + mustEndAbs = (isRelAbs || isSourceAbs || + (result.host && relative.pathname)), + removeAllDots = mustEndAbs, + srcPath = result.pathname && result.pathname.split('/') || [], + relPath = relative.pathname && relative.pathname.split('/') || [], + psychotic = result.protocol && !slashedProtocol[result.protocol]; + + // if the url is a non-slashed url, then relative + // links like ../.. should be able + // to crawl up to the hostname, as well. This is strange. + // result.protocol has already been set by now. + // Later on, put the first path part into the host field. + if (psychotic) { + result.hostname = ''; + result.port = null; + if (result.host) { + if (srcPath[0] === '') srcPath[0] = result.host; + else srcPath.unshift(result.host); + } + result.host = ''; + if (relative.protocol) { + relative.hostname = null; + relative.port = null; + if (relative.host) { + if (relPath[0] === '') relPath[0] = relative.host; + else relPath.unshift(relative.host); + } + relative.host = null; + } + mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === ''); + } + + if (isRelAbs) { + // it's absolute. + result.host = (relative.host || relative.host === '') ? + relative.host : result.host; + result.hostname = (relative.hostname || relative.hostname === '') ? + relative.hostname : result.hostname; + result.search = relative.search; + result.query = relative.query; + srcPath = relPath; + // fall through to the dot-handling below. + } else if (relPath.length) { + // it's relative + // throw away the existing file, and take the new path instead. + if (!srcPath) srcPath = []; + srcPath.pop(); + srcPath = srcPath.concat(relPath); + result.search = relative.search; + result.query = relative.query; + } else if (!util.isNullOrUndefined(relative.search)) { + // just pull out the search. + // like href='?foo'. + // Put this after the other two cases because it simplifies the booleans + if (psychotic) { + result.hostname = result.host = srcPath.shift(); + //occationaly the auth can get stuck only in host + //this especially happens in cases like + //url.resolveObject('mailto:local1@domain1', 'local2@domain2') + var authInHost = result.host && result.host.indexOf('@') > 0 ? + result.host.split('@') : false; + if (authInHost) { + result.auth = authInHost.shift(); + result.host = result.hostname = authInHost.shift(); + } + } + result.search = relative.search; + result.query = relative.query; + //to support http.request + if (!util.isNull(result.pathname) || !util.isNull(result.search)) { + result.path = (result.pathname ? result.pathname : '') + + (result.search ? result.search : ''); + } + result.href = result.format(); + return result; + } + + if (!srcPath.length) { + // no path at all. easy. + // we've already handled the other stuff above. + result.pathname = null; + //to support http.request + if (result.search) { + result.path = '/' + result.search; + } else { + result.path = null; + } + result.href = result.format(); + return result; + } + + // if a url ENDs in . or .., then it must get a trailing slash. + // however, if it ends in anything else non-slashy, + // then it must NOT get a trailing slash. + var last = srcPath.slice(-1)[0]; + var hasTrailingSlash = ( + (result.host || relative.host || srcPath.length > 1) && + (last === '.' || last === '..') || last === ''); + + // strip single dots, resolve double dots to parent dir + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = srcPath.length; i >= 0; i--) { + last = srcPath[i]; + if (last === '.') { + srcPath.splice(i, 1); + } else if (last === '..') { + srcPath.splice(i, 1); + up++; + } else if (up) { + srcPath.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (!mustEndAbs && !removeAllDots) { + for (; up--; up) { + srcPath.unshift('..'); + } + } + + if (mustEndAbs && srcPath[0] !== '' && + (!srcPath[0] || srcPath[0].charAt(0) !== '/')) { + srcPath.unshift(''); + } + + if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) { + srcPath.push(''); + } + + var isAbsolute = srcPath[0] === '' || + (srcPath[0] && srcPath[0].charAt(0) === '/'); + + // put the host back + if (psychotic) { + result.hostname = result.host = isAbsolute ? '' : + srcPath.length ? srcPath.shift() : ''; + //occationaly the auth can get stuck only in host + //this especially happens in cases like + //url.resolveObject('mailto:local1@domain1', 'local2@domain2') + var authInHost = result.host && result.host.indexOf('@') > 0 ? + result.host.split('@') : false; + if (authInHost) { + result.auth = authInHost.shift(); + result.host = result.hostname = authInHost.shift(); + } + } + + mustEndAbs = mustEndAbs || (result.host && srcPath.length); + + if (mustEndAbs && !isAbsolute) { + srcPath.unshift(''); + } + + if (!srcPath.length) { + result.pathname = null; + result.path = null; + } else { + result.pathname = srcPath.join('/'); + } + + //to support request.http + if (!util.isNull(result.pathname) || !util.isNull(result.search)) { + result.path = (result.pathname ? result.pathname : '') + + (result.search ? result.search : ''); + } + result.auth = relative.auth || result.auth; + result.slashes = result.slashes || relative.slashes; + result.href = result.format(); + return result; +}; + +Url.prototype.parseHost = function() { + var host = this.host; + var port = portPattern.exec(host); + if (port) { + port = port[0]; + if (port !== ':') { + this.port = port.substr(1); + } + host = host.substr(0, host.length - port.length); + } + if (host) this.hostname = host; +}; + +},{"./util":38,"punycode":17,"querystring":20}],38:[function(require,module,exports){ +'use strict'; + +module.exports = { + isString: function(arg) { + return typeof(arg) === 'string'; + }, + isObject: function(arg) { + return typeof(arg) === 'object' && arg !== null; + }, + isNull: function(arg) { + return arg === null; + }, + isNullOrUndefined: function(arg) { + return arg == null; + } +}; + +},{}],39:[function(require,module,exports){ +(function (global){ + +/** + * Module exports. + */ + +module.exports = deprecate; + +/** + * Mark that a method should not be used. + * Returns a modified function which warns once by default. + * + * If `localStorage.noDeprecation = true` is set, then it is a no-op. + * + * If `localStorage.throwDeprecation = true` is set, then deprecated functions + * will throw an Error when invoked. + * + * If `localStorage.traceDeprecation = true` is set, then deprecated functions + * will invoke `console.trace()` instead of `console.error()`. + * + * @param {Function} fn - the function to deprecate + * @param {String} msg - the string to print to the console when `fn` is invoked + * @returns {Function} a new "deprecated" version of `fn` + * @api public + */ + +function deprecate (fn, msg) { + if (config('noDeprecation')) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (config('throwDeprecation')) { + throw new Error(msg); + } else if (config('traceDeprecation')) { + console.trace(msg); + } else { + console.warn(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +} + +/** + * Checks `localStorage` for boolean values for the given `name`. + * + * @param {String} name + * @returns {Boolean} + * @api private + */ + +function config (name) { + // accessing global.localStorage can trigger a DOMException in sandboxed iframes + try { + if (!global.localStorage) return false; + } catch (_) { + return false; + } + var val = global.localStorage[name]; + if (null == val) return false; + return String(val).toLowerCase() === 'true'; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],40:[function(require,module,exports){ +arguments[4][10][0].apply(exports,arguments) +},{"dup":10}],41:[function(require,module,exports){ +module.exports = function isBuffer(arg) { + return arg && typeof arg === 'object' + && typeof arg.copy === 'function' + && typeof arg.fill === 'function' + && typeof arg.readUInt8 === 'function'; +} +},{}],42:[function(require,module,exports){ +(function (process,global){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var formatRegExp = /%[sdj%]/g; +exports.format = function(f) { + if (!isString(f)) { + var objects = []; + for (var i = 0; i < arguments.length; i++) { + objects.push(inspect(arguments[i])); + } + return objects.join(' '); + } + + var i = 1; + var args = arguments; + var len = args.length; + var str = String(f).replace(formatRegExp, function(x) { + if (x === '%%') return '%'; + if (i >= len) return x; + switch (x) { + case '%s': return String(args[i++]); + case '%d': return Number(args[i++]); + case '%j': + try { + return JSON.stringify(args[i++]); + } catch (_) { + return '[Circular]'; + } + default: + return x; + } + }); + for (var x = args[i]; i < len; x = args[++i]) { + if (isNull(x) || !isObject(x)) { + str += ' ' + x; + } else { + str += ' ' + inspect(x); + } + } + return str; +}; + + +// Mark that a method should not be used. +// Returns a modified function which warns once by default. +// If --no-deprecation is set, then it is a no-op. +exports.deprecate = function(fn, msg) { + // Allow for deprecating things in the process of starting up. + if (isUndefined(global.process)) { + return function() { + return exports.deprecate(fn, msg).apply(this, arguments); + }; + } + + if (process.noDeprecation === true) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (process.throwDeprecation) { + throw new Error(msg); + } else if (process.traceDeprecation) { + console.trace(msg); + } else { + console.error(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +}; + + +var debugs = {}; +var debugEnviron; +exports.debuglog = function(set) { + if (isUndefined(debugEnviron)) + debugEnviron = process.env.NODE_DEBUG || ''; + set = set.toUpperCase(); + if (!debugs[set]) { + if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { + var pid = process.pid; + debugs[set] = function() { + var msg = exports.format.apply(exports, arguments); + console.error('%s %d: %s', set, pid, msg); + }; + } else { + debugs[set] = function() {}; + } + } + return debugs[set]; +}; + + +/** + * Echos the value of a value. Trys to print the value out + * in the best way possible given the different types. + * + * @param {Object} obj The object to print out. + * @param {Object} opts Optional options object that alters the output. + */ +/* legacy: obj, showHidden, depth, colors*/ +function inspect(obj, opts) { + // default options + var ctx = { + seen: [], + stylize: stylizeNoColor + }; + // legacy... + if (arguments.length >= 3) ctx.depth = arguments[2]; + if (arguments.length >= 4) ctx.colors = arguments[3]; + if (isBoolean(opts)) { + // legacy... + ctx.showHidden = opts; + } else if (opts) { + // got an "options" object + exports._extend(ctx, opts); + } + // set default options + if (isUndefined(ctx.showHidden)) ctx.showHidden = false; + if (isUndefined(ctx.depth)) ctx.depth = 2; + if (isUndefined(ctx.colors)) ctx.colors = false; + if (isUndefined(ctx.customInspect)) ctx.customInspect = true; + if (ctx.colors) ctx.stylize = stylizeWithColor; + return formatValue(ctx, obj, ctx.depth); +} +exports.inspect = inspect; + + +// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics +inspect.colors = { + 'bold' : [1, 22], + 'italic' : [3, 23], + 'underline' : [4, 24], + 'inverse' : [7, 27], + 'white' : [37, 39], + 'grey' : [90, 39], + 'black' : [30, 39], + 'blue' : [34, 39], + 'cyan' : [36, 39], + 'green' : [32, 39], + 'magenta' : [35, 39], + 'red' : [31, 39], + 'yellow' : [33, 39] +}; + +// Don't use 'blue' not visible on cmd.exe +inspect.styles = { + 'special': 'cyan', + 'number': 'yellow', + 'boolean': 'yellow', + 'undefined': 'grey', + 'null': 'bold', + 'string': 'green', + 'date': 'magenta', + // "name": intentionally not styling + 'regexp': 'red' +}; + + +function stylizeWithColor(str, styleType) { + var style = inspect.styles[styleType]; + + if (style) { + return '\u001b[' + inspect.colors[style][0] + 'm' + str + + '\u001b[' + inspect.colors[style][1] + 'm'; + } else { + return str; + } +} + + +function stylizeNoColor(str, styleType) { + return str; +} + + +function arrayToHash(array) { + var hash = {}; + + array.forEach(function(val, idx) { + hash[val] = true; + }); + + return hash; +} + + +function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (ctx.customInspect && + value && + isFunction(value.inspect) && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes, ctx); + if (!isString(ret)) { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } + + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + + // Look up the keys of the object. + var keys = Object.keys(value); + var visibleKeys = arrayToHash(keys); + + if (ctx.showHidden) { + keys = Object.getOwnPropertyNames(value); + } + + // IE doesn't make error fields non-enumerable + // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx + if (isError(value) + && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { + return formatError(value); + } + + // Some type of object without properties can be shortcutted. + if (keys.length === 0) { + if (isFunction(value)) { + var name = value.name ? ': ' + value.name : ''; + return ctx.stylize('[Function' + name + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } + + var base = '', array = false, braces = ['{', '}']; + + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } + + // Make functions say that they are functions + if (isFunction(value)) { + var n = value.name ? ': ' + value.name : ''; + base = ' [Function' + n + ']'; + } + + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } + + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } + + // Make error with message first say the error + if (isError(value)) { + base = ' ' + formatError(value); + } + + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } + + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } + + ctx.seen.push(value); + + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } + + ctx.seen.pop(); + + return reduceToSingleString(output, base, braces); +} + + +function formatPrimitive(ctx, value) { + if (isUndefined(value)) + return ctx.stylize('undefined', 'undefined'); + if (isString(value)) { + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + } + if (isNumber(value)) + return ctx.stylize('' + value, 'number'); + if (isBoolean(value)) + return ctx.stylize('' + value, 'boolean'); + // For some reason typeof null is "object", so special case here. + if (isNull(value)) + return ctx.stylize('null', 'null'); +} + + +function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; +} + + +function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (hasOwnProperty(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; +} + + +function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str, desc; + desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; + if (desc.get) { + if (desc.set) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (desc.set) { + str = ctx.stylize('[Setter]', 'special'); + } + } + if (!hasOwnProperty(visibleKeys, key)) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(desc.value) < 0) { + if (isNull(recurseTimes)) { + str = formatValue(ctx, desc.value, null); + } else { + str = formatValue(ctx, desc.value, recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').substr(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (isUndefined(name)) { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.substr(1, name.length - 2); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } + + return name + ': ' + str; +} + + +function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } + + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; +} + + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. +function isArray(ar) { + return Array.isArray(ar); +} +exports.isArray = isArray; + +function isBoolean(arg) { + return typeof arg === 'boolean'; +} +exports.isBoolean = isBoolean; + +function isNull(arg) { + return arg === null; +} +exports.isNull = isNull; + +function isNullOrUndefined(arg) { + return arg == null; +} +exports.isNullOrUndefined = isNullOrUndefined; + +function isNumber(arg) { + return typeof arg === 'number'; +} +exports.isNumber = isNumber; + +function isString(arg) { + return typeof arg === 'string'; +} +exports.isString = isString; + +function isSymbol(arg) { + return typeof arg === 'symbol'; +} +exports.isSymbol = isSymbol; + +function isUndefined(arg) { + return arg === void 0; +} +exports.isUndefined = isUndefined; + +function isRegExp(re) { + return isObject(re) && objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return isObject(d) && objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; + +function isError(e) { + return isObject(e) && + (objectToString(e) === '[object Error]' || e instanceof Error); +} +exports.isError = isError; + +function isFunction(arg) { + return typeof arg === 'function'; +} +exports.isFunction = isFunction; + +function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; +} +exports.isPrimitive = isPrimitive; + +exports.isBuffer = require('./support/isBuffer'); + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + + +function pad(n) { + return n < 10 ? '0' + n.toString(10) : n.toString(10); +} + + +var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', + 'Oct', 'Nov', 'Dec']; + +// 26 Feb 16:19:34 +function timestamp() { + var d = new Date(); + var time = [pad(d.getHours()), + pad(d.getMinutes()), + pad(d.getSeconds())].join(':'); + return [d.getDate(), months[d.getMonth()], time].join(' '); +} + + +// log is just a thin wrapper to console.log that prepends a timestamp +exports.log = function() { + console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); +}; + + +/** + * Inherit the prototype methods from one constructor into another. + * + * The Function.prototype.inherits from lang.js rewritten as a standalone + * function (not on Function.prototype). NOTE: If this file is to be loaded + * during bootstrapping this function needs to be rewritten using some native + * functions as prototype setup using normal JavaScript does not work as + * expected during bootstrapping (see mirror.js in r114903). + * + * @param {function} ctor Constructor function which needs to inherit the + * prototype. + * @param {function} superCtor Constructor function to inherit prototype from. + */ +exports.inherits = require('inherits'); + +exports._extend = function(origin, add) { + // Don't do anything if add isn't an object + if (!add || !isObject(add)) return origin; + + var keys = Object.keys(add); + var i = keys.length; + while (i--) { + origin[keys[i]] = add[keys[i]]; + } + return origin; +}; + +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"./support/isBuffer":41,"_process":16,"inherits":40}],43:[function(require,module,exports){ +'use strict'; + +/*eslint complexity: 0*/ + +module.exports = function equal(a, b) { + if (a === b) return true; + + var arrA = Array.isArray(a) + , arrB = Array.isArray(b) + , i; + + if (arrA && arrB) { + if (a.length != b.length) return false; + for (i = 0; i < a.length; i++) + if (!equal(a[i], b[i])) return false; + return true; + } + + if (arrA != arrB) return false; + + if (a && b && typeof a === 'object' && typeof b === 'object') { + var keys = Object.keys(a); + if (keys.length !== Object.keys(b).length) return false; + + var dateA = a instanceof Date + , dateB = b instanceof Date; + if (dateA && dateB) return a.getTime() == b.getTime(); + if (dateA != dateB) return false; + + var regexpA = a instanceof RegExp + , regexpB = b instanceof RegExp; + if (regexpA && regexpB) return a.toString() == b.toString(); + if (regexpA != regexpB) return false; + + for (i = 0; i < keys.length; i++) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + + for (i = 0; i < keys.length; i++) + if(!equal(a[keys[i]], b[keys[i]])) return false; + + return true; + } + + return false; +}; + +},{}],44:[function(require,module,exports){ +'use strict'; +module.exports = function () { + return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g; +}; + +},{}],45:[function(require,module,exports){ +'use strict'; +const colorConvert = require('color-convert'); + +const wrapAnsi16 = (fn, offset) => function () { + const code = fn.apply(colorConvert, arguments); + return `\u001B[${code + offset}m`; +}; + +const wrapAnsi256 = (fn, offset) => function () { + const code = fn.apply(colorConvert, arguments); + return `\u001B[${38 + offset};5;${code}m`; +}; + +const wrapAnsi16m = (fn, offset) => function () { + const rgb = fn.apply(colorConvert, arguments); + return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; +}; + +function assembleStyles() { + const codes = new Map(); + const styles = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29] + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + gray: [90, 39], + + // Bright color + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39] + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + + // Bright color + bgBlackBright: [100, 49], + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49] + } + }; + + // Fix humans + styles.color.grey = styles.color.gray; + + for (const groupName of Object.keys(styles)) { + const group = styles[groupName]; + + for (const styleName of Object.keys(group)) { + const style = group[styleName]; + + styles[styleName] = { + open: `\u001B[${style[0]}m`, + close: `\u001B[${style[1]}m` + }; + + group[styleName] = styles[styleName]; + + codes.set(style[0], style[1]); + } + + Object.defineProperty(styles, groupName, { + value: group, + enumerable: false + }); + + Object.defineProperty(styles, 'codes', { + value: codes, + enumerable: false + }); + } + + const rgb2rgb = (r, g, b) => [r, g, b]; + + styles.color.close = '\u001B[39m'; + styles.bgColor.close = '\u001B[49m'; + + styles.color.ansi = {}; + styles.color.ansi256 = {}; + styles.color.ansi16m = { + rgb: wrapAnsi16m(rgb2rgb, 0) + }; + + styles.bgColor.ansi = {}; + styles.bgColor.ansi256 = {}; + styles.bgColor.ansi16m = { + rgb: wrapAnsi16m(rgb2rgb, 10) + }; + + for (const key of Object.keys(colorConvert)) { + if (typeof colorConvert[key] !== 'object') { + continue; + } + + const suite = colorConvert[key]; + + if ('ansi16' in suite) { + styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0); + styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10); + } + + if ('ansi256' in suite) { + styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0); + styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10); + } + + if ('rgb' in suite) { + styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0); + styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10); + } + } + + return styles; +} + +// Make the export immutable +Object.defineProperty(module, 'exports', { + enumerable: true, + get: assembleStyles +}); + +},{"color-convert":585}],46:[function(require,module,exports){ +/*! + * arr-diff + * + * Copyright (c) 2014 Jon Schlinkert, contributors. + * Licensed under the MIT License + */ + +'use strict'; + +var flatten = require('arr-flatten'); +var slice = [].slice; + +/** + * Return the difference between the first array and + * additional arrays. + * + * ```js + * var diff = require('{%= name %}'); + * + * var a = ['a', 'b', 'c', 'd']; + * var b = ['b', 'c']; + * + * console.log(diff(a, b)) + * //=> ['a', 'd'] + * ``` + * + * @param {Array} `a` + * @param {Array} `b` + * @return {Array} + * @api public + */ + +function diff(arr, arrays) { + var argsLen = arguments.length; + var len = arr.length, i = -1; + var res = [], arrays; + + if (argsLen === 1) { + return arr; + } + + if (argsLen > 2) { + arrays = flatten(slice.call(arguments, 1)); + } + + while (++i < len) { + if (!~arrays.indexOf(arr[i])) { + res.push(arr[i]); + } + } + return res; +} + +/** + * Expose `diff` + */ + +module.exports = diff; + +},{"arr-flatten":47}],47:[function(require,module,exports){ +/*! + * arr-flatten + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +'use strict'; + +module.exports = function (arr) { + return flat(arr, []); +}; + +function flat(arr, res) { + var i = 0, cur; + var len = arr.length; + for (; i < len; i++) { + cur = arr[i]; + Array.isArray(cur) ? flat(cur, res) : res.push(cur); + } + return res; +} + +},{}],48:[function(require,module,exports){ +'use strict'; +var arrayUniq = require('array-uniq'); + +module.exports = function () { + return arrayUniq([].concat.apply([], arguments)); +}; + +},{"array-uniq":49}],49:[function(require,module,exports){ +(function (global){ +'use strict'; + +// there's 3 implementations written in increasing order of efficiency + +// 1 - no Set type is defined +function uniqNoSet(arr) { + var ret = []; + + for (var i = 0; i < arr.length; i++) { + if (ret.indexOf(arr[i]) === -1) { + ret.push(arr[i]); + } + } + + return ret; +} + +// 2 - a simple Set type is defined +function uniqSet(arr) { + var seen = new Set(); + return arr.filter(function (el) { + if (!seen.has(el)) { + seen.add(el); + return true; + } + + return false; + }); +} + +// 3 - a standard Set type is defined and it has a forEach method +function uniqSetWithForEach(arr) { + var ret = []; + + (new Set(arr)).forEach(function (el) { + ret.push(el); + }); + + return ret; +} + +// V8 currently has a broken implementation +// https://github.com/joyent/node/issues/8449 +function doesForEachActuallyWork() { + var ret = false; + + (new Set([true])).forEach(function (el) { + ret = el; + }); + + return ret === true; +} + +if ('Set' in global) { + if (typeof Set.prototype.forEach === 'function' && doesForEachActuallyWork()) { + module.exports = uniqSetWithForEach; + } else { + module.exports = uniqSet; + } +} else { + module.exports = uniqNoSet; +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],50:[function(require,module,exports){ +/*! + * array-unique + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +module.exports = function unique(arr) { + if (!Array.isArray(arr)) { + throw new TypeError('array-unique expects an array.'); + } + + var len = arr.length; + var i = -1; + + while (i++ < len) { + var j = i + 1; + + for (; j < arr.length; ++j) { + if (arr[i] === arr[j]) { + arr.splice(j--, 1); + } + } + } + return arr; +}; + +},{}],51:[function(require,module,exports){ +'use strict'; +module.exports = function (val) { + if (val === null || val === undefined) { + return []; + } + + return Array.isArray(val) ? val : [val]; +}; + +},{}],52:[function(require,module,exports){ +'use strict'; + +var unpack = require('caniuse-lite').feature; + +var browsersSort = function browsersSort(a, b) { + a = a.split(' '); + b = b.split(' '); + if (a[0] > b[0]) { + return 1; + } else if (a[0] < b[0]) { + return -1; + } else { + return Math.sign(parseFloat(a[1]) - parseFloat(b[1])); + } +}; + +// Convert Can I Use data +function f(data, opts, callback) { + data = unpack(data); + + if (!callback) { + var _ref = [opts, {}]; + callback = _ref[0]; + opts = _ref[1]; + } + + var match = opts.match || /\sx($|\s)/; + var need = []; + + for (var browser in data.stats) { + var versions = data.stats[browser]; + for (var version in versions) { + var support = versions[version]; + if (support.match(match)) { + need.push(browser + ' ' + version); + } + } + } + + callback(need.sort(browsersSort)); +} + +// Add data for all properties +var result = {}; + +var prefix = function prefix(names, data) { + for (var _iterator = names, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref2; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref2 = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref2 = _i.value; + } + + var name = _ref2; + + result[name] = Object.assign({}, data); + } +}; + +var add = function add(names, data) { + for (var _iterator2 = names, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref3; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref3 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref3 = _i2.value; + } + + var name = _ref3; + + result[name].browsers = result[name].browsers.concat(data.browsers).sort(browsersSort); + } +}; + +module.exports = result; + +// Border Radius +f(require('caniuse-lite/data/features/border-radius.js'), function (browsers) { + return prefix(['border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius'], { + mistakes: ['-khtml-', '-ms-', '-o-'], + feature: 'border-radius', + browsers: browsers + }); +}); + +// Box Shadow +f(require('caniuse-lite/data/features/css-boxshadow.js'), function (browsers) { + return prefix(['box-shadow'], { + mistakes: ['-khtml-'], + feature: 'css-boxshadow', + browsers: browsers + }); +}); + +// Animation +f(require('caniuse-lite/data/features/css-animation.js'), function (browsers) { + return prefix(['animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes'], { + mistakes: ['-khtml-', '-ms-'], + feature: 'css-animation', + browsers: browsers + }); +}); + +// Transition +f(require('caniuse-lite/data/features/css-transitions.js'), function (browsers) { + return prefix(['transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function'], { + mistakes: ['-khtml-', '-ms-'], + browsers: browsers, + feature: 'css-transitions' + }); +}); + +// Transform 2D +f(require('caniuse-lite/data/features/transforms2d.js'), function (browsers) { + return prefix(['transform', 'transform-origin'], { + feature: 'transforms2d', + browsers: browsers + }); +}); + +// Transform 3D +var transforms3d = require('caniuse-lite/data/features/transforms3d.js'); + +f(transforms3d, function (browsers) { + prefix(['perspective', 'perspective-origin'], { + feature: 'transforms3d', + browsers: browsers + }); + return prefix(['transform-style'], { + mistakes: ['-ms-', '-o-'], + browsers: browsers, + feature: 'transforms3d' + }); +}); + +f(transforms3d, { match: /y\sx|y\s#2/ }, function (browsers) { + return prefix(['backface-visibility'], { + mistakes: ['-ms-', '-o-'], + feature: 'transforms3d', + browsers: browsers + }); +}); + +// Gradients +var gradients = require('caniuse-lite/data/features/css-gradients.js'); + +f(gradients, { match: /y\sx/ }, function (browsers) { + return prefix(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], { + props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'], + mistakes: ['-ms-'], + feature: 'css-gradients', + browsers: browsers + }); +}); + +f(gradients, { match: /a\sx/ }, function (browsers) { + browsers = browsers.map(function (i) { + if (/op/.test(i)) { + return i; + } else { + return i + ' old'; + } + }); + return add(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], { + feature: 'css-gradients', + browsers: browsers + }); +}); + +// Box sizing +f(require('caniuse-lite/data/features/css3-boxsizing.js'), function (browsers) { + return prefix(['box-sizing'], { + feature: 'css3-boxsizing', + browsers: browsers + }); +}); + +// Filter Effects +f(require('caniuse-lite/data/features/css-filters.js'), function (browsers) { + return prefix(['filter'], { + feature: 'css-filters', + browsers: browsers + }); +}); + +// filter() function +f(require('caniuse-lite/data/features/css-filter-function.js'), function (browsers) { + return prefix(['filter-function'], { + props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'], + feature: 'css-filter-function', + browsers: browsers + }); +}); + +// Backdrop-filter +f(require('caniuse-lite/data/features/css-backdrop-filter.js'), function (browsers) { + return prefix(['backdrop-filter'], { + feature: 'css-backdrop-filter', + browsers: browsers + }); +}); + +// element() function +f(require('caniuse-lite/data/features/css-element-function.js'), function (browsers) { + return prefix(['element'], { + props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'], + feature: 'css-element-function', + browsers: browsers + }); +}); + +// Multicolumns +f(require('caniuse-lite/data/features/multicolumn.js'), function (browsers) { + prefix(['columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width'], { + feature: 'multicolumn', + browsers: browsers + }); + + prefix(['column-count', 'column-rule-style', 'column-span', 'column-fill', 'break-before', 'break-after', 'break-inside'], { + feature: 'multicolumn', + browsers: browsers + }); +}); + +// User select +f(require('caniuse-lite/data/features/user-select-none.js'), function (browsers) { + return prefix(['user-select'], { + mistakes: ['-khtml-'], + feature: 'user-select-none', + browsers: browsers + }); +}); + +// Flexible Box Layout +var flexbox = require('caniuse-lite/data/features/flexbox.js'); +f(flexbox, { match: /a\sx/ }, function (browsers) { + browsers = browsers.map(function (i) { + if (/ie|firefox/.test(i)) { + return i; + } else { + return i + ' 2009'; + } + }); + prefix(['display-flex', 'inline-flex'], { + props: ['display'], + feature: 'flexbox', + browsers: browsers + }); + prefix(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], { + feature: 'flexbox', + browsers: browsers + }); + prefix(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], { + feature: 'flexbox', + browsers: browsers + }); +}); + +f(flexbox, { match: /y\sx/ }, function (browsers) { + add(['display-flex', 'inline-flex'], { + feature: 'flexbox', + browsers: browsers + }); + add(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], { + feature: 'flexbox', + browsers: browsers + }); + add(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], { + feature: 'flexbox', + browsers: browsers + }); +}); + +// calc() unit +f(require('caniuse-lite/data/features/calc.js'), function (browsers) { + return prefix(['calc'], { + props: ['*'], + feature: 'calc', + browsers: browsers + }); +}); + +// Background options +f(require('caniuse-lite/data/features/background-img-opts.js'), function (browsers) { + return prefix(['background-clip', 'background-origin', 'background-size'], { + feature: 'background-img-opts', + browsers: browsers + }); +}); + +// Font feature settings +f(require('caniuse-lite/data/features/font-feature.js'), function (browsers) { + return prefix(['font-feature-settings', 'font-variant-ligatures', 'font-language-override'], { + feature: 'font-feature', + browsers: browsers + }); +}); + +// CSS font-kerning property +f(require('caniuse-lite/data/features/font-kerning.js'), function (browsers) { + return prefix(['font-kerning'], { + feature: 'font-kerning', + browsers: browsers + }); +}); + +// Border image +f(require('caniuse-lite/data/features/border-image.js'), function (browsers) { + return prefix(['border-image'], { + feature: 'border-image', + browsers: browsers + }); +}); + +// Selection selector +f(require('caniuse-lite/data/features/css-selection.js'), function (browsers) { + return prefix(['::selection'], { + selector: true, + feature: 'css-selection', + browsers: browsers + }); +}); + +// Placeholder selector +f(require('caniuse-lite/data/features/css-placeholder.js'), function (browsers) { + browsers = browsers.map(function (i) { + var _i$split = i.split(' '), + name = _i$split[0], + version = _i$split[1]; + + if (name === 'firefox' && parseFloat(version) <= 18) { + return i + ' old'; + } else { + return i; + } + }); + + prefix(['::placeholder'], { + selector: true, + feature: 'css-placeholder', + browsers: browsers + }); +}); + +// Hyphenation +f(require('caniuse-lite/data/features/css-hyphens.js'), function (browsers) { + return prefix(['hyphens'], { + feature: 'css-hyphens', + browsers: browsers + }); +}); + +// Fullscreen selector +var fullscreen = require('caniuse-lite/data/features/fullscreen.js'); + +f(fullscreen, function (browsers) { + return prefix([':fullscreen'], { + selector: true, + feature: 'fullscreen', + browsers: browsers + }); +}); + +f(fullscreen, { match: /x(\s#2|$)/ }, function (browsers) { + return prefix(['::backdrop'], { + selector: true, + feature: 'fullscreen', + browsers: browsers + }); +}); + +// Tab size +f(require('caniuse-lite/data/features/css3-tabsize.js'), function (browsers) { + return prefix(['tab-size'], { + feature: 'css3-tabsize', + browsers: browsers + }); +}); + +// Intrinsic & extrinsic sizing +f(require('caniuse-lite/data/features/intrinsic-width.js'), function (browsers) { + return prefix(['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch'], { + props: ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size', 'grid', 'grid-template', 'grid-template-rows', 'grid-template-columns', 'grid-auto-columns', 'grid-auto-rows'], + feature: 'intrinsic-width', + browsers: browsers + }); +}); + +// Zoom cursors +f(require('caniuse-lite/data/features/css3-cursors-newer.js'), function (browsers) { + return prefix(['zoom-in', 'zoom-out'], { + props: ['cursor'], + feature: 'css3-cursors-newer', + browsers: browsers + }); +}); + +// Grab cursors +f(require('caniuse-lite/data/features/css3-cursors-grab.js'), function (browsers) { + return prefix(['grab', 'grabbing'], { + props: ['cursor'], + feature: 'css3-cursors-grab', + browsers: browsers + }); +}); + +// Sticky position +f(require('caniuse-lite/data/features/css-sticky.js'), function (browsers) { + return prefix(['sticky'], { + props: ['position'], + feature: 'css-sticky', + browsers: browsers + }); +}); + +// Pointer Events +f(require('caniuse-lite/data/features/pointer.js'), function (browsers) { + return prefix(['touch-action'], { + feature: 'pointer', + browsers: browsers + }); +}); + +// Text decoration +var decoration = require('caniuse-lite/data/features/text-decoration.js'); + +f(decoration, function (browsers) { + return prefix(['text-decoration-style', 'text-decoration-color', 'text-decoration-line', 'text-decoration'], { + feature: 'text-decoration', + browsers: browsers + }); +}); + +f(decoration, { match: /x.*#[23]/ }, function (browsers) { + return prefix(['text-decoration-skip'], { + feature: 'text-decoration', + browsers: browsers + }); +}); + +// Text Size Adjust +f(require('caniuse-lite/data/features/text-size-adjust.js'), function (browsers) { + return prefix(['text-size-adjust'], { + feature: 'text-size-adjust', + browsers: browsers + }); +}); + +// CSS Masks +f(require('caniuse-lite/data/features/css-masks.js'), function (browsers) { + prefix(['mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-repeat', 'mask-border-repeat', 'mask-border-source'], { + feature: 'css-masks', + browsers: browsers + }); + prefix(['mask', 'mask-position', 'mask-size', 'mask-border', 'mask-border-outset', 'mask-border-width', 'mask-border-slice'], { + feature: 'css-masks', + browsers: browsers + }); +}); + +// CSS clip-path property +f(require('caniuse-lite/data/features/css-clip-path.js'), function (browsers) { + return prefix(['clip-path'], { + feature: 'css-clip-path', + browsers: browsers + }); +}); + +// Fragmented Borders and Backgrounds +f(require('caniuse-lite/data/features/css-boxdecorationbreak.js'), function (browsers) { + return prefix(['box-decoration-break'], { + feature: 'css-boxdecorationbreak', + browsers: browsers + }); +}); + +// CSS3 object-fit/object-position +f(require('caniuse-lite/data/features/object-fit.js'), function (browsers) { + return prefix(['object-fit', 'object-position'], { + feature: 'object-fit', + browsers: browsers + }); +}); + +// CSS Shapes +f(require('caniuse-lite/data/features/css-shapes.js'), function (browsers) { + return prefix(['shape-margin', 'shape-outside', 'shape-image-threshold'], { + feature: 'css-shapes', + browsers: browsers + }); +}); + +// CSS3 text-overflow +f(require('caniuse-lite/data/features/text-overflow.js'), function (browsers) { + return prefix(['text-overflow'], { + feature: 'text-overflow', + browsers: browsers + }); +}); + +// Viewport at-rule +f(require('caniuse-lite/data/features/css-deviceadaptation.js'), function (browsers) { + return prefix(['@viewport'], { + feature: 'css-deviceadaptation', + browsers: browsers + }); +}); + +// Resolution Media Queries +var resolut = require('caniuse-lite/data/features/css-media-resolution.js'); +f(resolut, { match: /( x($| )|a #3)/ }, function (browsers) { + return prefix(['@resolution'], { + feature: 'css-media-resolution', + browsers: browsers + }); +}); + +// CSS text-align-last +f(require('caniuse-lite/data/features/css-text-align-last.js'), function (browsers) { + return prefix(['text-align-last'], { + feature: 'css-text-align-last', + browsers: browsers + }); +}); + +// Crisp Edges Image Rendering Algorithm +var crispedges = require('caniuse-lite/data/features/css-crisp-edges.js'); + +f(crispedges, { match: /y x|a x #1/ }, function (browsers) { + return prefix(['pixelated'], { + props: ['image-rendering'], + feature: 'css-crisp-edges', + browsers: browsers + }); +}); + +f(crispedges, { match: /a x #2/ }, function (browsers) { + return prefix(['image-rendering'], { + feature: 'css-crisp-edges', + browsers: browsers + }); +}); + +// Logical Properties +var logicalProps = require('caniuse-lite/data/features/css-logical-props.js'); + +f(logicalProps, function (browsers) { + return prefix(['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end'], { + feature: 'css-logical-props', + browsers: browsers + }); +}); + +f(logicalProps, { match: /x\s#2/ }, function (browsers) { + return prefix(['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end'], { + feature: 'css-logical-props', + browsers: browsers + }); +}); + +// CSS appearance +var appearance = require('caniuse-lite/data/features/css-appearance.js'); +f(appearance, { match: /#2|x/ }, function (browsers) { + return prefix(['appearance'], { + feature: 'css-appearance', + browsers: browsers + }); +}); + +// CSS Scroll snap points +f(require('caniuse-lite/data/features/css-snappoints.js'), function (browsers) { + return prefix(['scroll-snap-type', 'scroll-snap-coordinate', 'scroll-snap-destination', 'scroll-snap-points-x', 'scroll-snap-points-y'], { + feature: 'css-snappoints', + browsers: browsers + }); +}); + +// CSS Regions +f(require('caniuse-lite/data/features/css-regions.js'), function (browsers) { + return prefix(['flow-into', 'flow-from', 'region-fragment'], { + feature: 'css-regions', + browsers: browsers + }); +}); + +// CSS image-set +f(require('caniuse-lite/data/features/css-image-set.js'), function (browsers) { + return prefix(['image-set'], { + props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'], + feature: 'css-image-set', + browsers: browsers + }); +}); + +// Writing Mode +var writingMode = require('caniuse-lite/data/features/css-writing-mode.js'); +f(writingMode, { match: /a|x/ }, function (browsers) { + return prefix(['writing-mode'], { + feature: 'css-writing-mode', + browsers: browsers + }); +}); + +// Cross-Fade Function +f(require('caniuse-lite/data/features/css-cross-fade.js'), function (browsers) { + return prefix(['cross-fade'], { + props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'], + feature: 'css-cross-fade', + browsers: browsers + }); +}); + +// Read Only selector +f(require('caniuse-lite/data/features/css-read-only-write.js'), function (browsers) { + return prefix([':read-only', ':read-write'], { + selector: true, + feature: 'css-read-only-write', + browsers: browsers + }); +}); + +// Text Emphasize +f(require('caniuse-lite/data/features/text-emphasis.js'), function (browsers) { + return prefix(['text-emphasis', 'text-emphasis-position', 'text-emphasis-style', 'text-emphasis-color'], { + feature: 'text-emphasis', + browsers: browsers + }); +}); + +// CSS Grid Layout +var grid = require('caniuse-lite/data/features/css-grid.js'); + +f(grid, function (browsers) { + prefix(['display-grid', 'inline-grid'], { + props: ['display'], + feature: 'css-grid', + browsers: browsers + }); + prefix(['grid-template-columns', 'grid-template-rows', 'grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end', 'grid-row', 'grid-column'], { + feature: 'css-grid', + browsers: browsers + }); +}); + +f(grid, { match: /a x/ }, function (browsers) { + return prefix(['grid-column-align', 'grid-row-align'], { + feature: 'css-grid', + browsers: browsers + }); +}); + +// CSS text-spacing +f(require('caniuse-lite/data/features/css-text-spacing.js'), function (browsers) { + return prefix(['text-spacing'], { + feature: 'css-text-spacing', + browsers: browsers + }); +}); + +// :any-link selector +f(require('caniuse-lite/data/features/css-any-link.js'), function (browsers) { + return prefix([':any-link'], { + selector: true, + feature: 'css-any-link', + browsers: browsers + }); +}); + +// unicode-bidi +var bidi = require('caniuse-lite/data/features/css-unicode-bidi.js'); + +f(bidi, function (browsers) { + return prefix(['isolate'], { + props: ['unicode-bidi'], + feature: 'css-unicode-bidi', + browsers: browsers + }); +}); + +f(bidi, { match: /y x|a x #2/ }, function (browsers) { + return prefix(['plaintext'], { + props: ['unicode-bidi'], + feature: 'css-unicode-bidi', + browsers: browsers + }); +}); + +f(bidi, { match: /y x/ }, function (browsers) { + return prefix(['isolate-override'], { + props: ['unicode-bidi'], + feature: 'css-unicode-bidi', + browsers: browsers + }); +}); +},{"caniuse-lite":578,"caniuse-lite/data/features/background-img-opts.js":137,"caniuse-lite/data/features/border-image.js":145,"caniuse-lite/data/features/border-radius.js":146,"caniuse-lite/data/features/calc.js":149,"caniuse-lite/data/features/css-animation.js":171,"caniuse-lite/data/features/css-any-link.js":172,"caniuse-lite/data/features/css-appearance.js":173,"caniuse-lite/data/features/css-backdrop-filter.js":176,"caniuse-lite/data/features/css-boxdecorationbreak.js":179,"caniuse-lite/data/features/css-boxshadow.js":180,"caniuse-lite/data/features/css-clip-path.js":184,"caniuse-lite/data/features/css-crisp-edges.js":188,"caniuse-lite/data/features/css-cross-fade.js":189,"caniuse-lite/data/features/css-deviceadaptation.js":192,"caniuse-lite/data/features/css-element-function.js":195,"caniuse-lite/data/features/css-filter-function.js":198,"caniuse-lite/data/features/css-filters.js":199,"caniuse-lite/data/features/css-gradients.js":207,"caniuse-lite/data/features/css-grid.js":208,"caniuse-lite/data/features/css-hyphens.js":212,"caniuse-lite/data/features/css-image-set.js":214,"caniuse-lite/data/features/css-logical-props.js":221,"caniuse-lite/data/features/css-masks.js":223,"caniuse-lite/data/features/css-media-resolution.js":226,"caniuse-lite/data/features/css-placeholder.js":240,"caniuse-lite/data/features/css-read-only-write.js":241,"caniuse-lite/data/features/css-regions.js":244,"caniuse-lite/data/features/css-selection.js":253,"caniuse-lite/data/features/css-shapes.js":254,"caniuse-lite/data/features/css-snappoints.js":255,"caniuse-lite/data/features/css-sticky.js":256,"caniuse-lite/data/features/css-text-align-last.js":259,"caniuse-lite/data/features/css-text-spacing.js":263,"caniuse-lite/data/features/css-transitions.js":267,"caniuse-lite/data/features/css-unicode-bidi.js":268,"caniuse-lite/data/features/css-writing-mode.js":272,"caniuse-lite/data/features/css3-boxsizing.js":275,"caniuse-lite/data/features/css3-cursors-grab.js":277,"caniuse-lite/data/features/css3-cursors-newer.js":278,"caniuse-lite/data/features/css3-tabsize.js":280,"caniuse-lite/data/features/flexbox.js":323,"caniuse-lite/data/features/font-feature.js":326,"caniuse-lite/data/features/font-kerning.js":327,"caniuse-lite/data/features/fullscreen.js":338,"caniuse-lite/data/features/intrinsic-width.js":387,"caniuse-lite/data/features/multicolumn.js":424,"caniuse-lite/data/features/object-fit.js":433,"caniuse-lite/data/features/pointer.js":455,"caniuse-lite/data/features/text-decoration.js":517,"caniuse-lite/data/features/text-emphasis.js":518,"caniuse-lite/data/features/text-overflow.js":519,"caniuse-lite/data/features/text-size-adjust.js":520,"caniuse-lite/data/features/transforms2d.js":529,"caniuse-lite/data/features/transforms3d.js":530,"caniuse-lite/data/features/user-select-none.js":538}],53:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Prefixer = require('./prefixer'); + +var AtRule = function (_Prefixer) { + _inherits(AtRule, _Prefixer); + + function AtRule() { + _classCallCheck(this, AtRule); + + return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments)); + } + + /** + * Clone and add prefixes for at-rule + */ + AtRule.prototype.add = function add(rule, prefix) { + var prefixed = prefix + rule.name; + + var already = rule.parent.some(function (i) { + return i.name === prefixed && i.params === rule.params; + }); + if (already) { + return undefined; + } + + var cloned = this.clone(rule, { name: prefixed }); + return rule.parent.insertBefore(rule, cloned); + }; + + /** + * Clone node with prefixes + */ + + + AtRule.prototype.process = function process(node) { + var parent = this.parentPrefix(node); + + for (var _iterator = this.prefixes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prefix = _ref; + + if (!parent || parent === prefix) { + this.add(node, prefix); + } + } + }; + + return AtRule; +}(Prefixer); + +module.exports = AtRule; +},{"./prefixer":104}],54:[function(require,module,exports){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var browserslist = require('browserslist'); +var postcss = require('postcss'); + +var Browsers = require('./browsers'); +var Prefixes = require('./prefixes'); + +function isPlainObject(obj) { + return Object.prototype.toString.apply(obj) === '[object Object]'; +} + +var cache = {}; + +function timeCapsule(result, prefixes) { + if (prefixes.browsers.selected.length === 0) { + return; + } + if (prefixes.add.selectors.length > 0) { + return; + } + if (Object.keys(prefixes.add).length > 2) { + return; + } + + result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.'); +} + +module.exports = postcss.plugin('autoprefixer', function () { + for (var _len = arguments.length, reqs = Array(_len), _key = 0; _key < _len; _key++) { + reqs[_key] = arguments[_key]; + } + + var options = void 0; + if (reqs.length === 1 && isPlainObject(reqs[0])) { + options = reqs[0]; + reqs = undefined; + } else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) { + reqs = undefined; + } else if (reqs.length <= 2 && (reqs[0] instanceof Array || !reqs[0])) { + options = reqs[1]; + reqs = reqs[0]; + } else if (_typeof(reqs[reqs.length - 1]) === 'object') { + options = reqs.pop(); + } + + if (!options) { + options = {}; + } + + if (options.browser) { + throw new Error('Change `browser` option to `browsers` in Autoprefixer'); + } + + if (options.browsers) { + reqs = options.browsers; + } + + if (typeof options.grid === 'undefined') { + options.grid = false; + } + + var loadPrefixes = function loadPrefixes(opts) { + var data = module.exports.data; + var browsers = new Browsers(data.browsers, reqs, opts, options.stats); + var key = browsers.selected.join(', ') + JSON.stringify(options); + + if (!cache[key]) { + cache[key] = new Prefixes(data.prefixes, browsers, options); + } + + return cache[key]; + }; + + var plugin = function plugin(css, result) { + var prefixes = loadPrefixes({ + from: css.source && css.source.input.file, + env: options.env + }); + timeCapsule(result, prefixes); + if (options.remove !== false) { + prefixes.processor.remove(css); + } + if (options.add !== false) { + prefixes.processor.add(css, result); + } + }; + + plugin.options = options; + + plugin.info = function (opts) { + return require('./info')(loadPrefixes(opts)); + }; + + return plugin; +}); + +/** + * Autoprefixer data + */ +module.exports.data = { + browsers: require('caniuse-lite').agents, + prefixes: require('../data/prefixes') +}; + +/** + * Autoprefixer default browsers + */ +module.exports.defaults = browserslist.defaults; + +/** + * Inspect with default Autoprefixer + */ +module.exports.info = function () { + return module.exports().info(); +}; +},{"../data/prefixes":52,"./browsers":56,"./info":101,"./prefixes":105,"browserslist":116,"caniuse-lite":578,"postcss":828}],55:[function(require,module,exports){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var last = function last(array) { + return array[array.length - 1]; +}; + +var brackets = { + + /** + * Parse string to nodes tree + */ + parse: function parse(str) { + var current = ['']; + var stack = [current]; + + for (var i = 0; i < str.length; i++) { + var sym = str[i]; + if (sym === '(') { + current = ['']; + last(stack).push(current); + stack.push(current); + } else if (sym === ')') { + stack.pop(); + current = last(stack); + current.push(''); + } else { + current[current.length - 1] += sym; + } + } + + return stack[0]; + }, + + + /** + * Generate output string by nodes tree + */ + stringify: function stringify(ast) { + var result = ''; + for (var _iterator = ast, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') { + result += '(' + brackets.stringify(i) + ')'; + } else { + result += i; + } + } + return result; + } +}; + +module.exports = brackets; +},{}],56:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var browserslist = require('browserslist'); + +var utils = require('./utils'); + +var Browsers = function () { + + /** + * Return all prefixes for default browser data + */ + Browsers.prefixes = function prefixes() { + if (this.prefixesCache) { + return this.prefixesCache; + } + + var data = require('caniuse-lite').agents; + + this.prefixesCache = []; + for (var name in data) { + this.prefixesCache.push('-' + data[name].prefix + '-'); + } + + this.prefixesCache = utils.uniq(this.prefixesCache).sort(function (a, b) { + return b.length - a.length; + }); + + return this.prefixesCache; + }; + + /** + * Check is value contain any possibe prefix + */ + + + Browsers.withPrefix = function withPrefix(value) { + if (!this.prefixesRegexp) { + this.prefixesRegexp = new RegExp(this.prefixes().join('|')); + } + + return this.prefixesRegexp.test(value); + }; + + function Browsers(data, requirements, options, stats) { + _classCallCheck(this, Browsers); + + this.data = data; + this.options = options || {}; + this.stats = stats; + this.selected = this.parse(requirements); + } + + /** + * Return browsers selected by requirements + */ + + + Browsers.prototype.parse = function parse(requirements) { + return browserslist(requirements, { + stats: this.stats, + path: this.options.from, + env: this.options.env + }); + }; + + /** + * Select major browsers versions by criteria + */ + + + Browsers.prototype.browsers = function browsers(criteria) { + var _this = this; + + var selected = []; + + var _loop = function _loop(browser) { + var data = _this.data[browser]; + var versions = criteria(data).map(function (version) { + return browser + ' ' + version; + }); + selected = selected.concat(versions); + }; + + for (var browser in this.data) { + _loop(browser); + } + return selected; + }; + + /** + * Return prefix for selected browser + */ + + + Browsers.prototype.prefix = function prefix(browser) { + var _browser$split = browser.split(' '), + name = _browser$split[0], + version = _browser$split[1]; + + var data = this.data[name]; + + var prefix = data.prefix_exceptions && data.prefix_exceptions[version]; + if (!prefix) { + prefix = data.prefix; + } + return '-' + prefix + '-'; + }; + + /** + * Is browser is selected by requirements + */ + + + Browsers.prototype.isSelected = function isSelected(browser) { + return this.selected.indexOf(browser) !== -1; + }; + + return Browsers; +}(); + +module.exports = Browsers; +},{"./utils":111,"browserslist":116,"caniuse-lite":578}],57:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Prefixer = require('./prefixer'); +var Browsers = require('./browsers'); +var utils = require('./utils'); + +var Declaration = function (_Prefixer) { + _inherits(Declaration, _Prefixer); + + function Declaration() { + _classCallCheck(this, Declaration); + + return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments)); + } + + /** + * Always true, because we already get prefixer by property name + */ + Declaration.prototype.check = function check() /* decl */{ + return true; + }; + + /** + * Return prefixed version of property + */ + + + Declaration.prototype.prefixed = function prefixed(prop, prefix) { + return prefix + prop; + }; + + /** + * Return unprefixed version of property + */ + + + Declaration.prototype.normalize = function normalize(prop) { + return prop; + }; + + /** + * Check `value`, that it contain other prefixes, rather than `prefix` + */ + + + Declaration.prototype.otherPrefixes = function otherPrefixes(value, prefix) { + for (var _iterator = Browsers.prefixes(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var other = _ref; + + if (other === prefix) { + continue; + } + if (value.indexOf(other) !== -1) { + return true; + } + } + return false; + }; + + /** + * Set prefix to declaration + */ + + + Declaration.prototype.set = function set(decl, prefix) { + decl.prop = this.prefixed(decl.prop, prefix); + return decl; + }; + + /** + * Should we use visual cascade for prefixes + */ + + + Declaration.prototype.needCascade = function needCascade(decl) { + if (!decl._autoprefixerCascade) { + decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').indexOf('\n') !== -1; + } + return decl._autoprefixerCascade; + }; + + /** + * Return maximum length of possible prefixed property + */ + + + Declaration.prototype.maxPrefixed = function maxPrefixed(prefixes, decl) { + if (decl._autoprefixerMax) { + return decl._autoprefixerMax; + } + + var max = 0; + for (var _iterator2 = prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var prefix = _ref2; + + prefix = utils.removeNote(prefix); + if (prefix.length > max) { + max = prefix.length; + } + } + decl._autoprefixerMax = max; + + return decl._autoprefixerMax; + }; + + /** + * Calculate indentation to create visual cascade + */ + + + Declaration.prototype.calcBefore = function calcBefore(prefixes, decl) { + var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ''; + + var max = this.maxPrefixed(prefixes, decl); + var diff = max - utils.removeNote(prefix).length; + + var before = decl.raw('before'); + before += Array(diff).fill(' ').join(''); + + return before; + }; + + /** + * Remove visual cascade + */ + + + Declaration.prototype.restoreBefore = function restoreBefore(decl) { + var lines = decl.raw('before').split('\n'); + var min = lines[lines.length - 1]; + + this.all.group(decl).up(function (prefixed) { + var array = prefixed.raw('before').split('\n'); + var last = array[array.length - 1]; + if (last.length < min.length) { + min = last; + } + }); + + lines[lines.length - 1] = min; + decl.raws.before = lines.join('\n'); + }; + + /** + * Clone and insert new declaration + */ + + + Declaration.prototype.insert = function insert(decl, prefix, prefixes) { + var cloned = this.set(this.clone(decl), prefix); + if (!cloned) return undefined; + + var already = decl.parent.some(function (i) { + return i.prop === cloned.prop && i.value === cloned.value; + }); + if (already) { + return undefined; + } + + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + return decl.parent.insertBefore(decl, cloned); + }; + + /** + * Did this declaration has this prefix above + */ + + + Declaration.prototype.isAlready = function isAlready(decl, prefixed) { + var already = this.all.group(decl).up(function (i) { + return i.prop === prefixed; + }); + if (!already) { + already = this.all.group(decl).down(function (i) { + return i.prop === prefixed; + }); + } + return already; + }; + + /** + * Clone and add prefixes for declaration + */ + + + Declaration.prototype.add = function add(decl, prefix, prefixes) { + var prefixed = this.prefixed(decl.prop, prefix); + if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) { + return undefined; + } + return this.insert(decl, prefix, prefixes); + }; + + /** + * Add spaces for visual cascade + */ + + + Declaration.prototype.process = function process(decl) { + if (this.needCascade(decl)) { + var prefixes = _Prefixer.prototype.process.call(this, decl); + if (prefixes && prefixes.length) { + this.restoreBefore(decl); + decl.raws.before = this.calcBefore(prefixes, decl); + } + } else { + _Prefixer.prototype.process.call(this, decl); + } + }; + + /** + * Return list of prefixed properties to clean old prefixes + */ + + + Declaration.prototype.old = function old(prop, prefix) { + return [this.prefixed(prop, prefix)]; + }; + + return Declaration; +}(Prefixer); + +module.exports = Declaration; +},{"./browsers":56,"./prefixer":104,"./utils":111}],58:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var AlignContent = function (_Declaration) { + _inherits(AlignContent, _Declaration); + + function AlignContent() { + _classCallCheck(this, AlignContent); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for 2012 spec + */ + AlignContent.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-line-pack'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + AlignContent.prototype.normalize = function normalize() { + return 'align-content'; + }; + + /** + * Change value for 2012 spec and ignore prefix for 2009 + */ + + + AlignContent.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec === 2012) { + decl.value = AlignContent.oldValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } else if (spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + return undefined; + }; + + return AlignContent; +}(Declaration); + +Object.defineProperty(AlignContent, 'names', { + enumerable: true, + writable: true, + value: ['align-content', 'flex-line-pack'] +}); +Object.defineProperty(AlignContent, 'oldValues', { + enumerable: true, + writable: true, + value: { + 'flex-end': 'end', + 'flex-start': 'start', + 'space-between': 'justify', + 'space-around': 'distribute' + } +}); + + +module.exports = AlignContent; +},{"../declaration":57,"./flex-spec":77}],59:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var AlignItems = function (_Declaration) { + _inherits(AlignItems, _Declaration); + + function AlignItems() { + _classCallCheck(this, AlignItems); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for 2009 and 2012 specs + */ + AlignItems.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-align'; + } else if (spec === 2012) { + return prefix + 'flex-align'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + AlignItems.prototype.normalize = function normalize() { + return 'align-items'; + }; + + /** + * Change value for 2009 and 2012 specs + */ + + + AlignItems.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec === 2009 || spec === 2012) { + decl.value = AlignItems.oldValues[decl.value] || decl.value; + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return AlignItems; +}(Declaration); + +Object.defineProperty(AlignItems, 'names', { + enumerable: true, + writable: true, + value: ['align-items', 'flex-align', 'box-align'] +}); +Object.defineProperty(AlignItems, 'oldValues', { + enumerable: true, + writable: true, + value: { + 'flex-end': 'end', + 'flex-start': 'start' + } +}); + + +module.exports = AlignItems; +},{"../declaration":57,"./flex-spec":77}],60:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var AlignSelf = function (_Declaration) { + _inherits(AlignSelf, _Declaration); + + function AlignSelf() { + _classCallCheck(this, AlignSelf); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for 2012 specs + */ + AlignSelf.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-item-align'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + AlignSelf.prototype.normalize = function normalize() { + return 'align-self'; + }; + + /** + * Change value for 2012 spec and ignore prefix for 2009 + */ + + + AlignSelf.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec === 2012) { + decl.value = AlignSelf.oldValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } else if (spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + return undefined; + }; + + return AlignSelf; +}(Declaration); + +Object.defineProperty(AlignSelf, 'names', { + enumerable: true, + writable: true, + value: ['align-self', 'flex-item-align'] +}); +Object.defineProperty(AlignSelf, 'oldValues', { + enumerable: true, + writable: true, + value: { + 'flex-end': 'end', + 'flex-start': 'start' + } +}); + + +module.exports = AlignSelf; +},{"../declaration":57,"./flex-spec":77}],61:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); +var utils = require('../utils'); + +var Appearance = function (_Declaration) { + _inherits(Appearance, _Declaration); + + function Appearance(name, prefixes, all) { + _classCallCheck(this, Appearance); + + var _this = _possibleConstructorReturn(this, _Declaration.call(this, name, prefixes, all)); + + if (_this.prefixes) { + _this.prefixes = utils.uniq(_this.prefixes.map(function (i) { + if (i === '-ms-') { + return '-webkit-'; + } else { + return i; + } + })); + } + return _this; + } + + return Appearance; +}(Declaration); + +Object.defineProperty(Appearance, 'names', { + enumerable: true, + writable: true, + value: ['appearance'] +}); + + +module.exports = Appearance; +},{"../declaration":57,"../utils":111}],62:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var BackgroundSize = function (_Declaration) { + _inherits(BackgroundSize, _Declaration); + + function BackgroundSize() { + _classCallCheck(this, BackgroundSize); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Duplication parameter for -webkit- browsers + */ + BackgroundSize.prototype.set = function set(decl, prefix) { + var value = decl.value.toLowerCase(); + if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') { + decl.value = decl.value + ' ' + decl.value; + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return BackgroundSize; +}(Declaration); + +Object.defineProperty(BackgroundSize, 'names', { + enumerable: true, + writable: true, + value: ['background-size'] +}); + + +module.exports = BackgroundSize; +},{"../declaration":57}],63:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var BlockLogical = function (_Declaration) { + _inherits(BlockLogical, _Declaration); + + function BlockLogical() { + _classCallCheck(this, BlockLogical); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Use old syntax for -moz- and -webkit- + */ + BlockLogical.prototype.prefixed = function prefixed(prop, prefix) { + return prefix + (prop.indexOf('-start') !== -1 ? prop.replace('-block-start', '-before') : prop.replace('-block-end', '-after')); + }; + + /** + * Return property name by spec + */ + + + BlockLogical.prototype.normalize = function normalize(prop) { + if (prop.indexOf('-before') !== -1) { + return prop.replace('-before', '-block-start'); + } else { + return prop.replace('-after', '-block-end'); + } + }; + + return BlockLogical; +}(Declaration); + +Object.defineProperty(BlockLogical, 'names', { + enumerable: true, + writable: true, + value: ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after'] +}); + + +module.exports = BlockLogical; +},{"../declaration":57}],64:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var BorderImage = function (_Declaration) { + _inherits(BorderImage, _Declaration); + + function BorderImage() { + _classCallCheck(this, BorderImage); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Remove fill parameter for prefixed declarations + */ + BorderImage.prototype.set = function set(decl, prefix) { + decl.value = decl.value.replace(/\s+fill(\s)/, '$1'); + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return BorderImage; +}(Declaration); + +Object.defineProperty(BorderImage, 'names', { + enumerable: true, + writable: true, + value: ['border-image'] +}); + + +module.exports = BorderImage; +},{"../declaration":57}],65:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var BorderRadius = function (_Declaration) { + _inherits(BorderRadius, _Declaration); + + function BorderRadius() { + _classCallCheck(this, BorderRadius); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change syntax, when add Mozilla prefix + */ + BorderRadius.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-moz-') { + return prefix + (BorderRadius.toMozilla[prop] || prop); + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return unprefixed version of property + */ + + + BorderRadius.prototype.normalize = function normalize(prop) { + return BorderRadius.toNormal[prop] || prop; + }; + + return BorderRadius; +}(Declaration); + +Object.defineProperty(BorderRadius, 'names', { + enumerable: true, + writable: true, + value: ['border-radius'] +}); +Object.defineProperty(BorderRadius, 'toMozilla', { + enumerable: true, + writable: true, + value: {} +}); +Object.defineProperty(BorderRadius, 'toNormal', { + enumerable: true, + writable: true, + value: {} +}); +var _arr = ['top', 'bottom']; + + +for (var _i = 0; _i < _arr.length; _i++) { + var ver = _arr[_i];var _arr2 = ['left', 'right']; + + for (var _i2 = 0; _i2 < _arr2.length; _i2++) { + var hor = _arr2[_i2]; + var normal = 'border-' + ver + '-' + hor + '-radius'; + var mozilla = 'border-radius-' + ver + hor; + + BorderRadius.names.push(normal); + BorderRadius.names.push(mozilla); + + BorderRadius.toMozilla[normal] = mozilla; + BorderRadius.toNormal[mozilla] = normal; + } +} + +module.exports = BorderRadius; +},{"../declaration":57}],66:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var BreakProps = function (_Declaration) { + _inherits(BreakProps, _Declaration); + + function BreakProps() { + _classCallCheck(this, BreakProps); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change name for -webkit- and -moz- prefix + */ + BreakProps.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-webkit-') { + return '-webkit-column-' + prop; + } else if (prefix === '-moz-') { + return 'page-' + prop; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + BreakProps.prototype.normalize = function normalize(prop) { + if (prop.indexOf('inside') !== -1) { + return 'break-inside'; + } else if (prop.indexOf('before') !== -1) { + return 'break-before'; + } else if (prop.indexOf('after') !== -1) { + return 'break-after'; + } + return undefined; + }; + + /** + * Change prefixed value for avoid-column and avoid-page + */ + + + BreakProps.prototype.set = function set(decl, prefix) { + var v = decl.value; + if (decl.prop === 'break-inside' && v === 'avoid-column' || v === 'avoid-page') { + decl.value = 'avoid'; + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + /** + * Don’t prefix some values + */ + + + BreakProps.prototype.insert = function insert(decl, prefix, prefixes) { + if (decl.prop !== 'break-inside') { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } else if (decl.value === 'avoid-region') { + return undefined; + } else if (decl.value === 'avoid-page' && prefix === '-webkit-') { + return undefined; + } else { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + }; + + return BreakProps; +}(Declaration); + +Object.defineProperty(BreakProps, 'names', { + enumerable: true, + writable: true, + value: ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after'] +}); + + +module.exports = BreakProps; +},{"../declaration":57}],67:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Value = require('../value'); +var list = require('postcss/lib/list'); + +var CrossFade = function (_Value) { + _inherits(CrossFade, _Value); + + function CrossFade() { + _classCallCheck(this, CrossFade); + + return _possibleConstructorReturn(this, _Value.apply(this, arguments)); + } + + CrossFade.prototype.replace = function replace(string, prefix) { + var _this2 = this; + + return list.space(string).map(function (value) { + if (value.slice(0, +_this2.name.length + 1) !== _this2.name + '(') { + return value; + } + + var close = value.lastIndexOf(')'); + var after = value.slice(close + 1); + var args = value.slice(_this2.name.length + 1, close); + + if (prefix === '-webkit-') { + var match = args.match(/\d*.?\d+%?/); + if (match) { + args = args.slice(match[0].length).trim(); + args += ', ' + match[0]; + } else { + args += ', 0.5'; + } + } + return prefix + _this2.name + '(' + args + ')' + after; + }).join(' '); + }; + + return CrossFade; +}(Value); + +Object.defineProperty(CrossFade, 'names', { + enumerable: true, + writable: true, + value: ['cross-fade'] +}); + + +module.exports = CrossFade; +},{"../value":112,"postcss/lib/list":823}],68:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var OldValue = require('../old-value'); +var Value = require('../value'); + +var DisplayFlex = function (_Value) { + _inherits(DisplayFlex, _Value); + + function DisplayFlex(name, prefixes) { + _classCallCheck(this, DisplayFlex); + + var _this = _possibleConstructorReturn(this, _Value.call(this, name, prefixes)); + + if (name === 'display-flex') { + _this.name = 'flex'; + } + return _this; + } + + /** + * Faster check for flex value + */ + + + DisplayFlex.prototype.check = function check(decl) { + return decl.prop === 'display' && decl.value === this.name; + }; + + /** + * Return value by spec + */ + + + DisplayFlex.prototype.prefixed = function prefixed(prefix) { + var spec = void 0, + value = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + + if (spec === 2009) { + if (this.name === 'flex') { + value = 'box'; + } else { + value = 'inline-box'; + } + } else if (spec === 2012) { + if (this.name === 'flex') { + value = 'flexbox'; + } else { + value = 'inline-flexbox'; + } + } else if (spec === 'final') { + value = this.name; + } + + return prefix + value; + }; + + /** + * Add prefix to value depend on flebox spec version + */ + + + DisplayFlex.prototype.replace = function replace(string, prefix) { + return this.prefixed(prefix); + }; + + /** + * Change value for old specs + */ + + + DisplayFlex.prototype.old = function old(prefix) { + var prefixed = this.prefixed(prefix); + if (prefixed) { + return new OldValue(this.name, prefixed); + } + return undefined; + }; + + return DisplayFlex; +}(Value); + +Object.defineProperty(DisplayFlex, 'names', { + enumerable: true, + writable: true, + value: ['display-flex', 'inline-flex'] +}); + + +module.exports = DisplayFlex; +},{"../old-value":103,"../value":112,"./flex-spec":77}],69:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Value = require('../value'); + +var DisplayGrid = function (_Value) { + _inherits(DisplayGrid, _Value); + + function DisplayGrid(name, prefixes) { + _classCallCheck(this, DisplayGrid); + + var _this = _possibleConstructorReturn(this, _Value.call(this, name, prefixes)); + + if (name === 'display-grid') { + _this.name = 'grid'; + } + return _this; + } + + /** + * Faster check for flex value + */ + + + DisplayGrid.prototype.check = function check(decl) { + return decl.prop === 'display' && decl.value === this.name; + }; + + return DisplayGrid; +}(Value); + +Object.defineProperty(DisplayGrid, 'names', { + enumerable: true, + writable: true, + value: ['display-grid', 'inline-grid'] +}); + + +module.exports = DisplayGrid; +},{"../value":112}],70:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var OldValue = require('../old-value'); +var Value = require('../value'); +var utils = require('../utils'); + +var OldFilterValue = function (_OldValue) { + _inherits(OldFilterValue, _OldValue); + + function OldFilterValue() { + _classCallCheck(this, OldFilterValue); + + return _possibleConstructorReturn(this, _OldValue.apply(this, arguments)); + } + + /** + * Clean -webkit-filter from properties list + */ + OldFilterValue.prototype.clean = function clean(decl) { + var _this2 = this; + + decl.value = utils.editList(decl.value, function (props) { + if (props.every(function (i) { + return i.indexOf(_this2.unprefixed) !== 0; + })) { + return props; + } + return props.filter(function (i) { + return i.indexOf(_this2.prefixed) === -1; + }); + }); + }; + + return OldFilterValue; +}(OldValue); + +var FilterValue = function (_Value) { + _inherits(FilterValue, _Value); + + function FilterValue(name, prefixes) { + _classCallCheck(this, FilterValue); + + var _this3 = _possibleConstructorReturn(this, _Value.call(this, name, prefixes)); + + if (name === 'filter-function') { + _this3.name = 'filter'; + } + return _this3; + } + + /** + * Use prefixed and unprefixed filter for WebKit + */ + + + FilterValue.prototype.replace = function replace(value, prefix) { + if (prefix === '-webkit-' && value.indexOf('filter(') === -1) { + if (value.indexOf('-webkit-filter') === -1) { + return _Value.prototype.replace.call(this, value, prefix) + ', ' + value; + } else { + return value; + } + } else { + return _Value.prototype.replace.call(this, value, prefix); + } + }; + + /** + * Clean -webkit-filter + */ + + + FilterValue.prototype.old = function old(prefix) { + return new OldFilterValue(this.name, prefix + this.name); + }; + + return FilterValue; +}(Value); + +Object.defineProperty(FilterValue, 'names', { + enumerable: true, + writable: true, + value: ['filter', 'filter-function'] +}); + + +module.exports = FilterValue; +},{"../old-value":103,"../utils":111,"../value":112}],71:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var Filter = function (_Declaration) { + _inherits(Filter, _Declaration); + + function Filter() { + _classCallCheck(this, Filter); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Check is it Internet Explorer filter + */ + Filter.prototype.check = function check(decl) { + var v = decl.value; + return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1; + }; + + return Filter; +}(Declaration); + +Object.defineProperty(Filter, 'names', { + enumerable: true, + writable: true, + value: ['filter'] +}); + + +module.exports = Filter; +},{"../declaration":57}],72:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var FlexBasis = function (_Declaration) { + _inherits(FlexBasis, _Declaration); + + function FlexBasis() { + _classCallCheck(this, FlexBasis); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Return property name by final spec + */ + FlexBasis.prototype.normalize = function normalize() { + return 'flex-basis'; + }; + + /** + * Return flex property for 2012 spec + */ + + + FlexBasis.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-preferred-size'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Ignore 2009 spec and use flex property for 2012 + */ + + + FlexBasis.prototype.set = function set(decl, prefix) { + var spec = void 0; + + var _flexSpec2 = flexSpec(prefix); + + spec = _flexSpec2[0]; + prefix = _flexSpec2[1]; + + if (spec === 2012 || spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + return undefined; + }; + + return FlexBasis; +}(Declaration); + +Object.defineProperty(FlexBasis, 'names', { + enumerable: true, + writable: true, + value: ['flex-basis', 'flex-preferred-size'] +}); + + +module.exports = FlexBasis; +},{"../declaration":57,"./flex-spec":77}],73:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var FlexDirection = function (_Declaration) { + _inherits(FlexDirection, _Declaration); + + function FlexDirection() { + _classCallCheck(this, FlexDirection); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Return property name by final spec + */ + FlexDirection.prototype.normalize = function normalize() { + return 'flex-direction'; + }; + + /** + * Use two properties for 2009 spec + */ + + + FlexDirection.prototype.insert = function insert(decl, prefix, prefixes) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec !== 2009) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } else { + var already = decl.parent.some(function (i) { + return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction'; + }); + if (already) { + return undefined; + } + + var value = decl.value; + var orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical'; + var dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal'; + + var cloned = this.clone(decl); + cloned.prop = prefix + 'box-orient'; + cloned.value = orient; + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + decl.parent.insertBefore(decl, cloned); + + cloned = this.clone(decl); + cloned.prop = prefix + 'box-direction'; + cloned.value = dir; + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + return decl.parent.insertBefore(decl, cloned); + } + }; + + /** + * Clean two properties for 2009 spec + */ + + + FlexDirection.prototype.old = function old(prop, prefix) { + var spec = void 0; + + var _flexSpec2 = flexSpec(prefix); + + spec = _flexSpec2[0]; + prefix = _flexSpec2[1]; + + if (spec === 2009) { + return [prefix + 'box-orient', prefix + 'box-direction']; + } else { + return _Declaration.prototype.old.call(this, prop, prefix); + } + }; + + return FlexDirection; +}(Declaration); + +Object.defineProperty(FlexDirection, 'names', { + enumerable: true, + writable: true, + value: ['flex-direction', 'box-direction', 'box-orient'] +}); + + +module.exports = FlexDirection; +},{"../declaration":57,"./flex-spec":77}],74:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var FlexFlow = function (_Declaration) { + _inherits(FlexFlow, _Declaration); + + function FlexFlow() { + _classCallCheck(this, FlexFlow); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Use two properties for 2009 spec + */ + FlexFlow.prototype.insert = function insert(decl, prefix, prefixes) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec !== 2009) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } else { + var values = decl.value.split(/\s+/).filter(function (i) { + return i !== 'wrap' && i !== 'nowrap' && 'wrap-reverse'; + }); + if (values.length === 0) { + return undefined; + } + + var already = decl.parent.some(function (i) { + return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction'; + }); + if (already) { + return undefined; + } + + var value = values[0]; + var orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical'; + var dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal'; + + var cloned = this.clone(decl); + cloned.prop = prefix + 'box-orient'; + cloned.value = orient; + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + decl.parent.insertBefore(decl, cloned); + + cloned = this.clone(decl); + cloned.prop = prefix + 'box-direction'; + cloned.value = dir; + if (this.needCascade(decl)) { + cloned.raws.before = this.calcBefore(prefixes, decl, prefix); + } + return decl.parent.insertBefore(decl, cloned); + } + }; + + return FlexFlow; +}(Declaration); + +Object.defineProperty(FlexFlow, 'names', { + enumerable: true, + writable: true, + value: ['flex-flow', 'box-direction', 'box-orient'] +}); + + +module.exports = FlexFlow; +},{"../declaration":57,"./flex-spec":77}],75:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var Flex = function (_Declaration) { + _inherits(Flex, _Declaration); + + function Flex() { + _classCallCheck(this, Flex); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Return property name by final spec + */ + Flex.prototype.normalize = function normalize() { + return 'flex'; + }; + + /** + * Return flex property for 2009 and 2012 specs + */ + + + Flex.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-flex'; + } else if (spec === 2012) { + return prefix + 'flex-positive'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + return Flex; +}(Declaration); + +Object.defineProperty(Flex, 'names', { + enumerable: true, + writable: true, + value: ['flex-grow', 'flex-positive'] +}); + + +module.exports = Flex; +},{"../declaration":57,"./flex-spec":77}],76:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var FlexShrink = function (_Declaration) { + _inherits(FlexShrink, _Declaration); + + function FlexShrink() { + _classCallCheck(this, FlexShrink); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Return property name by final spec + */ + FlexShrink.prototype.normalize = function normalize() { + return 'flex-shrink'; + }; + + /** + * Return flex property for 2012 spec + */ + + + FlexShrink.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2012) { + return prefix + 'flex-negative'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Ignore 2009 spec and use flex property for 2012 + */ + + + FlexShrink.prototype.set = function set(decl, prefix) { + var spec = void 0; + + var _flexSpec2 = flexSpec(prefix); + + spec = _flexSpec2[0]; + prefix = _flexSpec2[1]; + + if (spec === 2012 || spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + return undefined; + }; + + return FlexShrink; +}(Declaration); + +Object.defineProperty(FlexShrink, 'names', { + enumerable: true, + writable: true, + value: ['flex-shrink', 'flex-negative'] +}); + + +module.exports = FlexShrink; +},{"../declaration":57,"./flex-spec":77}],77:[function(require,module,exports){ +'use strict'; + +/** + * Return flexbox spec versions by prefix + */ +module.exports = function (prefix) { + var spec = void 0; + if (prefix === '-webkit- 2009' || prefix === '-moz-') { + spec = 2009; + } else if (prefix === '-ms-') { + spec = 2012; + } else if (prefix === '-webkit-') { + spec = 'final'; + } + + if (prefix === '-webkit- 2009') { + prefix = '-webkit-'; + } + + return [spec, prefix]; +}; +},{}],78:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var OldValue = require('../old-value'); +var Value = require('../value'); + +var FlexValues = function (_Value) { + _inherits(FlexValues, _Value); + + function FlexValues() { + _classCallCheck(this, FlexValues); + + return _possibleConstructorReturn(this, _Value.apply(this, arguments)); + } + + /** + * Return prefixed property name + */ + FlexValues.prototype.prefixed = function prefixed(prefix) { + return this.all.prefixed(this.name, prefix); + }; + + /** + * Change property name to prefixed property name + */ + + + FlexValues.prototype.replace = function replace(string, prefix) { + return string.replace(this.regexp(), '$1' + this.prefixed(prefix) + '$3'); + }; + + /** + * Return function to fast prefixed property name + */ + + + FlexValues.prototype.old = function old(prefix) { + return new OldValue(this.name, this.prefixed(prefix)); + }; + + return FlexValues; +}(Value); + +Object.defineProperty(FlexValues, 'names', { + enumerable: true, + writable: true, + value: ['flex', 'flex-grow', 'flex-shrink', 'flex-basis'] +}); + + +module.exports = FlexValues; +},{"../old-value":103,"../value":112}],79:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var FlexWrap = function (_Declaration) { + _inherits(FlexWrap, _Declaration); + + function FlexWrap() { + _classCallCheck(this, FlexWrap); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Don't add prefix for 2009 spec + */ + FlexWrap.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec !== 2009) { + return _Declaration.prototype.set.call(this, decl, prefix); + } + return undefined; + }; + + return FlexWrap; +}(Declaration); + +Object.defineProperty(FlexWrap, 'names', { + enumerable: true, + writable: true, + value: ['flex-wrap'] +}); + + +module.exports = FlexWrap; +},{"../declaration":57,"./flex-spec":77}],80:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var list = require('postcss/lib/list'); + +var Flex = function (_Declaration) { + _inherits(Flex, _Declaration); + + function Flex() { + _classCallCheck(this, Flex); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for 2009 spec + */ + Flex.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-flex'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + Flex.prototype.normalize = function normalize() { + return 'flex'; + }; + + /** + * Spec 2009 supports only first argument + * Spec 2012 disallows unitless basis + */ + + + Flex.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec === 2009) { + decl.value = list.space(decl.value)[0]; + decl.value = Flex.oldValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } else if (spec === 2012) { + var components = list.space(decl.value); + if (components.length === 3 && components[2] === '0') { + decl.value = components.slice(0, 2).concat('0px').join(' '); + } + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return Flex; +}(Declaration); + +Object.defineProperty(Flex, 'names', { + enumerable: true, + writable: true, + value: ['flex', 'box-flex'] +}); +Object.defineProperty(Flex, 'oldValues', { + enumerable: true, + writable: true, + value: { + auto: '1', + none: '0' + } +}); + + +module.exports = Flex; +},{"../declaration":57,"./flex-spec":77,"postcss/lib/list":823}],81:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Selector = require('../selector'); + +var Fullscreen = function (_Selector) { + _inherits(Fullscreen, _Selector); + + function Fullscreen() { + _classCallCheck(this, Fullscreen); + + return _possibleConstructorReturn(this, _Selector.apply(this, arguments)); + } + + /** + * Return different selectors depend on prefix + */ + Fullscreen.prototype.prefixed = function prefixed(prefix) { + if (prefix === '-webkit-') { + return ':-webkit-full-screen'; + } else if (prefix === '-moz-') { + return ':-moz-full-screen'; + } else { + return ':' + prefix + 'fullscreen'; + } + }; + + return Fullscreen; +}(Selector); + +Object.defineProperty(Fullscreen, 'names', { + enumerable: true, + writable: true, + value: [':fullscreen'] +}); + + +module.exports = Fullscreen; +},{"../selector":108}],82:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var OldValue = require('../old-value'); +var Value = require('../value'); +var utils = require('../utils'); + +var parser = require('postcss-value-parser'); +var range = require('normalize-range'); + +var isDirection = /top|left|right|bottom/gi; + +var Gradient = function (_Value) { + _inherits(Gradient, _Value); + + function Gradient() { + var _temp, _this, _ret; + + _classCallCheck(this, Gradient); + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Value.call.apply(_Value, [this].concat(args))), _this), Object.defineProperty(_this, 'directions', { + enumerable: true, + writable: true, + value: { + top: 'bottom', + left: 'right', + bottom: 'top', + right: 'left' + } + }), Object.defineProperty(_this, 'oldDirections', { + enumerable: true, + writable: true, + value: { + 'top': 'left bottom, left top', + 'left': 'right top, left top', + 'bottom': 'left top, left bottom', + 'right': 'left top, right top', + + 'top right': 'left bottom, right top', + 'top left': 'right bottom, left top', + 'right top': 'left bottom, right top', + 'right bottom': 'left top, right bottom', + 'bottom right': 'left top, right bottom', + 'bottom left': 'right top, left bottom', + 'left top': 'right bottom, left top', + 'left bottom': 'right top, left bottom' + } + }), _temp), _possibleConstructorReturn(_this, _ret); + } + + // Direction to replace + + + // Direction to replace + + + /** + * Change degrees for webkit prefix + */ + Gradient.prototype.replace = function replace(string, prefix) { + var ast = parser(string); + for (var _iterator = ast.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var node = _ref; + + if (node.type === 'function' && node.value === this.name) { + node.nodes = this.newDirection(node.nodes); + node.nodes = this.normalize(node.nodes); + if (prefix === '-webkit- old') { + var changes = this.oldWebkit(node); + if (!changes) { + return undefined; + } + } else { + node.nodes = this.convertDirection(node.nodes); + node.value = prefix + node.value; + } + } + } + return ast.toString(); + }; + + /** + * Replace first token + */ + + + Gradient.prototype.replaceFirst = function replaceFirst(params) { + for (var _len2 = arguments.length, words = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + words[_key2 - 1] = arguments[_key2]; + } + + var prefix = words.map(function (i) { + if (i === ' ') { + return { type: 'space', value: i }; + } else { + return { type: 'word', value: i }; + } + }); + return prefix.concat(params.slice(1)); + }; + + /** + * Convert angle unit to deg + */ + + + Gradient.prototype.normalizeUnit = function normalizeUnit(str, full) { + var num = parseFloat(str); + var deg = num / full * 360; + return deg + 'deg'; + }; + + /** + * Normalize angle + */ + + + Gradient.prototype.normalize = function normalize(nodes) { + if (!nodes[0]) { + return nodes; + } + + if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) { + nodes[0].value = this.normalizeUnit(nodes[0].value, 400); + } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) { + nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI); + } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) { + nodes[0].value = this.normalizeUnit(nodes[0].value, 1); + } else if (nodes[0].value.indexOf('deg') !== -1) { + var num = parseFloat(nodes[0].value); + num = range.wrap(0, 360, num); + nodes[0].value = num + 'deg'; + } + + if (nodes[0].value === '0deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'top'); + } else if (nodes[0].value === '90deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'right'); + } else if (nodes[0].value === '180deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom'); + } else if (nodes[0].value === '270deg') { + nodes = this.replaceFirst(nodes, 'to', ' ', 'left'); + } + + return nodes; + }; + + /** + * Replace old direction to new + */ + + + Gradient.prototype.newDirection = function newDirection(params) { + if (params[0].value === 'to') { + return params; + } + if (!isDirection.test(params[0].value)) { + return params; + } + + params.unshift({ + type: 'word', + value: 'to' + }, { + type: 'space', + value: ' ' + }); + + for (var i = 2; i < params.length; i++) { + if (params[i].type === 'div') { + break; + } + if (params[i].type === 'word') { + params[i].value = this.revertDirection(params[i].value); + } + } + + return params; + }; + + /** + * Change new direction to old + */ + + + Gradient.prototype.convertDirection = function convertDirection(params) { + if (params.length > 0) { + if (params[0].value === 'to') { + this.fixDirection(params); + } else if (params[0].value.indexOf('deg') !== -1) { + this.fixAngle(params); + } else if (params[2].value === 'at') { + this.fixRadial(params); + } + } + return params; + }; + + /** + * Replace `to top left` to `bottom right` + */ + + + Gradient.prototype.fixDirection = function fixDirection(params) { + params.splice(0, 2); + + for (var _iterator2 = params, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var param = _ref2; + + if (param.type === 'div') { + break; + } + if (param.type === 'word') { + param.value = this.revertDirection(param.value); + } + } + }; + + /** + * Add 90 degrees + */ + + + Gradient.prototype.fixAngle = function fixAngle(params) { + var first = params[0].value; + first = parseFloat(first); + first = Math.abs(450 - first) % 360; + first = this.roundFloat(first, 3); + params[0].value = first + 'deg'; + }; + + /** + * Fix radial direction syntax + */ + + + Gradient.prototype.fixRadial = function fixRadial(params) { + var first = params[0]; + var second = []; + var i = void 0; + + for (i = 4; i < params.length; i++) { + if (params[i].type === 'div') { + break; + } else { + second.push(params[i]); + } + } + + params.splice.apply(params, [0, i].concat(second, [params[i + 2], first])); + }; + + Gradient.prototype.revertDirection = function revertDirection(word) { + return this.directions[word.toLowerCase()] || word; + }; + + /** + * Round float and save digits under dot + */ + + + Gradient.prototype.roundFloat = function roundFloat(float, digits) { + return parseFloat(float.toFixed(digits)); + }; + + /** + * Convert to old webkit syntax + */ + + + Gradient.prototype.oldWebkit = function oldWebkit(node) { + var nodes = node.nodes; + + var string = parser.stringify(node.nodes); + + if (this.name !== 'linear-gradient') { + return false; + } + if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) { + return false; + } + if (string.indexOf('px') !== -1) { + return false; + } + if (string.indexOf('-corner') !== -1) { + return false; + } + if (string.indexOf('-side') !== -1) { + return false; + } + + var params = [[]]; + for (var _iterator3 = nodes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var i = _ref3; + + params[params.length - 1].push(i); + if (i.type === 'div' && i.value === ',') { + params.push([]); + } + } + + this.oldDirection(params); + this.colorStops(params); + + node.nodes = []; + for (var _iterator4 = params, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var param = _ref4; + + node.nodes = node.nodes.concat(param); + } + + node.nodes.unshift({ type: 'word', value: 'linear' }, this.cloneDiv(node.nodes)); + node.value = '-webkit-gradient'; + + return true; + }; + + /** + * Change direction syntax to old webkit + */ + + + Gradient.prototype.oldDirection = function oldDirection(params) { + var div = this.cloneDiv(params[0]); + + if (params[0][0].value !== 'to') { + return params.unshift([{ type: 'word', value: this.oldDirections.bottom }, div]); + } else { + var _words = []; + for (var _iterator5 = params[0].slice(2), _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref5 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref5 = _i5.value; + } + + var node = _ref5; + + if (node.type === 'word') { + _words.push(node.value.toLowerCase()); + } + } + + _words = _words.join(' '); + var old = this.oldDirections[_words] || _words; + + params[0] = [{ type: 'word', value: old }, div]; + return params[0]; + } + }; + + /** + * Get div token from exists parameters + */ + + + Gradient.prototype.cloneDiv = function cloneDiv(params) { + for (var _iterator6 = params, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref6 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref6 = _i6.value; + } + + var i = _ref6; + + if (i.type === 'div' && i.value === ',') { + return i; + } + } + return { type: 'div', value: ',', after: ' ' }; + }; + + /** + * Change colors syntax to old webkit + */ + + + Gradient.prototype.colorStops = function colorStops(params) { + var result = []; + for (var i = 0; i < params.length; i++) { + var pos = void 0; + var param = params[i]; + var item = void 0; + if (i === 0) { + continue; + } + + var color = parser.stringify(param[0]); + if (param[1] && param[1].type === 'word') { + pos = param[1].value; + } else if (param[2] && param[2].type === 'word') { + pos = param[2].value; + } + + var stop = void 0; + if (i === 1 && (!pos || pos === '0%')) { + stop = 'from(' + color + ')'; + } else if (i === params.length - 1 && (!pos || pos === '100%')) { + stop = 'to(' + color + ')'; + } else if (pos) { + stop = 'color-stop(' + pos + ', ' + color + ')'; + } else { + stop = 'color-stop(' + color + ')'; + } + + var div = param[param.length - 1]; + params[i] = [{ type: 'word', value: stop }]; + if (div.type === 'div' && div.value === ',') { + item = params[i].push(div); + } + result.push(item); + } + return result; + }; + + /** + * Remove old WebKit gradient too + */ + + + Gradient.prototype.old = function old(prefix) { + if (prefix === '-webkit-') { + var type = this.name === 'linear-gradient' ? 'linear' : 'radial'; + var string = '-gradient'; + var regexp = utils.regexp('-webkit-(' + type + '-gradient|gradient\\(\\s*' + type + ')', false); + + return new OldValue(this.name, prefix + this.name, string, regexp); + } else { + return _Value.prototype.old.call(this, prefix); + } + }; + + /** + * Do not add non-webkit prefixes for list-style and object + */ + + + Gradient.prototype.add = function add(decl, prefix) { + var p = decl.prop; + if (p.indexOf('mask') !== -1) { + if (prefix === '-webkit-' || prefix === '-webkit- old') { + return _Value.prototype.add.call(this, decl, prefix); + } + } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') { + if (prefix === '-webkit-' || prefix === '-webkit- old') { + return _Value.prototype.add.call(this, decl, prefix); + } + } else { + return _Value.prototype.add.call(this, decl, prefix); + } + return undefined; + }; + + return Gradient; +}(Value); + +Object.defineProperty(Gradient, 'names', { + enumerable: true, + writable: true, + value: ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'] +}); + + +module.exports = Gradient; +},{"../old-value":103,"../utils":111,"../value":112,"normalize-range":708,"postcss-value-parser":811}],83:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var GridColumnAlign = function (_Declaration) { + _inherits(GridColumnAlign, _Declaration); + + function GridColumnAlign() { + _classCallCheck(this, GridColumnAlign); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Do not prefix flexbox values + */ + GridColumnAlign.prototype.check = function check(decl) { + return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline'; + }; + + /** + * Change property name for IE + */ + + + GridColumnAlign.prototype.prefixed = function prefixed(prop, prefix) { + return prefix + 'grid-column-align'; + }; + + /** + * Change IE property back + */ + + + GridColumnAlign.prototype.normalize = function normalize() { + return 'justify-self'; + }; + + return GridColumnAlign; +}(Declaration); + +Object.defineProperty(GridColumnAlign, 'names', { + enumerable: true, + writable: true, + value: ['grid-column-align'] +}); + + +module.exports = GridColumnAlign; +},{"../declaration":57}],84:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var GridEnd = function (_Declaration) { + _inherits(GridEnd, _Declaration); + + function GridEnd() { + _classCallCheck(this, GridEnd); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Do not add prefix for unsupported value in IE + */ + GridEnd.prototype.check = function check(decl) { + return decl.value.indexOf('span') !== -1; + }; + + /** + * Return a final spec property + */ + + + GridEnd.prototype.normalize = function normalize(prop) { + return prop.replace(/(-span|-end)/, ''); + }; + + /** + * Change property name for IE + */ + + + GridEnd.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-ms-') { + return prefix + prop.replace('-end', '-span'); + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Change repeating syntax for IE + */ + + + GridEnd.prototype.set = function set(decl, prefix) { + if (prefix === '-ms-') { + decl.value = decl.value.replace(/span\s/i, ''); + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return GridEnd; +}(Declaration); + +Object.defineProperty(GridEnd, 'names', { + enumerable: true, + writable: true, + value: ['grid-row-end', 'grid-column-end', 'grid-row-span', 'grid-column-span'] +}); + + +module.exports = GridEnd; +},{"../declaration":57}],85:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var GridRowAlign = function (_Declaration) { + _inherits(GridRowAlign, _Declaration); + + function GridRowAlign() { + _classCallCheck(this, GridRowAlign); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Do not prefix flexbox values + */ + GridRowAlign.prototype.check = function check(decl) { + return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline'; + }; + + /** + * Change property name for IE + */ + + + GridRowAlign.prototype.prefixed = function prefixed(prop, prefix) { + return prefix + 'grid-row-align'; + }; + + /** + * Change IE property back + */ + + + GridRowAlign.prototype.normalize = function normalize() { + return 'align-self'; + }; + + return GridRowAlign; +}(Declaration); + +Object.defineProperty(GridRowAlign, 'names', { + enumerable: true, + writable: true, + value: ['grid-row-align'] +}); + + +module.exports = GridRowAlign; +},{"../declaration":57}],86:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var GridStart = function (_Declaration) { + _inherits(GridStart, _Declaration); + + function GridStart() { + _classCallCheck(this, GridStart); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Do not add prefix for unsupported value in IE + */ + GridStart.prototype.check = function check(decl) { + return decl.value.indexOf('/') === -1 || decl.value.indexOf('span') !== -1; + }; + + /** + * Return a final spec property + */ + + + GridStart.prototype.normalize = function normalize(prop) { + return prop.replace('-start', ''); + }; + + /** + * Change property name for IE + */ + + + GridStart.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-ms-') { + return prefix + prop.replace('-start', ''); + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Split one value to two + */ + + + GridStart.prototype.insert = function insert(decl, prefix, prefixes) { + var parts = this.splitValue(decl, prefix); + if (parts.length === 2) { + decl.cloneBefore({ + prop: '-ms-' + decl.prop + '-span', + value: parts[1] + }); + } + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + }; + + /** + * Change value for combine property + */ + + + GridStart.prototype.set = function set(decl, prefix) { + var parts = this.splitValue(decl, prefix); + if (parts.length === 2) { + decl.value = parts[0]; + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + /** + * If property contains start and end + */ + + + GridStart.prototype.splitValue = function splitValue(decl, prefix) { + if (prefix === '-ms-' && decl.prop.indexOf('-start') === -1) { + var parts = decl.value.split(/\s*\/\s*span\s+/); + if (parts.length === 2) { + return parts; + } + } + return false; + }; + + return GridStart; +}(Declaration); + +Object.defineProperty(GridStart, 'names', { + enumerable: true, + writable: true, + value: ['grid-row-start', 'grid-column-start', 'grid-row', 'grid-column'] +}); + + +module.exports = GridStart; +},{"../declaration":57}],87:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var parser = require('postcss-value-parser'); + +var Declaration = require('../declaration'); + +var GridTemplate = function (_Declaration) { + _inherits(GridTemplate, _Declaration); + + function GridTemplate() { + _classCallCheck(this, GridTemplate); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for IE + */ + GridTemplate.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-ms-') { + return prefix + prop.replace('template-', ''); + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Change IE property back + */ + + + GridTemplate.prototype.normalize = function normalize(prop) { + return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1'); + }; + + /** + * Recursive part of changeRepeat + */ + + + GridTemplate.prototype.walkRepeat = function walkRepeat(node) { + var fixed = []; + for (var _iterator = node.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + if (i.nodes) { + this.walkRepeat(i); + } + fixed.push(i); + if (i.type === 'function' && i.value === 'repeat') { + var first = i.nodes.shift(); + if (first) { + var count = first.value; + i.nodes.shift(); + i.value = ''; + fixed.push({ type: 'word', value: '[' + count + ']' }); + } + } + } + node.nodes = fixed; + }; + + /** + * IE repeating syntax + */ + + + GridTemplate.prototype.changeRepeat = function changeRepeat(value) { + var ast = parser(value); + this.walkRepeat(ast); + return ast.toString(); + }; + + /** + * Change repeating syntax for IE + */ + + + GridTemplate.prototype.set = function set(decl, prefix) { + if (prefix === '-ms-' && decl.value.indexOf('repeat(') !== -1) { + decl.value = this.changeRepeat(decl.value); + } + return _Declaration.prototype.set.call(this, decl, prefix); + }; + + return GridTemplate; +}(Declaration); + +Object.defineProperty(GridTemplate, 'names', { + enumerable: true, + writable: true, + value: ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns'] +}); + + +module.exports = GridTemplate; +},{"../declaration":57,"postcss-value-parser":811}],88:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var ImageRendering = function (_Declaration) { + _inherits(ImageRendering, _Declaration); + + function ImageRendering() { + _classCallCheck(this, ImageRendering); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Add hack only for crisp-edges + */ + ImageRendering.prototype.check = function check(decl) { + return decl.value === 'pixelated'; + }; + + /** + * Change property name for IE + */ + + + ImageRendering.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-ms-') { + return '-ms-interpolation-mode'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Change property and value for IE + */ + + + ImageRendering.prototype.set = function set(decl, prefix) { + if (prefix === '-ms-') { + decl.prop = '-ms-interpolation-mode'; + decl.value = 'nearest-neighbor'; + return decl; + } else { + return _Declaration.prototype.set.call(this, decl, prefix); + } + }; + + /** + * Return property name by spec + */ + + + ImageRendering.prototype.normalize = function normalize() { + return 'image-rendering'; + }; + + /** + * Warn on old value + */ + + + ImageRendering.prototype.process = function process(node, result) { + return _Declaration.prototype.process.call(this, node, result); + }; + + return ImageRendering; +}(Declaration); + +Object.defineProperty(ImageRendering, 'names', { + enumerable: true, + writable: true, + value: ['image-rendering', 'interpolation-mode'] +}); + + +module.exports = ImageRendering; +},{"../declaration":57}],89:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Value = require('../value'); + +var ImageSet = function (_Value) { + _inherits(ImageSet, _Value); + + function ImageSet() { + _classCallCheck(this, ImageSet); + + return _possibleConstructorReturn(this, _Value.apply(this, arguments)); + } + + /** + * Use non-standard name for WebKit and Firefox + */ + ImageSet.prototype.replace = function replace(string, prefix) { + if (prefix === '-webkit-') { + return _Value.prototype.replace.call(this, string, prefix).replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2'); + } else { + return _Value.prototype.replace.call(this, string, prefix); + } + }; + + return ImageSet; +}(Value); + +Object.defineProperty(ImageSet, 'names', { + enumerable: true, + writable: true, + value: ['image-set'] +}); + + +module.exports = ImageSet; +},{"../value":112}],90:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var InlineLogical = function (_Declaration) { + _inherits(InlineLogical, _Declaration); + + function InlineLogical() { + _classCallCheck(this, InlineLogical); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Use old syntax for -moz- and -webkit- + */ + InlineLogical.prototype.prefixed = function prefixed(prop, prefix) { + return prefix + prop.replace('-inline', ''); + }; + + /** + * Return property name by spec + */ + + + InlineLogical.prototype.normalize = function normalize(prop) { + return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2'); + }; + + return InlineLogical; +}(Declaration); + +Object.defineProperty(InlineLogical, 'names', { + enumerable: true, + writable: true, + value: ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end'] +}); + + +module.exports = InlineLogical; +},{"../declaration":57}],91:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var OldValue = require('../old-value'); +var Value = require('../value'); + +function _regexp(name) { + return new RegExp('(^|[\\s,(])(' + name + '($|[\\s),]))', 'gi'); +} + +var Intrinsic = function (_Value) { + _inherits(Intrinsic, _Value); + + function Intrinsic() { + _classCallCheck(this, Intrinsic); + + return _possibleConstructorReturn(this, _Value.apply(this, arguments)); + } + + Intrinsic.prototype.regexp = function regexp() { + if (!this.regexpCache) this.regexpCache = _regexp(this.name); + return this.regexpCache; + }; + + Intrinsic.prototype.isStretch = function isStretch() { + return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available'; + }; + + Intrinsic.prototype.replace = function replace(string, prefix) { + if (prefix === '-moz-' && this.isStretch()) { + return string.replace(this.regexp(), '$1-moz-available$3'); + } else if (prefix === '-webkit-' && this.isStretch()) { + return string.replace(this.regexp(), '$1-webkit-fill-available$3'); + } else { + return _Value.prototype.replace.call(this, string, prefix); + } + }; + + Intrinsic.prototype.old = function old(prefix) { + var prefixed = prefix + this.name; + if (this.isStretch()) { + if (prefix === '-moz-') { + prefixed = '-moz-available'; + } else if (prefix === '-webkit-') { + prefixed = '-webkit-fill-available'; + } + } + return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed)); + }; + + Intrinsic.prototype.add = function add(decl, prefix) { + if (decl.prop.indexOf('grid') !== -1 && prefix !== '-webkit-') { + return undefined; + } + return _Value.prototype.add.call(this, decl, prefix); + }; + + return Intrinsic; +}(Value); + +Object.defineProperty(Intrinsic, 'names', { + enumerable: true, + writable: true, + value: ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch'] +}); + + +module.exports = Intrinsic; +},{"../old-value":103,"../value":112}],92:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var JustifyContent = function (_Declaration) { + _inherits(JustifyContent, _Declaration); + + function JustifyContent() { + _classCallCheck(this, JustifyContent); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for 2009 and 2012 specs + */ + JustifyContent.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-pack'; + } else if (spec === 2012) { + return prefix + 'flex-pack'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + JustifyContent.prototype.normalize = function normalize() { + return 'justify-content'; + }; + + /** + * Change value for 2009 and 2012 specs + */ + + + JustifyContent.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec === 2009 || spec === 2012) { + var value = JustifyContent.oldValues[decl.value] || decl.value; + decl.value = value; + if (spec !== 2009 || value !== 'distribute') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + } else if (spec === 'final') { + return _Declaration.prototype.set.call(this, decl, prefix); + } + return undefined; + }; + + return JustifyContent; +}(Declaration); + +Object.defineProperty(JustifyContent, 'names', { + enumerable: true, + writable: true, + value: ['justify-content', 'flex-pack', 'box-pack'] +}); +Object.defineProperty(JustifyContent, 'oldValues', { + enumerable: true, + writable: true, + value: { + 'flex-end': 'end', + 'flex-start': 'start', + 'space-between': 'justify', + 'space-around': 'distribute' + } +}); + + +module.exports = JustifyContent; +},{"../declaration":57,"./flex-spec":77}],93:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var MaskBorder = function (_Declaration) { + _inherits(MaskBorder, _Declaration); + + function MaskBorder() { + _classCallCheck(this, MaskBorder); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Return property name by final spec + */ + MaskBorder.prototype.normalize = function normalize() { + return this.name.replace('box-image', 'border'); + }; + + /** + * Return flex property for 2012 spec + */ + + + MaskBorder.prototype.prefixed = function prefixed(prop, prefix) { + if (prefix === '-webkit-') { + return _Declaration.prototype.prefixed.call(this, prop, prefix).replace('border', 'box-image'); + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + return MaskBorder; +}(Declaration); + +Object.defineProperty(MaskBorder, 'names', { + enumerable: true, + writable: true, + value: ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat'] +}); + + +module.exports = MaskBorder; +},{"../declaration":57}],94:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var flexSpec = require('./flex-spec'); +var Declaration = require('../declaration'); + +var Order = function (_Declaration) { + _inherits(Order, _Declaration); + + function Order() { + _classCallCheck(this, Order); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Change property name for 2009 and 2012 specs + */ + Order.prototype.prefixed = function prefixed(prop, prefix) { + var spec = void 0; + + var _flexSpec = flexSpec(prefix); + + spec = _flexSpec[0]; + prefix = _flexSpec[1]; + + if (spec === 2009) { + return prefix + 'box-ordinal-group'; + } else if (spec === 2012) { + return prefix + 'flex-order'; + } else { + return _Declaration.prototype.prefixed.call(this, prop, prefix); + } + }; + + /** + * Return property name by final spec + */ + + + Order.prototype.normalize = function normalize() { + return 'order'; + }; + + /** + * Fix value for 2009 spec + */ + + + Order.prototype.set = function set(decl, prefix) { + var spec = flexSpec(prefix)[0]; + if (spec === 2009 && /\d/.test(decl.value)) { + decl.value = (parseInt(decl.value) + 1).toString(); + return _Declaration.prototype.set.call(this, decl, prefix); + } else { + return _Declaration.prototype.set.call(this, decl, prefix); + } + }; + + return Order; +}(Declaration); + +Object.defineProperty(Order, 'names', { + enumerable: true, + writable: true, + value: ['order', 'flex-order', 'box-ordinal-group'] +}); + + +module.exports = Order; +},{"../declaration":57,"./flex-spec":77}],95:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var OldValue = require('../old-value'); +var Value = require('../value'); + +var Pixelated = function (_Value) { + _inherits(Pixelated, _Value); + + function Pixelated() { + _classCallCheck(this, Pixelated); + + return _possibleConstructorReturn(this, _Value.apply(this, arguments)); + } + + /** + * Use non-standard name for WebKit and Firefox + */ + Pixelated.prototype.replace = function replace(string, prefix) { + if (prefix === '-webkit-') { + return string.replace(this.regexp(), '$1-webkit-optimize-contrast'); + } else if (prefix === '-moz-') { + return string.replace(this.regexp(), '$1-moz-crisp-edges'); + } else { + return _Value.prototype.replace.call(this, string, prefix); + } + }; + + /** + * Different name for WebKit and Firefox + */ + + + Pixelated.prototype.old = function old(prefix) { + if (prefix === '-webkit-') { + return new OldValue(this.name, '-webkit-optimize-contrast'); + } else if (prefix === '-moz-') { + return new OldValue(this.name, '-moz-crisp-edges'); + } else { + return _Value.prototype.old.call(this, prefix); + } + }; + + return Pixelated; +}(Value); + +Object.defineProperty(Pixelated, 'names', { + enumerable: true, + writable: true, + value: ['pixelated'] +}); + + +module.exports = Pixelated; +},{"../old-value":103,"../value":112}],96:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Selector = require('../selector'); + +var Placeholder = function (_Selector) { + _inherits(Placeholder, _Selector); + + function Placeholder() { + _classCallCheck(this, Placeholder); + + return _possibleConstructorReturn(this, _Selector.apply(this, arguments)); + } + + /** + * Add old mozilla to possible prefixes + */ + Placeholder.prototype.possible = function possible() { + return _Selector.prototype.possible.call(this).concat('-moz- old'); + }; + + /** + * Return different selectors depend on prefix + */ + + + Placeholder.prototype.prefixed = function prefixed(prefix) { + if (prefix === '-webkit-') { + return '::-webkit-input-placeholder'; + } else if (prefix === '-ms-') { + return ':-ms-input-placeholder'; + } else if (prefix === '-moz- old') { + return ':-moz-placeholder'; + } else { + return '::' + prefix + 'placeholder'; + } + }; + + return Placeholder; +}(Selector); + +Object.defineProperty(Placeholder, 'names', { + enumerable: true, + writable: true, + value: [':placeholder-shown', '::placeholder'] +}); + + +module.exports = Placeholder; +},{"../selector":108}],97:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var BASIC = ['none', 'underline', 'overline', 'line-through', 'blink', 'inherit', 'initial', 'unset']; + +var TextDecoration = function (_Declaration) { + _inherits(TextDecoration, _Declaration); + + function TextDecoration() { + _classCallCheck(this, TextDecoration); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Do not add prefixes for basic values. + */ + TextDecoration.prototype.check = function check(decl) { + return decl.value.split(/\s+/).some(function (i) { + return BASIC.indexOf(i) === -1; + }); + }; + + return TextDecoration; +}(Declaration); + +Object.defineProperty(TextDecoration, 'names', { + enumerable: true, + writable: true, + value: ['text-decoration'] +}); + + +module.exports = TextDecoration; +},{"../declaration":57}],98:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var TextEmphasisPosition = function (_Declaration) { + _inherits(TextEmphasisPosition, _Declaration); + + function TextEmphasisPosition() { + _classCallCheck(this, TextEmphasisPosition); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + TextEmphasisPosition.prototype.set = function set(decl, prefix) { + if (prefix === '-webkit-') { + decl.value = decl.value.replace(/\s*(right|left)\s*/i, ''); + return _Declaration.prototype.set.call(this, decl, prefix); + } else { + return _Declaration.prototype.set.call(this, decl, prefix); + } + }; + + return TextEmphasisPosition; +}(Declaration); + +Object.defineProperty(TextEmphasisPosition, 'names', { + enumerable: true, + writable: true, + value: ['text-emphasis-position'] +}); + + +module.exports = TextEmphasisPosition; +},{"../declaration":57}],99:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var TransformDecl = function (_Declaration) { + _inherits(TransformDecl, _Declaration); + + function TransformDecl() { + _classCallCheck(this, TransformDecl); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + /** + * Recursively check all parents for @keyframes + */ + TransformDecl.prototype.keyframeParents = function keyframeParents(decl) { + var parent = decl.parent; + + while (parent) { + if (parent.type === 'atrule' && parent.name === 'keyframes') { + return true; + } + var _parent = parent; + parent = _parent.parent; + } + return false; + }; + + /** + * Is transform caontain 3D commands + */ + + + TransformDecl.prototype.contain3d = function contain3d(decl) { + if (decl.prop === 'transform-origin') { + return false; + } + + for (var _iterator = TransformDecl.functions3d, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var func = _ref; + + if (decl.value.indexOf(func + '(') !== -1) { + return true; + } + } + + return false; + }; + + /** + * Replace rotateZ to rotate for IE 9 + */ + + + TransformDecl.prototype.set = function set(decl, prefix) { + decl = _Declaration.prototype.set.call(this, decl, prefix); + if (prefix === '-ms-') { + decl.value = decl.value.replace(/rotateZ/gi, 'rotate'); + } + return decl; + }; + + /** + * Don't add prefix for IE in keyframes + */ + + + TransformDecl.prototype.insert = function insert(decl, prefix, prefixes) { + if (prefix === '-ms-') { + if (!this.contain3d(decl) && !this.keyframeParents(decl)) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + } else if (prefix === '-o-') { + if (!this.contain3d(decl)) { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + } else { + return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); + } + return undefined; + }; + + return TransformDecl; +}(Declaration); + +Object.defineProperty(TransformDecl, 'names', { + enumerable: true, + writable: true, + value: ['transform', 'transform-origin'] +}); +Object.defineProperty(TransformDecl, 'functions3d', { + enumerable: true, + writable: true, + value: ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'perspective'] +}); + + +module.exports = TransformDecl; +},{"../declaration":57}],100:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Declaration = require('../declaration'); + +var WritingMode = function (_Declaration) { + _inherits(WritingMode, _Declaration); + + function WritingMode() { + _classCallCheck(this, WritingMode); + + return _possibleConstructorReturn(this, _Declaration.apply(this, arguments)); + } + + WritingMode.prototype.set = function set(decl, prefix) { + if (prefix === '-ms-') { + decl.value = WritingMode.msValues[decl.value] || decl.value; + return _Declaration.prototype.set.call(this, decl, prefix); + } else { + return _Declaration.prototype.set.call(this, decl, prefix); + } + }; + + return WritingMode; +}(Declaration); + +Object.defineProperty(WritingMode, 'names', { + enumerable: true, + writable: true, + value: ['writing-mode'] +}); +Object.defineProperty(WritingMode, 'msValues', { + enumerable: true, + writable: true, + value: { + 'horizontal-tb': 'lr-tb', + 'vertical-rl': 'tb-rl', + 'vertical-lr': 'tb-lr' + } +}); + + +module.exports = WritingMode; +},{"../declaration":57}],101:[function(require,module,exports){ +'use strict'; + +var browserslist = require('browserslist'); + +function capitalize(str) { + return str.slice(0, 1).toUpperCase() + str.slice(1); +} + +var names = { + ie: 'IE', + ie_mob: 'IE Mobile', + ios_saf: 'iOS', + op_mini: 'Opera Mini', + op_mob: 'Opera Mobile', + and_chr: 'Chrome for Android', + and_ff: 'Firefox for Android', + and_uc: 'UC for Android' +}; + +var prefix = function prefix(name, prefixes) { + var out = ' ' + name + ': '; + out += prefixes.map(function (i) { + return i.replace(/^-(.*)-$/g, '$1'); + }).join(', '); + out += '\n'; + return out; +}; + +module.exports = function (prefixes) { + if (prefixes.browsers.selected.length === 0) { + return 'No browsers selected'; + } + + var versions = {}; + for (var _iterator = prefixes.browsers.selected, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var browser = _ref; + + var _browser$split = browser.split(' '), + name = _browser$split[0], + version = _browser$split[1]; + + name = names[name] || capitalize(name); + if (versions[name]) { + versions[name].push(version); + } else { + versions[name] = [version]; + } + } + + var out = 'Browsers:\n'; + for (var _browser in versions) { + var list = versions[_browser]; + list = list.sort(function (a, b) { + return parseFloat(b) - parseFloat(a); + }); + out += ' ' + _browser + ': ' + list.join(', ') + '\n'; + } + + var coverage = browserslist.coverage(prefixes.browsers.selected); + var round = Math.round(coverage * 100) / 100.0; + out += '\nThese browsers account for ' + round + '% of all users globally\n'; + + var atrules = ''; + for (var name in prefixes.add) { + var data = prefixes.add[name]; + if (name[0] === '@' && data.prefixes) { + atrules += prefix(name, data.prefixes); + } + } + if (atrules !== '') { + out += '\nAt-Rules:\n' + atrules; + } + + var selectors = ''; + for (var _iterator2 = prefixes.add.selectors, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var selector = _ref2; + + if (selector.prefixes) { + selectors += prefix(selector.name, selector.prefixes); + } + } + if (selectors !== '') { + out += '\nSelectors:\n' + selectors; + } + + var values = ''; + var props = ''; + for (var _name in prefixes.add) { + var _data = prefixes.add[_name]; + if (_name[0] !== '@' && _data.prefixes) { + props += prefix(_name, _data.prefixes); + } + + if (!_data.values) { + continue; + } + for (var _iterator3 = _data.values, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var value = _ref3; + + var string = prefix(value.name, value.prefixes); + if (values.indexOf(string) === -1) { + values += string; + } + } + } + + if (props !== '') { + out += '\nProperties:\n' + props; + } + if (values !== '') { + out += '\nValues:\n' + values; + } + + if (atrules === '' && selectors === '' && props === '' && values === '') { + out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.'; + } + + return out; +}; +},{"browserslist":116}],102:[function(require,module,exports){ +"use strict"; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var OldSelector = function () { + function OldSelector(selector, prefix) { + _classCallCheck(this, OldSelector); + + this.prefix = prefix; + this.prefixed = selector.prefixed(this.prefix); + this.regexp = selector.regexp(this.prefix); + + this.prefixeds = selector.possible().map(function (x) { + return [selector.prefixed(x), selector.regexp(x)]; + }); + + this.unprefixed = selector.name; + this.nameRegexp = selector.regexp(); + } + + /** + * Is rule a hack without unprefixed version bottom + */ + + + OldSelector.prototype.isHack = function isHack(rule) { + var index = rule.parent.index(rule) + 1; + var rules = rule.parent.nodes; + + while (index < rules.length) { + var before = rules[index].selector; + if (!before) { + return true; + } + + if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) { + return false; + } + + var some = false; + for (var _iterator = this.prefixeds, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref2; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref2 = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref2 = _i.value; + } + + var _ref = _ref2; + var string = _ref[0]; + var regexp = _ref[1]; + + if (before.indexOf(string) !== -1 && before.match(regexp)) { + some = true; + break; + } + } + + if (!some) { + return true; + } + + index += 1; + } + + return true; + }; + + /** + * Does rule contain an unnecessary prefixed selector + */ + + + OldSelector.prototype.check = function check(rule) { + if (rule.selector.indexOf(this.prefixed) === -1) { + return false; + } + if (!rule.selector.match(this.regexp)) { + return false; + } + if (this.isHack(rule)) { + return false; + } + return true; + }; + + return OldSelector; +}(); + +module.exports = OldSelector; +},{}],103:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var utils = require('./utils'); + +var OldValue = function () { + function OldValue(unprefixed, prefixed, string, regexp) { + _classCallCheck(this, OldValue); + + this.unprefixed = unprefixed; + this.prefixed = prefixed; + this.string = string || prefixed; + this.regexp = regexp || utils.regexp(prefixed); + } + + /** + * Check, that value contain old value + */ + + + OldValue.prototype.check = function check(value) { + if (value.indexOf(this.string) !== -1) { + return !!value.match(this.regexp); + } + return false; + }; + + return OldValue; +}(); + +module.exports = OldValue; +},{"./utils":111}],104:[function(require,module,exports){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Browsers = require('./browsers'); +var utils = require('./utils'); + +var vendor = require('postcss/lib/vendor'); + +/** + * Recursivly clone objects + */ +function _clone(obj, parent) { + var cloned = new obj.constructor(); + + for (var _iterator = Object.keys(obj || {}), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + var value = obj[i]; + if (i === 'parent' && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') { + if (parent) { + cloned[i] = parent; + } + } else if (i === 'source') { + cloned[i] = value; + } else if (i === null) { + cloned[i] = value; + } else if (value instanceof Array) { + cloned[i] = value.map(function (x) { + return _clone(x, cloned); + }); + } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') { + if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value !== null) { + value = _clone(value, cloned); + } + cloned[i] = value; + } + } + + return cloned; +} + +var Prefixer = function () { + + /** + * Add hack to selected names + */ + Prefixer.hack = function hack(klass) { + var _this = this; + + if (!this.hacks) { + this.hacks = {}; + } + return klass.names.map(function (name) { + _this.hacks[name] = klass; + return _this.hacks[name]; + }); + }; + + /** + * Load hacks for some names + */ + + + Prefixer.load = function load(name, prefixes, all) { + var Klass = this.hacks && this.hacks[name]; + if (Klass) { + return new Klass(name, prefixes, all); + } else { + return new this(name, prefixes, all); + } + }; + + /** + * Clone node and clean autprefixer custom caches + */ + + + Prefixer.clone = function clone(node, overrides) { + var cloned = _clone(node); + for (var name in overrides) { + cloned[name] = overrides[name]; + } + return cloned; + }; + + function Prefixer(name, prefixes, all) { + _classCallCheck(this, Prefixer); + + this.name = name; + this.prefixes = prefixes; + this.all = all; + } + + /** + * Find prefix in node parents + */ + + + Prefixer.prototype.parentPrefix = function parentPrefix(node) { + var prefix = void 0; + + if (typeof node._autoprefixerPrefix !== 'undefined') { + prefix = node._autoprefixerPrefix; + } else if (node.type === 'decl' && node.prop[0] === '-') { + prefix = vendor.prefix(node.prop); + } else if (node.type === 'root') { + prefix = false; + } else if (node.type === 'rule' && node.selector.indexOf(':-') !== -1 && /:(-\w+-)/.test(node.selector)) { + prefix = node.selector.match(/:(-\w+-)/)[1]; + } else if (node.type === 'atrule' && node.name[0] === '-') { + prefix = vendor.prefix(node.name); + } else { + prefix = this.parentPrefix(node.parent); + } + + if (Browsers.prefixes().indexOf(prefix) === -1) { + prefix = false; + } + + node._autoprefixerPrefix = prefix; + + return node._autoprefixerPrefix; + }; + + /** + * Clone node with prefixes + */ + + + Prefixer.prototype.process = function process(node) { + if (!this.check(node)) { + return undefined; + } + + var parent = this.parentPrefix(node); + + var prefixes = this.prefixes.filter(function (prefix) { + return !parent || parent === utils.removeNote(prefix); + }); + + var added = []; + for (var _iterator2 = prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var prefix = _ref2; + + if (this.add(node, prefix, added.concat([prefix]))) { + added.push(prefix); + } + } + + return added; + }; + + /** + * Shortcut for Prefixer.clone + */ + + + Prefixer.prototype.clone = function clone(node, overrides) { + return Prefixer.clone(node, overrides); + }; + + return Prefixer; +}(); + +module.exports = Prefixer; +},{"./browsers":56,"./utils":111,"postcss/lib/vendor":838}],105:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Declaration = require('./declaration'); +var Resolution = require('./resolution'); +var Transition = require('./transition'); +var Processor = require('./processor'); +var Supports = require('./supports'); +var Browsers = require('./browsers'); +var Selector = require('./selector'); +var AtRule = require('./at-rule'); +var Value = require('./value'); +var utils = require('./utils'); + +var vendor = require('postcss/lib/vendor'); + +Selector.hack(require('./hacks/fullscreen')); +Selector.hack(require('./hacks/placeholder')); + +Declaration.hack(require('./hacks/flex')); +Declaration.hack(require('./hacks/order')); +Declaration.hack(require('./hacks/filter')); +Declaration.hack(require('./hacks/grid-end')); +Declaration.hack(require('./hacks/flex-flow')); +Declaration.hack(require('./hacks/flex-grow')); +Declaration.hack(require('./hacks/flex-wrap')); +Declaration.hack(require('./hacks/grid-start')); +Declaration.hack(require('./hacks/align-self')); +Declaration.hack(require('./hacks/appearance')); +Declaration.hack(require('./hacks/flex-basis')); +Declaration.hack(require('./hacks/mask-border')); +Declaration.hack(require('./hacks/align-items')); +Declaration.hack(require('./hacks/flex-shrink')); +Declaration.hack(require('./hacks/break-props')); +Declaration.hack(require('./hacks/writing-mode')); +Declaration.hack(require('./hacks/border-image')); +Declaration.hack(require('./hacks/align-content')); +Declaration.hack(require('./hacks/border-radius')); +Declaration.hack(require('./hacks/block-logical')); +Declaration.hack(require('./hacks/grid-template')); +Declaration.hack(require('./hacks/inline-logical')); +Declaration.hack(require('./hacks/grid-row-align')); +Declaration.hack(require('./hacks/transform-decl')); +Declaration.hack(require('./hacks/flex-direction')); +Declaration.hack(require('./hacks/image-rendering')); +Declaration.hack(require('./hacks/text-decoration')); +Declaration.hack(require('./hacks/justify-content')); +Declaration.hack(require('./hacks/background-size')); +Declaration.hack(require('./hacks/grid-column-align')); +Declaration.hack(require('./hacks/text-emphasis-position')); + +Value.hack(require('./hacks/gradient')); +Value.hack(require('./hacks/intrinsic')); +Value.hack(require('./hacks/pixelated')); +Value.hack(require('./hacks/image-set')); +Value.hack(require('./hacks/cross-fade')); +Value.hack(require('./hacks/flex-values')); +Value.hack(require('./hacks/display-flex')); +Value.hack(require('./hacks/display-grid')); +Value.hack(require('./hacks/filter-value')); + +var declsCache = {}; + +var Prefixes = function () { + function Prefixes(data, browsers) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + _classCallCheck(this, Prefixes); + + this.data = data; + this.browsers = browsers; + this.options = options; + + var _preprocess = this.preprocess(this.select(this.data)); + + this.add = _preprocess[0]; + this.remove = _preprocess[1]; + + this.transition = new Transition(this); + this.processor = new Processor(this); + } + + /** + * Return clone instance to remove all prefixes + */ + + + Prefixes.prototype.cleaner = function cleaner() { + if (this.cleanerCache) { + return this.cleanerCache; + } + + if (this.browsers.selected.length) { + var empty = new Browsers(this.browsers.data, []); + this.cleanerCache = new Prefixes(this.data, empty, this.options); + } else { + return this; + } + + return this.cleanerCache; + }; + + /** + * Select prefixes from data, which is necessary for selected browsers + */ + + + Prefixes.prototype.select = function select(list) { + var _this = this; + + var selected = { add: {}, remove: {} }; + + var _loop = function _loop(name) { + var data = list[name]; + var add = data.browsers.map(function (i) { + var params = i.split(' '); + return { + browser: params[0] + ' ' + params[1], + note: params[2] + }; + }); + + var notes = add.filter(function (i) { + return i.note; + }).map(function (i) { + return _this.browsers.prefix(i.browser) + ' ' + i.note; + }); + notes = utils.uniq(notes); + + add = add.filter(function (i) { + return _this.browsers.isSelected(i.browser); + }).map(function (i) { + var prefix = _this.browsers.prefix(i.browser); + if (i.note) { + return prefix + ' ' + i.note; + } else { + return prefix; + } + }); + add = _this.sort(utils.uniq(add)); + + if (_this.options.flexbox === 'no-2009') { + add = add.filter(function (i) { + return i.indexOf('2009') === -1; + }); + } + + var all = data.browsers.map(function (i) { + return _this.browsers.prefix(i); + }); + if (data.mistakes) { + all = all.concat(data.mistakes); + } + all = all.concat(notes); + all = utils.uniq(all); + + if (add.length) { + selected.add[name] = add; + if (add.length < all.length) { + selected.remove[name] = all.filter(function (i) { + return add.indexOf(i) === -1; + }); + } + } else { + selected.remove[name] = all; + } + }; + + for (var name in list) { + _loop(name); + } + + return selected; + }; + + /** + * Sort vendor prefixes + */ + + + Prefixes.prototype.sort = function sort(prefixes) { + return prefixes.sort(function (a, b) { + var aLength = utils.removeNote(a).length; + var bLength = utils.removeNote(b).length; + + if (aLength === bLength) { + return b.length - a.length; + } else { + return bLength - aLength; + } + }); + }; + + /** + * Cache prefixes data to fast CSS processing + */ + + + Prefixes.prototype.preprocess = function preprocess(selected) { + var add = { + 'selectors': [], + '@supports': new Supports(Prefixes, this) + }; + for (var name in selected.add) { + var prefixes = selected.add[name]; + if (name === '@keyframes' || name === '@viewport') { + add[name] = new AtRule(name, prefixes, this); + } else if (name === '@resolution') { + add[name] = new Resolution(name, prefixes, this); + } else if (this.data[name].selector) { + add.selectors.push(Selector.load(name, prefixes, this)); + } else { + var props = this.data[name].props; + + if (props) { + var value = Value.load(name, prefixes, this); + for (var _iterator = props, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prop = _ref; + + if (!add[prop]) { + add[prop] = { values: [] }; + } + add[prop].values.push(value); + } + } else { + var values = add[name] && add[name].values || []; + add[name] = Declaration.load(name, prefixes, this); + add[name].values = values; + } + } + } + + var remove = { selectors: [] }; + for (var _name in selected.remove) { + var _prefixes = selected.remove[_name]; + if (this.data[_name].selector) { + var selector = Selector.load(_name, _prefixes); + for (var _iterator2 = _prefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var prefix = _ref2; + + remove.selectors.push(selector.old(prefix)); + } + } else if (_name === '@keyframes' || _name === '@viewport') { + for (var _iterator3 = _prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var _prefix = _ref3; + + var prefixed = '@' + _prefix + _name.slice(1); + remove[prefixed] = { remove: true }; + } + } else if (_name === '@resolution') { + remove[_name] = new Resolution(_name, _prefixes, this); + } else { + var _props = this.data[_name].props; + if (_props) { + var _value = Value.load(_name, [], this); + for (var _iterator4 = _prefixes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var _prefix2 = _ref4; + + var old = _value.old(_prefix2); + if (old) { + for (var _iterator5 = _props, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref5 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref5 = _i5.value; + } + + var _prop = _ref5; + + if (!remove[_prop]) { + remove[_prop] = {}; + } + if (!remove[_prop].values) { + remove[_prop].values = []; + } + remove[_prop].values.push(old); + } + } + } + } else { + for (var _iterator6 = _prefixes, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref6 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref6 = _i6.value; + } + + var _prefix3 = _ref6; + + var olds = this.decl(_name).old(_name, _prefix3); + if (_name === 'align-self') { + var a = add[_name] && add[_name].prefixes; + if (a) { + if (_prefix3 === '-webkit- 2009' && a.indexOf('-webkit-') !== -1) { + continue; + } else if (_prefix3 === '-webkit-' && a.indexOf('-webkit- 2009') !== -1) { + continue; + } + } + } + for (var _iterator7 = olds, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) { + var _ref7; + + if (_isArray7) { + if (_i7 >= _iterator7.length) break; + _ref7 = _iterator7[_i7++]; + } else { + _i7 = _iterator7.next(); + if (_i7.done) break; + _ref7 = _i7.value; + } + + var _prefixed = _ref7; + + if (!remove[_prefixed]) { + remove[_prefixed] = {}; + } + remove[_prefixed].remove = true; + } + } + } + } + } + + return [add, remove]; + }; + + /** + * Declaration loader with caching + */ + + + Prefixes.prototype.decl = function decl(prop) { + var decl = declsCache[prop]; + + if (decl) { + return decl; + } else { + declsCache[prop] = Declaration.load(prop); + return declsCache[prop]; + } + }; + + /** + * Return unprefixed version of property + */ + + + Prefixes.prototype.unprefixed = function unprefixed(prop) { + var value = this.normalize(vendor.unprefixed(prop)); + if (value === 'flex-direction') { + value = 'flex-flow'; + } + return value; + }; + + /** + * Normalize prefix for remover + */ + + + Prefixes.prototype.normalize = function normalize(prop) { + return this.decl(prop).normalize(prop); + }; + + /** + * Return prefixed version of property + */ + + + Prefixes.prototype.prefixed = function prefixed(prop, prefix) { + prop = vendor.unprefixed(prop); + return this.decl(prop).prefixed(prop, prefix); + }; + + /** + * Return values, which must be prefixed in selected property + */ + + + Prefixes.prototype.values = function values(type, prop) { + var data = this[type]; + + var global = data['*'] && data['*'].values; + var values = data[prop] && data[prop].values; + + if (global && values) { + return utils.uniq(global.concat(values)); + } else { + return global || values || []; + } + }; + + /** + * Group declaration by unprefixed property to check them + */ + + + Prefixes.prototype.group = function group(decl) { + var _this2 = this; + + var rule = decl.parent; + var index = rule.index(decl); + var length = rule.nodes.length; + + var unprefixed = this.unprefixed(decl.prop); + + var checker = function checker(step, callback) { + index += step; + while (index >= 0 && index < length) { + var other = rule.nodes[index]; + if (other.type === 'decl') { + + if (step === -1 && other.prop === unprefixed) { + if (!Browsers.withPrefix(other.value)) { + break; + } + } + + if (_this2.unprefixed(other.prop) !== unprefixed) { + break; + } else if (callback(other) === true) { + return true; + } + + if (step === +1 && other.prop === unprefixed) { + if (!Browsers.withPrefix(other.value)) { + break; + } + } + } + + index += step; + } + return false; + }; + + return { + up: function up(callback) { + return checker(-1, callback); + }, + down: function down(callback) { + return checker(+1, callback); + } + }; + }; + + return Prefixes; +}(); + +module.exports = Prefixes; +},{"./at-rule":53,"./browsers":56,"./declaration":57,"./hacks/align-content":58,"./hacks/align-items":59,"./hacks/align-self":60,"./hacks/appearance":61,"./hacks/background-size":62,"./hacks/block-logical":63,"./hacks/border-image":64,"./hacks/border-radius":65,"./hacks/break-props":66,"./hacks/cross-fade":67,"./hacks/display-flex":68,"./hacks/display-grid":69,"./hacks/filter":71,"./hacks/filter-value":70,"./hacks/flex":80,"./hacks/flex-basis":72,"./hacks/flex-direction":73,"./hacks/flex-flow":74,"./hacks/flex-grow":75,"./hacks/flex-shrink":76,"./hacks/flex-values":78,"./hacks/flex-wrap":79,"./hacks/fullscreen":81,"./hacks/gradient":82,"./hacks/grid-column-align":83,"./hacks/grid-end":84,"./hacks/grid-row-align":85,"./hacks/grid-start":86,"./hacks/grid-template":87,"./hacks/image-rendering":88,"./hacks/image-set":89,"./hacks/inline-logical":90,"./hacks/intrinsic":91,"./hacks/justify-content":92,"./hacks/mask-border":93,"./hacks/order":94,"./hacks/pixelated":95,"./hacks/placeholder":96,"./hacks/text-decoration":97,"./hacks/text-emphasis-position":98,"./hacks/transform-decl":99,"./hacks/writing-mode":100,"./processor":106,"./resolution":107,"./selector":108,"./supports":109,"./transition":110,"./utils":111,"./value":112,"postcss/lib/vendor":838}],106:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Value = require('./value'); + +var OLD_DIRECTION = /(^|[^-])(linear|radial)-gradient\(\s*(top|left|right|bottom)/i; + +var SIZES = ['width', 'height', 'min-width', 'max-width', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size']; + +var Processor = function () { + function Processor(prefixes) { + _classCallCheck(this, Processor); + + this.prefixes = prefixes; + } + + /** + * Add necessary prefixes + */ + + + Processor.prototype.add = function add(css, result) { + var _this = this; + + // At-rules + var resolution = this.prefixes.add['@resolution']; + var keyframes = this.prefixes.add['@keyframes']; + var viewport = this.prefixes.add['@viewport']; + var supports = this.prefixes.add['@supports']; + + css.walkAtRules(function (rule) { + if (rule.name === 'keyframes') { + if (!_this.disabled(rule)) { + return keyframes && keyframes.process(rule); + } + } else if (rule.name === 'viewport') { + if (!_this.disabled(rule)) { + return viewport && viewport.process(rule); + } + } else if (rule.name === 'supports') { + if (_this.prefixes.options.supports !== false && !_this.disabled(rule)) { + return supports.process(rule); + } + } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1) { + if (!_this.disabled(rule)) { + return resolution && resolution.process(rule); + } + } + + return undefined; + }); + + // Selectors + css.walkRules(function (rule) { + if (_this.disabled(rule)) return undefined; + + return _this.prefixes.add.selectors.map(function (selector) { + return selector.process(rule, result); + }); + }); + + css.walkDecls(function (decl) { + if (_this.disabledDecl(decl)) return undefined; + + if (decl.prop === 'display' && decl.value === 'box') { + result.warn('You should write display: flex by final spec ' + 'instead of display: box', { node: decl }); + return undefined; + } + if (decl.value.indexOf('linear-gradient') !== -1) { + if (OLD_DIRECTION.test(decl.value)) { + result.warn('Gradient has outdated direction syntax. ' + 'New syntax is like `to left` instead of `right`.', { node: decl }); + } + } + if (decl.prop === 'text-emphasis-position') { + if (decl.value === 'under' || decl.value === 'over') { + result.warn('You should use 2 values for text-emphasis-position ' + 'For example, `under left` instead of just `under`.', { node: decl }); + } + } + + if (SIZES.indexOf(decl.prop) !== -1) { + if (decl.value.indexOf('fill-available') !== -1) { + result.warn('Replace fill-available to stretch, ' + 'because spec had been changed', { node: decl }); + } else if (decl.value.indexOf('fill') !== -1) { + result.warn('Replace fill to stretch, ' + 'because spec had been changed', { node: decl }); + } + } + + if (_this.prefixes.options.flexbox !== false) { + if (decl.prop === 'grid-row-end' && decl.value.indexOf('span') === -1) { + result.warn('IE supports only grid-row-end with span. ' + 'You should add grid: false option to Autoprefixer ' + 'and use some JS grid polyfill for full spec support', { node: decl }); + } + if (decl.prop === 'grid-row') { + if (decl.value.indexOf('/') !== -1 && decl.value.indexOf('span') === -1) { + result.warn('IE supports only grid-row with / and span. ' + 'You should add grid: false option ' + 'to Autoprefixer and use some JS grid polyfill ' + 'for full spec support', { node: decl }); + } + } + } + + var prefixer = void 0; + + if (decl.prop === 'transition' || decl.prop === 'transition-property') { + // Transition + return _this.prefixes.transition.add(decl, result); + } else if (decl.prop === 'align-self') { + // align-self flexbox or grid + var display = _this.displayType(decl); + if (display !== 'grid' && _this.prefixes.options.flexbox !== false) { + prefixer = _this.prefixes.add['align-self']; + if (prefixer && prefixer.prefixes) { + prefixer.process(decl); + } + } + if (display !== 'flex' && _this.prefixes.options.grid !== false) { + prefixer = _this.prefixes.add['grid-row-align']; + if (prefixer && prefixer.prefixes) { + return prefixer.process(decl); + } + } + } else if (decl.prop === 'justify-self') { + // justify-self flexbox or grid + var _display = _this.displayType(decl); + if (_display !== 'flex' && _this.prefixes.options.grid !== false) { + prefixer = _this.prefixes.add['grid-column-align']; + if (prefixer && prefixer.prefixes) { + return prefixer.process(decl); + } + } + } else { + // Properties + prefixer = _this.prefixes.add[decl.prop]; + if (prefixer && prefixer.prefixes) { + return prefixer.process(decl); + } + } + + return undefined; + }); + + // Values + return css.walkDecls(function (decl) { + if (_this.disabledValue(decl)) return; + + var unprefixed = _this.prefixes.unprefixed(decl.prop); + for (var _iterator = _this.prefixes.values('add', unprefixed), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var value = _ref; + + value.process(decl, result); + } + Value.save(_this.prefixes, decl); + }); + }; + + /** + * Remove unnecessary pefixes + */ + + + Processor.prototype.remove = function remove(css) { + var _this2 = this; + + // At-rules + var resolution = this.prefixes.remove['@resolution']; + + css.walkAtRules(function (rule, i) { + if (_this2.prefixes.remove['@' + rule.name]) { + if (!_this2.disabled(rule)) { + rule.parent.removeChild(i); + } + } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1 && resolution) { + resolution.clean(rule); + } + }); + + // Selectors + + var _loop = function _loop(checker) { + css.walkRules(function (rule, i) { + if (checker.check(rule)) { + if (!_this2.disabled(rule)) { + rule.parent.removeChild(i); + } + } + }); + }; + + for (var _iterator2 = this.prefixes.remove.selectors, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var checker = _ref2; + + _loop(checker); + } + + return css.walkDecls(function (decl, i) { + if (_this2.disabled(decl)) return; + + var rule = decl.parent; + var unprefixed = _this2.prefixes.unprefixed(decl.prop); + + // Transition + if (decl.prop === 'transition' || decl.prop === 'transition-property') { + _this2.prefixes.transition.remove(decl); + } + + // Properties + if (_this2.prefixes.remove[decl.prop] && _this2.prefixes.remove[decl.prop].remove) { + var notHack = _this2.prefixes.group(decl).down(function (other) { + return _this2.prefixes.normalize(other.prop) === unprefixed; + }); + + if (unprefixed === 'flex-flow') { + notHack = true; + } + + if (notHack && !_this2.withHackValue(decl)) { + if (decl.raw('before').indexOf('\n') > -1) { + _this2.reduceSpaces(decl); + } + rule.removeChild(i); + return; + } + } + + // Values + for (var _iterator3 = _this2.prefixes.values('remove', unprefixed), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var checker = _ref3; + + if (checker.check(decl.value)) { + unprefixed = checker.unprefixed; + var _notHack = _this2.prefixes.group(decl).down(function (other) { + return other.value.indexOf(unprefixed) !== -1; + }); + + if (_notHack) { + rule.removeChild(i); + return; + } else if (checker.clean) { + checker.clean(decl); + return; + } + } + } + }); + }; + + /** + * Some rare old values, which is not in standard + */ + + + Processor.prototype.withHackValue = function withHackValue(decl) { + return decl.prop === '-webkit-background-clip' && decl.value === 'text'; + }; + + /** + * Check for grid/flexbox options. + */ + + + Processor.prototype.disabledValue = function disabledValue(node) { + if (this.prefixes.options.grid === false && node.type === 'decl') { + if (node.prop === 'display' && node.value.indexOf('grid') !== -1) { + return true; + } + } + if (this.prefixes.options.flexbox === false && node.type === 'decl') { + if (node.prop === 'display' && node.value.indexOf('flex') !== -1) { + return true; + } + } + + return this.disabled(node); + }; + + /** + * Check for grid/flexbox options. + */ + + + Processor.prototype.disabledDecl = function disabledDecl(node) { + if (this.prefixes.options.grid === false && node.type === 'decl') { + if (node.prop.indexOf('grid') !== -1 || node.prop === 'justify-items') { + return true; + } + } + if (this.prefixes.options.flexbox === false && node.type === 'decl') { + var other = ['order', 'justify-content', 'align-items', 'align-content']; + if (node.prop.indexOf('flex') !== -1 || other.indexOf(node.prop) !== -1) { + return true; + } + } + + return this.disabled(node); + }; + + /** + * Check for control comment and global options + */ + + + Processor.prototype.disabled = function disabled(node) { + if (node._autoprefixerDisabled !== undefined) { + return node._autoprefixerDisabled; + } else if (node.nodes) { + var status = undefined; + node.each(function (i) { + if (i.type !== 'comment') { + return undefined; + } + if (/(!\s*)?autoprefixer:\s*off/i.test(i.text)) { + status = false; + return false; + } else if (/(!\s*)?autoprefixer:\s*on/i.test(i.text)) { + status = true; + return false; + } + return undefined; + }); + + var result = false; + if (status !== undefined) { + result = !status; + } else if (node.parent) { + result = this.disabled(node.parent); + } + + node._autoprefixerDisabled = result; + return node._autoprefixerDisabled; + } else if (node.parent) { + node._autoprefixerDisabled = this.disabled(node.parent); + return node._autoprefixerDisabled; + } else { + // unknown state + return false; + } + }; + + /** + * Normalize spaces in cascade declaration group + */ + + + Processor.prototype.reduceSpaces = function reduceSpaces(decl) { + var stop = false; + this.prefixes.group(decl).up(function () { + stop = true; + return true; + }); + if (stop) { + return; + } + + var parts = decl.raw('before').split('\n'); + var prevMin = parts[parts.length - 1].length; + var diff = false; + + this.prefixes.group(decl).down(function (other) { + parts = other.raw('before').split('\n'); + var last = parts.length - 1; + + if (parts[last].length > prevMin) { + if (diff === false) { + diff = parts[last].length - prevMin; + } + + parts[last] = parts[last].slice(0, -diff); + other.raws.before = parts.join('\n'); + } + }); + }; + + /** + * Is it flebox or grid rule + */ + + + Processor.prototype.displayType = function displayType(decl) { + for (var _iterator4 = decl.parent.nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var i = _ref4; + + if (i.prop === 'display') { + if (i.value.indexOf('flex') !== -1) { + return 'flex'; + } else if (i.value.indexOf('grid') !== -1) { + return 'grid'; + } + } + } + return false; + }; + + return Processor; +}(); + +module.exports = Processor; +},{"./value":112}],107:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Prefixer = require('./prefixer'); +var utils = require('./utils'); + +var n2f = require('num2fraction'); + +var regexp = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi)/gi; +var split = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi)/i; + +var Resolution = function (_Prefixer) { + _inherits(Resolution, _Prefixer); + + function Resolution() { + _classCallCheck(this, Resolution); + + return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments)); + } + + /** + * Return prefixed query name + */ + Resolution.prototype.prefixName = function prefixName(prefix, name) { + var newName = prefix === '-moz-' ? name + '--moz-device-pixel-ratio' : prefix + name + '-device-pixel-ratio'; + return newName; + }; + + /** + * Return prefixed query + */ + + + Resolution.prototype.prefixQuery = function prefixQuery(prefix, name, colon, value, units) { + if (units === 'dpi') { + value = Number(value / 96); + } + if (prefix === '-o-') { + value = n2f(value); + } + return this.prefixName(prefix, name) + colon + value; + }; + + /** + * Remove prefixed queries + */ + + + Resolution.prototype.clean = function clean(rule) { + var _this2 = this; + + if (!this.bad) { + this.bad = []; + for (var _iterator = this.prefixes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prefix = _ref; + + this.bad.push(this.prefixName(prefix, 'min')); + this.bad.push(this.prefixName(prefix, 'max')); + } + } + + rule.params = utils.editList(rule.params, function (queries) { + return queries.filter(function (query) { + return _this2.bad.every(function (i) { + return query.indexOf(i) === -1; + }); + }); + }); + }; + + /** + * Add prefixed queries + */ + + + Resolution.prototype.process = function process(rule) { + var _this3 = this; + + var parent = this.parentPrefix(rule); + var prefixes = parent ? [parent] : this.prefixes; + + rule.params = utils.editList(rule.params, function (origin, prefixed) { + for (var _iterator2 = origin, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var query = _ref2; + + if (query.indexOf('min-resolution') === -1 && query.indexOf('max-resolution') === -1) { + prefixed.push(query); + continue; + } + + var _loop = function _loop(prefix) { + if (prefix === '-moz-' && rule.params.indexOf('dpi') !== -1) { + return 'continue'; + } else { + var processed = query.replace(regexp, function (str) { + var parts = str.match(split); + return _this3.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]); + }); + prefixed.push(processed); + } + }; + + for (var _iterator3 = prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var prefix = _ref3; + + var _ret = _loop(prefix); + + if (_ret === 'continue') continue; + } + prefixed.push(query); + } + + return utils.uniq(prefixed); + }); + }; + + return Resolution; +}(Prefixer); + +module.exports = Resolution; +},{"./prefixer":104,"./utils":111,"num2fraction":710}],108:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var OldSelector = require('./old-selector'); +var Prefixer = require('./prefixer'); +var Browsers = require('./browsers'); +var utils = require('./utils'); + +var Selector = function (_Prefixer) { + _inherits(Selector, _Prefixer); + + function Selector(name, prefixes, all) { + _classCallCheck(this, Selector); + + var _this = _possibleConstructorReturn(this, _Prefixer.call(this, name, prefixes, all)); + + _this.regexpCache = {}; + return _this; + } + + /** + * Is rule selectors need to be prefixed + */ + + + Selector.prototype.check = function check(rule) { + if (rule.selector.indexOf(this.name) !== -1) { + return !!rule.selector.match(this.regexp()); + } else { + return false; + } + }; + + /** + * Return prefixed version of selector + */ + + + Selector.prototype.prefixed = function prefixed(prefix) { + return this.name.replace(/^([^\w]*)/, '$1' + prefix); + }; + + /** + * Lazy loadRegExp for name + */ + + + Selector.prototype.regexp = function regexp(prefix) { + if (this.regexpCache[prefix]) { + return this.regexpCache[prefix]; + } + + var name = prefix ? this.prefixed(prefix) : this.name; + this.regexpCache[prefix] = new RegExp('(^|[^:"\'=])' + utils.escapeRegexp(name), 'gi'); + return this.regexpCache[prefix]; + }; + + /** + * All possible prefixes + */ + + + Selector.prototype.possible = function possible() { + return Browsers.prefixes(); + }; + + /** + * Return all possible selector prefixes + */ + + + Selector.prototype.prefixeds = function prefixeds(rule) { + if (rule._autoprefixerPrefixeds) { + return rule._autoprefixerPrefixeds; + } + + var prefixeds = {}; + for (var _iterator = this.possible(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var prefix = _ref; + + prefixeds[prefix] = this.replace(rule.selector, prefix); + } + + rule._autoprefixerPrefixeds = prefixeds; + return rule._autoprefixerPrefixeds; + }; + + /** + * Is rule already prefixed before + */ + + + Selector.prototype.already = function already(rule, prefixeds, prefix) { + var index = rule.parent.index(rule) - 1; + + while (index >= 0) { + var before = rule.parent.nodes[index]; + + if (before.type !== 'rule') { + return false; + } + + var some = false; + for (var key in prefixeds) { + var prefixed = prefixeds[key]; + if (before.selector === prefixed) { + if (prefix === key) { + return true; + } else { + some = true; + break; + } + } + } + if (!some) { + return false; + } + + index -= 1; + } + + return false; + }; + + /** + * Replace selectors by prefixed one + */ + + + Selector.prototype.replace = function replace(selector, prefix) { + return selector.replace(this.regexp(), '$1' + this.prefixed(prefix)); + }; + + /** + * Clone and add prefixes for at-rule + */ + + + Selector.prototype.add = function add(rule, prefix) { + var prefixeds = this.prefixeds(rule); + + if (this.already(rule, prefixeds, prefix)) { + return; + } + + var cloned = this.clone(rule, { selector: prefixeds[prefix] }); + rule.parent.insertBefore(rule, cloned); + }; + + /** + * Return function to fast find prefixed selector + */ + + + Selector.prototype.old = function old(prefix) { + return new OldSelector(this, prefix); + }; + + return Selector; +}(Prefixer); + +module.exports = Selector; +},{"./browsers":56,"./old-selector":102,"./prefixer":104,"./utils":111}],109:[function(require,module,exports){ +'use strict'; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Browsers = require('./browsers'); +var brackets = require('./brackets'); +var Value = require('./value'); +var utils = require('./utils'); + +var postcss = require('postcss'); + +var supported = []; +var data = require('caniuse-lite').feature(require('caniuse-lite/data/features/css-featurequeries.js')); +for (var browser in data.stats) { + var versions = data.stats[browser]; + for (var version in versions) { + var support = versions[version]; + if (/y/.test(support)) { + supported.push(browser + ' ' + version); + } + } +} + +var Supports = function () { + function Supports(Prefixes, all) { + _classCallCheck(this, Supports); + + this.Prefixes = Prefixes; + this.all = all; + } + + /** + * Return prefixer only with @supports supported browsers + */ + + + Supports.prototype.prefixer = function prefixer() { + if (this.prefixerCache) { + return this.prefixerCache; + } + + var filtered = this.all.browsers.selected.filter(function (i) { + return supported.indexOf(i) !== -1; + }); + + var browsers = new Browsers(this.all.browsers.data, filtered, this.all.options); + this.prefixerCache = new this.Prefixes(this.all.data, browsers, this.all.options); + return this.prefixerCache; + }; + + /** + * Parse string into declaration property and value + */ + + + Supports.prototype.parse = function parse(str) { + var _str$split = str.split(':'), + prop = _str$split[0], + value = _str$split[1]; + + if (!value) value = ''; + return [prop.trim(), value.trim()]; + }; + + /** + * Create virtual rule to process it by prefixer + */ + + + Supports.prototype.virtual = function virtual(str) { + var _parse = this.parse(str), + prop = _parse[0], + value = _parse[1]; + + var rule = postcss.parse('a{}').first; + rule.append({ prop: prop, value: value, raws: { before: '' } }); + return rule; + }; + + /** + * Return array of Declaration with all necessary prefixes + */ + + + Supports.prototype.prefixed = function prefixed(str) { + var rule = this.virtual(str); + if (this.disabled(rule.first)) { + return rule.nodes; + } + + var prefixer = this.prefixer().add[rule.first.prop]; + prefixer && prefixer.process && prefixer.process(rule.first); + + for (var _iterator = rule.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var decl = _ref; + + for (var _iterator2 = this.prefixer().values('add', rule.first.prop), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var value = _ref2; + + value.process(decl); + } + Value.save(this.all, decl); + } + + return rule.nodes; + }; + + /** + * Return true if brackets node is "not" word + */ + + + Supports.prototype.isNot = function isNot(node) { + return typeof node === 'string' && /not\s*/i.test(node); + }; + + /** + * Return true if brackets node is "or" word + */ + + + Supports.prototype.isOr = function isOr(node) { + return typeof node === 'string' && /\s*or\s*/i.test(node); + }; + + /** + * Return true if brackets node is (prop: value) + */ + + + Supports.prototype.isProp = function isProp(node) { + return (typeof node === 'undefined' ? 'undefined' : _typeof(node)) === 'object' && node.length === 1 && typeof node[0] === 'string'; + }; + + /** + * Return true if prefixed property has no unprefixed + */ + + + Supports.prototype.isHack = function isHack(all, unprefixed) { + var check = new RegExp('(\\(|\\s)' + utils.escapeRegexp(unprefixed) + ':'); + return !check.test(all); + }; + + /** + * Return true if we need to remove node + */ + + + Supports.prototype.toRemove = function toRemove(str, all) { + var _parse2 = this.parse(str), + prop = _parse2[0], + value = _parse2[1]; + + var unprefixed = this.all.unprefixed(prop); + + var cleaner = this.all.cleaner(); + + if (cleaner.remove[prop] && cleaner.remove[prop].remove && !this.isHack(all, unprefixed)) { + return true; + } + + for (var _iterator3 = cleaner.values('remove', unprefixed), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var checker = _ref3; + + if (checker.check(value)) { + return true; + } + } + + return false; + }; + + /** + * Remove all unnecessary prefixes + */ + + + Supports.prototype.remove = function remove(nodes, all) { + var i = 0; + while (i < nodes.length) { + if (!this.isNot(nodes[i - 1]) && this.isProp(nodes[i]) && this.isOr(nodes[i + 1])) { + if (this.toRemove(nodes[i][0], all)) { + nodes.splice(i, 2); + } else { + i += 2; + } + } else { + if (_typeof(nodes[i]) === 'object') { + nodes[i] = this.remove(nodes[i], all); + } + i += 1; + } + } + return nodes; + }; + + /** + * Clean brackets with one child + */ + + + Supports.prototype.cleanBrackets = function cleanBrackets(nodes) { + var _this = this; + + return nodes.map(function (i) { + if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') { + if (i.length === 1 && _typeof(i[0]) === 'object') { + return _this.cleanBrackets(i[0]); + } else { + return _this.cleanBrackets(i); + } + } else { + return i; + } + }); + }; + + /** + * Add " or " between properties and convert it to brackets format + */ + + + Supports.prototype.convert = function convert(progress) { + var result = ['']; + for (var _iterator4 = progress, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref4 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref4 = _i4.value; + } + + var i = _ref4; + + result.push([i.prop + ': ' + i.value]); + result.push(' or '); + } + result[result.length - 1] = ''; + return result; + }; + + /** + * Compress value functions into a string nodes + */ + + + Supports.prototype.normalize = function normalize(nodes) { + var _this2 = this; + + if ((typeof nodes === 'undefined' ? 'undefined' : _typeof(nodes)) === 'object') { + nodes = nodes.filter(function (i) { + return i !== ''; + }); + if (typeof nodes[0] === 'string' && nodes[0].indexOf(':') !== -1) { + return [brackets.stringify(nodes)]; + } else { + return nodes.map(function (i) { + return _this2.normalize(i); + }); + } + } else { + return nodes; + } + }; + + /** + * Add prefixes + */ + + + Supports.prototype.add = function add(nodes, all) { + var _this3 = this; + + return nodes.map(function (i) { + if (_this3.isProp(i)) { + var prefixed = _this3.prefixed(i[0]); + if (prefixed.length > 1) { + return _this3.convert(prefixed); + } else { + return i; + } + } else if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') { + return _this3.add(i, all); + } else { + return i; + } + }); + }; + + /** + * Add prefixed declaration + */ + + + Supports.prototype.process = function process(rule) { + var ast = brackets.parse(rule.params); + ast = this.normalize(ast); + ast = this.remove(ast, rule.params); + ast = this.add(ast, rule.params); + ast = this.cleanBrackets(ast); + rule.params = brackets.stringify(ast); + }; + + /** + * Check global options + */ + + + Supports.prototype.disabled = function disabled(node) { + if (this.all.options.grid === false) { + if (node.prop === 'display' && node.value.indexOf('grid') !== -1) { + return true; + } + if (node.prop.indexOf('grid') !== -1 || node.prop === 'justify-items') { + return true; + } + } + + if (this.all.options.flexbox === false) { + if (node.prop === 'display' && node.value.indexOf('flex') !== -1) { + return true; + } + var other = ['order', 'justify-content', 'align-items', 'align-content']; + if (node.prop.indexOf('flex') !== -1 || other.indexOf(node.prop) !== -1) { + return true; + } + } + + return false; + }; + + return Supports; +}(); + +module.exports = Supports; +},{"./brackets":55,"./browsers":56,"./utils":111,"./value":112,"caniuse-lite":578,"caniuse-lite/data/features/css-featurequeries.js":197,"postcss":828}],110:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var parser = require('postcss-value-parser'); +var vendor = require('postcss/lib/vendor'); +var list = require('postcss/lib/list'); + +var Transition = function () { + function Transition(prefixes) { + _classCallCheck(this, Transition); + + Object.defineProperty(this, 'props', { + enumerable: true, + writable: true, + value: ['transition', 'transition-property'] + }); + + this.prefixes = prefixes; + } + + /** + * Process transition and add prefies for all necessary properties + */ + + + Transition.prototype.add = function add(decl, result) { + var _this = this; + + var prefix = void 0, + prop = void 0; + var declPrefixes = this.prefixes.add[decl.prop] && this.prefixes.add[decl.prop].prefixes || []; + + var params = this.parse(decl.value); + var names = params.map(function (i) { + return _this.findProp(i); + }); + var added = []; + + if (names.some(function (i) { + return i[0] === '-'; + })) { + return; + } + + for (var _iterator = params, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var param = _ref; + + prop = this.findProp(param); + if (prop[0] === '-') { + continue; + } + var prefixer = this.prefixes.add[prop]; + if (!prefixer || !prefixer.prefixes) { + continue; + } + + for (var _iterator3 = prefixer.prefixes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + prefix = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + prefix = _i3.value; + } + + var prefixed = this.prefixes.prefixed(prop, prefix); + if (prefixed !== '-ms-transform' && names.indexOf(prefixed) === -1) { + if (!this.disabled(prop, prefix)) { + added.push(this.clone(prop, prefixed, param)); + } + } + } + } + + params = params.concat(added); + var value = this.stringify(params); + + var webkitClean = this.stringify(this.cleanFromUnprefixed(params, '-webkit-')); + if (declPrefixes.indexOf('-webkit-') !== -1) { + this.cloneBefore(decl, '-webkit-' + decl.prop, webkitClean); + } + this.cloneBefore(decl, decl.prop, webkitClean); + if (declPrefixes.indexOf('-o-') !== -1) { + var operaClean = this.stringify(this.cleanFromUnprefixed(params, '-o-')); + this.cloneBefore(decl, '-o-' + decl.prop, operaClean); + } + + for (var _iterator2 = declPrefixes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + prefix = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + prefix = _i2.value; + } + + if (prefix !== '-webkit-' && prefix !== '-o-') { + var prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix)); + this.cloneBefore(decl, prefix + decl.prop, prefixValue); + } + } + + if (value !== decl.value && !this.already(decl, decl.prop, value)) { + this.checkForWarning(result, decl); + decl.cloneBefore(); + decl.value = value; + } + }; + + /** + * Find property name + */ + + + Transition.prototype.findProp = function findProp(param) { + var prop = param[0].value; + if (/^\d/.test(prop)) { + for (var i = 0; i < param.length; i++) { + var token = param[i]; + if (i !== 0 && token.type === 'word') { + return token.value; + } + } + } + return prop; + }; + + /** + * Does we aready have this declaration + */ + + + Transition.prototype.already = function already(decl, prop, value) { + return decl.parent.some(function (i) { + return i.prop === prop && i.value === value; + }); + }; + + /** + * Add declaration if it is not exist + */ + + + Transition.prototype.cloneBefore = function cloneBefore(decl, prop, value) { + if (!this.already(decl, prop, value)) { + decl.cloneBefore({ prop: prop, value: value }); + } + }; + + /** + * Show transition-property warning + */ + + + Transition.prototype.checkForWarning = function checkForWarning(result, decl) { + if (decl.prop === 'transition-property') { + decl.parent.each(function (i) { + if (i.type !== 'decl') { + return undefined; + } + if (i.prop.indexOf('transition-') !== 0) { + return undefined; + } + if (i.prop === 'transition-property') { + return undefined; + } + + if (list.comma(i.value).length > 1) { + decl.warn(result, 'Replace transition-property to transition, ' + 'because Autoprefixer could not support ' + 'any cases of transition-property ' + 'and other transition-*'); + } + return false; + }); + } + }; + + /** + * Process transition and remove all unnecessary properties + */ + + + Transition.prototype.remove = function remove(decl) { + var _this2 = this; + + var params = this.parse(decl.value); + params = params.filter(function (i) { + var prop = _this2.prefixes.remove[_this2.findProp(i)]; + return !prop || !prop.remove; + }); + var value = this.stringify(params); + + if (decl.value === value) { + return; + } + + if (params.length === 0) { + decl.remove(); + return; + } + + var double = decl.parent.some(function (i) { + return i.prop === decl.prop && i.value === value; + }); + var smaller = decl.parent.some(function (i) { + return i !== decl && i.prop === decl.prop && i.value.length > value.length; + }); + + if (double || smaller) { + decl.remove(); + } else { + decl.value = value; + } + }; + + /** + * Parse properties list to array + */ + + + Transition.prototype.parse = function parse(value) { + var ast = parser(value); + var result = []; + var param = []; + for (var _iterator4 = ast.nodes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref2; + + if (_isArray4) { + if (_i4 >= _iterator4.length) break; + _ref2 = _iterator4[_i4++]; + } else { + _i4 = _iterator4.next(); + if (_i4.done) break; + _ref2 = _i4.value; + } + + var node = _ref2; + + param.push(node); + if (node.type === 'div' && node.value === ',') { + result.push(param); + param = []; + } + } + result.push(param); + return result.filter(function (i) { + return i.length > 0; + }); + }; + + /** + * Return properties string from array + */ + + + Transition.prototype.stringify = function stringify(params) { + if (params.length === 0) { + return ''; + } + var nodes = []; + for (var _iterator5 = params, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref3; + + if (_isArray5) { + if (_i5 >= _iterator5.length) break; + _ref3 = _iterator5[_i5++]; + } else { + _i5 = _iterator5.next(); + if (_i5.done) break; + _ref3 = _i5.value; + } + + var param = _ref3; + + if (param[param.length - 1].type !== 'div') { + param.push(this.div(params)); + } + nodes = nodes.concat(param); + } + if (nodes[0].type === 'div') { + nodes = nodes.slice(1); + } + if (nodes[nodes.length - 1].type === 'div') { + nodes = nodes.slice(0, +-2 + 1 || undefined); + } + return parser.stringify({ nodes: nodes }); + }; + + /** + * Return new param array with different name + */ + + + Transition.prototype.clone = function clone(origin, name, param) { + var result = []; + var changed = false; + for (var _iterator6 = param, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref4; + + if (_isArray6) { + if (_i6 >= _iterator6.length) break; + _ref4 = _iterator6[_i6++]; + } else { + _i6 = _iterator6.next(); + if (_i6.done) break; + _ref4 = _i6.value; + } + + var i = _ref4; + + if (!changed && i.type === 'word' && i.value === origin) { + result.push({ type: 'word', value: name }); + changed = true; + } else { + result.push(i); + } + } + return result; + }; + + /** + * Find or create seperator + */ + + + Transition.prototype.div = function div(params) { + for (var _iterator7 = params, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : _iterator7[Symbol.iterator]();;) { + var _ref5; + + if (_isArray7) { + if (_i7 >= _iterator7.length) break; + _ref5 = _iterator7[_i7++]; + } else { + _i7 = _iterator7.next(); + if (_i7.done) break; + _ref5 = _i7.value; + } + + var param = _ref5; + + for (var _iterator8 = param, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : _iterator8[Symbol.iterator]();;) { + var _ref6; + + if (_isArray8) { + if (_i8 >= _iterator8.length) break; + _ref6 = _iterator8[_i8++]; + } else { + _i8 = _iterator8.next(); + if (_i8.done) break; + _ref6 = _i8.value; + } + + var node = _ref6; + + if (node.type === 'div' && node.value === ',') { + return node; + } + } + } + return { type: 'div', value: ',', after: ' ' }; + }; + + Transition.prototype.cleanOtherPrefixes = function cleanOtherPrefixes(params, prefix) { + var _this3 = this; + + return params.filter(function (param) { + var current = vendor.prefix(_this3.findProp(param)); + return current === '' || current === prefix; + }); + }; + + /** + * Remove all non-webkit prefixes and unprefixed params if we have prefixed + */ + + + Transition.prototype.cleanFromUnprefixed = function cleanFromUnprefixed(params, prefix) { + var _this4 = this; + + var remove = params.map(function (i) { + return _this4.findProp(i); + }).filter(function (i) { + return i.slice(0, prefix.length) === prefix; + }).map(function (i) { + return _this4.prefixes.unprefixed(i); + }); + + var result = []; + for (var _iterator9 = params, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : _iterator9[Symbol.iterator]();;) { + var _ref7; + + if (_isArray9) { + if (_i9 >= _iterator9.length) break; + _ref7 = _iterator9[_i9++]; + } else { + _i9 = _iterator9.next(); + if (_i9.done) break; + _ref7 = _i9.value; + } + + var param = _ref7; + + var prop = this.findProp(param); + var p = vendor.prefix(prop); + if (remove.indexOf(prop) === -1 && (p === prefix || p === '')) { + result.push(param); + } + } + return result; + }; + + /** + * Check property for disabled by option + */ + + + Transition.prototype.disabled = function disabled(prop, prefix) { + var other = ['order', 'justify-content', 'align-self', 'align-content']; + if (prop.indexOf('flex') !== -1 || other.indexOf(prop) !== -1) { + if (this.prefixes.options.flexbox === false) { + return true; + } else if (this.prefixes.options.flexbox === 'no-2009') { + return prefix.indexOf('2009') !== -1; + } + } + return undefined; + }; + + return Transition; +}(); + +module.exports = Transition; +},{"postcss-value-parser":811,"postcss/lib/list":823,"postcss/lib/vendor":838}],111:[function(require,module,exports){ +'use strict'; + +var list = require('postcss/lib/list'); + +module.exports = { + + /** + * Throw special error, to tell beniary, + * that this error is from Autoprefixer. + */ + error: function error(text) { + var err = new Error(text); + err.autoprefixer = true; + throw err; + }, + + + /** + * Return array, that doesn’t contain duplicates. + */ + uniq: function uniq(array) { + var filtered = []; + for (var _iterator = array, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var i = _ref; + + if (filtered.indexOf(i) === -1) { + filtered.push(i); + } + } + return filtered; + }, + + + /** + * Return "-webkit-" on "-webkit- old" + */ + removeNote: function removeNote(string) { + if (string.indexOf(' ') === -1) { + return string; + } else { + return string.split(' ')[0]; + } + }, + + + /** + * Escape RegExp symbols + */ + escapeRegexp: function escapeRegexp(string) { + return string.replace(/[.?*+\^\$\[\]\\(){}|\-]/g, '\\$&'); + }, + + + /** + * Return regexp to check, that CSS string contain word + */ + regexp: function regexp(word) { + var escape = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + if (escape) { + word = this.escapeRegexp(word); + } + return new RegExp('(^|[\\s,(])(' + word + '($|[\\s(,]))', 'gi'); + }, + + + /** + * Change comma list + */ + editList: function editList(value, callback) { + var origin = list.comma(value); + var changed = callback(origin, []); + + if (origin === changed) { + return value; + } else { + var join = value.match(/,\s*/); + join = join ? join[0] : ', '; + return changed.join(join); + } + } +}; +},{"postcss/lib/list":823}],112:[function(require,module,exports){ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Prefixer = require('./prefixer'); +var OldValue = require('./old-value'); +var utils = require('./utils'); + +var vendor = require('postcss/lib/vendor'); + +var Value = function (_Prefixer) { + _inherits(Value, _Prefixer); + + function Value() { + _classCallCheck(this, Value); + + return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments)); + } + + /** + * Clone decl for each prefixed values + */ + Value.save = function save(prefixes, decl) { + var _this2 = this; + + var prop = decl.prop; + var result = []; + + for (var prefix in decl._autoprefixerValues) { + var value = decl._autoprefixerValues[prefix]; + + if (value === decl.value) { + continue; + } + + var item = void 0; + var propPrefix = vendor.prefix(prop); + + if (propPrefix === prefix) { + item = decl.value = value; + } else if (propPrefix === '-pie-') { + continue; + } else { + (function () { + var prefixed = prefixes.prefixed(prop, prefix); + var rule = decl.parent; + if (rule.every(function (i) { + return i.prop !== prefixed; + })) { + var trimmed = value.replace(/\s+/, ' '); + var already = rule.some(function (i) { + return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed; + }); + + if (!already) { + var cloned = _this2.clone(decl, { value: value }); + item = decl.parent.insertBefore(decl, cloned); + } + } + })(); + } + + result.push(item); + } + + return result; + }; + + /** + * Is declaration need to be prefixed + */ + + + Value.prototype.check = function check(decl) { + var value = decl.value; + if (value.indexOf(this.name) !== -1) { + return !!value.match(this.regexp()); + } else { + return false; + } + }; + + /** + * Lazy regexp loading + */ + + + Value.prototype.regexp = function regexp() { + return this.regexpCache || (this.regexpCache = utils.regexp(this.name)); + }; + + /** + * Add prefix to values in string + */ + + + Value.prototype.replace = function replace(string, prefix) { + return string.replace(this.regexp(), '$1' + prefix + '$2'); + }; + + /** + * Get value with comments if it was not changed + */ + + + Value.prototype.value = function value(decl) { + if (decl.raws.value && decl.raws.value.value === decl.value) { + return decl.raws.value.raw; + } else { + return decl.value; + } + }; + + /** + * Save values with next prefixed token + */ + + + Value.prototype.add = function add(decl, prefix) { + if (!decl._autoprefixerValues) { + decl._autoprefixerValues = {}; + } + var value = decl._autoprefixerValues[prefix] || this.value(decl); + value = this.replace(value, prefix); + if (value) { + decl._autoprefixerValues[prefix] = value; + } + }; + + /** + * Return function to fast find prefixed value + */ + + + Value.prototype.old = function old(prefix) { + return new OldValue(this.name, prefix + this.name); + }; + + return Value; +}(Prefixer); + +module.exports = Value; +},{"./old-value":103,"./prefixer":104,"./utils":111,"postcss/lib/vendor":838}],113:[function(require,module,exports){ +'use strict'; +module.exports = balanced; +function balanced(a, b, str) { + if (a instanceof RegExp) a = maybeMatch(a, str); + if (b instanceof RegExp) b = maybeMatch(b, str); + + var r = range(a, b, str); + + return r && { + start: r[0], + end: r[1], + pre: str.slice(0, r[0]), + body: str.slice(r[0] + a.length, r[1]), + post: str.slice(r[1] + b.length) + }; +} + +function maybeMatch(reg, str) { + var m = str.match(reg); + return m ? m[0] : null; +} + +balanced.range = range; +function range(a, b, str) { + var begs, beg, left, right, result; + var ai = str.indexOf(a); + var bi = str.indexOf(b, ai + 1); + var i = ai; + + if (ai >= 0 && bi > 0) { + begs = []; + left = str.length; + + while (i >= 0 && !result) { + if (i == ai) { + begs.push(i); + ai = str.indexOf(a, i + 1); + } else if (begs.length == 1) { + result = [ begs.pop(), bi ]; + } else { + beg = begs.pop(); + if (beg < left) { + left = beg; + right = bi; + } + + bi = str.indexOf(b, i + 1); + } + + i = ai < bi && ai >= 0 ? ai : bi; + } + + if (begs.length) { + result = [ left, right ]; + } + } + + return result; +} + +},{}],114:[function(require,module,exports){ +var concatMap = require('concat-map'); +var balanced = require('balanced-match'); + +module.exports = expandTop; + +var escSlash = '\0SLASH'+Math.random()+'\0'; +var escOpen = '\0OPEN'+Math.random()+'\0'; +var escClose = '\0CLOSE'+Math.random()+'\0'; +var escComma = '\0COMMA'+Math.random()+'\0'; +var escPeriod = '\0PERIOD'+Math.random()+'\0'; + +function numeric(str) { + return parseInt(str, 10) == str + ? parseInt(str, 10) + : str.charCodeAt(0); +} + +function escapeBraces(str) { + return str.split('\\\\').join(escSlash) + .split('\\{').join(escOpen) + .split('\\}').join(escClose) + .split('\\,').join(escComma) + .split('\\.').join(escPeriod); +} + +function unescapeBraces(str) { + return str.split(escSlash).join('\\') + .split(escOpen).join('{') + .split(escClose).join('}') + .split(escComma).join(',') + .split(escPeriod).join('.'); +} + + +// Basically just str.split(","), but handling cases +// where we have nested braced sections, which should be +// treated as individual members, like {a,{b,c},d} +function parseCommaParts(str) { + if (!str) + return ['']; + + var parts = []; + var m = balanced('{', '}', str); + + if (!m) + return str.split(','); + + var pre = m.pre; + var body = m.body; + var post = m.post; + var p = pre.split(','); + + p[p.length-1] += '{' + body + '}'; + var postParts = parseCommaParts(post); + if (post.length) { + p[p.length-1] += postParts.shift(); + p.push.apply(p, postParts); + } + + parts.push.apply(parts, p); + + return parts; +} + +function expandTop(str) { + if (!str) + return []; + + // I don't know why Bash 4.3 does this, but it does. + // Anything starting with {} will have the first two bytes preserved + // but *only* at the top level, so {},a}b will not expand to anything, + // but a{},b}c will be expanded to [a}c,abc]. + // One could argue that this is a bug in Bash, but since the goal of + // this module is to match Bash's rules, we escape a leading {} + if (str.substr(0, 2) === '{}') { + str = '\\{\\}' + str.substr(2); + } + + return expand(escapeBraces(str), true).map(unescapeBraces); +} + +function identity(e) { + return e; +} + +function embrace(str) { + return '{' + str + '}'; +} +function isPadded(el) { + return /^-?0\d/.test(el); +} + +function lte(i, y) { + return i <= y; +} +function gte(i, y) { + return i >= y; +} + +function expand(str, isTop) { + var expansions = []; + + var m = balanced('{', '}', str); + if (!m || /\$$/.test(m.pre)) return [str]; + + var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); + var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); + var isSequence = isNumericSequence || isAlphaSequence; + var isOptions = m.body.indexOf(',') >= 0; + if (!isSequence && !isOptions) { + // {a},b} + if (m.post.match(/,.*\}/)) { + str = m.pre + '{' + m.body + escClose + m.post; + return expand(str); + } + return [str]; + } + + var n; + if (isSequence) { + n = m.body.split(/\.\./); + } else { + n = parseCommaParts(m.body); + if (n.length === 1) { + // x{{a,b}}y ==> x{a}y x{b}y + n = expand(n[0], false).map(embrace); + if (n.length === 1) { + var post = m.post.length + ? expand(m.post, false) + : ['']; + return post.map(function(p) { + return m.pre + n[0] + p; + }); + } + } + } + + // at this point, n is the parts, and we know it's not a comma set + // with a single entry. + + // no need to expand pre, since it is guaranteed to be free of brace-sets + var pre = m.pre; + var post = m.post.length + ? expand(m.post, false) + : ['']; + + var N; + + if (isSequence) { + var x = numeric(n[0]); + var y = numeric(n[1]); + var width = Math.max(n[0].length, n[1].length) + var incr = n.length == 3 + ? Math.abs(numeric(n[2])) + : 1; + var test = lte; + var reverse = y < x; + if (reverse) { + incr *= -1; + test = gte; + } + var pad = n.some(isPadded); + + N = []; + + for (var i = x; test(i, y); i += incr) { + var c; + if (isAlphaSequence) { + c = String.fromCharCode(i); + if (c === '\\') + c = ''; + } else { + c = String(i); + if (pad) { + var need = width - c.length; + if (need > 0) { + var z = new Array(need + 1).join('0'); + if (i < 0) + c = '-' + z + c.slice(1); + else + c = z + c; + } + } + } + N.push(c); + } + } else { + N = concatMap(n, function(el) { return expand(el, false) }); + } + + for (var j = 0; j < N.length; j++) { + for (var k = 0; k < post.length; k++) { + var expansion = pre + N[j] + post[k]; + if (!isTop || isSequence || expansion) + expansions.push(expansion); + } + } + + return expansions; +} + + +},{"balanced-match":113,"concat-map":588}],115:[function(require,module,exports){ +/*! + * braces + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT license. + */ + +'use strict'; + +/** + * Module dependencies + */ + +var expand = require('expand-range'); +var repeat = require('repeat-element'); +var tokens = require('preserve'); + +/** + * Expose `braces` + */ + +module.exports = function(str, options) { + if (typeof str !== 'string') { + throw new Error('braces expects a string'); + } + return braces(str, options); +}; + +/** + * Expand `{foo,bar}` or `{1..5}` braces in the + * given `string`. + * + * @param {String} `str` + * @param {Array} `arr` + * @param {Object} `options` + * @return {Array} + */ + +function braces(str, arr, options) { + if (str === '') { + return []; + } + + if (!Array.isArray(arr)) { + options = arr; + arr = []; + } + + var opts = options || {}; + arr = arr || []; + + if (typeof opts.nodupes === 'undefined') { + opts.nodupes = true; + } + + var fn = opts.fn; + var es6; + + if (typeof opts === 'function') { + fn = opts; + opts = {}; + } + + if (!(patternRe instanceof RegExp)) { + patternRe = patternRegex(); + } + + var matches = str.match(patternRe) || []; + var m = matches[0]; + + switch(m) { + case '\\,': + return escapeCommas(str, arr, opts); + case '\\.': + return escapeDots(str, arr, opts); + case '\/.': + return escapePaths(str, arr, opts); + case ' ': + return splitWhitespace(str); + case '{,}': + return exponential(str, opts, braces); + case '{}': + return emptyBraces(str, arr, opts); + case '\\{': + case '\\}': + return escapeBraces(str, arr, opts); + case '${': + if (!/\{[^{]+\{/.test(str)) { + return arr.concat(str); + } else { + es6 = true; + str = tokens.before(str, es6Regex()); + } + } + + if (!(braceRe instanceof RegExp)) { + braceRe = braceRegex(); + } + + var match = braceRe.exec(str); + if (match == null) { + return [str]; + } + + var outter = match[1]; + var inner = match[2]; + if (inner === '') { return [str]; } + + var segs, segsLength; + + if (inner.indexOf('..') !== -1) { + segs = expand(inner, opts, fn) || inner.split(','); + segsLength = segs.length; + + } else if (inner[0] === '"' || inner[0] === '\'') { + return arr.concat(str.split(/['"]/).join('')); + + } else { + segs = inner.split(','); + if (opts.makeRe) { + return braces(str.replace(outter, wrap(segs, '|')), opts); + } + + segsLength = segs.length; + if (segsLength === 1 && opts.bash) { + segs[0] = wrap(segs[0], '\\'); + } + } + + var len = segs.length; + var i = 0, val; + + while (len--) { + var path = segs[i++]; + + if (/(\.[^.\/])/.test(path)) { + if (segsLength > 1) { + return segs; + } else { + return [str]; + } + } + + val = splice(str, outter, path); + + if (/\{[^{}]+?\}/.test(val)) { + arr = braces(val, arr, opts); + } else if (val !== '') { + if (opts.nodupes && arr.indexOf(val) !== -1) { continue; } + arr.push(es6 ? tokens.after(val) : val); + } + } + + if (opts.strict) { return filter(arr, filterEmpty); } + return arr; +} + +/** + * Expand exponential ranges + * + * `a{,}{,}` => ['a', 'a', 'a', 'a'] + */ + +function exponential(str, options, fn) { + if (typeof options === 'function') { + fn = options; + options = null; + } + + var opts = options || {}; + var esc = '__ESC_EXP__'; + var exp = 0; + var res; + + var parts = str.split('{,}'); + if (opts.nodupes) { + return fn(parts.join(''), opts); + } + + exp = parts.length - 1; + res = fn(parts.join(esc), opts); + var len = res.length; + var arr = []; + var i = 0; + + while (len--) { + var ele = res[i++]; + var idx = ele.indexOf(esc); + + if (idx === -1) { + arr.push(ele); + + } else { + ele = ele.split('__ESC_EXP__').join(''); + if (!!ele && opts.nodupes !== false) { + arr.push(ele); + + } else { + var num = Math.pow(2, exp); + arr.push.apply(arr, repeat(ele, num)); + } + } + } + return arr; +} + +/** + * Wrap a value with parens, brackets or braces, + * based on the given character/separator. + * + * @param {String|Array} `val` + * @param {String} `ch` + * @return {String} + */ + +function wrap(val, ch) { + if (ch === '|') { + return '(' + val.join(ch) + ')'; + } + if (ch === ',') { + return '{' + val.join(ch) + '}'; + } + if (ch === '-') { + return '[' + val.join(ch) + ']'; + } + if (ch === '\\') { + return '\\{' + val + '\\}'; + } +} + +/** + * Handle empty braces: `{}` + */ + +function emptyBraces(str, arr, opts) { + return braces(str.split('{}').join('\\{\\}'), arr, opts); +} + +/** + * Filter out empty-ish values + */ + +function filterEmpty(ele) { + return !!ele && ele !== '\\'; +} + +/** + * Handle patterns with whitespace + */ + +function splitWhitespace(str) { + var segs = str.split(' '); + var len = segs.length; + var res = []; + var i = 0; + + while (len--) { + res.push.apply(res, braces(segs[i++])); + } + return res; +} + +/** + * Handle escaped braces: `\\{foo,bar}` + */ + +function escapeBraces(str, arr, opts) { + if (!/\{[^{]+\{/.test(str)) { + return arr.concat(str.split('\\').join('')); + } else { + str = str.split('\\{').join('__LT_BRACE__'); + str = str.split('\\}').join('__RT_BRACE__'); + return map(braces(str, arr, opts), function(ele) { + ele = ele.split('__LT_BRACE__').join('{'); + return ele.split('__RT_BRACE__').join('}'); + }); + } +} + +/** + * Handle escaped dots: `{1\\.2}` + */ + +function escapeDots(str, arr, opts) { + if (!/[^\\]\..+\\\./.test(str)) { + return arr.concat(str.split('\\').join('')); + } else { + str = str.split('\\.').join('__ESC_DOT__'); + return map(braces(str, arr, opts), function(ele) { + return ele.split('__ESC_DOT__').join('.'); + }); + } +} + +/** + * Handle escaped dots: `{1\\.2}` + */ + +function escapePaths(str, arr, opts) { + str = str.split('\/.').join('__ESC_PATH__'); + return map(braces(str, arr, opts), function(ele) { + return ele.split('__ESC_PATH__').join('\/.'); + }); +} + +/** + * Handle escaped commas: `{a\\,b}` + */ + +function escapeCommas(str, arr, opts) { + if (!/\w,/.test(str)) { + return arr.concat(str.split('\\').join('')); + } else { + str = str.split('\\,').join('__ESC_COMMA__'); + return map(braces(str, arr, opts), function(ele) { + return ele.split('__ESC_COMMA__').join(','); + }); + } +} + +/** + * Regex for common patterns + */ + +function patternRegex() { + return /\${|( (?=[{,}])|(?=[{,}]) )|{}|{,}|\\,(?=.*[{}])|\/\.(?=.*[{}])|\\\.(?={)|\\{|\\}/; +} + +/** + * Braces regex. + */ + +function braceRegex() { + return /.*(\\?\{([^}]+)\})/; +} + +/** + * es6 delimiter regex. + */ + +function es6Regex() { + return /\$\{([^}]+)\}/; +} + +var braceRe; +var patternRe; + +/** + * Faster alternative to `String.replace()` when the + * index of the token to be replaces can't be supplied + */ + +function splice(str, token, replacement) { + var i = str.indexOf(token); + return str.substr(0, i) + replacement + + str.substr(i + token.length); +} + +/** + * Fast array map + */ + +function map(arr, fn) { + if (arr == null) { + return []; + } + + var len = arr.length; + var res = new Array(len); + var i = -1; + + while (++i < len) { + res[i] = fn(arr[i], i, arr); + } + + return res; +} + +/** + * Fast array filter + */ + +function filter(arr, cb) { + if (arr == null) return []; + if (typeof cb !== 'function') { + throw new TypeError('braces: filter expects a callback function.'); + } + + var len = arr.length; + var res = arr.slice(); + var i = 0; + + while (len--) { + if (!cb(arr[len], i++)) { + res.splice(len, 1); + } + } + return res; +} + +},{"expand-range":607,"preserve":841,"repeat-element":848}],116:[function(require,module,exports){ +(function (process){ +var path = require('path') +var e2c = require('electron-to-chromium/versions') +var fs = require('fs') + +var agents = require('caniuse-lite/dist/unpacker/agents').agents +var region = require('caniuse-lite/dist/unpacker/region').default + +function normalize (versions) { + return versions.filter(function (version) { + return typeof version === 'string' + }) +} + +var env = process.env + +// eslint-disable-next-line security/detect-unsafe-regex +var FLOAT_RANGE = /^\d+(\.\d+)?(-\d+(\.\d+)?)*$/ +var IS_SECTION = /^\s*\[(.+)\]\s*$/ + +function uniq (array) { + var filtered = [] + for (var i = 0; i < array.length; i++) { + if (filtered.indexOf(array[i]) === -1) filtered.push(array[i]) + } + return filtered +} + +function BrowserslistError (message) { + this.name = 'BrowserslistError' + this.message = message || '' + this.browserslist = true + if (Error.captureStackTrace) { + Error.captureStackTrace(this, BrowserslistError) + } +} +BrowserslistError.prototype = Error.prototype + +// Helpers + +function fillUsage (result, name, data) { + for (var i in data) { + result[name + ' ' + i] = data[i] + } +} + +var cacheEnabled = !env.BROWSERSLIST_DISABLE_CACHE +var filenessCache = {} +var configCache = {} + +function isFile (file) { + if (!fs.existsSync) { + return false + } + if (file in filenessCache) { + return filenessCache[file] + } + var result = fs.existsSync(file) && fs.statSync(file).isFile() + if (cacheEnabled) { + filenessCache[file] = result + } + return result +} + +function eachParent (file, callback) { + var loc = path.resolve(file) + do { + var result = callback(loc) + if (typeof result !== 'undefined') return result + } while (loc !== (loc = path.dirname(loc))) + return undefined +} + +function getStat (opts) { + if (opts.stats) { + return opts.stats + } else if (env.BROWSERSLIST_STATS) { + return env.BROWSERSLIST_STATS + } else if (opts.path) { + return eachParent(opts.path, function (dir) { + var file = path.join(dir, 'browserslist-stats.json') + return isFile(file) ? file : undefined + }) + } + + return undefined +} + +function parsePackage (file) { + var config = JSON.parse(fs.readFileSync(file)).browserslist + if (typeof config === 'object' && config.length) { + config = { defaults: config } + } + return config +} + +function pickEnv (config, opts) { + if (typeof config !== 'object') return config + + var name + if (typeof opts.env === 'string') { + name = opts.env + } else if (env.BROWSERSLIST_ENV) { + name = env.BROWSERSLIST_ENV + } else if (env.NODE_ENV) { + name = env.NODE_ENV + } else { + name = 'development' + } + + return config[name] || config.defaults +} + +function generateFilter (sign, version) { + version = parseFloat(version) + if (sign === '>') { + return function (v) { + return parseFloat(v) > version + } + } else if (sign === '>=') { + return function (v) { + return parseFloat(v) >= version + } + } else if (sign === '<') { + return function (v) { + return parseFloat(v) < version + } + } else { + return function (v) { + return parseFloat(v) <= version + } + } +} + +function compareStrings (a, b) { + if (a < b) return -1 + if (a > b) return +1 + return 0 +} + +/** + * Return array of browsers by selection queries. + * + * @param {string[]} queries Browser queries. + * @param {object} opts Options. + * @param {string} [opts.path="."] Path to processed file. + * It will be used to find config files. + * @param {string} [opts.env="development"] Processing environment. + * It will be used to take right + * queries from config file. + * @param {string} [opts.config] Path to config file with queries. + * @param {object} [opts.stats] Custom browser usage statistics + * for "> 1% in my stats" query. + * @return {string[]} Array with browser names in Can I Use. + * + * @example + * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8'] + */ +function browserslist (queries, opts) { + if (typeof opts === 'undefined') opts = { } + + if (!opts.hasOwnProperty('path')) { + opts.path = path.resolve('.') + } + + if (typeof queries === 'undefined' || queries === null) { + if (env.BROWSERSLIST) { + queries = env.BROWSERSLIST + } else if (opts.config || env.BROWSERSLIST_CONFIG) { + var file = opts.config || env.BROWSERSLIST_CONFIG + if (path.basename(file) === 'package.json') { + queries = pickEnv(parsePackage(file), opts) + } else { + queries = pickEnv(browserslist.readConfig(file), opts) + } + } else if (opts.path) { + queries = pickEnv(browserslist.findConfig(opts.path), opts) + } + } + + if (typeof queries === 'undefined' || queries === null) { + queries = browserslist.defaults + } + + if (typeof queries === 'string') { + queries = queries.split(/,\s*/) + } + + var context = { } + + var stats = getStat(opts) + if (stats) { + if (typeof stats === 'string') { + try { + stats = JSON.parse(fs.readFileSync(stats)) + } catch (e) { + throw new BrowserslistError('Can\'t read ' + stats) + } + } + if ('dataByBrowser' in stats) { + stats = stats.dataByBrowser + } + + context.customUsage = { } + for (var browser in stats) { + fillUsage(context.customUsage, browser, stats[browser]) + } + } + + var result = [] + + queries.forEach(function (selection, index) { + if (selection.trim() === '') return + + var exclude = selection.indexOf('not ') === 0 + if (exclude) { + if (index === 0) { + throw new BrowserslistError( + 'Write any browsers query (for instance, `defaults`) ' + + 'before `' + selection + '`') + } + selection = selection.slice(4) + } + + for (var i = 0; i < QUERIES.length; i++) { + var type = QUERIES[i] + var match = selection.match(type.regexp) + if (match) { + var args = [context].concat(match.slice(1)) + var array = type.select.apply(browserslist, args) + if (exclude) { + array = array.concat(array.map(function (j) { + return j.replace(/\s\d+/, ' 0') + })) + result = result.filter(function (j) { + return array.indexOf(j) === -1 + }) + } else { + result = result.concat(array) + } + return + } + } + + throw new BrowserslistError('Unknown browser query `' + selection + '`') + }) + result = result.map(function (i) { + var parts = i.split(' ') + var name = parts[0] + var version = parts[1] + if (version === '0') { + return name + ' ' + byName(name).versions[0] + } else { + return i + } + }).sort(function (name1, name2) { + name1 = name1.split(' ') + name2 = name2.split(' ') + if (name1[0] === name2[0]) { + if (FLOAT_RANGE.test(name1[1]) && FLOAT_RANGE.test(name2[1])) { + return parseFloat(name2[1]) - parseFloat(name1[1]) + } else { + return compareStrings(name2[1], name1[1]) + } + } else { + return compareStrings(name1[0], name2[0]) + } + }) + + return uniq(result) +} + +function normalizeVersion (data, version) { + if (data.versions.indexOf(version) !== -1) { + return version + } else if (browserslist.versionAliases[data.name][version]) { + return browserslist.versionAliases[data.name][version] + } else if (data.versions.length === 1) { + return data.versions[0] + } else { + return false + } +} + +function loadCountryStatistics (country) { + country = country.replace(/[^\w-]/g, '') + if (!browserslist.usage[country]) { + var usage = { } + // eslint-disable-next-line security/detect-non-literal-require + var compressed = require('caniuse-lite/data/regions/' + country + '.js') + var data = region(compressed) + for (var i in data) { + fillUsage(usage, i, data[i]) + } + browserslist.usage[country] = usage + } +} + +// Will be filled by Can I Use data below +browserslist.data = { } +browserslist.usage = { + global: { }, + custom: null +} + +// Default browsers query +browserslist.defaults = [ + '> 1%', + 'last 2 versions', + 'Firefox ESR' +] + +// Browser names aliases +browserslist.aliases = { + fx: 'firefox', + ff: 'firefox', + ios: 'ios_saf', + explorer: 'ie', + blackberry: 'bb', + explorermobile: 'ie_mob', + operamini: 'op_mini', + operamobile: 'op_mob', + chromeandroid: 'and_chr', + firefoxandroid: 'and_ff', + ucandroid: 'and_uc', + qqandroid: 'and_qq' +} + +// Aliases to work with joined versions like `ios_saf 7.0-7.1` +browserslist.versionAliases = { } + +// Get browser data by alias or case insensitive name +function byName (name) { + name = name.toLowerCase() + name = browserslist.aliases[name] || name + return browserslist.data[name] +} + +// Get browser data by alias or case insensitive name and throw error +// on unknown browser +function checkName (name) { + var data = byName(name) + if (!data) throw new BrowserslistError('Unknown browser ' + name) + return data +} + +// Read and parse config +browserslist.readConfig = function (file) { + if (!isFile(file)) { + throw new BrowserslistError('Can\'t read ' + file + ' config') + } + return browserslist.parseConfig(fs.readFileSync(file)) +} + +// Find config, read file and parse it +browserslist.findConfig = function (from) { + from = path.resolve(from) + + var cacheKey = isFile(from) ? path.dirname(from) : from + if (cacheKey in configCache) { + return configCache[cacheKey] + } + + var resolved = eachParent(from, function (dir) { + var config = path.join(dir, 'browserslist') + var pkg = path.join(dir, 'package.json') + var rc = path.join(dir, '.browserslistrc') + + var pkgBrowserslist + if (isFile(pkg)) { + try { + pkgBrowserslist = parsePackage(pkg) + } catch (e) { + console.warn( + '[Browserslist] Could not parse ' + pkg + '. Ignoring it.') + } + } + + if (isFile(config) && pkgBrowserslist) { + throw new BrowserslistError( + dir + ' contains both browserslist and package.json with browsers') + } else if (isFile(rc) && pkgBrowserslist) { + throw new BrowserslistError( + dir + ' contains both .browserslistrc and package.json with browsers') + } else if (isFile(config) && isFile(rc)) { + throw new BrowserslistError( + dir + ' contains both .browserslistrc and browserslist') + } else if (isFile(config)) { + return browserslist.readConfig(config) + } else if (isFile(rc)) { + return browserslist.readConfig(rc) + } else { + return pkgBrowserslist + } + }) + if (cacheEnabled) { + configCache[cacheKey] = resolved + } + return resolved +} + +/** + * Return browsers market coverage. + * + * @param {string[]} browsers Browsers names in Can I Use. + * @param {string} [country="global"] Which country statistics should be used. + * + * @return {number} Total market coverage for all selected browsers. + * + * @example + * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1 + */ +browserslist.coverage = function (browsers, country) { + if (country && country !== 'global') { + if (country.length > 2) { + country = country.toLowerCase() + } else { + country = country.toUpperCase() + } + loadCountryStatistics(country) + } else { + country = 'global' + } + + return browsers.reduce(function (all, i) { + var usage = browserslist.usage[country][i] + if (usage === undefined) { + usage = browserslist.usage[country][i.replace(/ [\d.]+$/, ' 0')] + } + return all + (usage || 0) + }, 0) +} + +// Return array of queries from config content +browserslist.parseConfig = function (string) { + var result = { defaults: [] } + var section = 'defaults' + + string.toString() + .replace(/#[^\n]*/g, '') + .split(/\n/) + .map(function (line) { + return line.trim() + }) + .filter(function (line) { + return line !== '' + }) + .forEach(function (line) { + if (IS_SECTION.test(line)) { + section = line.match(IS_SECTION)[1].trim() + result[section] = result[section] || [] + } else { + result[section].push(line) + } + }) + + return result +} + +// Clear internal caches +browserslist.clearCaches = function () { + filenessCache = {} + configCache = {} +} + +var QUERIES = [ + { + regexp: /^last\s+(\d+)\s+versions?$/i, + select: function (context, versions) { + var selected = [] + Object.keys(agents).forEach(function (name) { + var data = byName(name) + if (!data) return + var array = data.released.slice(-versions) + + array = array.map(function (v) { + return data.name + ' ' + v + }) + selected = selected.concat(array) + }) + return selected + } + }, + { + regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i, + select: function (context, versions, name) { + var data = checkName(name) + return data.released.slice(-versions).map(function (v) { + return data.name + ' ' + v + }) + } + }, + { + regexp: /^unreleased\s+versions$/i, + select: function () { + var selected = [] + Object.keys(agents).forEach(function (name) { + var data = byName(name) + if (!data) return + var array = data.versions.filter(function (v) { + return data.released.indexOf(v) === -1 + }) + + array = array.map(function (v) { + return data.name + ' ' + v + }) + selected = selected.concat(array) + }) + return selected + } + }, + { + regexp: /^unreleased\s+(\w+)\s+versions?$/i, + select: function (context, name) { + var data = checkName(name) + return data.versions.filter(function (v) { + return data.released.indexOf(v) === -1 + }).map(function (v) { + return data.name + ' ' + v + }) + } + }, + { + regexp: /^(>=?)\s*(\d*\.?\d+)%$/, + select: function (context, sign, popularity) { + popularity = parseFloat(popularity) + var result = [] + + for (var version in browserslist.usage.global) { + if (sign === '>') { + if (browserslist.usage.global[version] > popularity) { + result.push(version) + } + } else if (browserslist.usage.global[version] >= popularity) { + result.push(version) + } + } + + return result + } + }, + { + regexp: /^(>=?)\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/, + select: function (context, sign, popularity) { + popularity = parseFloat(popularity) + var result = [] + + if (!context.customUsage) { + throw new BrowserslistError('Custom usage statistics was not provided') + } + + for (var version in context.customUsage) { + if (sign === '>') { + if (context.customUsage[version] > popularity) { + result.push(version) + } + } else if (context.customUsage[version] >= popularity) { + result.push(version) + } + } + + return result + } + }, + { + regexp: /^(>=?)\s*(\d*\.?\d+)%\s+in\s+((alt-)?\w\w)$/, + select: function (context, sign, popularity, place) { + popularity = parseFloat(popularity) + var result = [] + + if (place.length === 2) { + place = place.toUpperCase() + } else { + place = place.toLowerCase() + } + + loadCountryStatistics(place) + var usage = browserslist.usage[place] + + for (var version in usage) { + if (sign === '>') { + if (usage[version] > popularity) { + result.push(version) + } + } else if (usage[version] >= popularity) { + result.push(version) + } + } + + return result + } + }, + { + regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i, + select: function (context, from, to) { + if (!e2c[from]) { + throw new BrowserslistError('Unknown version ' + from + ' of electron') + } + if (!e2c[to]) { + throw new BrowserslistError('Unknown version ' + to + ' of electron') + } + + from = parseFloat(from) + to = parseFloat(to) + + return Object.keys(e2c).filter(function (i) { + var parsed = parseFloat(i) + return parsed >= from && parsed <= to + }).map(function (i) { + return 'chrome ' + e2c[i] + }) + } + }, + { + regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i, + select: function (context, name, from, to) { + var data = checkName(name) + from = parseFloat(normalizeVersion(data, from) || from) + to = parseFloat(normalizeVersion(data, to) || to) + + function filter (v) { + var parsed = parseFloat(v) + return parsed >= from && parsed <= to + } + + return data.released.filter(filter).map(function (v) { + return data.name + ' ' + v + }) + } + }, + { + regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i, + select: function (context, sign, version) { + return Object.keys(e2c) + .filter(generateFilter(sign, version)) + .map(function (i) { + return 'chrome ' + e2c[i] + }) + } + }, + { + regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/, + select: function (context, name, sign, version) { + var data = checkName(name) + var alias = browserslist.versionAliases[data.name][version] + if (alias) { + version = alias + } + return data.released + .filter(generateFilter(sign, version)) + .map(function (v) { + return data.name + ' ' + v + }) + } + }, + { + regexp: /^(firefox|ff|fx)\s+esr$/i, + select: function () { + return ['firefox 52'] + } + }, + { + regexp: /(operamini|op_mini)\s+all/i, + select: function () { + return ['op_mini all'] + } + }, + { + regexp: /^electron\s+([\d.]+)$/i, + select: function (context, version) { + var chrome = e2c[version] + if (!chrome) { + throw new BrowserslistError( + 'Unknown version ' + version + ' of electron') + } + return ['chrome ' + chrome] + } + }, + { + regexp: /^(\w+)\s+(tp|[\d.]+)$/i, + select: function (context, name, version) { + if (/^tp$/i.test(version)) version = 'TP' + var data = checkName(name) + var alias = normalizeVersion(data, version) + if (alias) { + version = alias + } else { + if (version.indexOf('.') === -1) { + alias = version + '.0' + } else if (/\.0$/.test(version)) { + alias = version.replace(/\.0$/, '') + } + alias = normalizeVersion(data, alias) + if (alias) { + version = alias + } else { + throw new BrowserslistError( + 'Unknown version ' + version + ' of ' + name) + } + } + return [data.name + ' ' + version] + } + }, + { + regexp: /^defaults$/i, + select: function () { + return browserslist(browserslist.defaults) + } + } +]; + +// Get and convert Can I Use data + +(function () { + for (var name in agents) { + var browser = agents[name] + browserslist.data[name] = { + name: name, + versions: normalize(agents[name].versions), + released: normalize(agents[name].versions.slice(0, -3)) + } + fillUsage(browserslist.usage.global, name, browser.usage_global) + + browserslist.versionAliases[name] = { } + for (var i = 0; i < browser.versions.length; i++) { + var full = browser.versions[i] + if (!full) continue + + if (full.indexOf('-') !== -1) { + var interval = full.split('-') + for (var j = 0; j < interval.length; j++) { + browserslist.versionAliases[name][interval[j]] = full + } + } + } + } +}()) + +module.exports = browserslist + +}).call(this,require('_process')) +},{"_process":16,"caniuse-lite/dist/unpacker/agents":573,"caniuse-lite/dist/unpacker/region":579,"electron-to-chromium/versions":602,"fs":4,"path":4}],117:[function(require,module,exports){ +module.exports={A:{A:{J:0.0344717,C:0.0172359,G:0.336099,E:0.193904,B:0.198212,A:3.09815,UB:0.009298},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","UB","J","C","G","E","B","A","","",""],E:"IE"},B:{A:{D:0.03717,X:0.09086,g:0.84665,H:0,L:0},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","D","X","g","H","L","",""],E:"Edge"},C:{A:{"0":0.18172,"1":3.75417,"2":0.01652,"4":0,"5":0,SB:0.004227,F:0.00413,I:0.004879,J:0.020136,C:0.005725,G:0.00826,E:0.00533,B:0.00413,A:0.00413,D:0.00826,X:0.004486,g:0.00453,H:0.00413,L:0.00826,M:0.00413,N:0.00826,O:0.004443,P:0.004227,Q:0.00826,R:0.00413,S:0.00413,T:0.00826,U:0.00826,V:0.00413,W:0.00826,u:0.00413,Y:0.00826,Z:0.01239,a:0.02065,b:0.00826,c:0.00826,d:0.00826,e:0.01239,f:0.01239,K:0.01239,h:0.0413,i:0.01239,j:0.01652,k:0.02478,l:0.01652,m:0.04956,n:0.02065,o:0.07021,p:0.02065,q:0.09086,r:0.14868,w:0.07847,x:0.07021,v:0.11151,z:0.51625,t:0.1652,s:0,QB:0.004534,PB:0.01239},B:"moz",C:["","SB","2","QB","PB","F","I","J","C","G","E","B","A","D","X","g","H","L","M","N","O","P","Q","R","S","T","U","V","W","u","Y","Z","a","b","c","d","e","f","K","h","i","j","k","l","m","n","o","p","q","r","w","x","v","z","0","1","t","s","4","5"],E:"Firefox"},D:{A:{"0":0.06608,"1":0.14042,"4":0.2065,"5":1.04902,"8":20.4724,F:0.004706,I:0.004879,J:0.004879,C:0.005591,G:0.005591,E:0.005591,B:0.004534,A:0.02065,D:0.004367,X:0.004879,g:0.004706,H:0.004706,L:0.00413,M:0.00413,N:0.00826,O:0.00413,P:0.00413,Q:0.00826,R:0.03304,S:0.00413,T:0.00826,U:0.00826,V:0.01652,W:0.00826,u:0.00826,Y:0.03304,Z:0.01239,a:0.06608,b:0.01652,c:0.02478,d:0.02891,e:0.01652,f:0.09086,K:0.01652,h:0.03717,i:0.03717,j:0.01652,k:0.02478,l:0.02065,m:0.15694,n:0.02478,o:0.28497,p:0.03304,q:0.09499,r:0.07434,w:1.10684,x:0.10325,v:0.14042,z:0.0413,t:0.28084,s:0.2891,EB:0.30149,BB:0.05369,TB:0,CB:0},B:"webkit",C:["F","I","J","C","G","E","B","A","D","X","g","H","L","M","N","O","P","Q","R","S","T","U","V","W","u","Y","Z","a","b","c","d","e","f","K","h","i","j","k","l","m","n","o","p","q","r","w","x","v","z","0","1","t","s","4","5","8","EB","BB","TB","CB"],E:"Chrome"},E:{A:{"9":0.008692,F:0.00826,I:0.02065,J:0.00413,C:0.01239,G:0.06195,E:0.06195,B:0.22302,A:0.00826,DB:0,FB:0.05782,GB:0.02065,HB:0.00413,IB:0.2478,JB:1.30921,KB:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","DB","9","F","I","FB","J","GB","C","HB","G","E","IB","B","JB","A","KB",""],E:"Safari"},F:{A:{"6":0.004879,"7":0.006229,E:0.0082,A:0.016581,D:0.00413,H:0.00685,L:0.00685,M:0.00685,N:0.005014,O:0.006015,P:0.004879,Q:0.006597,R:0.006597,S:0.013434,T:0.006702,U:0.006015,V:0.005595,W:0.004706,u:0.00413,Y:0.004879,Z:0.004879,a:0.00533,b:0.005152,c:0.005014,d:0.009758,e:0.004879,f:0.02891,K:0.00413,h:0.004367,i:0.004534,j:0.004367,k:0.004227,l:0.00826,m:0.01239,n:0.004227,o:0.04956,p:0.6608,q:0.00413,r:0.00413,LB:0.00685,MB:0,NB:0.008392,OB:0.004706,RB:0.004534,y:0.06195},B:"webkit",C:["","","","","","","","","","","","","","","E","LB","MB","NB","OB","A","7","6","RB","D","y","H","L","M","N","O","P","Q","R","S","T","U","V","W","u","Y","Z","a","b","c","d","e","f","K","h","i","j","k","l","m","n","o","p","q","r",""],E:"Opera",D:{"6":"o","7":"o",E:"o",A:"o",D:"o",LB:"o",MB:"o",NB:"o",OB:"o",RB:"o",y:"o"}},G:{A:{"3":0,"9":0,G:0,A:0,AB:0,VB:0,WB:0,XB:0.0488638,YB:0.0374276,ZB:0.0259914,aB:0.51359,bB:1.46487,cB:7.99806},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","9","AB","3","VB","WB","XB","G","YB","ZB","aB","bB","cB","A","",""],E:"iOS Safari"},H:{A:{dB:3.26376},B:"o",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","dB","","",""],E:"Opera Mini"},I:{A:{"2":0,"3":0.348738,F:0,s:0,eB:0,fB:0,gB:0,hB:0.136648,iB:0.938034,jB:0.577909},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","eB","fB","gB","2","F","hB","3","iB","jB","s","","",""],E:"Android Browser"},J:{A:{C:0.0322795,B:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","C","B","","",""],E:"Blackberry Browser"},K:{A:{"6":0,"7":0,B:0,A:0,D:0,K:0.0111391,y:0},B:"o",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","B","A","7","6","D","y","K","","",""],E:"Opera Mobile",D:{K:"webkit"}},L:{A:{"8":29.8734},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","8","","",""],E:"Chrome for Android"},M:{A:{t:0.035214},B:"moz",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","t","","",""],E:"Firefox for Android"},N:{A:{B:0.0564638,A:0.307414},B:"ms",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","B","A","","",""],E:"IE Mobile"},O:{A:{kB:9.1263},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","kB","","",""],E:"UC Browser for Android",D:{kB:"webkit"}},P:{A:{F:3.83833,I:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","F","I","","",""],E:"Samsung Internet"},Q:{A:{lB:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","lB","","",""],E:"QQ Browser"},R:{A:{mB:0},B:"webkit",C:["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mB","","",""],E:"Baidu Browser"}}; + +},{}],118:[function(require,module,exports){ +module.exports={"0":"53","1":"54","2":"3","3":"4.2-4.3","4":"57","5":"58","6":"11.5","7":"11.1","8":"59","9":"3.2",A:"11",B:"10",C:"7",D:"12",E:"9",F:"4",G:"8",H:"15",I:"5",J:"6",K:"37",L:"16",M:"17",N:"18",O:"19",P:"20",Q:"21",R:"22",S:"23",T:"24",U:"25",V:"26",W:"27",X:"13",Y:"29",Z:"30",a:"31",b:"32",c:"33",d:"34",e:"35",f:"36",g:"14",h:"38",i:"39",j:"40",k:"41",l:"42",m:"43",n:"44",o:"45",p:"46",q:"47",r:"48",s:"56",t:"55",u:"28",v:"51",w:"49",x:"50",y:"12.1",z:"52",AB:"4.0-4.1",BB:"61",CB:"63",DB:"3.1",EB:"60",FB:"5.1",GB:"6.1",HB:"7.1",IB:"9.1",JB:"10.1",KB:"TP",LB:"9.5-9.6",MB:"10.0-10.1",NB:"10.5",OB:"10.6",PB:"3.6",QB:"3.5",RB:"11.6",SB:"2",TB:"62",UB:"5.5",VB:"5.0-5.1",WB:"6.0-6.1",XB:"7.0-7.1",YB:"8.1-8.4",ZB:"9.0-9.2",aB:"9.3",bB:"10.0-10.2",cB:"10.3",dB:"all",eB:"2.1",fB:"2.2",gB:"2.3",hB:"4.1",iB:"4.4",jB:"4.4.3-4.4.4",kB:"11.4",lB:"1.2",mB:"7.12"}; + +},{}],119:[function(require,module,exports){ +module.exports={A:"ie",B:"edge",C:"firefox",D:"chrome",E:"safari",F:"opera",G:"ios_saf",H:"op_mini",I:"android",J:"bb",K:"op_mob",L:"and_chr",M:"and_ff",N:"ie_mob",O:"and_uc",P:"samsung",Q:"and_qq",R:"baidu"}; + +},{}],120:[function(require,module,exports){ +module.exports={"aac":require("./features/aac"),"ac3-ec3":require("./features/ac3-ec3"),"addeventlistener":require("./features/addeventlistener"),"alternate-stylesheet":require("./features/alternate-stylesheet"),"ambient-light":require("./features/ambient-light"),"apng":require("./features/apng"),"arrow-functions":require("./features/arrow-functions"),"asmjs":require("./features/asmjs"),"async-functions":require("./features/async-functions"),"atob-btoa":require("./features/atob-btoa"),"audio-api":require("./features/audio-api"),"audio":require("./features/audio"),"audiotracks":require("./features/audiotracks"),"autofocus":require("./features/autofocus"),"aux-click":require("./features/aux-click"),"background-attachment":require("./features/background-attachment"),"background-img-opts":require("./features/background-img-opts"),"background-position-x-y":require("./features/background-position-x-y"),"background-repeat-round-space":require("./features/background-repeat-round-space"),"battery-status":require("./features/battery-status"),"beacon":require("./features/beacon"),"beforeafterprint":require("./features/beforeafterprint"),"blobbuilder":require("./features/blobbuilder"),"bloburls":require("./features/bloburls"),"border-image":require("./features/border-image"),"border-radius":require("./features/border-radius"),"broadcastchannel":require("./features/broadcastchannel"),"brotli":require("./features/brotli"),"calc":require("./features/calc"),"canvas-blending":require("./features/canvas-blending"),"canvas-text":require("./features/canvas-text"),"canvas":require("./features/canvas"),"ch-unit":require("./features/ch-unit"),"chacha20-poly1305":require("./features/chacha20-poly1305"),"channel-messaging":require("./features/channel-messaging"),"childnode-remove":require("./features/childnode-remove"),"classlist":require("./features/classlist"),"client-hints-dpr-width-viewport":require("./features/client-hints-dpr-width-viewport"),"clipboard":require("./features/clipboard"),"comparedocumentposition":require("./features/comparedocumentposition"),"console-basic":require("./features/console-basic"),"const":require("./features/const"),"constraint-validation":require("./features/constraint-validation"),"contenteditable":require("./features/contenteditable"),"contentsecuritypolicy":require("./features/contentsecuritypolicy"),"contentsecuritypolicy2":require("./features/contentsecuritypolicy2"),"cors":require("./features/cors"),"credential-management":require("./features/credential-management"),"cryptography":require("./features/cryptography"),"css-all":require("./features/css-all"),"css-animation":require("./features/css-animation"),"css-any-link":require("./features/css-any-link"),"css-appearance":require("./features/css-appearance"),"css-apply-rule":require("./features/css-apply-rule"),"css-at-counter-style":require("./features/css-at-counter-style"),"css-backdrop-filter":require("./features/css-backdrop-filter"),"css-background-offsets":require("./features/css-background-offsets"),"css-backgroundblendmode":require("./features/css-backgroundblendmode"),"css-boxdecorationbreak":require("./features/css-boxdecorationbreak"),"css-boxshadow":require("./features/css-boxshadow"),"css-canvas":require("./features/css-canvas"),"css-caret-color":require("./features/css-caret-color"),"css-case-insensitive":require("./features/css-case-insensitive"),"css-clip-path":require("./features/css-clip-path"),"css-conic-gradients":require("./features/css-conic-gradients"),"css-containment":require("./features/css-containment"),"css-counters":require("./features/css-counters"),"css-crisp-edges":require("./features/css-crisp-edges"),"css-cross-fade":require("./features/css-cross-fade"),"css-default-pseudo":require("./features/css-default-pseudo"),"css-descendant-gtgt":require("./features/css-descendant-gtgt"),"css-deviceadaptation":require("./features/css-deviceadaptation"),"css-dir-pseudo":require("./features/css-dir-pseudo"),"css-display-contents":require("./features/css-display-contents"),"css-element-function":require("./features/css-element-function"),"css-exclusions":require("./features/css-exclusions"),"css-featurequeries":require("./features/css-featurequeries"),"css-filter-function":require("./features/css-filter-function"),"css-filters":require("./features/css-filters"),"css-first-letter":require("./features/css-first-letter"),"css-first-line":require("./features/css-first-line"),"css-fixed":require("./features/css-fixed"),"css-focus-within":require("./features/css-focus-within"),"css-font-rendering-controls":require("./features/css-font-rendering-controls"),"css-font-stretch":require("./features/css-font-stretch"),"css-gencontent":require("./features/css-gencontent"),"css-gradients":require("./features/css-gradients"),"css-grid":require("./features/css-grid"),"css-hanging-punctuation":require("./features/css-hanging-punctuation"),"css-has":require("./features/css-has"),"css-hyphenate":require("./features/css-hyphenate"),"css-hyphens":require("./features/css-hyphens"),"css-image-orientation":require("./features/css-image-orientation"),"css-image-set":require("./features/css-image-set"),"css-in-out-of-range":require("./features/css-in-out-of-range"),"css-indeterminate-pseudo":require("./features/css-indeterminate-pseudo"),"css-initial-letter":require("./features/css-initial-letter"),"css-initial-value":require("./features/css-initial-value"),"css-letter-spacing":require("./features/css-letter-spacing"),"css-line-clamp":require("./features/css-line-clamp"),"css-logical-props":require("./features/css-logical-props"),"css-marker-pseudo":require("./features/css-marker-pseudo"),"css-masks":require("./features/css-masks"),"css-matches-pseudo":require("./features/css-matches-pseudo"),"css-media-interaction":require("./features/css-media-interaction"),"css-media-resolution":require("./features/css-media-resolution"),"css-media-scripting":require("./features/css-media-scripting"),"css-mediaqueries":require("./features/css-mediaqueries"),"css-mixblendmode":require("./features/css-mixblendmode"),"css-motion-paths":require("./features/css-motion-paths"),"css-namespaces":require("./features/css-namespaces"),"css-not-sel-list":require("./features/css-not-sel-list"),"css-nth-child-of":require("./features/css-nth-child-of"),"css-opacity":require("./features/css-opacity"),"css-optional-pseudo":require("./features/css-optional-pseudo"),"css-overflow-anchor":require("./features/css-overflow-anchor"),"css-page-break":require("./features/css-page-break"),"css-paged-media":require("./features/css-paged-media"),"css-placeholder-shown":require("./features/css-placeholder-shown"),"css-placeholder":require("./features/css-placeholder"),"css-read-only-write":require("./features/css-read-only-write"),"css-rebeccapurple":require("./features/css-rebeccapurple"),"css-reflections":require("./features/css-reflections"),"css-regions":require("./features/css-regions"),"css-repeating-gradients":require("./features/css-repeating-gradients"),"css-resize":require("./features/css-resize"),"css-revert-value":require("./features/css-revert-value"),"css-rrggbbaa":require("./features/css-rrggbbaa"),"css-scroll-behavior":require("./features/css-scroll-behavior"),"css-scrollbar":require("./features/css-scrollbar"),"css-sel2":require("./features/css-sel2"),"css-sel3":require("./features/css-sel3"),"css-selection":require("./features/css-selection"),"css-shapes":require("./features/css-shapes"),"css-snappoints":require("./features/css-snappoints"),"css-sticky":require("./features/css-sticky"),"css-supports-api":require("./features/css-supports-api"),"css-table":require("./features/css-table"),"css-text-align-last":require("./features/css-text-align-last"),"css-text-indent":require("./features/css-text-indent"),"css-text-justify":require("./features/css-text-justify"),"css-text-orientation":require("./features/css-text-orientation"),"css-text-spacing":require("./features/css-text-spacing"),"css-textshadow":require("./features/css-textshadow"),"css-touch-action-2":require("./features/css-touch-action-2"),"css-touch-action":require("./features/css-touch-action"),"css-transitions":require("./features/css-transitions"),"css-unicode-bidi":require("./features/css-unicode-bidi"),"css-unset-value":require("./features/css-unset-value"),"css-variables":require("./features/css-variables"),"css-widows-orphans":require("./features/css-widows-orphans"),"css-writing-mode":require("./features/css-writing-mode"),"css-zoom":require("./features/css-zoom"),"css3-attr":require("./features/css3-attr"),"css3-boxsizing":require("./features/css3-boxsizing"),"css3-colors":require("./features/css3-colors"),"css3-cursors-grab":require("./features/css3-cursors-grab"),"css3-cursors-newer":require("./features/css3-cursors-newer"),"css3-cursors":require("./features/css3-cursors"),"css3-tabsize":require("./features/css3-tabsize"),"currentcolor":require("./features/currentcolor"),"custom-elements":require("./features/custom-elements"),"custom-elementsv1":require("./features/custom-elementsv1"),"customevent":require("./features/customevent"),"datalist":require("./features/datalist"),"dataset":require("./features/dataset"),"datauri":require("./features/datauri"),"details":require("./features/details"),"deviceorientation":require("./features/deviceorientation"),"devicepixelratio":require("./features/devicepixelratio"),"dialog":require("./features/dialog"),"dispatchevent":require("./features/dispatchevent"),"document-currentscript":require("./features/document-currentscript"),"document-evaluate-xpath":require("./features/document-evaluate-xpath"),"document-execcommand":require("./features/document-execcommand"),"documenthead":require("./features/documenthead"),"dom-manip-convenience":require("./features/dom-manip-convenience"),"dom-range":require("./features/dom-range"),"domcontentloaded":require("./features/domcontentloaded"),"domfocusin-domfocusout-events":require("./features/domfocusin-domfocusout-events"),"dommatrix":require("./features/dommatrix"),"download":require("./features/download"),"dragndrop":require("./features/dragndrop"),"element-closest":require("./features/element-closest"),"element-from-point":require("./features/element-from-point"),"eme":require("./features/eme"),"eot":require("./features/eot"),"es5":require("./features/es5"),"es6-class":require("./features/es6-class"),"es6-generators":require("./features/es6-generators"),"es6-module-dynamic-import":require("./features/es6-module-dynamic-import"),"es6-module-nomodule":require("./features/es6-module-nomodule"),"es6-module":require("./features/es6-module"),"es6-number":require("./features/es6-number"),"eventsource":require("./features/eventsource"),"fetch":require("./features/fetch"),"fieldset-disabled":require("./features/fieldset-disabled"),"fileapi":require("./features/fileapi"),"filereader":require("./features/filereader"),"filereadersync":require("./features/filereadersync"),"filesystem":require("./features/filesystem"),"flac":require("./features/flac"),"flexbox":require("./features/flexbox"),"flow-root":require("./features/flow-root"),"focusin-focusout-events":require("./features/focusin-focusout-events"),"font-feature":require("./features/font-feature"),"font-kerning":require("./features/font-kerning"),"font-loading":require("./features/font-loading"),"font-size-adjust":require("./features/font-size-adjust"),"font-smooth":require("./features/font-smooth"),"font-unicode-range":require("./features/font-unicode-range"),"font-variant-alternates":require("./features/font-variant-alternates"),"fontface":require("./features/fontface"),"form-attribute":require("./features/form-attribute"),"form-submit-attributes":require("./features/form-submit-attributes"),"form-validation":require("./features/form-validation"),"forms":require("./features/forms"),"fullscreen":require("./features/fullscreen"),"gamepad":require("./features/gamepad"),"geolocation":require("./features/geolocation"),"getboundingclientrect":require("./features/getboundingclientrect"),"getcomputedstyle":require("./features/getcomputedstyle"),"getelementsbyclassname":require("./features/getelementsbyclassname"),"getrandomvalues":require("./features/getrandomvalues"),"hardwareconcurrency":require("./features/hardwareconcurrency"),"hashchange":require("./features/hashchange"),"heif":require("./features/heif"),"hevc":require("./features/hevc"),"hidden":require("./features/hidden"),"high-resolution-time":require("./features/high-resolution-time"),"history":require("./features/history"),"html-media-capture":require("./features/html-media-capture"),"html5semantic":require("./features/html5semantic"),"http-live-streaming":require("./features/http-live-streaming"),"http2":require("./features/http2"),"iframe-sandbox":require("./features/iframe-sandbox"),"iframe-seamless":require("./features/iframe-seamless"),"iframe-srcdoc":require("./features/iframe-srcdoc"),"imagecapture":require("./features/imagecapture"),"ime":require("./features/ime"),"img-naturalwidth-naturalheight":require("./features/img-naturalwidth-naturalheight"),"imports":require("./features/imports"),"indeterminate-checkbox":require("./features/indeterminate-checkbox"),"indexeddb":require("./features/indexeddb"),"indexeddb2":require("./features/indexeddb2"),"inline-block":require("./features/inline-block"),"innertext":require("./features/innertext"),"input-autocomplete-onoff":require("./features/input-autocomplete-onoff"),"input-color":require("./features/input-color"),"input-datetime":require("./features/input-datetime"),"input-email-tel-url":require("./features/input-email-tel-url"),"input-event":require("./features/input-event"),"input-file-accept":require("./features/input-file-accept"),"input-file-directory":require("./features/input-file-directory"),"input-file-multiple":require("./features/input-file-multiple"),"input-inputmode":require("./features/input-inputmode"),"input-minlength":require("./features/input-minlength"),"input-number":require("./features/input-number"),"input-pattern":require("./features/input-pattern"),"input-placeholder":require("./features/input-placeholder"),"input-range":require("./features/input-range"),"input-search":require("./features/input-search"),"insert-adjacent":require("./features/insert-adjacent"),"insertadjacenthtml":require("./features/insertadjacenthtml"),"internationalization":require("./features/internationalization"),"intersectionobserver":require("./features/intersectionobserver"),"intrinsic-width":require("./features/intrinsic-width"),"jpeg2000":require("./features/jpeg2000"),"jpegxr":require("./features/jpegxr"),"json":require("./features/json"),"kerning-pairs-ligatures":require("./features/kerning-pairs-ligatures"),"keyboardevent-charcode":require("./features/keyboardevent-charcode"),"keyboardevent-code":require("./features/keyboardevent-code"),"keyboardevent-getmodifierstate":require("./features/keyboardevent-getmodifierstate"),"keyboardevent-key":require("./features/keyboardevent-key"),"keyboardevent-location":require("./features/keyboardevent-location"),"keyboardevent-which":require("./features/keyboardevent-which"),"lazyload":require("./features/lazyload"),"let":require("./features/let"),"link-icon-png":require("./features/link-icon-png"),"link-icon-svg":require("./features/link-icon-svg"),"link-rel-dns-prefetch":require("./features/link-rel-dns-prefetch"),"link-rel-preconnect":require("./features/link-rel-preconnect"),"link-rel-prefetch":require("./features/link-rel-prefetch"),"link-rel-preload":require("./features/link-rel-preload"),"link-rel-prerender":require("./features/link-rel-prerender"),"localecompare":require("./features/localecompare"),"matchesselector":require("./features/matchesselector"),"matchmedia":require("./features/matchmedia"),"mathml":require("./features/mathml"),"maxlength":require("./features/maxlength"),"media-attribute":require("./features/media-attribute"),"media-session-api":require("./features/media-session-api"),"mediacapture-fromelement":require("./features/mediacapture-fromelement"),"mediarecorder":require("./features/mediarecorder"),"mediasource":require("./features/mediasource"),"menu":require("./features/menu"),"meter":require("./features/meter"),"midi":require("./features/midi"),"minmaxwh":require("./features/minmaxwh"),"mp3":require("./features/mp3"),"mpeg4":require("./features/mpeg4"),"multibackgrounds":require("./features/multibackgrounds"),"multicolumn":require("./features/multicolumn"),"mutation-events":require("./features/mutation-events"),"mutationobserver":require("./features/mutationobserver"),"namevalue-storage":require("./features/namevalue-storage"),"nav-timing":require("./features/nav-timing"),"netinfo":require("./features/netinfo"),"node-contains":require("./features/node-contains"),"node-parentelement":require("./features/node-parentelement"),"notifications":require("./features/notifications"),"object-fit":require("./features/object-fit"),"object-observe":require("./features/object-observe"),"objectrtc":require("./features/objectrtc"),"offline-apps":require("./features/offline-apps"),"offscreencanvas":require("./features/offscreencanvas"),"ogg-vorbis":require("./features/ogg-vorbis"),"ogv":require("./features/ogv"),"ol-reversed":require("./features/ol-reversed"),"once-event-listener":require("./features/once-event-listener"),"online-status":require("./features/online-status"),"opus":require("./features/opus"),"outline":require("./features/outline"),"pad-start-end":require("./features/pad-start-end"),"page-transition-events":require("./features/page-transition-events"),"pagevisibility":require("./features/pagevisibility"),"passive-event-listener":require("./features/passive-event-listener"),"payment-request":require("./features/payment-request"),"permissions-api":require("./features/permissions-api"),"picture":require("./features/picture"),"ping":require("./features/ping"),"png-alpha":require("./features/png-alpha"),"pointer-events":require("./features/pointer-events"),"pointer":require("./features/pointer"),"pointerlock":require("./features/pointerlock"),"progress":require("./features/progress"),"promises":require("./features/promises"),"proximity":require("./features/proximity"),"proxy":require("./features/proxy"),"publickeypinning":require("./features/publickeypinning"),"push-api":require("./features/push-api"),"queryselector":require("./features/queryselector"),"readonly-attr":require("./features/readonly-attr"),"referrer-policy":require("./features/referrer-policy"),"registerprotocolhandler":require("./features/registerprotocolhandler"),"rel-noopener":require("./features/rel-noopener"),"rel-noreferrer":require("./features/rel-noreferrer"),"rellist":require("./features/rellist"),"rem":require("./features/rem"),"requestanimationframe":require("./features/requestanimationframe"),"requestidlecallback":require("./features/requestidlecallback"),"resizeobserver":require("./features/resizeobserver"),"resource-timing":require("./features/resource-timing"),"rest-parameters":require("./features/rest-parameters"),"rtcpeerconnection":require("./features/rtcpeerconnection"),"ruby":require("./features/ruby"),"same-site-cookie-attribute":require("./features/same-site-cookie-attribute"),"screen-orientation":require("./features/screen-orientation"),"script-async":require("./features/script-async"),"script-defer":require("./features/script-defer"),"scrollintoview":require("./features/scrollintoview"),"scrollintoviewifneeded":require("./features/scrollintoviewifneeded"),"sdch":require("./features/sdch"),"selection-api":require("./features/selection-api"),"serviceworkers":require("./features/serviceworkers"),"setimmediate":require("./features/setimmediate"),"sha-2":require("./features/sha-2"),"shadowdom":require("./features/shadowdom"),"shadowdomv1":require("./features/shadowdomv1"),"sharedworkers":require("./features/sharedworkers"),"sni":require("./features/sni"),"spdy":require("./features/spdy"),"speech-recognition":require("./features/speech-recognition"),"speech-synthesis":require("./features/speech-synthesis"),"spellcheck-attribute":require("./features/spellcheck-attribute"),"sql-storage":require("./features/sql-storage"),"srcset":require("./features/srcset"),"stopimmediatepropagation":require("./features/stopimmediatepropagation"),"stream":require("./features/stream"),"stricttransportsecurity":require("./features/stricttransportsecurity"),"style-scoped":require("./features/style-scoped"),"subresource-integrity":require("./features/subresource-integrity"),"svg-css":require("./features/svg-css"),"svg-filters":require("./features/svg-filters"),"svg-fonts":require("./features/svg-fonts"),"svg-fragment":require("./features/svg-fragment"),"svg-html":require("./features/svg-html"),"svg-html5":require("./features/svg-html5"),"svg-img":require("./features/svg-img"),"svg-smil":require("./features/svg-smil"),"svg":require("./features/svg"),"tabindex-attr":require("./features/tabindex-attr"),"template-literals":require("./features/template-literals"),"template":require("./features/template"),"testfeat":require("./features/testfeat"),"text-decoration":require("./features/text-decoration"),"text-emphasis":require("./features/text-emphasis"),"text-overflow":require("./features/text-overflow"),"text-size-adjust":require("./features/text-size-adjust"),"text-stroke":require("./features/text-stroke"),"textcontent":require("./features/textcontent"),"textencoder":require("./features/textencoder"),"tls1-1":require("./features/tls1-1"),"tls1-2":require("./features/tls1-2"),"tls1-3":require("./features/tls1-3"),"token-binding":require("./features/token-binding"),"touch":require("./features/touch"),"transforms2d":require("./features/transforms2d"),"transforms3d":require("./features/transforms3d"),"ttf":require("./features/ttf"),"typedarrays":require("./features/typedarrays"),"u2f":require("./features/u2f"),"upgradeinsecurerequests":require("./features/upgradeinsecurerequests"),"url":require("./features/url"),"urlsearchparams":require("./features/urlsearchparams"),"use-strict":require("./features/use-strict"),"user-select-none":require("./features/user-select-none"),"user-timing":require("./features/user-timing"),"vibration":require("./features/vibration"),"video":require("./features/video"),"videotracks":require("./features/videotracks"),"viewport-units":require("./features/viewport-units"),"wai-aria":require("./features/wai-aria"),"wasm":require("./features/wasm"),"wav":require("./features/wav"),"wbr-element":require("./features/wbr-element"),"web-animation":require("./features/web-animation"),"web-app-manifest":require("./features/web-app-manifest"),"web-bluetooth":require("./features/web-bluetooth"),"web-share":require("./features/web-share"),"webgl":require("./features/webgl"),"webgl2":require("./features/webgl2"),"webm":require("./features/webm"),"webp":require("./features/webp"),"websockets":require("./features/websockets"),"webvr":require("./features/webvr"),"webvtt":require("./features/webvtt"),"webworkers":require("./features/webworkers"),"will-change":require("./features/will-change"),"woff":require("./features/woff"),"woff2":require("./features/woff2"),"word-break":require("./features/word-break"),"wordwrap":require("./features/wordwrap"),"x-doc-messaging":require("./features/x-doc-messaging"),"x-frame-options":require("./features/x-frame-options"),"xhr2":require("./features/xhr2"),"xhtml":require("./features/xhtml"),"xhtmlsmil":require("./features/xhtmlsmil"),"xml-serializer":require("./features/xml-serializer")}; + +},{"./features/aac":121,"./features/ac3-ec3":122,"./features/addeventlistener":123,"./features/alternate-stylesheet":124,"./features/ambient-light":125,"./features/apng":126,"./features/arrow-functions":127,"./features/asmjs":128,"./features/async-functions":129,"./features/atob-btoa":130,"./features/audio":132,"./features/audio-api":131,"./features/audiotracks":133,"./features/autofocus":134,"./features/aux-click":135,"./features/background-attachment":136,"./features/background-img-opts":137,"./features/background-position-x-y":138,"./features/background-repeat-round-space":139,"./features/battery-status":140,"./features/beacon":141,"./features/beforeafterprint":142,"./features/blobbuilder":143,"./features/bloburls":144,"./features/border-image":145,"./features/border-radius":146,"./features/broadcastchannel":147,"./features/brotli":148,"./features/calc":149,"./features/canvas":152,"./features/canvas-blending":150,"./features/canvas-text":151,"./features/ch-unit":153,"./features/chacha20-poly1305":154,"./features/channel-messaging":155,"./features/childnode-remove":156,"./features/classlist":157,"./features/client-hints-dpr-width-viewport":158,"./features/clipboard":159,"./features/comparedocumentposition":160,"./features/console-basic":161,"./features/const":162,"./features/constraint-validation":163,"./features/contenteditable":164,"./features/contentsecuritypolicy":165,"./features/contentsecuritypolicy2":166,"./features/cors":167,"./features/credential-management":168,"./features/cryptography":169,"./features/css-all":170,"./features/css-animation":171,"./features/css-any-link":172,"./features/css-appearance":173,"./features/css-apply-rule":174,"./features/css-at-counter-style":175,"./features/css-backdrop-filter":176,"./features/css-background-offsets":177,"./features/css-backgroundblendmode":178,"./features/css-boxdecorationbreak":179,"./features/css-boxshadow":180,"./features/css-canvas":181,"./features/css-caret-color":182,"./features/css-case-insensitive":183,"./features/css-clip-path":184,"./features/css-conic-gradients":185,"./features/css-containment":186,"./features/css-counters":187,"./features/css-crisp-edges":188,"./features/css-cross-fade":189,"./features/css-default-pseudo":190,"./features/css-descendant-gtgt":191,"./features/css-deviceadaptation":192,"./features/css-dir-pseudo":193,"./features/css-display-contents":194,"./features/css-element-function":195,"./features/css-exclusions":196,"./features/css-featurequeries":197,"./features/css-filter-function":198,"./features/css-filters":199,"./features/css-first-letter":200,"./features/css-first-line":201,"./features/css-fixed":202,"./features/css-focus-within":203,"./features/css-font-rendering-controls":204,"./features/css-font-stretch":205,"./features/css-gencontent":206,"./features/css-gradients":207,"./features/css-grid":208,"./features/css-hanging-punctuation":209,"./features/css-has":210,"./features/css-hyphenate":211,"./features/css-hyphens":212,"./features/css-image-orientation":213,"./features/css-image-set":214,"./features/css-in-out-of-range":215,"./features/css-indeterminate-pseudo":216,"./features/css-initial-letter":217,"./features/css-initial-value":218,"./features/css-letter-spacing":219,"./features/css-line-clamp":220,"./features/css-logical-props":221,"./features/css-marker-pseudo":222,"./features/css-masks":223,"./features/css-matches-pseudo":224,"./features/css-media-interaction":225,"./features/css-media-resolution":226,"./features/css-media-scripting":227,"./features/css-mediaqueries":228,"./features/css-mixblendmode":229,"./features/css-motion-paths":230,"./features/css-namespaces":231,"./features/css-not-sel-list":232,"./features/css-nth-child-of":233,"./features/css-opacity":234,"./features/css-optional-pseudo":235,"./features/css-overflow-anchor":236,"./features/css-page-break":237,"./features/css-paged-media":238,"./features/css-placeholder":240,"./features/css-placeholder-shown":239,"./features/css-read-only-write":241,"./features/css-rebeccapurple":242,"./features/css-reflections":243,"./features/css-regions":244,"./features/css-repeating-gradients":245,"./features/css-resize":246,"./features/css-revert-value":247,"./features/css-rrggbbaa":248,"./features/css-scroll-behavior":249,"./features/css-scrollbar":250,"./features/css-sel2":251,"./features/css-sel3":252,"./features/css-selection":253,"./features/css-shapes":254,"./features/css-snappoints":255,"./features/css-sticky":256,"./features/css-supports-api":257,"./features/css-table":258,"./features/css-text-align-last":259,"./features/css-text-indent":260,"./features/css-text-justify":261,"./features/css-text-orientation":262,"./features/css-text-spacing":263,"./features/css-textshadow":264,"./features/css-touch-action":266,"./features/css-touch-action-2":265,"./features/css-transitions":267,"./features/css-unicode-bidi":268,"./features/css-unset-value":269,"./features/css-variables":270,"./features/css-widows-orphans":271,"./features/css-writing-mode":272,"./features/css-zoom":273,"./features/css3-attr":274,"./features/css3-boxsizing":275,"./features/css3-colors":276,"./features/css3-cursors":279,"./features/css3-cursors-grab":277,"./features/css3-cursors-newer":278,"./features/css3-tabsize":280,"./features/currentcolor":281,"./features/custom-elements":282,"./features/custom-elementsv1":283,"./features/customevent":284,"./features/datalist":285,"./features/dataset":286,"./features/datauri":287,"./features/details":288,"./features/deviceorientation":289,"./features/devicepixelratio":290,"./features/dialog":291,"./features/dispatchevent":292,"./features/document-currentscript":293,"./features/document-evaluate-xpath":294,"./features/document-execcommand":295,"./features/documenthead":296,"./features/dom-manip-convenience":297,"./features/dom-range":298,"./features/domcontentloaded":299,"./features/domfocusin-domfocusout-events":300,"./features/dommatrix":301,"./features/download":302,"./features/dragndrop":303,"./features/element-closest":304,"./features/element-from-point":305,"./features/eme":306,"./features/eot":307,"./features/es5":308,"./features/es6-class":309,"./features/es6-generators":310,"./features/es6-module":313,"./features/es6-module-dynamic-import":311,"./features/es6-module-nomodule":312,"./features/es6-number":314,"./features/eventsource":315,"./features/fetch":316,"./features/fieldset-disabled":317,"./features/fileapi":318,"./features/filereader":319,"./features/filereadersync":320,"./features/filesystem":321,"./features/flac":322,"./features/flexbox":323,"./features/flow-root":324,"./features/focusin-focusout-events":325,"./features/font-feature":326,"./features/font-kerning":327,"./features/font-loading":328,"./features/font-size-adjust":329,"./features/font-smooth":330,"./features/font-unicode-range":331,"./features/font-variant-alternates":332,"./features/fontface":333,"./features/form-attribute":334,"./features/form-submit-attributes":335,"./features/form-validation":336,"./features/forms":337,"./features/fullscreen":338,"./features/gamepad":339,"./features/geolocation":340,"./features/getboundingclientrect":341,"./features/getcomputedstyle":342,"./features/getelementsbyclassname":343,"./features/getrandomvalues":344,"./features/hardwareconcurrency":345,"./features/hashchange":346,"./features/heif":347,"./features/hevc":348,"./features/hidden":349,"./features/high-resolution-time":350,"./features/history":351,"./features/html-media-capture":352,"./features/html5semantic":353,"./features/http-live-streaming":354,"./features/http2":355,"./features/iframe-sandbox":356,"./features/iframe-seamless":357,"./features/iframe-srcdoc":358,"./features/imagecapture":359,"./features/ime":360,"./features/img-naturalwidth-naturalheight":361,"./features/imports":362,"./features/indeterminate-checkbox":363,"./features/indexeddb":364,"./features/indexeddb2":365,"./features/inline-block":366,"./features/innertext":367,"./features/input-autocomplete-onoff":368,"./features/input-color":369,"./features/input-datetime":370,"./features/input-email-tel-url":371,"./features/input-event":372,"./features/input-file-accept":373,"./features/input-file-directory":374,"./features/input-file-multiple":375,"./features/input-inputmode":376,"./features/input-minlength":377,"./features/input-number":378,"./features/input-pattern":379,"./features/input-placeholder":380,"./features/input-range":381,"./features/input-search":382,"./features/insert-adjacent":383,"./features/insertadjacenthtml":384,"./features/internationalization":385,"./features/intersectionobserver":386,"./features/intrinsic-width":387,"./features/jpeg2000":388,"./features/jpegxr":389,"./features/json":390,"./features/kerning-pairs-ligatures":391,"./features/keyboardevent-charcode":392,"./features/keyboardevent-code":393,"./features/keyboardevent-getmodifierstate":394,"./features/keyboardevent-key":395,"./features/keyboardevent-location":396,"./features/keyboardevent-which":397,"./features/lazyload":398,"./features/let":399,"./features/link-icon-png":400,"./features/link-icon-svg":401,"./features/link-rel-dns-prefetch":402,"./features/link-rel-preconnect":403,"./features/link-rel-prefetch":404,"./features/link-rel-preload":405,"./features/link-rel-prerender":406,"./features/localecompare":407,"./features/matchesselector":408,"./features/matchmedia":409,"./features/mathml":410,"./features/maxlength":411,"./features/media-attribute":412,"./features/media-session-api":413,"./features/mediacapture-fromelement":414,"./features/mediarecorder":415,"./features/mediasource":416,"./features/menu":417,"./features/meter":418,"./features/midi":419,"./features/minmaxwh":420,"./features/mp3":421,"./features/mpeg4":422,"./features/multibackgrounds":423,"./features/multicolumn":424,"./features/mutation-events":425,"./features/mutationobserver":426,"./features/namevalue-storage":427,"./features/nav-timing":428,"./features/netinfo":429,"./features/node-contains":430,"./features/node-parentelement":431,"./features/notifications":432,"./features/object-fit":433,"./features/object-observe":434,"./features/objectrtc":435,"./features/offline-apps":436,"./features/offscreencanvas":437,"./features/ogg-vorbis":438,"./features/ogv":439,"./features/ol-reversed":440,"./features/once-event-listener":441,"./features/online-status":442,"./features/opus":443,"./features/outline":444,"./features/pad-start-end":445,"./features/page-transition-events":446,"./features/pagevisibility":447,"./features/passive-event-listener":448,"./features/payment-request":449,"./features/permissions-api":450,"./features/picture":451,"./features/ping":452,"./features/png-alpha":453,"./features/pointer":455,"./features/pointer-events":454,"./features/pointerlock":456,"./features/progress":457,"./features/promises":458,"./features/proximity":459,"./features/proxy":460,"./features/publickeypinning":461,"./features/push-api":462,"./features/queryselector":463,"./features/readonly-attr":464,"./features/referrer-policy":465,"./features/registerprotocolhandler":466,"./features/rel-noopener":467,"./features/rel-noreferrer":468,"./features/rellist":469,"./features/rem":470,"./features/requestanimationframe":471,"./features/requestidlecallback":472,"./features/resizeobserver":473,"./features/resource-timing":474,"./features/rest-parameters":475,"./features/rtcpeerconnection":476,"./features/ruby":477,"./features/same-site-cookie-attribute":478,"./features/screen-orientation":479,"./features/script-async":480,"./features/script-defer":481,"./features/scrollintoview":482,"./features/scrollintoviewifneeded":483,"./features/sdch":484,"./features/selection-api":485,"./features/serviceworkers":486,"./features/setimmediate":487,"./features/sha-2":488,"./features/shadowdom":489,"./features/shadowdomv1":490,"./features/sharedworkers":491,"./features/sni":492,"./features/spdy":493,"./features/speech-recognition":494,"./features/speech-synthesis":495,"./features/spellcheck-attribute":496,"./features/sql-storage":497,"./features/srcset":498,"./features/stopimmediatepropagation":499,"./features/stream":500,"./features/stricttransportsecurity":501,"./features/style-scoped":502,"./features/subresource-integrity":503,"./features/svg":512,"./features/svg-css":504,"./features/svg-filters":505,"./features/svg-fonts":506,"./features/svg-fragment":507,"./features/svg-html":508,"./features/svg-html5":509,"./features/svg-img":510,"./features/svg-smil":511,"./features/tabindex-attr":513,"./features/template":515,"./features/template-literals":514,"./features/testfeat":516,"./features/text-decoration":517,"./features/text-emphasis":518,"./features/text-overflow":519,"./features/text-size-adjust":520,"./features/text-stroke":521,"./features/textcontent":522,"./features/textencoder":523,"./features/tls1-1":524,"./features/tls1-2":525,"./features/tls1-3":526,"./features/token-binding":527,"./features/touch":528,"./features/transforms2d":529,"./features/transforms3d":530,"./features/ttf":531,"./features/typedarrays":532,"./features/u2f":533,"./features/upgradeinsecurerequests":534,"./features/url":535,"./features/urlsearchparams":536,"./features/use-strict":537,"./features/user-select-none":538,"./features/user-timing":539,"./features/vibration":540,"./features/video":541,"./features/videotracks":542,"./features/viewport-units":543,"./features/wai-aria":544,"./features/wasm":545,"./features/wav":546,"./features/wbr-element":547,"./features/web-animation":548,"./features/web-app-manifest":549,"./features/web-bluetooth":550,"./features/web-share":551,"./features/webgl":552,"./features/webgl2":553,"./features/webm":554,"./features/webp":555,"./features/websockets":556,"./features/webvr":557,"./features/webvtt":558,"./features/webworkers":559,"./features/will-change":560,"./features/woff":561,"./features/woff2":562,"./features/word-break":563,"./features/wordwrap":564,"./features/x-doc-messaging":565,"./features/x-frame-options":566,"./features/xhr2":567,"./features/xhtml":568,"./features/xhtmlsmil":569,"./features/xml-serializer":570}],121:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","132":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","16":"B A"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"132":"t"},N:{"1":"B","2":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"AAC audio file format"}; + +},{}],122:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB","132":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","132":"B"},K:{"2":"6 7 B A D K","132":"y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"132":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"AC-3 (Dolby Digital) and EC-3 (Dolby Digital Plus) codecs"}; + +},{}],123:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","130":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","257":"2 SB F I J QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"EventTarget.addEventListener()"}; + +},{}],124:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D LB MB NB OB RB y","16":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"2":"lB"},R:{"16":"mB"}},B:1,C:"Alternate stylesheet"}; + +},{}],125:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","132":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","322":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"Ambient Light API"}; + +},{}],126:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"8 EB BB TB CB","2":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"6 7 A D p q r LB MB NB OB RB y","2":"E H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"6 7 B A D y","2":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Animated PNG (APNG)"}; + +},{}],127:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Arrow functions"}; + +},{}],128:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","322":"D"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W","132":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","132":"I"},Q:{"132":"lB"},R:{"132":"mB"}},B:6,C:"asm.js"}; + +},{}],129:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X","194":"g"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"4 5 8 t s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Async functions"}; + +},{}],130:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB","16":"NB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","16":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Base64 encoding and decoding"}; + +},{}],131:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB"},D:{"1":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","33":"B A D X g H L M N O P Q R S T U V W u Y Z a b c"},E:{"2":"9 F I DB FB","33":"J C G E B A GB HB IB JB KB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q"},G:{"2":"3 9 AB VB","33":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Web Audio API"}; + +},{}],132:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","132":"F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E","4":"LB MB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","2":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Audio element"}; + +},{}],133:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","194":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Audio Tracks"}; + +},{}],134:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Autofocus attribute"}; + +},{}],135:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","129":"0 1 4 5 t s"},D:{"1":"4 5 8 t s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"16":"lB"},R:{"1":"mB"}},B:5,C:"Auxclick"}; + +},{}],136:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","132":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","132":"E LB MB"},G:{"2":"3 9 AB","772":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 F s eB fB gB iB jB","132":"3 hB"},J:{"260":"C B"},K:{"1":"6 7 A D K y","132":"B"},L:{"1028":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"132":"kB"},P:{"2":"F","1028":"I"},Q:{"1":"lB"},R:{"1028":"mB"}},B:4,C:"CSS background-attachment"}; + +},{}],137:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","36":"PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","516":"F I J C G E B A D X g"},E:{"1":"C G E B A HB IB JB KB","772":"9 F I J DB FB GB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB","36":"MB"},G:{"1":"G A XB YB ZB aB bB cB","4":"3 9 AB WB","516":"VB"},H:{"132":"dB"},I:{"1":"s iB jB","36":"eB","516":"2 3 F hB","548":"fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Background-image options"}; + +},{}],138:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"background-position-x & background-position-y"}; + +},{}],139:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G UB","132":"E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"6 7 A D O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E H L M N LB MB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS background-repeat round and space"}; + +},{}],140:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"m n o p q r w x v","2":"0 1 2 4 5 SB F I J C G E z t s QB PB","132":"L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","164":"B A D X g H"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f","66":"K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"132":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"Battery Status API"}; + +},{}],141:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB"},D:{"1":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h"},E:{"1":"KB","2":"9 F I J C G E B A DB FB GB HB IB JB"},F:{"1":"V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Beacon API"}; + +},{}],142:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"2":"I","16":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:2,C:"Printing Events"}; + +},{}],143:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB","36":"J C G E B A D"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C","36":"G E B A D X g H L M N O"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","36":"2 3 F hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Blob constructing"}; + +},{}],144:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C","33":"G E B A D X g H L M N O P Q R"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","33":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"33":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Blob URLs"}; + +},{}],145:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"g H L","129":"D X"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB","260":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","804":"F I J C G E B A D X g QB PB"},D:{"260":"0 1 4 5 8 v z t s EB BB TB CB","388":"Z a b c d e f K h i j k l m n o p q r w x","1412":"H L M N O P Q R S T U V W u Y","1956":"F I J C G E B A D X g"},E:{"129":"B A IB JB KB","1412":"J C G E GB HB","1956":"9 F I DB FB"},F:{"2":"E LB MB","260":"h i j k l m n o p q r","388":"H L M N O P Q R S T U V W u Y Z a b c d e f K","1796":"NB OB","1828":"6 7 A D RB y"},G:{"129":"A aB bB cB","1412":"G WB XB YB ZB","1956":"3 9 AB VB"},H:{"1828":"dB"},I:{"388":"s iB jB","1956":"2 3 F eB fB gB hB"},J:{"1412":"B","1924":"C"},K:{"2":"B","388":"K","1828":"6 7 A D y"},L:{"260":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"388":"kB"},P:{"260":"I","388":"F"},Q:{"260":"lB"},R:{"260":"mB"}},B:4,C:"CSS3 Border images"}; + +},{}],146:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 x v z t s","257":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","289":"2 QB PB","292":"SB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F"},E:{"1":"I C G E B A HB IB JB KB","33":"9 F DB","129":"J FB GB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","33":"9"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","33":"eB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Border-radius (rounded corners)"}; + +},{}],147:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","2":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"BroadcastChannel"}; + +},{}],148:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","194":"w","257":"x"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","513":"A KB"},F:{"1":"h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y","194":"f K"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","257":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:6,C:"Brotli Accept-Encoding/Content-Encoding"}; + +},{}],149:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G UB","260":"E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"F I J C G E B A D X g H"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N","33":"O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","132":"iB jB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"calc() as CSS unit value"}; + +},{}],150:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Canvas blend modes"}; + +},{}],151:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","8":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Text API for Canvas"}; + +},{}],152:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","132":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","132":"9 DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"260":"dB"},I:{"1":"2 3 F s hB iB jB","132":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Canvas (basic support)"}; + +},{}],153:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"ch (character) unit"}; + +},{}],154:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b","129":"c d e f K h i j k l m n o p q r"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB","16":"jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ChaCha20-Poly1305 cipher suites for TLS"}; + +},{}],155:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB","194":"V W u Y Z a b c d e f K h i j"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB","16":"NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Channel messaging"}; + +},{}],156:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","16":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"ChildNode.remove()"}; + +},{}],157:[function(require,module,exports){ +module.exports={A:{A:{"8":"J C G E UB","900":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB","516":"T U","772":"F I J C G E B A D X g H L M N O P Q R S PB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J C","516":"T U V W","772":"S","900":"G E B A D X g H L M N O P Q R"},E:{"1":"C G E B A HB IB JB KB","8":"9 F I DB","900":"J FB GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","8":"7 E A LB MB NB OB","900":"6 D RB y"},G:{"1":"G A XB YB ZB aB bB cB","8":"3 9 AB","900":"VB WB"},H:{"900":"dB"},I:{"1":"s iB jB","8":"eB fB gB","900":"2 3 F hB"},J:{"1":"B","900":"C"},K:{"1":"K","8":"B A","900":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"900":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"classList (DOMTokenList)"}; + +},{}],158:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Client Hints: DPR, Width, Viewport-Width"}; + +},{}],159:[function(require,module,exports){ +module.exports={A:{A:{"2436":"J C G E B A UB"},B:{"2436":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","772":"R S T U V W u Y Z a b c d e f K h i j","4100":"0 1 4 5 k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D","2564":"X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","10244":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 DB","2308":"B A JB KB","2820":"F I J C G E FB GB HB IB"},F:{"2":"6 7 E A LB MB NB OB RB","16":"D","516":"y","2564":"H L M N O P Q R S T U V W u Y","10244":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB","2820":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","2308":"s iB jB"},J:{"2":"C","2308":"B"},K:{"2":"6 7 B A D","16":"y","3076":"K"},L:{"2052":"8"},M:{"1028":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2052":"I","2308":"F"},Q:{"10244":"lB"},R:{"2052":"mB"}},B:5,C:"Clipboard API"}; + +},{}],160:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","16":"2 SB QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g","132":"H L M N O P Q R S T U V W u Y"},E:{"1":"B A JB KB","16":"9 F I J DB","132":"C G E GB HB IB","260":"FB"},F:{"1":"D M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"6 7 E A LB MB NB OB","132":"H L"},G:{"1":"A bB cB","16":"9","132":"3 G AB VB WB XB YB ZB aB"},H:{"1":"dB"},I:{"1":"s iB jB","16":"eB fB","132":"2 3 F gB hB"},J:{"132":"C B"},K:{"1":"D K y","16":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.compareDocumentPosition()"}; + +},{}],161:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C UB","132":"G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"1":"3 9 AB VB","513":"G A WB XB YB ZB aB bB cB"},H:{"4097":"dB"},I:{"1025":"2 3 F s eB fB gB hB iB jB"},J:{"258":"C B"},K:{"2":"B","258":"6 7 A D K y"},L:{"1025":"8"},M:{"2049":"t"},N:{"258":"B A"},O:{"258":"kB"},P:{"1025":"F I"},Q:{"1":"lB"},R:{"1025":"mB"}},B:1,C:"Basic console logging functions"}; + +},{}],162:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D QB PB","260":"X g H L M N O P Q R S T U V W u Y Z a b c d e"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","260":"F I J C G E B A D X g H L M N O P","772":"Q R S T U V W u Y Z a b c d e f K h i j","1028":"k l m n o p q r"},E:{"1":"B A JB KB","260":"9 F I DB","772":"J C G E FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"E LB","132":"6 7 A MB NB OB","644":"D RB y","772":"H L M N O P Q R S T U V W","1028":"u Y Z a b c d e"},G:{"1":"A bB cB","260":"3 9 AB","772":"G VB WB XB YB ZB aB"},H:{"644":"dB"},I:{"1":"s","16":"eB fB","260":"gB","772":"2 3 F hB iB jB"},J:{"772":"C B"},K:{"1":"K","132":"6 7 B A","644":"D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"772":"kB"},P:{"1":"I","1028":"F"},Q:{"772":"lB"},R:{"1028":"mB"}},B:6,C:"const"}; + +},{}],163:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","900":"B A"},B:{"388":"g H L","900":"D X"},C:{"1":"0 1 4 5 v z t s","2":"2 SB QB PB","260":"w x","388":"Y Z a b c d e f K h i j k l m n o p q r","900":"F I J C G E B A D X g H L M N O P Q R S T U V W u"},D:{"1":"0 1 4 5 8 j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g","388":"U V W u Y Z a b c d e f K h i","900":"H L M N O P Q R S T"},E:{"1":"B A JB KB","16":"9 F I DB","388":"G E HB IB","900":"J C FB GB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","388":"H L M N O P Q R S T U V","900":"D RB y"},G:{"1":"A bB cB","16":"3 9 AB","388":"G XB YB ZB aB","900":"VB WB"},H:{"2":"dB"},I:{"1":"s","16":"2 eB fB gB","388":"iB jB","900":"3 F hB"},J:{"16":"C","388":"B"},K:{"1":"K","16":"6 7 B A","900":"D y"},L:{"1":"8"},M:{"1":"t"},N:{"900":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"388":"lB"},R:{"1":"mB"}},B:1,C:"Constraint Validation API"}; + +},{}],164:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB","4":"2"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"contenteditable attribute (basic support)"}; + +},{}],165:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","129":"F I J C G E B A D X g H L M N O P Q R"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X","257":"g H L M N O P Q R S T"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I DB","257":"J GB","260":"FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB","257":"WB","260":"VB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C","257":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"257":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Content Security Policy 1.0"}; + +},{}],166:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB","132":"a b c d","260":"e","516":"f K h i j k l m n","8196":"0 1 4 5 o p q r w x v z t s"},D:{"1":"0 1 4 5 8 j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e","1028":"f K h","2052":"i"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y","1028":"S T U","2052":"V"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"4100":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Content Security Policy Level 2"}; + +},{}],167:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C UB","132":"B","260":"G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D"},E:{"2":"9 DB","513":"J C G E B A GB HB IB JB KB","644":"F I FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB"},G:{"513":"G A WB XB YB ZB aB bB cB","644":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","132":"2 3 F eB fB gB hB"},J:{"1":"B","132":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","132":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Cross-Origin Resource Sharing"}; + +},{}],168:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","66":"r w x","129":"0 1 v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Credential Management API"}; + +},{}],169:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G E B","164":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","8":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB","322":"b c"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"1":"A","8":"9 F I J C DB FB GB","545":"G E B HB IB JB KB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","8":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A","8":"3 9 AB VB WB XB","545":"G YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","8":"2 3 F eB fB gB hB iB jB"},J:{"8":"C B"},K:{"1":"K","8":"6 7 B A D y"},L:{"1":"8"},M:{"8":"t"},N:{"8":"B","164":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Web Cryptography"}; + +},{}],170:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS all property"}; + +},{}],171:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F QB PB","33":"I J C G E B A D X g H"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"1":"E B A IB JB KB","2":"9 DB","33":"J C G FB GB HB","292":"F I"},F:{"1":"Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","33":"D H L M N O P Q R S T U V W u Y"},G:{"1":"A ZB aB bB cB","33":"G WB XB YB","164":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s","33":"3 F hB iB jB","164":"2 eB fB gB"},J:{"33":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"33":"kB"},P:{"1":"F I"},Q:{"33":"lB"},R:{"1":"mB"}},B:5,C:"CSS Animation"}; + +},{}],172:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 x v z t s","16":"2 SB F I J C G E B A D X g H L M N O P QB PB","33":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w"},D:{"16":"F I J C G E B A D X g H L M N O P Q R S","33":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 F I J DB FB","33":"C G E B A GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB","33":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"2 3 F eB fB gB hB iB jB","33":"s"},J:{"16":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"16":"F","33":"I"},Q:{"33":"lB"},R:{"33":"mB"}},B:5,C:"CSS :any-link selector"}; + +},{}],173:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"388":"D X g H L"},C:{"164":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","676":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB"},D:{"164":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"164":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"164":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"164":"2 3 F s eB fB gB hB iB jB"},J:{"164":"C B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"164":"t"},N:{"2":"B","388":"A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:5,C:"CSS Appearance"}; + +},{}],174:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","16":"H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","194":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y","194":"h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"2":"lB"},R:{"194":"mB"}},B:7,C:"CSS @apply rule"}; + +},{}],175:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","132":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"132":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS Counter Styles"}; + +},{}],176:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p","194":"0 1 4 5 8 q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","33":"E B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y","194":"d e f K h i j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB","33":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"194":"lB"},R:{"194":"mB"}},B:7,C:"CSS Backdrop Filter"}; + +},{}],177:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D QB PB"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS background-position edge offsets"}; + +},{}],178:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d","260":"p"},E:{"2":"9 F I J C DB FB GB","132":"G E B A HB IB JB KB"},F:{"1":"R S T U V W u Y Z a b d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y","260":"c"},G:{"2":"3 9 AB VB WB XB","132":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","260":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS background-blend-mode"}; + +},{}],179:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q","164":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J DB FB","164":"C G E B A GB HB IB JB KB"},F:{"2":"E LB MB NB OB","129":"6 7 A D RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB VB WB","164":"G A XB YB ZB aB bB cB"},H:{"132":"dB"},I:{"2":"2 3 F eB fB gB hB","164":"s iB jB"},J:{"2":"C","164":"B"},K:{"2":"B","129":"6 7 A D y","164":"K"},L:{"164":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:5,C:"CSS box-decoration-break"}; + +},{}],180:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","33":"QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E"},E:{"1":"J C G E B A FB GB HB IB JB KB","33":"I","164":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","33":"3 AB","164":"9"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","164":"2 eB fB gB"},J:{"1":"B","33":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Box-shadow"}; + +},{}],181:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"2":"0 1 4 5 8 r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"2":"9 DB","33":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D e f K h i j k l m n o p q r LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d"},G:{"33":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"s","33":"2 3 F eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"2":"I","33":"F"},Q:{"33":"lB"},R:{"2":"mB"}},B:7,C:"CSS Canvas Drawings"}; + +},{}],182:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS caret-color"}; + +},{}],183:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Case-insensitive CSS attribute selectors"}; + +},{}],184:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"1 4 5 t s","2":"2 SB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB","644":"0 q r w x v z"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S","260":"4 5 8 t s EB BB TB CB","292":"0 1 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J DB FB GB","292":"C G E B A HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","260":"l m n o p q r","292":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k"},G:{"2":"3 9 AB VB WB","292":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","260":"s","292":"iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","292":"K"},L:{"260":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"292":"kB"},P:{"292":"F I"},Q:{"292":"lB"},R:{"260":"mB"}},B:4,C:"CSS clip-path property (for HTML)"}; + +},{}],185:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o LB MB NB OB RB y","194":"p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Conical Gradients"}; + +},{}],186:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"1":"0 1 4 5 8 z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","194":"v"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y","194":"h i"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"CSS Containment"}; + +},{}],187:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS Counters"}; + +},{}],188:[function(require,module,exports){ +module.exports={A:{A:{"2":"J UB","2340":"C G E B A"},B:{"2":"D X g H L"},C:{"2":"2 SB QB","545":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","1025":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","2":"9 F I DB FB","164":"J","4644":"C G E GB HB IB"},F:{"2":"6 7 E A H L M N O P Q R S T U V W LB MB NB OB","545":"D RB y","1025":"u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A bB cB","2":"3 9 AB","4260":"VB WB","4644":"G XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","1025":"s"},J:{"2":"C","4260":"B"},K:{"2":"6 7 B A","545":"D y","1025":"K"},L:{"1025":"8"},M:{"545":"t"},N:{"2340":"B A"},O:{"4260":"kB"},P:{"1025":"F I"},Q:{"2":"lB"},R:{"1025":"mB"}},B:7,C:"Crisp edges/pixelated images"}; + +},{}],189:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L","33":"0 1 4 5 8 M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","2":"9 F I DB","33":"J C G E FB GB HB IB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A bB cB","2":"3 9 AB","33":"G VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","33":"s iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS Cross-Fade Function"}; + +},{}],190:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","16":"2 SB QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","16":"F I J C G E B A D X g","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"1":"A JB KB","16":"9 F I DB","132":"J C G E B FB GB HB IB"},F:{"1":"h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K","260":"D RB y"},G:{"1":"A cB","16":"3 9 AB VB WB","132":"G XB YB ZB aB bB"},H:{"260":"dB"},I:{"1":"s","16":"2 eB fB gB","132":"3 F hB iB jB"},J:{"16":"C","132":"B"},K:{"16":"6 7 B A D","132":"K","260":"y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"132":"kB"},P:{"1":"I","132":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:7,C:":default CSS pseudo-class"}; + +},{}],191:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Explicit descendant combinator >>"}; + +},{}],192:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","164":"B A"},B:{"164":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u","66":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","66":"j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"292":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"B K","292":"6 7 A D y"},L:{"2":"8"},M:{"2":"t"},N:{"164":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"66":"lB"},R:{"2":"mB"}},B:5,C:"CSS Device Adaptation"}; + +},{}],193:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L QB PB","33":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:":dir() CSS pseudo-class"}; + +},{}],194:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f QB PB"},D:{"2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS display: contents"}; + +},{}],195:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"33":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","164":"2 SB QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS element() function"}; + +},{}],196:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","33":"B A"},B:{"33":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"33":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Exclusions Level 1"}; + +},{}],197:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Feature Queries"}; + +},{}],198:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A IB JB KB","2":"9 F I J C G DB FB GB HB","33":"E"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB","33":"ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS filter() function"}; + +},{}],199:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1028":"X g H L","1346":"D"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","196":"d","516":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c PB"},D:{"1":"0 1 4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M","33":"N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"1":"B A IB JB KB","2":"9 F I DB FB","33":"J C G E GB HB"},F:{"1":"j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i"},G:{"1":"A aB bB cB","2":"3 9 AB VB","33":"G WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"2":"C","33":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:5,C:"CSS Filter Effects"}; + +},{}],200:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","16":"UB","516":"G","1540":"J C"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","132":"2","260":"SB"},D:{"1":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"I J C G","132":"F"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"I DB","132":"9 F"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"E LB","260":"6 7 A MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","16":"eB fB","132":"gB"},J:{"1":"C B"},K:{"1":"D K y","260":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"::first-letter CSS pseudo-element selector"}; + +},{}],201:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS first-line pseudo-element"}; + +},{}],202:[function(require,module,exports){ +module.exports={A:{A:{"1":"C G E B A","2":"UB","8":"J"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB","132":"VB WB XB"},H:{"2":"dB"},I:{"1":"2 s iB jB","260":"eB fB gB","513":"3 F hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS position:fixed"}; + +},{}],203:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"EB BB TB CB","2":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"8"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o LB MB NB OB RB y","194":"p"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:":focus-within CSS pseudo-class"}; + +},{}],204:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o QB PB","322":"0 1 4 5 p q r w x v z t s"},D:{"1":"EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","194":"0 1 4 5 8 w x v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y","194":"f K h i j k l m n o p"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"194":"lB"},R:{"2":"mB"}},B:7,C:"CSS font-rendering controls"}; + +},{}],205:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"CSS font-stretch"}; + +},{}],206:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C UB","132":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS Generated content for pseudo-elements"}; + +},{}],207:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","33":"F I J C G E B A D X g H PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"B A D X g H L M N O P Q R S T U","36":"F I J C G E"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 DB","33":"J FB","36":"F I"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E A LB MB NB OB","33":"D RB","164":"6 7"},G:{"1":"G A XB YB ZB aB bB cB","33":"VB WB","36":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","33":"3 F hB","36":"2 eB fB gB"},J:{"1":"B","36":"C"},K:{"1":"K y","2":"B A","33":"D","164":"6 7"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Gradients"}; + +},{}],208:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","8":"E","292":"B A"},B:{"1":"L","292":"D X g H"},C:{"1":"1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N QB PB","8":"O P Q R S T U V W u Y Z a b c d e f K h i","584":"j k l m n o p q r w x v","1025":"0 z"},D:{"1":"5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T","8":"U V W u","200":"0 1 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","1025":"4"},E:{"1":"A JB KB","2":"9 F I DB FB","8":"J C G E B GB HB IB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y","200":"u Y Z a b c d e f K h i j k l m"},G:{"1":"A cB","2":"3 9 AB VB","8":"G WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 F eB fB gB hB","8":"3 iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","8":"K"},L:{"1":"8"},M:{"1":"t"},N:{"292":"B A"},O:{"2":"kB"},P:{"2":"I","8":"F"},Q:{"200":"lB"},R:{"2":"mB"}},B:4,C:"CSS Grid Layout"}; + +},{}],209:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","16":"H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS hanging-punctuation"}; + +},{}],210:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:":has() CSS relational pseudo-class"}; + +},{}],211:[function(require,module,exports){ +module.exports={A:{A:{"16":"J C G E B A UB"},B:{"16":"D X g H L"},C:{"16":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 t s EB BB TB CB","16":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"16":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"16":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"16":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"16":"lB"},R:{"16":"mB"}},B:5,C:"CSS4 Hyphenation"}; + +},{}],212:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","33":"B A"},B:{"33":"D X g H L"},C:{"1":"0 1 4 5 m n o p q r w x v z t s","2":"2 SB F I QB PB","33":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},D:{"2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","132":"4 5 8 t s EB BB TB CB"},E:{"2":"9 F I DB","33":"J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y","132":"l m n o p q r"},G:{"2":"9 AB","33":"3 G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"132":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"36":"kB"},P:{"2":"F","132":"I"},Q:{"2":"lB"},R:{"132":"mB"}},B:5,C:"CSS Hyphenation"}; + +},{}],213:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"132":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 image-orientation"}; + +},{}],214:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P","33":"0 1 4 5 8 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I DB FB","33":"J C G E B A GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB VB","33":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","33":"s iB jB"},J:{"2":"C","33":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS image-set"}; + +},{}],215:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D","260":"X g H L"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","516":"Y Z a b c d e f K h i j k l m n o p q r w"},D:{"1":"0 1 4 5 8 t s EB BB TB CB","2":"F","16":"I J C G E B A D X g","260":"z","772":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v"},E:{"1":"A JB KB","2":"9 F DB","16":"I","772":"J C G E B FB GB HB IB"},F:{"1":"j k l m n o p q r","16":"E LB","260":"6 7 A D i MB NB OB RB y","772":"H L M N O P Q R S T U V W u Y Z a b c d e f K h"},G:{"1":"A cB","2":"3 9 AB","772":"G VB WB XB YB ZB aB bB"},H:{"132":"dB"},I:{"1":"s","2":"2 eB fB gB","260":"3 F hB iB jB"},J:{"2":"C","260":"B"},K:{"260":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"260":"kB"},P:{"1":"I","260":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:":in-range and :out-of-range CSS pseudo-classes"}; + +},{}],216:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","132":"B A","388":"E"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 v z t s","16":"2 SB QB PB","132":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","388":"F I"},D:{"1":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h"},E:{"1":"A JB KB","16":"9 F I J DB","132":"C G E B GB HB IB","388":"FB"},F:{"1":"V W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","132":"H L M N O P Q R S T U","516":"D RB y"},G:{"1":"A cB","16":"3 9 AB VB WB","132":"G XB YB ZB aB bB"},H:{"516":"dB"},I:{"1":"s","16":"2 eB fB gB jB","132":"iB","388":"3 F hB"},J:{"16":"C","132":"B"},K:{"1":"K","16":"6 7 B A D","516":"y"},L:{"1":"8"},M:{"132":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:":indeterminate CSS pseudo-class"}; + +},{}],217:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","4":"E","164":"B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB","164":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Initial Letter"}; + +},{}],218:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS initial value"}; + +},{}],219:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","16":"UB","132":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A GB HB IB JB KB","16":"DB","132":"9 F I J FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D H L MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"2":"dB"},I:{"1":"s iB jB","16":"eB fB","132":"2 3 F gB hB"},J:{"132":"C B"},K:{"1":"K","132":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"letter-spacing CSS property"}; + +},{}],220:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"16":"F I J C G E B A D X","33":"0 1 4 5 8 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F DB","33":"I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 AB","33":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","33":"2 3 F s gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS line-clamp"}; + +},{}],221:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"SB","164":"2 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j QB PB"},D:{"292":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"292":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","292":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"292":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"292":"2 3 F s eB fB gB hB iB jB"},J:{"292":"C B"},K:{"2":"6 7 B A D y","292":"K"},L:{"292":"8"},M:{"164":"t"},N:{"2":"B A"},O:{"292":"kB"},P:{"292":"F I"},Q:{"292":"lB"},R:{"292":"mB"}},B:7,C:"CSS Logical Properties"}; + +},{}],222:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS ::marker pseudo-element"}; + +},{}],223:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 t s","2":"2 SB","260":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB"},D:{"164":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","164":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"164":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"164":"s iB jB","676":"2 3 F eB fB gB hB"},J:{"164":"C B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:4,C:"CSS Masks"}; + +},{}],224:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"16":"2 SB QB PB","548":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"16":"F I J C G E B A D X g","164":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F DB","16":"I","164":"J C G FB GB HB","257":"E B A IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB WB","164":"G XB YB","257":"A ZB aB bB cB"},H:{"2":"dB"},I:{"16":"2 eB fB gB","164":"3 F s hB iB jB"},J:{"16":"C","164":"B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"548":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:5,C:":matches() CSS pseudo-class"}; + +},{}],225:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Media Queries: interaction media features"}; + +},{}],226:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","260":"F I J C G E B A D X g H QB PB"},D:{"1":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","548":"F I J C G E B A D X g H L M N O P Q R S T U V W u"},E:{"2":"9 DB","548":"F I J C G E B A FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E","548":"6 7 A D LB MB NB OB RB"},G:{"16":"9","548":"3 G A AB VB WB XB YB ZB aB bB cB"},H:{"132":"dB"},I:{"1":"s iB jB","16":"eB fB","548":"2 3 F gB hB"},J:{"548":"C B"},K:{"1":"K y","548":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Media Queries: resolution feature"}; + +},{}],227:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"16":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p LB MB NB OB RB y","16":"q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Media Queries: scripting media feature"}; + +},{}],228:[function(require,module,exports){ +module.exports={A:{A:{"8":"J C G UB","129":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","129":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","129":"F I J FB","388":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"G A XB YB ZB aB bB cB","129":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","129":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 Media Queries"}; + +},{}],229:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u","194":"Y Z a b c d e f K h i j"},E:{"2":"9 F I J C DB FB GB","260":"G E B A HB IB JB KB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB XB","260":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Blending of HTML/SVG elements"}; + +},{}],230:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","194":"m n o"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","194":"Z a b"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:7,C:"CSS Motion Path"}; + +},{}],231:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","16":"9 DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","16":"9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS namespaces"}; + +},{}],232:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t QB PB","16":"4 5 s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"selector list argument of :not()"}; + +},{}],233:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"selector list argument of :nth-child and :nth-last-child CSS pseudo-classes"}; + +},{}],234:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","4":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 Opacity"}; + +},{}],235:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"132":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","132":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:":optional CSS pseudo-class"}; + +},{}],236:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"CSS overflow-anchor (Scroll Anchoring)"}; + +},{}],237:[function(require,module,exports){ +module.exports={A:{A:{"388":"B A","900":"J C G E UB"},B:{"388":"D X g H L"},C:{"900":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"900":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"772":"B","900":"9 F I J C G E A DB FB GB HB IB JB KB"},F:{"16":"E LB","129":"6 7 A D MB NB OB RB y","900":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"900":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"129":"dB"},I:{"900":"2 3 F s eB fB gB hB iB jB"},J:{"900":"C B"},K:{"129":"6 7 B A D y","900":"K"},L:{"900":"8"},M:{"900":"t"},N:{"388":"B A"},O:{"900":"kB"},P:{"900":"F I"},Q:{"900":"lB"},R:{"900":"mB"}},B:2,C:"CSS page-break properties"}; + +},{}],238:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","132":"G E B A"},B:{"132":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N QB PB","132":"0 1 4 5 O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","132":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D y","258":"K"},L:{"1":"8"},M:{"132":"t"},N:{"258":"B A"},O:{"258":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS Paged Media (@page)"}; + +},{}],239:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:":placeholder-shown CSS pseudo-class"}; + +},{}],240:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","36":"B A"},B:{"36":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB QB PB","33":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","164":"F I J C G E B A D X g H L M N"},D:{"1":"4 5 8 EB BB TB CB","36":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"1":"A JB KB","2":"9 F DB","36":"I J C G E B FB GB HB IB"},F:{"1":"n o p q r","2":"6 7 E A D LB MB NB OB RB y","36":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m"},G:{"1":"A cB","2":"9 AB","36":"3 G VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","36":"2 3 F eB fB gB hB iB jB"},J:{"36":"C B"},K:{"2":"6 7 B A D y","36":"K"},L:{"1":"8"},M:{"1":"t"},N:{"36":"B A"},O:{"36":"kB"},P:{"36":"F I"},Q:{"36":"lB"},R:{"1":"mB"}},B:5,C:"::placeholder CSS pseudo-element"}; + +},{}],241:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"16":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB","33":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"16":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","132":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 F I J DB FB GB","132":"C G E B A HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB WB XB","132":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"16":"C B"},K:{"2":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"33":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"2":"F","132":"I"},Q:{"132":"lB"},R:{"132":"mB"}},B:1,C:"CSS :read-only and :read-write selectors"}; + +},{}],242:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB","16":"GB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Rebeccapurple color"}; + +},{}],243:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"33":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","33":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"33":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"33":"2 3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS Reflections"}; + +},{}],244:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","420":"B A"},B:{"420":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g e f K h i j k l m n o p q r w x v z t s EB BB TB CB","36":"H L M N","66":"O P Q R S T U V W u Y Z a b c d"},E:{"2":"9 F I J DB FB","33":"C G E B A GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB","33":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"420":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Regions"}; + +},{}],245:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","33":"F I J C G E B A D X g H PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","33":"B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB","33":"J FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E A LB MB NB OB","33":"D RB","36":"6 7"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB","33":"VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","33":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"B A","33":"D","36":"6 7"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Repeating Gradients"}; + +},{}],246:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"F"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS resize property"}; + +},{}],247:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS revert value"}; + +},{}],248:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","194":"0 1 4 5 8 z t s EB BB"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h LB MB NB OB RB y","194":"i j k l m n o p q r"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"194":"lB"},R:{"194":"mB"}},B:7,C:"#rrggbbaa hex color notation"}; + +},{}],249:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","450":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y","450":"u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"450":"lB"},R:{"2":"mB"}},B:5,C:"CSSOM Scroll-behavior"}; + +},{}],250:[function(require,module,exports){ +module.exports={A:{A:{"132":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"289":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 F I DB","289":"J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","289":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB VB WB","289":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","289":"2 3 F s gB hB iB jB"},J:{"289":"C B"},K:{"2":"6 7 B A D y","289":"K"},L:{"289":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"289":"kB"},P:{"289":"F I"},Q:{"289":"lB"},R:{"289":"mB"}},B:7,C:"CSS scrollbar styling"}; + +},{}],251:[function(require,module,exports){ +module.exports={A:{A:{"1":"C G E B A","2":"UB","8":"J"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS 2.1 selectors"}; + +},{}],252:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J","132":"C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 selectors"}; + +},{}],253:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"33":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 D K y","16":"7 B A"},L:{"1":"8"},M:{"33":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"::selection CSS pseudo-element"}; + +},{}],254:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","194":"d e f"},E:{"1":"A JB KB","2":"9 F I J C DB FB GB","33":"G E B HB IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 AB VB WB XB","33":"G YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Shapes Level 1"}; + +},{}],255:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","6308":"B","6436":"A"},B:{"6436":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h QB PB","2052":"0 1 4 5 i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A KB","2":"9 F I J C G DB FB GB HB","3108":"E B IB JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB","3108":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2052":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS Scroll snap points"}; + +},{}],256:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB","194":"V W u Y Z a","516":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R K h i j k l m n o p q r w x v","322":"0 1 S T U V W u Y Z a b c d e f z t","1028":"4 5 8 s EB BB TB CB"},E:{"2":"9 F I J DB FB","33":"G E B A HB IB JB KB","2084":"C GB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h LB MB NB OB RB y","322":"i j k","1028":"l m n o p q r"},G:{"2":"3 9 AB VB","33":"G A YB ZB aB bB cB","2084":"WB XB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","1028":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1028":"8"},M:{"516":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"322":"lB"},R:{"2":"mB"}},B:5,C:"CSS position:sticky"}; + +},{}],257:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O QB PB","66":"P Q R"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"132":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS.supports() API"}; + +},{}],258:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","132":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS Table display"}; + +},{}],259:[function(require,module,exports){ +module.exports={A:{A:{"132":"J C G E B A UB"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A QB PB","33":"D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d","322":"e f K h i j k l m n o p"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y","578":"R S T U V W u Y Z a b c"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 text-align-last"}; + +},{}],260:[function(require,module,exports){ +module.exports={A:{A:{"132":"J C G E B A UB"},B:{"132":"D X g H L"},C:{"132":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K","388":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"132":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"132":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y","388":"U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"132":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"132":"dB"},I:{"132":"2 3 F s eB fB gB hB iB jB"},J:{"132":"C B"},K:{"132":"6 7 B A D y","388":"K"},L:{"388":"8"},M:{"132":"t"},N:{"132":"B A"},O:{"132":"kB"},P:{"132":"F","388":"I"},Q:{"388":"lB"},R:{"388":"mB"}},B:5,C:"CSS text-indent"}; + +},{}],261:[function(require,module,exports){ +module.exports={A:{A:{"16":"J C UB","132":"G E B A"},B:{"132":"D X g H L"},C:{"2":"0 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","1025":"4 5 t s","1602":"1"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","322":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","322":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","322":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","322":"K"},L:{"322":"8"},M:{"1025":"t"},N:{"132":"B A"},O:{"2":"kB"},P:{"2":"F","322":"I"},Q:{"322":"lB"},R:{"322":"mB"}},B:5,C:"CSS text-justify"}; + +},{}],262:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"2":"9 F I J C G E DB FB GB HB IB","16":"B","33":"A JB KB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"CSS text-orientation"}; + +},{}],263:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","161":"G E B A"},B:{"161":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"16":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"CSS Text 4 text-spacing"}; + +},{}],264:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","129":"B A"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","260":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"B","4":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Text-shadow"}; + +},{}],265:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"A","164":"B"},B:{"132":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","260":"t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y","260":"l"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"132":"A","164":"B"},O:{"2":"kB"},P:{"1":"I","16":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"CSS touch-action level 2 values"}; + +},{}],266:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E UB","289":"B"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","194":"Y Z a b c d e f K h i j k l m n o p q r w x v","1025":"0 1 4 5 z t s"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB","516":"A aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","289":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS touch-action property"}; + +},{}],267:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"I J C G E B A D X g H","164":"F"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","33":"J FB","164":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB","33":"D","164":"6 7 A NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","33":"WB","164":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","33":"2 3 F eB fB gB hB"},J:{"1":"B","33":"C"},K:{"1":"K y","33":"D","164":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 Transitions"}; + +},{}],268:[function(require,module,exports){ +module.exports={A:{A:{"132":"J C G E B A UB"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 x v z t s","33":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","132":"2 SB F I J C G E QB PB","292":"B A D X g H L"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L","548":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"132":"9 F I J C G DB FB GB HB","548":"E B A IB JB KB"},F:{"132":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"132":"3 9 G AB VB WB XB YB","548":"A ZB aB bB cB"},H:{"16":"dB"},I:{"1":"s","16":"2 3 F eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"16":"lB"},R:{"16":"mB"}},B:4,C:"CSS unicode-bidi property"}; + +},{}],269:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"CSS unset value"}; + +},{}],270:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","260":"H L"},C:{"1":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","194":"r"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","194":"e"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS Variables (Custom Properties)"}; + +},{}],271:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C UB","129":"G E"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","129":"6 7 E A LB MB NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS widows & orphans"}; + +},{}],272:[function(require,module,exports){ +module.exports={A:{A:{"132":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB","322":"f K h i j"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J","16":"C","33":"G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q"},E:{"2":"9 F DB","16":"I","33":"J C G E B A FB GB HB IB JB KB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d"},G:{"16":"3 9 AB","33":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","33":"2 3 F hB iB jB"},J:{"33":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"36":"B A"},O:{"33":"kB"},P:{"1":"I","33":"F"},Q:{"33":"lB"},R:{"1":"mB"}},B:4,C:"CSS writing-mode property"}; + +},{}],273:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C UB","129":"G E B A"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"CSS zoom"}; + +},{}],274:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 attr() function"}; + +},{}],275:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","8":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","33":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E"},E:{"1":"J C G E B A FB GB HB IB JB KB","33":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"G A VB WB XB YB ZB aB bB cB","33":"3 9 AB"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","33":"2 eB fB gB"},J:{"1":"B","33":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Box-sizing"}; + +},{}],276:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E","4":"LB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS3 Colors"}; + +},{}],277:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","33":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"33":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"33":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D RB y","2":"6 7 E A LB MB NB OB","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"33":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 Cursors: grab & grabbing"}; + +},{}],278:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","33":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"1":"E B A IB JB KB","33":"9 F I J C G DB FB GB HB"},F:{"1":"D T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB","33":"H L M N O P Q R S"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 Cursors: zoom-in & zoom-out"}; + +},{}],279:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"g H L","260":"D X"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","4":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","260":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"CSS3 Cursors (original values)"}; + +},{}],280:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB QB PB","33":"0 1 4 5 t s","164":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},D:{"1":"0 1 4 5 8 l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P","132":"Q R S T U V W u Y Z a b c d e f K h i j k"},E:{"2":"9 F I J DB FB","132":"C G E B A GB HB IB JB KB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"E LB MB NB","132":"H L M N O P Q R S T U V W u","164":"6 7 A D OB RB y"},G:{"2":"3 9 AB VB WB","132":"G A XB YB ZB aB bB cB"},H:{"164":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","132":"iB jB"},J:{"132":"C B"},K:{"1":"K","2":"B","164":"6 7 A D y"},L:{"1":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 tab-size"}; + +},{}],281:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS currentColor value"}; + +},{}],282:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"8":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB","194":"S T U V W u Y","200":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V","66":"W u Y Z a b"},E:{"2":"9 F I DB FB","8":"J C G E B A GB HB IB JB KB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","66":"H L M N O"},G:{"2":"3 9 AB VB WB","8":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"200":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Custom Elements v0"}; + +},{}],283:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"8":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB","8":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","8":"0 z","132":"1 4 5 8 t s EB BB TB CB"},E:{"2":"9 F I J C DB FB GB HB","8":"G E B IB","132":"A JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j LB MB NB OB RB y","132":"k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB ZB aB bB","132":"A cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"132":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","132":"I"},Q:{"8":"lB"},R:{"132":"mB"}},B:1,C:"Custom Elements v1"}; + +},{}],284:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB","132":"J C G E B"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","16":"I J C G X g","388":"E B A D"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F DB","16":"I J","388":"FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","132":"6 7 A"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"AB","16":"3 9","388":"VB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","388":"2 3 F hB"},J:{"1":"B","388":"C"},K:{"1":"D K y","2":"B","132":"6 7 A"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"CustomEvent"}; + +},{}],285:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G E","260":"B A"},B:{"260":"D X g H L"},C:{"8":"2 SB QB PB","516":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"8":"F I J C G E B A D X g H L M N O","132":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"8":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"8":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"jB","8":"2 3 F eB fB gB hB iB","132":"s"},J:{"1":"B","8":"C"},K:{"1":"6 7 B A D y","8":"K"},L:{"1":"8"},M:{"516":"t"},N:{"8":"B A"},O:{"8":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Datalist element"}; + +},{}],286:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","4":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","4":"2 SB F I QB PB","129":"0 1 4 5 v z t s"},D:{"1":"0 1 o p q r w x v z","4":"F I J","129":"4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n t s EB BB TB CB"},E:{"4":"9 F I DB","129":"J C G E B A FB GB HB IB JB KB"},F:{"1":"6 7 D b c d e f K h i j k RB y","4":"E A LB MB NB OB","129":"H L M N O P Q R S T U V W u Y Z a l m n o p q r"},G:{"4":"3 9 AB","129":"G A VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"4":"eB fB gB","129":"2 3 F s hB iB jB"},J:{"129":"C B"},K:{"1":"6 7 D y","4":"B A","129":"K"},L:{"129":"8"},M:{"129":"t"},N:{"1":"A","4":"B"},O:{"129":"kB"},P:{"129":"F I"},Q:{"1":"lB"},R:{"129":"mB"}},B:1,C:"dataset & data-* attributes"}; + +},{}],287:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","132":"G","260":"E B A"},B:{"260":"D X H L","772":"g"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Data URIs"}; + +},{}],288:[function(require,module,exports){ +module.exports={A:{A:{"2":"E B A UB","8":"J C G"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"SB","8":"2 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB","194":"q r"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J C G E B A","257":"O P Q R S T U V W u Y Z a b c d e","769":"D X g H L M N"},E:{"1":"A JB KB","8":"9 F I DB FB","257":"J C G E B GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 D RB y","8":"E A LB MB NB OB"},G:{"1":"G A WB XB YB ZB aB bB cB","8":"3 9 AB VB"},H:{"8":"dB"},I:{"1":"3 F s hB iB jB","8":"2 eB fB gB"},J:{"1":"B","8":"C"},K:{"1":"K","8":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"769":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Details & Summary elements"}; + +},{}],289:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"1":"D X g H L"},C:{"2":"2 SB QB","4":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"F I PB"},D:{"2":"F I J","4":"0 1 4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"9 AB","4":"3 G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"eB fB gB","4":"2 3 F s hB iB jB"},J:{"2":"C","4":"B"},K:{"1":"D y","2":"6 7 B A","4":"K"},L:{"4":"8"},M:{"4":"t"},N:{"1":"A","2":"B"},O:{"4":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:4,C:"DeviceOrientation & DeviceMotion events"}; + +},{}],290:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Window.devicePixelRatio"}; + +},{}],291:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","194":"0 1 4 5 t s"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a","322":"b c d e f"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N LB MB NB OB RB y","578":"O P Q R S"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Dialog element"}; + +},{}],292:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","16":"UB","129":"E B","130":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","129":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"EventTarget.dispatchEvent"}; + +},{}],293:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"document.currentScript"}; + +},{}],294:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"document.evaluate & XPath"}; + +},{}],295:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","16":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"G A XB YB ZB aB bB cB","2":"9 AB","16":"3 VB WB"},H:{"2":"dB"},I:{"1":"3 hB iB jB","2":"2 F s eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Document.execCommand()"}; + +},{}],296:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"document.head"}; + +},{}],297:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","194":"0 z"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","194":"j"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"194":"lB"},R:{"2":"mB"}},B:1,C:"DOM manipulation convenience methods"}; + +},{}],298:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Document Object Model Range"}; + +},{}],299:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"DOMContentLoaded"}; + +},{}],300:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"6 7 E A LB MB NB OB"},G:{"1":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"DOMFocusIn & DOMFocusOut events"}; + +},{}],301:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","516":"c d e f K h i j k l m n o p q r"},D:{"16":"F I J C","132":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","388":"G"},E:{"1":"A KB","16":"9 F DB","132":"I J C G E B FB GB HB IB JB"},F:{"2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"3 9 AB","132":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"132":"3 F s hB iB jB","292":"2 eB fB gB"},J:{"16":"C","132":"B"},K:{"2":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"132":"kB"},P:{"132":"F I"},Q:{"132":"lB"},R:{"132":"mB"}},B:4,C:"DOMMatrix"}; + +},{}],302:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Download attribute"}; + +},{}],303:[function(require,module,exports){ +module.exports={A:{A:{"644":"J C G E UB","772":"B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","8":"6 7 E A LB MB NB OB RB"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"y","2":"K","8":"6 7 B A D"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Drag and Drop"}; + +},{}],304:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"Element.closest()"}; + +},{}],305:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"SB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"I J C G E B A FB GB HB IB JB KB","16":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"E LB MB NB OB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"D K y","16":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"document.elementFromPoint()"}; + +},{}],306:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","164":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"0 1 4 5 8 l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d","132":"e f K h i j k"},E:{"2":"9 F I J DB FB GB","164":"C G E B A HB IB JB KB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y","132":"R S T U V W u"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:3,C:"Encrypted Media Extensions"}; + +},{}],307:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"EOT - Embedded OpenType fonts"}; + +},{}],308:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C UB","260":"E","1026":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"2 SB QB PB","132":"F I J C G E B A D X g H L M N O P"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N","132":"O P Q R"},E:{"1":"J C G E B A GB HB IB JB KB","4":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","4":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"1":"G A WB XB YB ZB aB bB cB","4":"3 9 AB VB"},H:{"132":"dB"},I:{"1":"s iB jB","4":"2 eB fB gB","132":"3 hB","900":"F"},J:{"1":"B","4":"C"},K:{"1":"K","4":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ECMAScript 5"}; + +},{}],309:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k","132":"l m n o p q r"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y","132":"Y Z a b c d e"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"ES6 classes"}; + +},{}],310:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB"},D:{"1":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"ES6 Generators"}; + +},{}],311:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"KB","2":"9 F I J C G E B DB FB GB HB IB","16":"A","130":"JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB aB bB","16":"A","130":"cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"JavaScript modules: dynamic import()"}; + +},{}],312:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H","514":"L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","322":"4 5 t s"},D:{"1":"BB TB CB","2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"EB"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q LB MB NB OB RB y","194":"r"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"JavaScript modules: nomodule attribute"}; + +},{}],313:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","194":"H L"},C:{"2":"0 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","322":"1 4 5 t s"},D:{"1":"BB TB CB","2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","194":"EB"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p LB MB NB OB RB y","194":"q r"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"322":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"JavaScript modules via script tag"}; + +},{}],314:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H QB PB","132":"L M N O P Q R S T","260":"U V W u Y Z","516":"a"},D:{"1":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N","1028":"O P Q R S T U V W u Y Z a b c"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"1":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","1028":"H L M N O P"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 F eB fB gB","1028":"3 hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ES6 Number"}; + +},{}],315:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","4":"E LB MB NB OB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 D K y","4":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Server-sent events"}; + +},{}],316:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c QB PB","1025":"i","1218":"d e f K h"},D:{"1":"0 1 4 5 8 l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i","260":"j","772":"k"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y","260":"W","772":"u"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Fetch"}; + +},{}],317:[function(require,module,exports){ +module.exports={A:{A:{"16":"UB","132":"G E","388":"J C B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","16":"L M N O"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"388":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B","260":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"disabled attribute of the fieldset element"}; + +},{}],318:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","260":"B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","260":"F I J C G E B A D X g H L M N O P Q R S T U V W PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","260":"X g H L M N O P Q R S T U V W u Y Z a b c d e f K","388":"J C G E B A D"},E:{"1":"B A JB KB","2":"9 F I DB","260":"J C G E GB HB IB","388":"FB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E A LB MB NB OB","260":"6 7 D H L M N O P Q R S T RB y"},G:{"1":"A bB cB","2":"3 9 AB VB","260":"G WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s jB","2":"eB fB gB","260":"iB","388":"2 3 F hB"},J:{"260":"B","388":"C"},K:{"1":"K","2":"B A","260":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B","260":"A"},O:{"260":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"File API"}; + +},{}],319:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E A LB MB NB OB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 D K y","2":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"FileReader API"}; + +},{}],320:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB","16":"6 7 A NB OB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 D K y","2":"B","16":"7 A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"FileReaderSync"}; + +},{}],321:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C","33":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","36":"G E B A D"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","33":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","33":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Filesystem & FileWriter API"}; + +},{}],322:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"4 5 8 s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m","16":"n o p","388":"0 1 q r w x v z t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","16":"2 3 F hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"y","16":"6 7 B A D","129":"K"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","129":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"FLAC audio format"}; + +},{}],323:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","1028":"A","1316":"B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","164":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","516":"R S T U V W"},D:{"1":"0 1 4 5 8 Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"Q R S T U V W u","164":"F I J C G E B A D X g H L M N O P"},E:{"1":"E B A IB JB KB","33":"C G GB HB","164":"9 F I J DB FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB","33":"H L"},G:{"1":"A ZB aB bB cB","33":"G XB YB","164":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"s iB jB","164":"2 3 F eB fB gB hB"},J:{"1":"B","164":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","292":"B"},O:{"164":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Flexible Box Layout Module"}; + +},{}],324:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB"},D:{"1":"5 8 EB BB TB CB","2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"display: flow-root"}; + +},{}],325:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","16":"6 7 A"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","2":"eB fB gB","16":"2"},J:{"1":"C B"},K:{"1":"D K y","2":"B","16":"6 7 A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"focusin & focusout events"}; + +},{}],326:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"H L M N O P Q R S T U V W u Y Z a b c","164":"F I J C G E B A D X g"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","33":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","292":"L M N O P"},E:{"1":"B A IB JB KB","2":"9 C G E DB GB HB","4":"F I J FB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d"},G:{"1":"A aB bB cB","2":"G XB YB ZB","4":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"2":"C","33":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"33":"kB"},P:{"1":"I","33":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS font-feature-settings"}; + +},{}],327:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB","194":"T U V W u Y Z a b c"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u","33":"Y Z a b"},E:{"1":"B A IB JB KB","2":"9 F I J DB FB GB","33":"C G E HB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H LB MB NB OB RB y","33":"L M N O"},G:{"2":"3 9 AB VB WB XB","33":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB","33":"iB"},J:{"2":"C","33":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 font-kerning"}; + +},{}],328:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB","194":"e f K h i j"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS Font Loading"}; + +},{}],329:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","194":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","194":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"258":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"194":"lB"},R:{"2":"mB"}},B:4,C:"CSS font-size-adjust"}; + +},{}],330:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB","804":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F","676":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","676":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"6 7 E A D LB MB NB OB RB y","676":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"CSS font-smooth"}; + +},{}],331:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","4":"E B A"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB","194":"f K h i j k l m"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"1":"B A JB KB","4":"9 F I J C G E DB FB GB HB IB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R"},G:{"1":"A bB cB","4":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","4":"2 3 F eB fB gB hB iB jB"},J:{"2":"C","4":"B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"4":"kB"},P:{"1":"I","4":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:4,C:"Font unicode-range subsetting"}; + +},{}],332:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","130":"B A"},B:{"130":"D X g H L"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","130":"F I J C G E B A D X g H L M N O P Q R S","322":"T U V W u Y Z a b c"},D:{"2":"F I J C G E B A D X g H","130":"0 1 4 5 8 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A IB JB KB","2":"9 C G E DB GB HB","130":"F I J FB"},F:{"2":"6 7 E A D LB MB NB OB RB y","130":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A aB bB cB","2":"9 G XB YB ZB","130":"3 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","130":"s iB jB"},J:{"2":"C","130":"B"},K:{"2":"6 7 B A D y","130":"K"},L:{"130":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"130":"kB"},P:{"130":"F I"},Q:{"130":"lB"},R:{"130":"mB"}},B:4,C:"CSS font-variant-alternates"}; + +},{}],333:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","132":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E LB"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","260":"9 AB"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","2":"eB","4":"2 fB gB"},J:{"1":"B","4":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"@font-face Web fonts"}; + +},{}],334:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Form attribute"}; + +},{}],335:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB","16":"MB NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","2":"eB fB gB","16":"2"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","16":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Attributes for form submission"}; + +},{}],336:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E"},E:{"1":"A JB KB","2":"9 F DB","132":"I J C G E B FB GB HB IB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E LB"},G:{"1":"A cB","2":"9","132":"3 G AB VB WB XB YB ZB aB bB"},H:{"516":"dB"},I:{"1":"s jB","2":"2 eB fB gB","132":"3 F hB iB"},J:{"1":"B","132":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Form validation"}; + +},{}],337:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","4":"B A","8":"J C G E"},B:{"4":"D X g H L"},C:{"4":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB PB"},D:{"4":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"4":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"9","4":"3 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","4":"s iB jB"},J:{"2":"C","4":"B"},K:{"1":"6 7 B A D y","4":"K"},L:{"4":"8"},M:{"4":"t"},N:{"4":"B A"},O:{"1":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:1,C:"HTML5 form features"}; + +},{}],338:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","548":"A"},B:{"516":"D X g H L"},C:{"2":"2 SB F I J C G E QB PB","676":"B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p","1700":"0 1 4 5 q r w x v z t s"},D:{"2":"F I J C G E B A D X g","676":"H L M N O","804":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I DB","676":"FB","804":"J C G E B A GB HB IB JB KB"},F:{"1":"y","2":"6 7 E A D LB MB NB OB RB","804":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","292":"B"},K:{"2":"6 7 B A D y","804":"K"},L:{"804":"8"},M:{"1700":"t"},N:{"2":"B","548":"A"},O:{"804":"kB"},P:{"804":"F I"},Q:{"804":"lB"},R:{"804":"mB"}},B:1,C:"Full Screen API"}; + +},{}],339:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P","33":"Q R S T"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Gamepad API"}; + +},{}],340:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","8":"2 SB","129":"4 5 t s"},D:{"1":"I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","4":"F","129":"0 1 4 5 8 x v z t s EB BB TB CB"},E:{"1":"I J C G E A FB GB HB IB JB KB","8":"9 F DB","129":"B"},F:{"1":"6 7 A D L M N O P Q R S T U V W u Y Z a b c d e f K h OB RB y","2":"E H LB","8":"MB NB","129":"i j k l m n o p q r"},G:{"1":"3 9 G AB VB WB XB YB ZB aB","129":"A bB cB"},H:{"2":"dB"},I:{"1":"2 3 F eB fB gB hB iB jB","129":"s"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"129":"8"},M:{"129":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F","129":"I"},Q:{"129":"lB"},R:{"129":"mB"}},B:2,C:"Geolocation"}; + +},{}],341:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","644":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","260":"F I J C G E B A","1156":"2","1284":"QB","1796":"PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","16":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","16":"E LB","132":"MB NB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","132":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Element.getBoundingClientRect()"}; + +},{}],342:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","132":"2 QB PB"},D:{"1":"0 1 4 5 8 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","260":"F I J C G E B"},E:{"1":"I J C G E B A FB GB HB IB JB KB","260":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","260":"E LB MB NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","260":"3 9 AB"},H:{"260":"dB"},I:{"1":"3 F s hB iB jB","260":"2 eB fB gB"},J:{"1":"B","260":"C"},K:{"1":"6 7 A D K y","260":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"getComputedStyle"}; + +},{}],343:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"getElementsByClassName"}; + +},{}],344:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","33":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P QB PB"},D:{"1":"0 1 4 5 8 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B","33":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"crypto.getRandomValues()"}; + +},{}],345:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},E:{"2":"9 F I J C DB FB GB HB","129":"A JB KB","194":"G E B IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB XB","129":"A cB","194":"G YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"navigator.hardwareConcurrency"}; + +},{}],346:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","8":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","8":"2 SB QB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","8":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","8":"E LB MB NB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","2":"eB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Hashchange event"}; + +},{}],347:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","129":"A KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB aB bB cB","129":"A"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"HEIF/ISO Base Media File Format"}; + +},{}],348:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"132":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","513":"A KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","258":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"258":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","258":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"HEVC/H.265 video format"}; + +},{}],349:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","2":"2 eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 D K y","2":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"hidden attribute"}; + +},{}],350:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O","33":"P Q R S"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A ZB aB bB cB","2":"3 9 AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"High Resolution Time API"}; + +},{}],351:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F DB","4":"I FB"},F:{"1":"6 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"7 E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"9 AB","4":"3"},H:{"2":"dB"},I:{"1":"3 s fB gB iB jB","2":"2 F eB hB"},J:{"1":"C B"},K:{"1":"6 7 D K y","2":"B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Session history management"}; + +},{}],352:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB VB","129":"G A WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB","257":"fB gB"},J:{"1":"B","16":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"516":"kB"},P:{"1":"F I"},Q:{"16":"lB"},R:{"1":"mB"}},B:4,C:"HTML Media Capture"}; + +},{}],353:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G","260":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","132":"2 QB PB","260":"F I J C G E B A D X g H L M N O P"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I","260":"J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","132":"9 F DB","260":"I J FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","132":"E A LB MB NB OB","260":"6 7 D RB y"},G:{"1":"G A XB YB ZB aB bB cB","132":"9","260":"3 AB VB WB"},H:{"132":"dB"},I:{"1":"s iB jB","132":"eB","260":"2 3 F fB gB hB"},J:{"260":"C B"},K:{"1":"K","132":"B","260":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"260":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"New semantic elements"}; + +},{}],354:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"HTTP Live Streaming (HLS)"}; + +},{}],355:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","388":"A"},B:{"257":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB","257":"0 1 4 5 f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","257":"k l m n o p q r w x","1281":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","772":"E B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W LB MB NB OB RB y","257":"u Y Z a b c d e f K","1281":"h i j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB","257":"A ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","257":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","257":"K"},L:{"1281":"8"},M:{"257":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"257":"F","1281":"I"},Q:{"1281":"lB"},R:{"257":"mB"}},B:6,C:"HTTP/2 protocol"}; + +},{}],356:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L QB PB","4":"M N O P Q R S T U V W"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","2":"9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","2":"eB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"sandbox attribute for iframes"}; + +},{}],357:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","16":"0 1 4 5 z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","66":"P Q R S T U V"},E:{"2":"9 F I J G E B A DB FB GB IB JB KB","130":"C HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB YB ZB aB bB cB","130":"XB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"seamless attribute for iframes"}; + +},{}],358:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G E B A"},B:{"8":"D X g H L"},C:{"1":"0 1 4 5 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"SB","8":"2 F I J C G E B A D X g H L M N O P Q R S T QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X","8":"g H L M N O"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 DB","8":"F I FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E A LB MB NB OB","8":"6 7 D RB y"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"9","8":"3 AB VB"},H:{"2":"dB"},I:{"1":"s iB jB","8":"2 3 F eB fB gB hB"},J:{"1":"B","8":"C"},K:{"1":"K","2":"B A","8":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"srcdoc attribute for iframes"}; + +},{}],359:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB","194":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","322":"0 1 4 5 8 t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","322":"j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"322":"lB"},R:{"1":"mB"}},B:5,C:"ImageCapture API"}; + +},{}],360:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","161":"A"},B:{"161":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B","161":"A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Input Method Editor API"}; + +},{}],361:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"naturalWidth & naturalHeight image properties"}; + +},{}],362:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"8":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB","8":"Z a","200":"0 1 4 5 b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y","322":"Z a b c d","584":"e"},E:{"2":"9 F I DB FB","8":"J C G E B A GB HB IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y","1090":"M N O P Q","2120":"R"},G:{"2":"3 9 AB VB WB","8":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"HTML Imports"}; + +},{}],363:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB","16":"QB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"indeterminate checkbox"}; + +},{}],364:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"B A D X g H","36":"F I J C G E"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"B","8":"F I J C G E","33":"S","36":"A D X g H L M N O P Q R"},E:{"1":"B A JB KB","8":"9 F I J C DB FB GB","260":"G E HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E LB MB","8":"6 7 A D NB OB RB y"},G:{"1":"A bB cB","8":"3 9 AB VB WB XB","260":"G YB ZB aB"},H:{"2":"dB"},I:{"1":"s iB jB","8":"2 3 F eB fB gB hB"},J:{"1":"B","8":"C"},K:{"1":"K","2":"B","8":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"IndexedDB"}; + +},{}],365:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB","132":"n o p","260":"q r w x"},D:{"1":"5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q","132":"r w x v","260":"0 1 4 z t s"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","132":"e f K h","260":"i j k l m n"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB","16":"bB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","260":"s"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D y","132":"K"},L:{"260":"8"},M:{"16":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"16":"F","260":"I"},Q:{"16":"lB"},R:{"16":"mB"}},B:5,C:"IndexedDB 2.0"}; + +},{}],366:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","4":"UB","132":"J C"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","36":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS inline-block"}; + +},{}],367:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.innerText"}; + +},{}],368:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B UB","132":"A"},B:{"132":"D X g H L"},C:{"1":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB","516":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"M N O P Q R S T U V","2":"F I J C G E B A D X g H L","132":"W u Y Z a b c d e f K h i j","260":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J FB GB","2":"9 F I DB","2052":"C G E B A HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB","1025":"G A VB WB XB YB ZB aB bB cB"},H:{"1025":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2052":"B A"},O:{"1025":"kB"},P:{"1":"F I"},Q:{"260":"lB"},R:{"1":"mB"}},B:1,C:"autocomplete attribute: on & off values"}; + +},{}],369:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"6 7 A D M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E H L LB MB NB OB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Color input type"}; + +},{}],370:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","132":"D"},C:{"1":"4 5","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","1090":"0 1 t s"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 AB","260":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","514":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Date and time input types"}; + +},{}],371:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","132":"eB fB gB"},J:{"1":"B","132":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Email, telephone & URL input types"}; + +},{}],372:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","2561":"B A","2692":"E"},B:{"2561":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","16":"SB","1537":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r PB","1796":"2 QB"},D:{"16":"F I J C G E B A D X g","1025":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","1537":"H L M N O P Q R S T U V W u Y Z a b c d"},E:{"16":"9 F I J DB","1025":"C G E B A GB HB IB JB KB","1537":"FB"},F:{"1":"y","16":"6 7 E A D LB MB NB OB","260":"RB","1025":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","1537":"H L M N O P Q"},G:{"16":"3 9 AB","1025":"G A YB ZB aB bB cB","1537":"VB WB XB"},H:{"2":"dB"},I:{"16":"eB fB","1025":"s jB","1537":"2 3 F gB hB iB"},J:{"1025":"B","1537":"C"},K:{"1":"6 7 B A D y","1025":"K"},L:{"1025":"8"},M:{"1537":"t"},N:{"2561":"B A"},O:{"1537":"kB"},P:{"1025":"F I"},Q:{"1025":"lB"},R:{"1025":"mB"}},B:1,C:"input event"}; + +},{}],373:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","16":"I J C G Q R S T U","132":"E B A D X g H L M N O P"},E:{"2":"9 F I DB FB","132":"J C G E B A GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"WB XB","132":"G A YB ZB aB bB cB","514":"3 9 AB VB"},H:{"2":"dB"},I:{"2":"eB fB gB","260":"2 3 F hB","514":"s iB jB"},J:{"132":"B","260":"C"},K:{"2":"6 7 B A D y","260":"K"},L:{"260":"8"},M:{"2":"t"},N:{"514":"B","1028":"A"},O:{"2":"kB"},P:{"260":"F I"},Q:{"1":"lB"},R:{"260":"mB"}},B:1,C:"accept attribute for file input"}; + +},{}],374:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Directory selection from file input"}; + +},{}],375:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB NB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"130":"dB"},I:{"130":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"130":"6 7 B A D K y"},L:{"132":"8"},M:{"130":"t"},N:{"2":"B A"},O:{"130":"kB"},P:{"130":"F","132":"I"},Q:{"1":"lB"},R:{"132":"mB"}},B:1,C:"Multiple file selection"}; + +},{}],376:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L QB PB","4":"M N O P","194":"0 1 4 5 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"194":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"inputmode attribute"}; + +},{}],377:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB"},D:{"1":"0 1 4 5 8 j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"Minimum length attribute for input fields"}; + +},{}],378:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","129":"B A"},B:{"129":"D X","1025":"g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","513":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"388":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 eB fB gB","388":"3 F s hB iB jB"},J:{"2":"C","388":"B"},K:{"1":"6 7 B A D y","388":"K"},L:{"388":"8"},M:{"641":"t"},N:{"388":"B A"},O:{"388":"kB"},P:{"388":"F I"},Q:{"1":"lB"},R:{"388":"mB"}},B:1,C:"Number input type"}; + +},{}],379:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E"},E:{"1":"A JB KB","2":"9 F DB","16":"I","388":"J C G E B FB GB HB IB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"A cB","16":"3 9 AB","388":"G VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D y","132":"K"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Pattern attribute for input fields"}; + +},{}],380:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","132":"9 F DB"},F:{"1":"6 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","132":"7 A"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 s eB fB gB iB jB","4":"F hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"input placeholder attribute"}; + +},{}],381:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"3 s iB jB","4":"2 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Range input type"}; + +},{}],382:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","129":"B A"},B:{"129":"D X g H L"},C:{"2":"2 SB QB PB","129":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g Q R S T U","129":"H L M N O P"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB","16":"6 7 A"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"129":"dB"},I:{"1":"s iB jB","16":"eB fB","129":"2 3 F gB hB"},J:{"1":"C","129":"B"},K:{"1":"D","2":"B","16":"6 7 A","129":"K y"},L:{"1":"8"},M:{"129":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Search input type"}; + +},{}],383:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Element.insertAdjacentElement() & Element.insertAdjacentText()"}; + +},{}],384:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","16":"UB","132":"J C G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Element.insertAdjacentHTML()"}; + +},{}],385:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Internationalization API"}; + +},{}],386:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB","194":"0 1 z"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"IntersectionObserver"}; + +},{}],387:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"SB","932":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q","545":"R S T U V W u Y Z a b c d e f K h i j k l m n o","1537":"0 1 4 5 8 p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J DB FB","516":"A KB","548":"E B IB JB","676":"C G GB HB"},F:{"2":"6 7 E A D LB MB NB OB RB y","513":"d","545":"H L M N O P Q R S T U V W u Y Z a b","1537":"c e f K h i j k l m n o p q r"},G:{"2":"3 9 AB VB WB","548":"A ZB aB bB cB","676":"G XB YB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","545":"iB jB","1537":"s"},J:{"2":"C","545":"B"},K:{"2":"6 7 B A D y","1537":"K"},L:{"1537":"8"},M:{"932":"t"},N:{"2":"B A"},O:{"545":"kB"},P:{"545":"F","1537":"I"},Q:{"545":"lB"},R:{"1537":"mB"}},B:5,C:"Intrinsic & Extrinsic Sizing"}; + +},{}],388:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F DB","129":"I FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"JPEG 2000 image format"}; + +},{}],389:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"JPEG XR image format"}; + +},{}],390:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C UB","129":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"JSON parsing"}; + +},{}],391:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","16":"9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"eB fB gB","132":"2 3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Improved kerning pairs & ligatures"}; + +},{}],392:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","16":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"y","2":"6 7 B A","16":"D","130":"K"},L:{"1":"8"},M:{"130":"t"},N:{"130":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"KeyboardEvent.charCode"}; + +},{}],393:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"0 1 4 5 8 r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k","194":"l m n o p q"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y","194":"Y Z a b c d"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","194":"K"},L:{"194":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","194":"I"},Q:{"2":"lB"},R:{"194":"mB"}},B:5,C:"KeyboardEvent.code"}; + +},{}],394:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A H L LB MB NB OB RB","16":"D"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K y","2":"6 7 B A","16":"D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"KeyboardEvent.getModifierState()"}; + +},{}],395:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","260":"E B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB","132":"S T U V W u"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"h i j k l m n o p q r y","2":"6 7 E A H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB","16":"D"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"y","2":"6 7 B A K","16":"D"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"KeyboardEvent.key"}; + +},{}],396:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A GB HB IB JB KB","16":"9 J DB","132":"F I FB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D","132":"H L"},G:{"1":"G A YB ZB aB bB cB","16":"3 9 AB","132":"VB WB XB"},H:{"2":"dB"},I:{"1":"s iB jB","16":"eB fB","132":"2 3 F gB hB"},J:{"132":"C B"},K:{"1":"K y","2":"6 7 B A","16":"D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"KeyboardEvent.location"}; + +},{}],397:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","16":"I"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","16":"E LB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB","16":"eB fB","132":"iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D y","132":"K"},L:{"132":"8"},M:{"132":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"2":"F","132":"I"},Q:{"1":"lB"},R:{"132":"mB"}},B:7,C:"KeyboardEvent.which"}; + +},{}],398:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Resource Hints: Lazyload"}; + +},{}],399:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","194":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N","322":"O P Q R S T U V W u Y Z a b c d e f K h i j","516":"k l m n o p q r"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","322":"H L M N O P Q R S T U V W","516":"u Y Z a b c d e"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"I","516":"F"},Q:{"2":"lB"},R:{"516":"mB"}},B:6,C:"let"}; + +},{}],400:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"129":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"257":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"129":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","513":"6 7 E A D LB MB NB OB RB y"},G:{"1026":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1026":"dB"},I:{"1":"2 3 F eB fB gB hB","513":"s iB jB"},J:{"1":"C","1026":"B"},K:{"1026":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1026":"B A"},O:{"257":"kB"},P:{"1":"I","513":"F"},Q:{"129":"lB"},R:{"1":"mB"}},B:1,C:"PNG favicons"}; + +},{}],401:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB QB PB","260":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","1025":"0 1 4 5 k l m n o p q r w x v z t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","516":"E B A IB JB KB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m LB MB NB OB RB y"},G:{"130":"3 9 G AB VB WB XB YB","516":"A ZB aB bB cB"},H:{"130":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","130":"B"},K:{"130":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"130":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"SVG favicons"}; + +},{}],402:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G UB","132":"E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"16":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: dns-prefetch"}; + +},{}],403:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h QB PB","129":"i"},D:{"1":"0 1 4 5 8 p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"16":"t"},N:{"2":"B A"},O:{"16":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: preconnect"}; + +},{}],404:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"F s iB jB","2":"2 3 eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: prefetch"}; + +},{}],405:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t QB PB","132":"4 5 s"},D:{"1":"0 1 4 5 8 x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"Resource Hints: preload"}; + +},{}],406:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"5 8 F I J C G E B A D EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Resource Hints: prerender"}; + +},{}],407:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","16":"UB","132":"J C G E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S"},E:{"1":"B A JB KB","132":"9 F I J C G E DB FB GB HB IB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A D LB MB NB OB RB","132":"y"},G:{"1":"A bB cB","132":"3 9 G AB VB WB XB YB ZB aB"},H:{"132":"dB"},I:{"1":"s iB jB","132":"2 3 F eB fB gB hB"},J:{"132":"C B"},K:{"1":"K","16":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","132":"B"},O:{"132":"kB"},P:{"1":"I","132":"F"},Q:{"132":"lB"},R:{"1":"mB"}},B:6,C:"localeCompare()"}; + +},{}],408:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","36":"E B A"},B:{"1":"H L","36":"D X g"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB","36":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c PB"},D:{"1":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","36":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c"},E:{"1":"G E B A HB IB JB KB","2":"9 F DB","36":"I J C FB GB"},F:{"1":"Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"7 E A LB MB NB OB","36":"6 D H L M N O P RB y"},G:{"1":"G A YB ZB aB bB cB","2":"9","36":"3 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s","2":"eB","36":"2 3 F fB gB hB iB jB"},J:{"36":"C B"},K:{"1":"K","2":"B A","36":"6 7 D y"},L:{"1":"8"},M:{"1":"t"},N:{"36":"B A"},O:{"36":"kB"},P:{"1":"I","36":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"matches() DOM method"}; + +},{}],409:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"1":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"matchMedia"}; + +},{}],410:[function(require,module,exports){ +module.exports={A:{A:{"2":"E B A UB","8":"J C G"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","129":"2 SB QB PB"},D:{"1":"T","8":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"B A JB KB","260":"9 F I J C G E DB FB GB HB IB"},F:{"2":"E","4":"6 7 A D LB MB NB OB RB y","8":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"G A VB WB XB YB ZB aB bB cB","8":"3 9 AB"},H:{"8":"dB"},I:{"8":"2 3 F s eB fB gB hB iB jB"},J:{"1":"B","8":"C"},K:{"8":"6 7 B A D K y"},L:{"8":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"4":"kB"},P:{"8":"F I"},Q:{"8":"lB"},R:{"8":"mB"}},B:2,C:"MathML"}; + +},{}],411:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","16":"UB","900":"J C G E"},B:{"1025":"D X g H L"},C:{"1":"0 1 4 5 v z t s","900":"2 SB QB PB","1025":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"I DB","900":"9 F"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E","132":"6 7 A D LB MB NB OB RB y"},G:{"1":"3 A AB VB WB XB ZB aB bB cB","16":"9","2052":"G YB"},H:{"132":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"132":"6 7 B A D y","4100":"K"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"4100":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"maxlength attribute for input and textarea elements"}; + +},{}],412:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","2":"0 1 4 5 8 d e f K h i j k l m n o p q r w x v z t s EB","16":"BB TB CB"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T MB NB OB RB y","2":"E U V W u Y Z a b c d e f K h i j k l m n o p q r LB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"1":"D K y","16":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"Media attribute"}; + +},{}],413:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"2":"9 F I J C G E B DB FB GB HB IB JB","16":"A KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p LB MB NB OB RB y","16":"q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Media Session API"}; + +},{}],414:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","193":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Media Capture from DOM Elements API"}; + +},{}],415:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p","194":"q r"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y","194":"d e"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:5,C:"MediaRecorder API"}; + +},{}],416:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","260":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB","194":"U V W u Y Z a b c d e f K h i j k"},D:{"1":"0 1 4 5 8 a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L","33":"S T U V W u Y Z","66":"M N O P Q R"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"I","514":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"Media Source Extensions"}; + +},{}],417:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C QB PB","132":"0 1 4 5 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","322":"r w x v","578":"k l m n o p q","2114":"0 1 4 5 8 z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","322":"e f K h","2114":"i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1156":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2114":"lB"},R:{"2":"mB"}},B:1,C:"Toolbar/context menu"}; + +},{}],418:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"meter element"}; + +},{}],419:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Web MIDI API"}; + +},{}],420:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","8":"J UB","129":"C","257":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"CSS min/max-width/height"}; + +},{}],421:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","132":"F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","2":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"MP3 audio format"}; + +},{}],422:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P QB PB","4":"Q R S T U V W u Y Z a b c d"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","4":"2 3 F eB fB hB","132":"gB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"260":"t"},N:{"1":"B A"},O:{"4":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"MPEG-4/H.264 video format"}; + +},{}],423:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Multiple backgrounds"}; + +},{}],424:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"132":"0 1 4 5 z t s","164":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"132":"0 1 4 5 8 x v z t s EB BB TB CB","420":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w"},E:{"132":"E B A IB JB KB","164":"C G HB","420":"9 F I J DB FB GB"},F:{"1":"6 7 D RB y","2":"E A LB MB NB OB","132":"K h i j k l m n o p q r","420":"H L M N O P Q R S T U V W u Y Z a b c d e f"},G:{"132":"A ZB aB bB cB","164":"G XB YB","420":"3 9 AB VB WB"},H:{"1":"dB"},I:{"132":"s","420":"2 3 F eB fB gB hB iB jB"},J:{"420":"C B"},K:{"1":"6 7 D y","2":"B A","132":"K"},L:{"132":"8"},M:{"132":"t"},N:{"1":"B A"},O:{"420":"kB"},P:{"132":"I","420":"F"},Q:{"132":"lB"},R:{"132":"mB"}},B:4,C:"CSS3 Multiple column layout"}; + +},{}],425:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","260":"E B A"},B:{"260":"D X g H L"},C:{"2":"2 SB F I QB PB","260":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"16":"F I J C G E B A D X g","132":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"16":"9 DB","132":"F I J C G E B A FB GB HB IB JB KB"},F:{"1":"D RB y","2":"E LB MB NB OB","16":"6 7 A","132":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"16":"9 AB","132":"3 G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","132":"2 3 F s gB hB iB jB"},J:{"132":"C B"},K:{"1":"D y","2":"B","16":"6 7 A","132":"K"},L:{"132":"8"},M:{"260":"t"},N:{"260":"B A"},O:{"132":"kB"},P:{"132":"F I"},Q:{"132":"lB"},R:{"132":"mB"}},B:5,C:"Mutation events"}; + +},{}],426:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G UB","8":"E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X QB PB"},D:{"1":"0 1 4 5 8 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M","33":"N O P Q R S T U V"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 eB fB gB","8":"3 F hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","8":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Mutation Observer"}; + +},{}],427:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","2":"UB","8":"J C"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Web Storage - name/value pairs"}; + +},{}],428:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J QB PB"},D:{"1":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","33":"J C G E B A D"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A ZB aB bB cB","2":"3 9 AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"3 F s hB iB jB","2":"2 eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Navigation Timing API"}; + +},{}],429:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB iB jB","132":"2 3 F fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","132":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:7,C:"Network Information API"}; + +},{}],430:[function(require,module,exports){ +module.exports={A:{A:{"16":"UB","644":"E B A","2308":"J C G"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","16":"9 F I J DB","1668":"FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","16":"6 7 E A D LB MB NB OB","132":"RB"},G:{"1":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"16":"dB"},I:{"1":"s iB jB","16":"2 eB fB gB","1668":"3 F hB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.contains()"}; + +},{}],431:[function(require,module,exports){ +module.exports={A:{A:{"16":"UB","132":"E B A","260":"J C G"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"6 7 E A LB MB NB OB","132":"D RB y"},G:{"1":"G A WB XB YB ZB aB bB cB","16":"3 9 AB VB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.parentElement"}; + +},{}],432:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","36":"I J C G E B A D X g H L M N O P Q"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","36":"s iB jB"},J:{"1":"B","2":"C"},K:{"2":"6 7 B A D y","36":"K"},L:{"258":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"36":"F","258":"I"},Q:{"2":"lB"},R:{"258":"mB"}},B:1,C:"Web Notifications"}; + +},{}],433:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"1":"0 1 4 5 8 a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z"},E:{"1":"B A JB KB","2":"9 F I J C DB FB GB","132":"G E HB IB"},F:{"1":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E H L M N LB MB NB","33":"6 7 A D OB RB y"},G:{"1":"A bB cB","2":"3 9 AB VB WB XB","132":"G YB ZB aB"},H:{"33":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB iB"},J:{"2":"C B"},K:{"1":"K","2":"B","33":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 object-fit/object-position"}; + +},{}],434:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"f K h i j k l m n o p q r w","2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f","2":"6 7 E A D H L M N O P Q R K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F","2":"I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Object.observe data binding"}; + +},{}],435:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","130":"B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Object RTC (ORTC) API for WebRTC"}; + +},{}],436:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"E UB","8":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"2","8":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB","8":"MB NB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Offline web applications"}; + +},{}],437:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB","194":"0 1 4 5 n o p q r w x v z t s"},D:{"2":"0 1 4 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","322":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n LB MB NB OB RB y","322":"o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"194":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"OffscreenCanvas"}; + +},{}],438:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"B","2":"C"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Ogg Vorbis audio format"}; + +},{}],439:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","8":"E B A"},B:{"8":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Ogg/Theora video format"}; + +},{}],440:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB"},D:{"1":"0 1 4 5 8 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","16":"L M N O"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","16":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Reversed attribute of ordered lists"}; + +},{}],441:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"1":"0 1 4 5 x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w QB PB"},D:{"1":"4 5 8 t s EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"\"once\" event listener option"}; + +},{}],442:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C UB","260":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s QB PB","2":"2 SB","516":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},D:{"1":"0 1 4 5 8 g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB","4":"y"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","16":"9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"B","132":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"132":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Online/offline status"}; + +},{}],443:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Opus"}; + +},{}],444:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","260":"G","388":"E B A"},B:{"1":"H L","388":"D X g"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB","129":"y","260":"6 7 E A LB MB NB OB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"D K y","260":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"388":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS outline properties"}; + +},{}],445:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB"},D:{"1":"4 5 8 EB BB TB CB","2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"16":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","16":"s"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D y","16":"K"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"String.prototype.padStart(), String.prototype.padEnd()"}; + +},{}],446:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"PageTransitionEvent"}; + +},{}],447:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E QB PB","33":"B A D X g H L M"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X","33":"g H L M N O P Q R S T U V W u Y Z a b"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB","33":"H L M N O"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"I","33":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Page Visibility"}; + +},{}],448:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g H"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Passive event listeners"}; + +},{}],449:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X","322":"g"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","4162":"4 5 t s"},D:{"1":"BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","194":"0 1 4 5 t s","1090":"8 EB"},E:{"2":"9 F I J C G E DB FB GB HB IB","514":"B A JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y","194":"j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB ZB aB","514":"A bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2049":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"194":"lB"},R:{"2":"mB"}},B:5,C:"Payment Request API"}; + +},{}],450:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o QB PB"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Permissions API"}; + +},{}],451:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c QB PB","578":"d e f K"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f","194":"K"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y","322":"T"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Picture element"}; + +},{}],452:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"SB","194":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"194":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Ping attribute"}; + +},{}],453:[function(require,module,exports){ +module.exports={A:{A:{"1":"C G E B A","2":"UB","8":"J"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"PNG alpha transparency"}; + +},{}],454:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"CSS pointer-events (for HTML)"}; + +},{}],455:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E UB","164":"B"},B:{"1":"D X g H L"},C:{"2":"2 SB F I QB PB","8":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j","328":"0 1 4 5 k l m n o p q r w x v z t s"},D:{"1":"4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q","8":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v","584":"0 1 z"},E:{"2":"9 F I J DB FB","8":"C G E B A GB HB IB JB KB"},F:{"1":"l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","8":"H L M N O P Q R S T U V W u Y Z a b c d e f K h","584":"i j k"},G:{"8":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","8":"2 3 F eB fB gB hB iB jB"},J:{"8":"C B"},K:{"2":"B","8":"6 7 A D K y"},L:{"1":"8"},M:{"328":"t"},N:{"1":"A","36":"B"},O:{"8":"kB"},P:{"2":"I","8":"F"},Q:{"584":"lB"},R:{"2":"mB"}},B:2,C:"Pointer events"}; + +},{}],456:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","2":"D"},C:{"1":"0 1 4 5 k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X QB PB","33":"g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},D:{"1":"0 1 4 5 8 K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H","33":"R S T U V W u Y Z a b c d e f","66":"L M N O P Q"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"PointerLock API"}; + +},{}],457:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E LB MB NB OB"},G:{"2":"3 9 AB VB WB","132":"G A XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"progress element"}; + +},{}],458:[function(require,module,exports){ +module.exports={A:{A:{"8":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"W u","8":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V QB PB"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"b","8":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a"},E:{"1":"G E B A HB IB JB KB","8":"9 F I J C DB FB GB"},F:{"1":"P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","4":"O","8":"6 7 E A D H L M N LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","8":"3 9 AB VB WB XB"},H:{"8":"dB"},I:{"1":"s jB","8":"2 3 F eB fB gB hB iB"},J:{"8":"C B"},K:{"1":"K","8":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Promises"}; + +},{}],459:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:4,C:"Proximity API"}; + +},{}],460:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N h i j k l m n o p q r","66":"O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D U V W u Y Z a b c d e LB MB NB OB RB y","66":"H L M N O P Q R S T"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"Proxy object"}; + +},{}],461:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O LB MB NB OB RB y","4":"S","16":"P Q R T"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Public Key Pinning"}; + +},{}],462:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m QB PB","257":"0 1 4 5 n p q r w x v t s","1281":"o z"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m","257":"0 1 4 5 8 x v z t s EB BB TB CB","388":"n o p q r w"},E:{"2":"9 F I J C G E DB FB GB HB","514":"B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f LB MB NB OB RB y","16":"K h i j k","257":"l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"2":"mB"}},B:5,C:"Push API"}; + +},{}],463:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"UB","8":"J C","132":"G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","8":"E LB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"querySelector/querySelectorAll"}; + +},{}],464:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","16":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","16":"2 SB QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","132":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"257":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"readonly attribute of input and textarea elements"}; + +},{}],465:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"1":"BB TB CB","2":"F I J C G E B A D X g H L M N O P","260":"0 1 4 5 8 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB"},E:{"2":"9 F I J C DB FB GB","132":"G E B A HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 AB VB WB XB","132":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Referrer Policy"}; + +},{}],466:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"2":"F I J C G E B A D","129":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A LB MB NB OB","129":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C","129":"B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Custom protocol handling"}; + +},{}],467:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v QB PB"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"rel=noopener"}; + +},{}],468:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","132":"A"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB"},D:{"1":"0 1 4 5 8 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Link type \"noreferrer\""}; + +},{}],469:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w","132":"0 1 4 5 8 x v z t s EB BB TB CB"},E:{"1":"E B A IB JB KB","2":"9 F I J C G DB FB GB HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f LB MB NB OB RB y","132":"K h i j k l m n o p q r"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","132":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"132":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","132":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"relList (DOMTokenList)"}; + +},{}],470:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G UB","132":"E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"3 G A AB WB XB YB ZB aB bB cB","2":"9","260":"VB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"rem (root em) units"}; + +},{}],471:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","33":"A D X g H L M N O P Q R","164":"F I J C G E B"},D:{"1":"0 1 4 5 8 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E","33":"R S","164":"N O P Q","420":"B A D X g H L M"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","33":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB","33":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"requestAnimationFrame"}; + +},{}],472:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","194":"0 1"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"requestIdleCallback"}; + +},{}],473:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","194":"1 4 5 8 t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j LB MB NB OB RB y","194":"k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"194":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Resize Observer"}; + +},{}],474:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB","194":"a b c d"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Resource Timing"}; + +},{}],475:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m","194":"n o p"},E:{"1":"B A JB KB","2":"9 F I J C G E DB FB GB HB IB"},F:{"1":"d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z LB MB NB OB RB y","194":"a b c"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"Rest parameters"}; + +},{}],476:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"H L","2":"D X g"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","33":"R S T U V W u Y Z a b c d e f K h i j k l m"},D:{"2":"F I J C G E B A D X g H L M N O P Q R","33":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D H L M LB MB NB OB RB y","33":"N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","33":"s"},J:{"2":"C","130":"B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:5,C:"WebRTC Peer-to-peer connections"}; + +},{}],477:[function(require,module,exports){ +module.exports={A:{A:{"4":"J C G E B A UB"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","8":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"4":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F"},E:{"4":"I J C G E B A FB GB HB IB JB KB","8":"9 F DB"},F:{"4":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","8":"6 7 E A D LB MB NB OB RB y"},G:{"4":"G A VB WB XB YB ZB aB bB cB","8":"3 9 AB"},H:{"8":"dB"},I:{"4":"2 3 F s hB iB jB","8":"eB fB gB"},J:{"4":"B","8":"C"},K:{"4":"K","8":"6 7 B A D y"},L:{"4":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"4":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:1,C:"Ruby annotation"}; + +},{}],478:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"'SameSite' cookie attribute"}; + +},{}],479:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","36":"A"},B:{"36":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M QB PB","36":"N O P Q R S T U V W u Y Z a b c d e f K h i j k l m"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B","36":"A"},O:{"1":"kB"},P:{"1":"I","16":"F"},Q:{"2":"lB"},R:{"1":"mB"}},B:5,C:"Screen Orientation"}; + +},{}],480:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F DB","132":"I"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"async attribute for external scripts"}; + +},{}],481:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","132":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","257":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"9 F DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"defer attribute for external scripts"}; + +},{}],482:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","132":"G E B A"},B:{"132":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e QB PB"},D:{"132":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I DB","132":"J C G E B A FB GB HB IB JB KB"},F:{"2":"E LB MB NB OB","16":"6 7 A","132":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y"},G:{"16":"3 9 AB","132":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"16":"eB fB","132":"2 3 F s gB hB iB jB"},J:{"132":"C B"},K:{"132":"6 7 B A D K y"},L:{"132":"8"},M:{"132":"t"},N:{"132":"B A"},O:{"132":"kB"},P:{"132":"F I"},Q:{"132":"lB"},R:{"132":"mB"}},B:5,C:"scrollIntoView"}; + +},{}],483:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Element.scrollIntoViewIfNeeded()"}; + +},{}],484:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"SDCH Accept-Encoding/Content-Encoding"}; + +},{}],485:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","16":"UB","260":"J C G"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 z t s","132":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l QB PB","2180":"m n o p q r w x v"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","132":"6 7 E A D LB MB NB OB RB y"},G:{"16":"3","132":"9 AB","516":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","16":"2 F eB fB gB hB","1025":"3"},J:{"1":"B","16":"C"},K:{"1":"K","16":"6 7 B A D","132":"y"},L:{"1":"8"},M:{"132":"t"},N:{"1":"A","16":"B"},O:{"1025":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Selection API"}; + +},{}],486:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","322":"H L"},C:{"1":"0 1 4 5 n p q r w x v t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","194":"c d e f K h i j k l m","513":"o z"},D:{"1":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i","4":"j k l m n"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y","4":"W u Y Z a"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","4":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"4":"kB"},P:{"1":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:5,C:"Service Workers"}; + +},{}],487:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"1":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Efficient Script Yielding: setImmediate()"}; + +},{}],488:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","260":"eB"},J:{"1":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"SHA-2 SSL certificates"}; + +},{}],489:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","194":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T","33":"U V W u Y Z a b c d"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB","33":"iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"I","33":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Shadow DOM v0"}; + +},{}],490:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"2":"9 F I J C G E DB FB GB HB IB","132":"B A JB KB"},F:{"1":"j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i LB MB NB OB RB y"},G:{"2":"3 9 G AB VB WB XB YB ZB aB","132":"A bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","4":"I"},Q:{"1":"lB"},R:{"2":"mB"}},B:5,C:"Shadow DOM v1"}; + +},{}],491:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"I J FB","2":"9 F C G E B A DB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB MB NB"},G:{"1":"VB WB","2":"3 9 G A AB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D y","2":"K","16":"B"},L:{"2":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F","2":"I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Shared Web Workers"}; + +},{}],492:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J UB","132":"C G"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","2":"9"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Server Name Indication"}; + +},{}],493:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E B UB"},B:{"2":"D X g H L"},C:{"1":"X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","2":"0 1 2 4 5 SB F I J C G E B A D v z t s QB PB"},D:{"1":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","2":"0 1 4 5 8 v z t s EB BB TB CB"},E:{"1":"G E B A IB JB KB","2":"9 F I J C DB FB GB HB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i l n y","2":"6 7 E A D j k m o p q r LB MB NB OB RB"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"2 3 F hB iB jB","2":"s eB fB gB"},J:{"2":"C B"},K:{"1":"K y","2":"6 7 B A D"},L:{"2":"8"},M:{"2":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F","2":"I"},Q:{"2":"lB"},R:{"16":"mB"}},B:7,C:"SPDY protocol"}; + +},{}],494:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB","322":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T","164":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y","164":"W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"164":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:7,C:"Speech Recognition API"}; + +},{}],495:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z QB PB","194":"a b c d e f K h i j k l m n o p q r"},D:{"1":"0 1 c d e f K h i j k l m n o p q r w x v z","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b","257":"4 5 8 t s EB BB TB CB"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"2":"mB"}},B:7,C:"Speech Synthesis API"}; + +},{}],496:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"4":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"4":"2 3 F s eB fB gB hB iB jB"},J:{"1":"B","4":"C"},K:{"4":"6 7 B A D K y"},L:{"4":"8"},M:{"4":"t"},N:{"4":"B A"},O:{"4":"kB"},P:{"4":"F I"},Q:{"1":"lB"},R:{"4":"mB"}},B:1,C:"Spellcheck attribute"}; + +},{}],497:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"Web SQL Database"}; + +},{}],498:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","260":"D","514":"X g H"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a QB PB","194":"b c d e f K"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c","260":"d e f K"},E:{"1":"E B A IB JB KB","2":"9 F I J C DB FB GB","260":"G HB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P LB MB NB OB RB y","260":"Q R S T"},G:{"1":"A ZB aB bB cB","2":"3 9 AB VB WB XB","260":"G YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Srcset and sizes attributes"}; + +},{}],499:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"1":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","16":"D"},G:{"1":"G A WB XB YB ZB aB bB cB","16":"3 9 AB VB"},H:{"16":"dB"},I:{"1":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"1":"I","16":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Event.stopImmediatePropagation()"}; + +},{}],500:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L QB PB","33":"0 1 4 5 M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"2":"F I J C G E B A D X g H L M N O P","164":"0 1 4 5 8 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A","2":"9 F I J C G E B DB FB GB HB IB JB KB"},F:{"2":"6 7 E A H L M LB MB NB OB RB","164":"D N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","164":"s"},J:{"2":"C","164":"B"},K:{"2":"6 7 B A","164":"D K y"},L:{"164":"8"},M:{"33":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"16":"F","164":"I"},Q:{"164":"lB"},R:{"164":"mB"}},B:4,C:"getUserMedia/Stream API"}; + +},{}],501:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B UB","129":"A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Strict Transport Security"}; + +},{}],502:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","2":"2 SB F I J C G E B A D X g H L M N O P QB PB","322":"4 5 t s"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O K h i j k l m n o p q r w x v z t s EB BB TB CB","194":"P Q R S T U V W u Y Z a b c d e f"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"322":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Scoped CSS"}; + +},{}],503:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l QB PB"},D:{"1":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Subresource Integrity"}; + +},{}],504:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","260":"F I J C G E B A D X g H L M N O P Q R S"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F"},E:{"1":"I J C G E B A FB GB HB IB JB KB","2":"DB","132":"9 F"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","132":"9 AB"},H:{"260":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"K","260":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"SVG in CSS backgrounds"}; + +},{}],505:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F","4":"I J C"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"3 9 AB VB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"SVG filters"}; + +},{}],506:[function(require,module,exports){ +module.exports={A:{A:{"2":"E B A UB","8":"J C G"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K","2":"0 1 4 5 8 v z t s EB BB TB CB","130":"h i j k l m n o p q r w x"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","2":"DB"},F:{"1":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y","2":"K h i j k l m n o p q r","130":"U V W u Y Z a b c d e f"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"258":"dB"},I:{"1":"2 3 F hB iB jB","2":"s eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"130":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F","130":"I"},Q:{"1":"lB"},R:{"130":"mB"}},B:7,C:"SVG fonts"}; + +},{}],507:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e","132":"f K h i j k l m n o p q r w"},E:{"2":"9 F I J C E B A DB FB GB IB JB KB","132":"G HB"},F:{"1":"K h i j k l m n o p q r y","2":"H L M N O P Q R","4":"6 7 A D MB NB OB RB","16":"E LB","132":"S T U V W u Y Z a b c d e f"},G:{"2":"3 9 A AB VB WB XB ZB aB bB cB","132":"G YB"},H:{"1":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C","132":"B"},K:{"1":"K y","4":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"132":"kB"},P:{"1":"I","132":"F"},Q:{"132":"lB"},R:{"132":"mB"}},B:2,C:"SVG fragment identifiers"}; + +},{}],508:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","388":"E B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB","4":"2"},D:{"4":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","4":"F I J C G E B A FB GB HB IB JB KB"},F:{"4":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"4":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","4":"s iB jB"},J:{"1":"B","2":"C"},K:{"4":"6 7 B A D K y"},L:{"4":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:2,C:"SVG effects for HTML"}; + +},{}],509:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G","129":"E B A"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB PB"},D:{"1":"0 1 4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","8":"F I J"},E:{"1":"E B A IB JB KB","8":"9 F I DB","129":"J C G FB GB HB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 A OB","8":"E LB MB NB"},G:{"1":"A ZB aB bB cB","8":"3 9 AB","129":"G VB WB XB YB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","129":"2 3 F hB"},J:{"1":"B","129":"C"},K:{"1":"D K y","8":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"129":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Inline SVG in HTML5"}; + +},{}],510:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W"},E:{"1":"E B A IB JB KB","2":"DB","4":"9","132":"F I J C G FB GB HB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","132":"3 9 G AB VB WB XB YB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","132":"2 3 F hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"SVG in HTML img element"}; + +},{}],511:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G E B A"},B:{"8":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB QB PB"},D:{"1":"I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n","4":"F","257":"0 1 4 5 8 o p q r w x v z t s EB BB TB CB"},E:{"1":"J C G E B A GB HB IB JB KB","8":"9 DB","132":"F I FB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y","257":"b c d e f K h i j k l m n o p q r"},G:{"1":"G A WB XB YB ZB aB bB cB","132":"3 9 AB VB"},H:{"2":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"257":"lB"},R:{"1":"mB"}},B:2,C:"SVG SMIL animation"}; + +},{}],512:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G","257":"E B A"},B:{"257":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","4":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","4":"DB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"s iB jB","2":"eB fB gB","132":"2 3 F hB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"257":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"SVG (basic support)"}; + +},{}],513:[function(require,module,exports){ +module.exports={A:{A:{"1":"C G E B A","16":"J UB"},B:{"1":"D X g H L"},C:{"16":"2 SB QB PB","129":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g"},E:{"16":"9 F I DB","257":"J C G E B A FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"769":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"16":"dB"},I:{"16":"2 3 F s eB fB gB hB iB jB"},J:{"16":"C B"},K:{"16":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"16":"B A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"2":"lB"},R:{"16":"mB"}},B:1,C:"tabindex global attribute"}; + +},{}],514:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"X g H L","16":"D"},C:{"1":"0 1 4 5 d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u LB MB NB OB RB y"},G:{"1":"A ZB aB bB cB","2":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:6,C:"ES6 Template Literals (Template Strings)"}; + +},{}],515:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D","388":"X g H L"},C:{"1":"0 1 4 5 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q QB PB"},D:{"1":"0 1 4 5 8 e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U","132":"V W u Y Z a b c d"},E:{"1":"E B A IB JB KB","2":"9 F I J C DB FB","388":"G HB","514":"GB"},F:{"1":"R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","132":"H L M N O P Q"},G:{"1":"A ZB aB bB cB","2":"3 9 AB VB WB XB","388":"G YB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"HTML templates"}; + +},{}],516:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G B A UB","16":"E"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","16":"F I"},D:{"2":"0 1 4 5 8 F I J C G E B X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"A D"},E:{"2":"9 F J DB FB","16":"I C G E B A GB HB IB JB KB"},F:{"2":"6 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"7"},G:{"2":"3 9 AB VB WB","16":"G A XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB hB iB jB","16":"gB"},J:{"2":"B","16":"C"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"Test feature - updated"}; + +},{}],517:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I QB PB","1028":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","1060":"J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U","226":"0 1 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2052":"4 5 8 EB BB TB CB"},E:{"2":"9 F I J C DB FB GB","804":"G E B A IB JB KB","1316":"HB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d LB MB NB OB RB y","226":"e f K h i j k l m","2052":"n o p q r"},G:{"2":"3 9 AB VB WB XB","292":"G A YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2052":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:4,C:"text-decoration styling"}; + +},{}],518:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n QB PB","322":"o"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T","164":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"G E B A HB IB JB KB","2":"9 F I J DB FB","164":"C GB"},F:{"2":"6 7 E A D LB MB NB OB RB y","164":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB","164":"s iB jB"},J:{"2":"C","164":"B"},K:{"2":"6 7 B A D y","164":"K"},L:{"164":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"164":"kB"},P:{"164":"F I"},Q:{"164":"lB"},R:{"164":"mB"}},B:4,C:"text-emphasis styling"}; + +},{}],519:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A","2":"UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","8":"2 SB F I J QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","33":"E LB MB NB OB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"K y","33":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"CSS3 Text-overflow"}; + +},{}],520:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","2":"0 F I J C G E B A D X g H L M N O P Q R S T U W u Y Z a b c d e f K h i j k l m n o p q r w x v z","258":"V"},E:{"2":"9 F I J C G E B A DB GB HB IB JB KB","258":"FB"},F:{"1":"m o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l n LB MB NB OB RB y"},G:{"2":"3 9 AB","33":"G A VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"33":"t"},N:{"161":"B A"},O:{"33":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:7,C:"CSS text-size-adjust"}; + +},{}],521:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","161":"H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q QB PB","161":"0 1 4 5 w x v z t s","450":"r"},D:{"33":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"A KB","33":"9 F I J C G E B DB FB GB HB IB JB"},F:{"2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"33":"3 G A AB VB WB XB YB ZB aB bB cB","36":"9"},H:{"2":"dB"},I:{"2":"2","33":"3 F s eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"33":"8"},M:{"161":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"33":"mB"}},B:7,C:"CSS text-stroke and text-fill"}; + +},{}],522:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"3 G A AB VB WB XB YB ZB aB bB cB","16":"9"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Node.textContent"}; + +},{}],523:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N QB PB","132":"O"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"2":"lB"},R:{"1":"mB"}},B:1,C:"TextEncoder & TextDecoder"}; + +},{}],524:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C UB","66":"G E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R QB PB","66":"S"},D:{"1":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A D LB MB NB OB RB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","66":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"TLS 1.1"}; + +},{}],525:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C UB","66":"G E B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB","66":"T U V"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"C G E B A HB IB JB KB","2":"9 F I J DB FB GB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E H L LB","66":"6 7 A D MB NB OB RB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"K y","2":"6 7 B A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","66":"B"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"TLS 1.2"}; + +},{}],526:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x QB PB","66":"v"},D:{"1":"4 5 8 s EB BB TB CB","2":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","66":"1 t"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k LB MB NB OB RB y","66":"l"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","16":"s"},J:{"2":"C","16":"B"},K:{"2":"6 7 B A D K y"},L:{"16":"8"},M:{"16":"t"},N:{"2":"B","16":"A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"16":"lB"},R:{"16":"mB"}},B:6,C:"TLS 1.3"}; + +},{}],527:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","257":"H L"},C:{"2":"0 1 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t QB PB","16":"4 5 s"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h","16":"0 1 4 i j k l m n o p q r w x v z t s","194":"5 8 EB BB TB CB"},E:{"2":"9 F I J C G DB FB GB HB","16":"E B A IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y","16":"Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G AB VB WB XB YB","16":"A ZB aB bB cB"},H:{"16":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","16":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","16":"K"},L:{"16":"8"},M:{"16":"t"},N:{"2":"B","16":"A"},O:{"16":"kB"},P:{"16":"F I"},Q:{"16":"lB"},R:{"16":"mB"}},B:6,C:"Token Binding"}; + +},{}],528:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","8":"B A"},B:{"578":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T z t s","2":"2 SB QB PB","4":"F I J C G E B A D X g H L M","194":"U V W u Y Z a b c d e f K h i j k l m n o p q r w x v"},D:{"1":"0 1 4 5 8 R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B","260":"A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Touch events"}; + +},{}],529:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G","129":"B A","161":"E"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","33":"F I J C G E B A D X g H QB PB"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","33":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"1":"E B A IB JB KB","33":"9 F I J C G DB FB GB HB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB","33":"6 7 A D H L M N O P Q R NB OB RB"},G:{"1":"A ZB aB bB cB","33":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","33":"2 3 F eB fB gB hB iB jB"},J:{"33":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"33":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 2D Transforms"}; + +},{}],530:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E QB PB","33":"B A D X g H"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A","33":"D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"2":"9 DB","33":"F I J C G FB GB HB","257":"E B A IB JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R"},G:{"1":"A ZB aB bB cB","33":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB gB","33":"2 3 F hB iB jB"},J:{"33":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"33":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 3D Transforms"}; + +},{}],531:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","132":"E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r MB NB OB RB y","2":"E LB"},G:{"1":"3 G A VB WB XB YB ZB aB bB cB","2":"9 AB"},H:{"2":"dB"},I:{"1":"2 3 F s fB gB hB iB jB","2":"eB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"TTF/OTF - TrueType and OpenType font support"}; + +},{}],532:[function(require,module,exports){ +module.exports={A:{A:{"1":"A","2":"J C G E UB","132":"B"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB","260":"FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"9 AB","260":"3"},H:{"1":"dB"},I:{"1":"3 F s hB iB jB","2":"2 eB fB gB"},J:{"1":"B","2":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Typed Arrays"}; + +},{}],533:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K","130":"h i j"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"j l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i k LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:6,C:"FIDO U2F API"}; + +},{}],534:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k QB PB"},D:{"1":"0 1 4 5 8 m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Upgrade Insecure Requests"}; + +},{}],535:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U QB PB"},D:{"1":"0 1 4 5 8 b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R","130":"S T U V W u Y Z a"},E:{"1":"G E B A HB IB JB KB","2":"9 F I J DB FB GB","130":"C"},F:{"1":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","130":"H L M N"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB","130":"XB"},H:{"2":"dB"},I:{"1":"s jB","2":"2 3 F eB fB gB hB","130":"iB"},J:{"2":"C","130":"B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"URL API"}; + +},{}],536:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","132":"Y Z a b c d e f K h i j k l m"},D:{"1":"0 1 4 5 8 w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r"},E:{"1":"A JB KB","2":"9 F I J C G E B DB FB GB HB IB"},F:{"1":"f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y"},G:{"1":"A cB","2":"3 9 G AB VB WB XB YB ZB aB bB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"I","2":"F"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"URLSearchParams"}; + +},{}],537:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB"},D:{"1":"0 1 4 5 8 X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F DB","132":"I FB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"6 7 E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s hB iB jB","2":"eB fB gB"},J:{"1":"C B"},K:{"1":"6 D K y","2":"7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"ECMAScript 5 Strict Mode"}; + +},{}],538:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","33":"B A"},B:{"33":"D X g H L"},C:{"33":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"1 4 5 8 t s EB BB TB CB","33":"0 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z"},E:{"33":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","33":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j"},G:{"33":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","33":"2 3 F eB fB gB hB iB jB"},J:{"33":"C B"},K:{"2":"6 7 B A D y","33":"K"},L:{"1":"8"},M:{"33":"t"},N:{"33":"B A"},O:{"33":"kB"},P:{"33":"F I"},Q:{"33":"lB"},R:{"2":"mB"}},B:5,C:"CSS user-select: none"}; + +},{}],539:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K QB PB"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"User Timing API"}; + +},{}],540:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B QB PB","33":"A D X g H"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"Vibration API"}; + +},{}],541:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","260":"F I J C G E B A D X g H L M N O QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","132":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Video element"}; + +},{}],542:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I J DB FB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"2":"lB"},R:{"2":"mB"}},B:1,C:"Video Tracks"}; + +},{}],543:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","132":"E","260":"B A"},B:{"260":"D X g H L"},C:{"1":"0 1 4 5 O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N QB PB"},D:{"1":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O","260":"P Q R S T U"},E:{"1":"C G E B A GB HB IB JB KB","2":"9 F I DB FB","260":"J"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB","516":"XB","772":"WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"260":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"Viewport units: vw, vh, vmin, vmax"}; + +},{}],544:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","4":"G E B A"},B:{"4":"D X g H L"},C:{"4":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"4":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 DB","4":"F I J C G E B A FB GB HB IB JB KB"},F:{"2":"E","4":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"4":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"4":"dB"},I:{"2":"2 3 F eB fB gB hB","4":"s iB jB"},J:{"2":"C B"},K:{"4":"6 7 B A D K y"},L:{"4":"8"},M:{"4":"t"},N:{"4":"B A"},O:{"2":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:2,C:"WAI-ARIA Accessibility features"}; + +},{}],545:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"L","2":"D X g","578":"H"},C:{"1":"0 1 4 5 t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p QB PB","194":"q r w x v","1025":"z"},D:{"1":"4 5 8 EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x","322":"0 1 v z t s"},E:{"1":"A KB","2":"9 F I J C G E B DB FB GB HB IB JB"},F:{"1":"n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K LB MB NB OB RB y","322":"h i j k l m"},G:{"1":"A","2":"3 9 G AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"322":"lB"},R:{"2":"mB"}},B:6,C:"WebAssembly"}; + +},{}],546:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"2 SB"},D:{"1":"0 1 4 5 8 G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r NB OB RB y","2":"E LB MB"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","16":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"Wav audio format"}; + +},{}],547:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C UB","2":"G E B A"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A FB GB HB IB JB KB","16":"DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","16":"E"},G:{"1":"G A VB WB XB YB ZB aB bB cB","16":"3 9 AB"},H:{"1":"dB"},I:{"1":"2 3 F s gB hB iB jB","16":"eB fB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"wbr (word break opportunity) element"}; + +},{}],548:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b QB PB","516":"0 1 4 5 q r w x v z t s","580":"c d e f K h i j k l m n o p"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e","132":"f K h","260":"0 1 4 5 8 i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y","132":"S T U","260":"V W u Y Z a b c d e f K h i j k l m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","260":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D y","260":"K"},L:{"260":"8"},M:{"516":"t"},N:{"2":"B A"},O:{"260":"kB"},P:{"260":"F I"},Q:{"260":"lB"},R:{"260":"mB"}},B:5,C:"Web Animations API"}; + +},{}],549:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"Web App Manifest"}; + +},{}],550:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n","194":"o p q r w x v z","706":"0 1 t","1025":"4 5 8 s EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e LB MB NB OB RB y","450":"f K h i","706":"j k l","1025":"m n o p q r"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB jB","1025":"s"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1025":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"706":"lB"},R:{"2":"mB"}},B:7,C:"Web Bluetooth"}; + +},{}],551:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"2":"0 1 F I J C G E B A D X g H L M U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z","129":"4 5 8 t s EB BB TB CB","258":"N O P Q R S T"},E:{"2":"9 F I J C G E B A DB FB HB IB JB KB","16":"GB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F eB fB gB hB iB","129":"s","514":"jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"642":"8"},M:{"514":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F","642":"I"},Q:{"2":"lB"},R:{"16":"mB"}},B:5,C:"Web Share Api"}; + +},{}],552:[function(require,module,exports){ +module.exports={A:{A:{"2":"UB","8":"J C G E B","129":"A"},B:{"129":"D X g H L"},C:{"1":"0 1 4 5 T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","129":"F I J C G E B A D X g H L M N O P Q R S"},D:{"1":"0 1 4 5 8 c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C","129":"G E B A D X g H L M N O P Q R S T U V W u Y Z a b"},E:{"1":"G E B A IB JB KB","2":"9 F I DB","129":"J C FB GB HB"},F:{"1":"O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A LB MB NB OB RB","129":"D H L M N y"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB VB WB XB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"1":"B","2":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B","129":"A"},O:{"129":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"WebGL - 3D Canvas graphics"}; + +},{}],553:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T QB PB","194":"l m n","450":"U V W u Y Z a b c d e f K h i j k","2242":"o p q r w x"},D:{"1":"4 5 8 s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l","578":"0 1 m n o p q r w x v z t"},E:{"2":"9 F I J C G E B DB FB GB HB IB","1090":"A JB KB"},F:{"1":"m n o p q r","2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"2":"F I"},Q:{"578":"lB"},R:{"2":"mB"}},B:6,C:"WebGL 2.0"}; + +},{}],554:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G UB","8":"E B A"},B:{"4":"g H L","8":"D X"},C:{"1":"0 1 4 5 u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W"},D:{"1":"0 1 4 5 8 U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","4":"J C G E B A D X g H L M N O P Q R S T"},E:{"2":"DB","8":"9 F I J C G E B A FB GB HB IB JB KB"},F:{"1":"L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"E LB MB NB","4":"6 7 A D H OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"1":"s","2":"eB fB","4":"2 3 F gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"8":"B A"},O:{"1":"kB"},P:{"1":"I","4":"F"},Q:{"1":"lB"},R:{"1":"mB"}},B:6,C:"WebM video format"}; + +},{}],555:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"2":"2 SB QB PB","8":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I","8":"J C G","132":"E B A D X g H L M N O P Q R"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB NB","8":"A OB","132":"6 7 RB"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"3 s iB jB","2":"2 eB fB gB","132":"F hB"},J:{"2":"C B"},K:{"1":"6 7 D K y","2":"B","132":"A"},L:{"1":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:7,C:"WebP image format"}; + +},{}],556:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB QB PB","132":"F I","292":"J C G E B"},D:{"1":"0 1 4 5 8 L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g","260":"H"},E:{"1":"C G E B A HB IB JB KB","2":"9 F DB","132":"I FB","260":"J GB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB NB OB","132":"6 7 A D RB"},G:{"1":"G A WB XB YB ZB aB bB cB","2":"9 AB","132":"3 VB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","129":"C"},K:{"1":"K y","2":"B","132":"6 7 A D"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Web Sockets"}; + +},{}],557:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g","513":"H L"},C:{"2":"0 2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z QB PB","129":"4 5 t s","194":"1"},D:{"2":"0 1 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","322":"4 5 8 EB BB TB CB"},E:{"2":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"2":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"2":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"2":"dB"},I:{"2":"2 3 F s eB fB gB hB iB jB"},J:{"2":"C B"},K:{"2":"6 7 B A D K y"},L:{"2049":"8"},M:{"2":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1025":"F","1028":"I"},Q:{"2":"lB"},R:{"322":"mB"}},B:7,C:"WebVR API"}; + +},{}],558:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"J C G E UB"},B:{"1":"D X g H L"},C:{"2":"2 SB F I J C G E B A D X g H L M N O P Q R S QB PB","66":"T U V W u Y Z","129":"0 1 4 5 a b c d e f K h i j k l m n o p q r w x v z t s"},D:{"1":"0 1 4 5 8 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M"},E:{"1":"J C G E B A GB HB IB JB KB","2":"9 F I DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y"},G:{"1":"G A XB YB ZB aB bB cB","2":"3 9 AB VB WB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 F eB fB gB hB"},J:{"1":"B","2":"C"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"A","2":"B"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"WebVTT - Web Video Text Tracks"}; + +},{}],559:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","2":"UB","8":"J C G E"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","8":"2 SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","8":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r OB RB y","2":"E LB","8":"MB NB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s eB iB jB","2":"2 3 F fB gB hB"},J:{"1":"C B"},K:{"1":"6 7 A D K y","8":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Web Workers"}; + +},{}],560:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"2":"D X g H L"},C:{"1":"0 1 4 5 f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u QB PB","194":"Y Z a b c d e"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"1":"B A IB JB KB","2":"9 F I J C G E DB FB GB HB"},F:{"1":"T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R S LB MB NB OB RB y"},G:{"1":"A aB bB cB","2":"3 9 G AB VB WB XB YB ZB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS will-change property"}; + +},{}],561:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s PB","2":"2 SB QB"},D:{"1":"0 1 4 5 8 I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F"},E:{"1":"J C G E B A FB GB HB IB JB KB","2":"9 F I DB"},F:{"1":"6 7 D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","2":"E A LB MB NB OB"},G:{"1":"G A VB WB XB YB ZB aB bB cB","2":"3 9 AB"},H:{"2":"dB"},I:{"1":"s iB jB","2":"2 3 eB fB gB hB","130":"F"},J:{"1":"C B"},K:{"1":"6 7 A D K y","2":"B"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:2,C:"WOFF - Web Open Font Format"}; + +},{}],562:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E B A UB"},B:{"1":"g H L","2":"D X"},C:{"1":"0 1 4 5 i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h QB PB"},D:{"1":"0 1 4 5 8 f K h i j k l m n o p q r w x v z t s EB BB TB CB","2":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e"},E:{"2":"9 F I J C G E DB FB GB HB IB","132":"B A JB KB"},F:{"1":"S T U V W u Y Z a b c d e f K h i j k l m n o p q r","2":"6 7 E A D H L M N O P Q R LB MB NB OB RB y"},G:{"1":"A bB cB","2":"3 9 G AB VB WB XB YB ZB aB"},H:{"2":"dB"},I:{"1":"s","2":"2 3 F eB fB gB hB iB jB"},J:{"2":"C B"},K:{"1":"K","2":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"2":"B A"},O:{"2":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"WOFF 2.0 - Web Open Font Format"}; + +},{}],563:[function(require,module,exports){ +module.exports={A:{A:{"1":"J C G E B A UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB F I J C G E B A D X g QB PB"},D:{"1":"0 1 4 5 8 n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m"},E:{"1":"E B A IB JB KB","4":"9 F I J C G DB FB GB HB"},F:{"1":"a b c d e f K h i j k l m n o p q r","2":"6 7 E A D LB MB NB OB RB y","4":"H L M N O P Q R S T U V W u Y Z"},G:{"1":"A ZB aB bB cB","4":"3 9 G AB VB WB XB YB"},H:{"2":"dB"},I:{"1":"s","4":"2 3 F eB fB gB hB iB jB"},J:{"4":"C B"},K:{"2":"6 7 B A D y","4":"K"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"4":"kB"},P:{"1":"F I"},Q:{"4":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 word-break"}; + +},{}],564:[function(require,module,exports){ +module.exports={A:{A:{"4":"J C G E B A UB"},B:{"4":"D X g H L"},C:{"1":"0 1 4 5 w x v z t s","2":"2 SB","4":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r QB PB"},D:{"1":"0 1 4 5 8 S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","4":"F I J C G E B A D X g H L M N O P Q R"},E:{"1":"C G E B A GB HB IB JB KB","4":"9 F I J DB FB"},F:{"1":"H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"E LB MB","4":"6 7 A D NB OB RB"},G:{"1":"G A XB YB ZB aB bB cB","4":"3 9 AB VB WB"},H:{"4":"dB"},I:{"1":"s iB jB","4":"2 3 F eB fB gB hB"},J:{"1":"B","4":"C"},K:{"1":"K","4":"6 7 B A D y"},L:{"1":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:5,C:"CSS3 Overflow-wrap"}; + +},{}],565:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C UB","132":"G E","260":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB","2":"SB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"F I J C G E B A FB GB HB IB JB KB","2":"9 DB"},F:{"1":"6 7 A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y","2":"E"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"4":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"Cross-document messaging"}; + +},{}],566:[function(require,module,exports){ +module.exports={A:{A:{"1":"G E B A","2":"J C UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","4":"F I J C G E B A D X g H L M","16":"2 SB QB PB"},D:{"4":"0 1 4 5 8 V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J C G E B A D X g H L M N O P Q R S T U"},E:{"4":"J C G E B A FB GB HB IB JB KB","16":"9 F I DB"},F:{"4":"D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r RB y","16":"6 7 E A LB MB NB OB"},G:{"4":"G A XB YB ZB aB bB cB","16":"3 9 AB VB WB"},H:{"2":"dB"},I:{"4":"3 F s hB iB jB","16":"2 eB fB gB"},J:{"4":"C B"},K:{"4":"K y","16":"6 7 B A D"},L:{"4":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"4":"kB"},P:{"4":"F I"},Q:{"4":"lB"},R:{"4":"mB"}},B:6,C:"X-Frame-Options HTTP header"}; + +},{}],567:[function(require,module,exports){ +module.exports={A:{A:{"2":"J C G E UB","132":"B A"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","2":"2 SB","260":"B A","388":"J C G E","900":"F I QB PB"},D:{"1":"0 1 4 5 8 a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","16":"F I J","132":"Y Z","388":"C G E B A D X g H L M N O P Q R S T U V W u"},E:{"1":"G E B A HB IB JB KB","2":"9 F DB","132":"C GB","388":"I J FB"},F:{"1":"D N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r y","2":"6 7 E A LB MB NB OB RB","132":"H L M"},G:{"1":"G A YB ZB aB bB cB","2":"3 9 AB","132":"XB","388":"VB WB"},H:{"2":"dB"},I:{"1":"s jB","2":"eB fB gB","388":"iB","900":"2 3 F hB"},J:{"132":"B","388":"C"},K:{"1":"D K y","2":"6 7 B A"},L:{"1":"8"},M:{"1":"t"},N:{"132":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:1,C:"XMLHttpRequest advanced features"}; + +},{}],568:[function(require,module,exports){ +module.exports={A:{A:{"1":"E B A","2":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"1":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"1":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"1":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"1":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"1":"dB"},I:{"1":"2 3 F s eB fB gB hB iB jB"},J:{"1":"C B"},K:{"1":"6 7 B A D K y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"2":"mB"}},B:1,C:"XHTML served as application/xhtml+xml"}; + +},{}],569:[function(require,module,exports){ +module.exports={A:{A:{"2":"E B A UB","4":"J C G"},B:{"2":"D X g H L"},C:{"8":"0 1 2 4 5 SB F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s QB PB"},D:{"8":"0 1 4 5 8 F I J C G E B A D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB"},E:{"8":"9 F I J C G E B A DB FB GB HB IB JB KB"},F:{"8":"6 7 E A D H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r LB MB NB OB RB y"},G:{"8":"3 9 G A AB VB WB XB YB ZB aB bB cB"},H:{"8":"dB"},I:{"8":"2 3 F s eB fB gB hB iB jB"},J:{"8":"C B"},K:{"8":"6 7 B A D K y"},L:{"8":"8"},M:{"8":"t"},N:{"2":"B A"},O:{"8":"kB"},P:{"8":"F I"},Q:{"8":"lB"},R:{"8":"mB"}},B:7,C:"XHTML+SMIL animation"}; + +},{}],570:[function(require,module,exports){ +module.exports={A:{A:{"1":"B A","132":"E","260":"J C G UB"},B:{"1":"D X g H L"},C:{"1":"0 1 4 5 D X g H L M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r w x v z t s","132":"A","260":"2 SB F I J C QB PB","516":"G E B"},D:{"1":"0 1 4 5 8 Z a b c d e f K h i j k l m n o p q r w x v z t s EB BB TB CB","132":"F I J C G E B A D X g H L M N O P Q R S T U V W u Y"},E:{"1":"G E B A HB IB JB KB","132":"9 F I J C DB FB GB"},F:{"1":"M N O P Q R S T U V W u Y Z a b c d e f K h i j k l m n o p q r","16":"E LB","132":"6 7 A D H L MB NB OB RB y"},G:{"1":"G A YB ZB aB bB cB","132":"3 9 AB VB WB XB"},H:{"132":"dB"},I:{"1":"s iB jB","132":"2 3 F eB fB gB hB"},J:{"132":"C B"},K:{"1":"K","16":"B","132":"6 7 A D y"},L:{"1":"8"},M:{"1":"t"},N:{"1":"B A"},O:{"1":"kB"},P:{"1":"F I"},Q:{"1":"lB"},R:{"1":"mB"}},B:4,C:"DOM Parsing and Serialization"}; + +},{}],571:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = { + 1: "ls", // WHATWG Living Standard + 2: "rec", // W3C Recommendation + 3: "pr", // W3C Proposed Recommendation + 4: "cr", // W3C Candidate Recommendation + 5: "wd", // W3C Working Draft + 6: "other", // Non-W3C, but reputable + 7: "unoff" // Unofficial, Editor's Draft or W3C "Note" +}; + +},{}],572:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = { + y: 1 << 0, + n: 1 << 1, + a: 1 << 2, + p: 1 << 3, + u: 1 << 4, + x: 1 << 5, + d: 1 << 6 +}; + +},{}],573:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.agents = undefined; + +var _browsers = require('./browsers'); + +var _browserVersions = require('./browserVersions'); + +var agentsData = require('../../data/agents'); + +function unpackBrowserVersions(versionsData) { + return Object.keys(versionsData).reduce(function (usage, version) { + usage[_browserVersions.browserVersions[version]] = versionsData[version]; + return usage; + }, {}); +} + +var agents = exports.agents = Object.keys(agentsData).reduce(function (map, key) { + var versionsData = agentsData[key]; + map[_browsers.browsers[key]] = Object.keys(versionsData).reduce(function (data, entry) { + if (entry === 'A') { + data.usage_global = unpackBrowserVersions(versionsData[entry]); + } else if (entry === 'C') { + data.versions = versionsData[entry].reduce(function (list, version) { + if (version === '') { + list.push(null); + } else { + list.push(_browserVersions.browserVersions[version]); + } + return list; + }, []); + } else if (entry === 'D') { + data.prefix_exceptions = unpackBrowserVersions(versionsData[entry]); + } else if (entry === 'E') { + data.browser = versionsData[entry]; + } else { + // entry is B + data.prefix = versionsData[entry]; + } + return data; + }, {}); + return map; +}, {}); +},{"../../data/agents":117,"./browserVersions":574,"./browsers":575}],574:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var browserVersions = exports.browserVersions = require('../../data/browserVersions'); +},{"../../data/browserVersions":118}],575:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var browsers = exports.browsers = require('../../data/browsers'); +},{"../../data/browsers":119}],576:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = unpackFeature; + +var _statuses = require('../lib/statuses'); + +var _statuses2 = _interopRequireDefault(_statuses); + +var _supported = require('../lib/supported'); + +var _supported2 = _interopRequireDefault(_supported); + +var _browsers = require('./browsers'); + +var _browserVersions = require('./browserVersions'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function unpackSupport(cipher) { + // bit flags + var stats = Object.keys(_supported2.default).reduce(function (list, support) { + if (cipher & _supported2.default[support]) list.push(support); + return list; + }, []); + + // notes + var notes = cipher >> 7; + var notesArray = []; + while (notes) { + var note = Math.floor(Math.log2(notes)) + 1; + notesArray.unshift('#' + note); + notes -= Math.pow(2, note - 1); + } + + return stats.concat(notesArray).join(' '); +} + +function unpackFeature(packed) { + var unpacked = { status: _statuses2.default[packed.B], title: packed.C }; + unpacked.stats = Object.keys(packed.A).reduce(function (browserStats, key) { + var browser = packed.A[key]; + browserStats[_browsers.browsers[key]] = Object.keys(browser).reduce(function (stats, support) { + var packedVersions = browser[support].split(' '); + var unpacked = unpackSupport(support); + packedVersions.forEach(function (v) { + return stats[_browserVersions.browserVersions[v]] = unpacked; + }); + return stats; + }, {}); + return browserStats; + }, {}); + return unpacked; +} +},{"../lib/statuses":571,"../lib/supported":572,"./browserVersions":574,"./browsers":575}],577:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/* + * Load this dynamically so that it + * doesn't appear in the rollup bundle. + */ + +var features = exports.features = require('../../data/features'); +},{"../../data/features":120}],578:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _agents = require('./agents'); + +Object.defineProperty(exports, 'agents', { + enumerable: true, + get: function get() { + return _agents.agents; + } +}); + +var _feature = require('./feature'); + +Object.defineProperty(exports, 'feature', { + enumerable: true, + get: function get() { + return _interopRequireDefault(_feature).default; + } +}); + +var _features = require('./features'); + +Object.defineProperty(exports, 'features', { + enumerable: true, + get: function get() { + return _features.features; + } +}); + +var _region = require('./region'); + +Object.defineProperty(exports, 'region', { + enumerable: true, + get: function get() { + return _interopRequireDefault(_region).default; + } +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +},{"./agents":573,"./feature":576,"./features":577,"./region":579}],579:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = unpackRegion; + +var _browsers = require('./browsers'); + +function unpackRegion(packed) { + return Object.keys(packed).reduce(function (list, browser) { + var data = packed[browser]; + list[_browsers.browsers[browser]] = Object.keys(data).reduce(function (memo, key) { + var stats = data[key]; + if (key === '_') { + stats.split(' ').forEach(function (version) { + return memo[version] = null; + }); + } else { + memo[key] = stats; + } + return memo; + }, {}); + return list; + }, {}); +} +},{"./browsers":575}],580:[function(require,module,exports){ +(function (process){ +'use strict'; +const escapeStringRegexp = require('escape-string-regexp'); +const ansiStyles = require('ansi-styles'); +const supportsColor = require('supports-color'); + +const template = require('./templates.js'); + +const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm'); + +// `supportsColor.level` → `ansiStyles.color[name]` mapping +const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m']; + +// `color-convert` models to exclude from the Chalk API due to conflicts and such +const skipModels = new Set(['gray']); + +const styles = Object.create(null); + +function applyOptions(obj, options) { + options = options || {}; + + // Detect level if not set manually + const scLevel = supportsColor ? supportsColor.level : 0; + obj.level = options.level === undefined ? scLevel : options.level; + obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0; +} + +function Chalk(options) { + // We check for this.template here since calling `chalk.constructor()` + // by itself will have a `this` of a previously constructed chalk object + if (!this || !(this instanceof Chalk) || this.template) { + const chalk = {}; + applyOptions(chalk, options); + + chalk.template = function () { + const args = [].slice.call(arguments); + return chalkTag.apply(null, [chalk.template].concat(args)); + }; + + Object.setPrototypeOf(chalk, Chalk.prototype); + Object.setPrototypeOf(chalk.template, chalk); + + chalk.template.constructor = Chalk; + + return chalk.template; + } + + applyOptions(this, options); +} + +// Use bright blue on Windows as the normal blue color is illegible +if (isSimpleWindowsTerm) { + ansiStyles.blue.open = '\u001B[94m'; +} + +for (const key of Object.keys(ansiStyles)) { + ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g'); + + styles[key] = { + get() { + const codes = ansiStyles[key]; + return build.call(this, this._styles ? this._styles.concat(codes) : [codes], key); + } + }; +} + +ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g'); +for (const model of Object.keys(ansiStyles.color.ansi)) { + if (skipModels.has(model)) { + continue; + } + + styles[model] = { + get() { + const level = this.level; + return function () { + const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments); + const codes = { + open, + close: ansiStyles.color.close, + closeRe: ansiStyles.color.closeRe + }; + return build.call(this, this._styles ? this._styles.concat(codes) : [codes], model); + }; + } + }; +} + +ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g'); +for (const model of Object.keys(ansiStyles.bgColor.ansi)) { + if (skipModels.has(model)) { + continue; + } + + const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); + styles[bgModel] = { + get() { + const level = this.level; + return function () { + const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments); + const codes = { + open, + close: ansiStyles.bgColor.close, + closeRe: ansiStyles.bgColor.closeRe + }; + return build.call(this, this._styles ? this._styles.concat(codes) : [codes], model); + }; + } + }; +} + +const proto = Object.defineProperties(() => {}, styles); + +function build(_styles, key) { + const builder = function () { + return applyStyle.apply(builder, arguments); + }; + + builder._styles = _styles; + + const self = this; + + Object.defineProperty(builder, 'level', { + enumerable: true, + get() { + return self.level; + }, + set(level) { + self.level = level; + } + }); + + Object.defineProperty(builder, 'enabled', { + enumerable: true, + get() { + return self.enabled; + }, + set(enabled) { + self.enabled = enabled; + } + }); + + // See below for fix regarding invisible grey/dim combination on Windows + builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey'; + + // `__proto__` is used because we must return a function, but there is + // no way to create a function with a different prototype + builder.__proto__ = proto; // eslint-disable-line no-proto + + return builder; +} + +function applyStyle() { + // Support varags, but simply cast to string in case there's only one arg + const args = arguments; + const argsLen = args.length; + let str = String(arguments[0]); + + if (argsLen === 0) { + return ''; + } + + if (argsLen > 1) { + // Don't slice `arguments`, it prevents V8 optimizations + for (let a = 1; a < argsLen; a++) { + str += ' ' + args[a]; + } + } + + if (!this.enabled || this.level <= 0 || !str) { + return str; + } + + // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe, + // see https://github.com/chalk/chalk/issues/58 + // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop. + const originalDim = ansiStyles.dim.open; + if (isSimpleWindowsTerm && this.hasGrey) { + ansiStyles.dim.open = ''; + } + + for (const code of this._styles.slice().reverse()) { + // Replace any instances already present with a re-opening code + // otherwise only the part of the string until said closing code + // will be colored, and the rest will simply be 'plain'. + str = code.open + str.replace(code.closeRe, code.open) + code.close; + + // Close the styling before a linebreak and reopen + // after next line to fix a bleed issue on macOS + // https://github.com/chalk/chalk/pull/92 + str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`); + } + + // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue + ansiStyles.dim.open = originalDim; + + return str; +} + +function chalkTag(chalk, strings) { + if (!Array.isArray(strings)) { + // If chalk() was called by itself or with a string, + // return the string itself as a string. + return [].slice.call(arguments, 1).join(' '); + } + + const args = [].slice.call(arguments, 2); + const parts = [strings.raw[0]]; + + for (let i = 1; i < strings.length; i++) { + parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&')); + parts.push(String(strings.raw[i])); + } + + return template(chalk, parts.join('')); +} + +Object.defineProperties(Chalk.prototype, styles); + +module.exports = Chalk(); // eslint-disable-line new-cap +module.exports.supportsColor = supportsColor; + +}).call(this,require('_process')) +},{"./templates.js":581,"_process":16,"ansi-styles":45,"escape-string-regexp":604,"supports-color":1155}],581:[function(require,module,exports){ +'use strict'; +const TEMPLATE_REGEX = /(?:\\(u[a-f0-9]{4}|x[a-f0-9]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi; +const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g; +const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/; +const ESCAPE_REGEX = /\\(u[0-9a-f]{4}|x[0-9a-f]{2}|.)|([^\\])/gi; + +const ESCAPES = { + n: '\n', + r: '\r', + t: '\t', + b: '\b', + f: '\f', + v: '\v', + 0: '\0', + '\\': '\\', + e: '\u001b', + a: '\u0007' +}; + +function unescape(c) { + if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) { + return String.fromCharCode(parseInt(c.slice(1), 16)); + } + + return ESCAPES[c] || c; +} + +function parseArguments(name, args) { + const results = []; + const chunks = args.trim().split(/\s*,\s*/g); + let matches; + + for (const chunk of chunks) { + if (!isNaN(chunk)) { + results.push(Number(chunk)); + } else if ((matches = chunk.match(STRING_REGEX))) { + results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr)); + } else { + throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`); + } + } + + return results; +} + +function parseStyle(style) { + STYLE_REGEX.lastIndex = 0; + + const results = []; + let matches; + + while ((matches = STYLE_REGEX.exec(style)) !== null) { + const name = matches[1]; + + if (matches[2]) { + const args = parseArguments(name, matches[2]); + results.push([name].concat(args)); + } else { + results.push([name]); + } + } + + return results; +} + +function buildStyle(chalk, styles) { + const enabled = {}; + + for (const layer of styles) { + for (const style of layer.styles) { + enabled[style[0]] = layer.inverse ? null : style.slice(1); + } + } + + let current = chalk; + for (const styleName of Object.keys(enabled)) { + if (Array.isArray(enabled[styleName])) { + if (!(styleName in current)) { + throw new Error(`Unknown Chalk style: ${styleName}`); + } + + if (enabled[styleName].length > 0) { + current = current[styleName].apply(current, enabled[styleName]); + } else { + current = current[styleName]; + } + } + } + + return current; +} + +module.exports = (chalk, tmp) => { + const styles = []; + const chunks = []; + let chunk = []; + + // eslint-disable-next-line max-params + tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => { + if (escapeChar) { + chunk.push(unescape(escapeChar)); + } else if (style) { + const str = chunk.join(''); + chunk = []; + chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str)); + styles.push({inverse, styles: parseStyle(style)}); + } else if (close) { + if (styles.length === 0) { + throw new Error('Found extraneous } in Chalk template literal'); + } + + chunks.push(buildStyle(chalk, styles)(chunk.join(''))); + chunk = []; + styles.pop(); + } else { + chunk.push(chr); + } + }); + + chunks.push(chunk.join('')); + + if (styles.length > 0) { + const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`; + throw new Error(errMsg); + } + + return chunks.join(''); +}; + +},{}],582:[function(require,module,exports){ +/*! +Copyright (C) 2013 by WebReflection + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +*/ +var + // should be a not so common char + // possibly one JSON does not encode + // possibly one encodeURIComponent does not encode + // right now this char is '~' but this might change in the future + specialChar = '~', + safeSpecialChar = '\\x' + ( + '0' + specialChar.charCodeAt(0).toString(16) + ).slice(-2), + escapedSafeSpecialChar = '\\' + safeSpecialChar, + specialCharRG = new RegExp(safeSpecialChar, 'g'), + safeSpecialCharRG = new RegExp(escapedSafeSpecialChar, 'g'), + + safeStartWithSpecialCharRG = new RegExp('(?:^|([^\\\\]))' + escapedSafeSpecialChar), + + indexOf = [].indexOf || function(v){ + for(var i=this.length;i--&&this[i]!==v;); + return i; + }, + $String = String // there's no way to drop warnings in JSHint + // about new String ... well, I need that here! + // faked, and happy linter! +; + +function generateReplacer(value, replacer, resolve) { + var + path = [], + all = [value], + seen = [value], + mapp = [resolve ? specialChar : '[Circular]'], + last = value, + lvl = 1, + i + ; + return function(key, value) { + // the replacer has rights to decide + // if a new object should be returned + // or if there's some key to drop + // let's call it here rather than "too late" + if (replacer) value = replacer.call(this, key, value); + + // did you know ? Safari passes keys as integers for arrays + // which means if (key) when key === 0 won't pass the check + if (key !== '') { + if (last !== this) { + i = lvl - indexOf.call(all, this) - 1; + lvl -= i; + all.splice(lvl, all.length); + path.splice(lvl - 1, path.length); + last = this; + } + // console.log(lvl, key, path); + if (typeof value === 'object' && value) { + // if object isn't referring to parent object, add to the + // object path stack. Otherwise it is already there. + if (indexOf.call(all, value) < 0) { + all.push(last = value); + } + lvl = all.length; + i = indexOf.call(seen, value); + if (i < 0) { + i = seen.push(value) - 1; + if (resolve) { + // key cannot contain specialChar but could be not a string + path.push(('' + key).replace(specialCharRG, safeSpecialChar)); + mapp[i] = specialChar + path.join(specialChar); + } else { + mapp[i] = mapp[0]; + } + } else { + value = mapp[i]; + } + } else { + if (typeof value === 'string' && resolve) { + // ensure no special char involved on deserialization + // in this case only first char is important + // no need to replace all value (better performance) + value = value .replace(safeSpecialChar, escapedSafeSpecialChar) + .replace(specialChar, safeSpecialChar); + } + } + } + return value; + }; +} + +function retrieveFromPath(current, keys) { + for(var i = 0, length = keys.length; i < length; current = current[ + // keys should be normalized back here + keys[i++].replace(safeSpecialCharRG, specialChar) + ]); + return current; +} + +function generateReviver(reviver) { + return function(key, value) { + var isString = typeof value === 'string'; + if (isString && value.charAt(0) === specialChar) { + return new $String(value.slice(1)); + } + if (key === '') value = regenerate(value, value, {}); + // again, only one needed, do not use the RegExp for this replacement + // only keys need the RegExp + if (isString) value = value .replace(safeStartWithSpecialCharRG, '$1' + specialChar) + .replace(escapedSafeSpecialChar, safeSpecialChar); + return reviver ? reviver.call(this, key, value) : value; + }; +} + +function regenerateArray(root, current, retrieve) { + for (var i = 0, length = current.length; i < length; i++) { + current[i] = regenerate(root, current[i], retrieve); + } + return current; +} + +function regenerateObject(root, current, retrieve) { + for (var key in current) { + if (current.hasOwnProperty(key)) { + current[key] = regenerate(root, current[key], retrieve); + } + } + return current; +} + +function regenerate(root, current, retrieve) { + return current instanceof Array ? + // fast Array reconstruction + regenerateArray(root, current, retrieve) : + ( + current instanceof $String ? + ( + // root is an empty string + current.length ? + ( + retrieve.hasOwnProperty(current) ? + retrieve[current] : + retrieve[current] = retrieveFromPath( + root, current.split(specialChar) + ) + ) : + root + ) : + ( + current instanceof Object ? + // dedicated Object parser + regenerateObject(root, current, retrieve) : + // value as it is + current + ) + ) + ; +} + +function stringifyRecursion(value, replacer, space, doNotResolve) { + return JSON.stringify(value, generateReplacer(value, replacer, !doNotResolve), space); +} + +function parseRecursion(text, reviver) { + return JSON.parse(text, generateReviver(reviver)); +} +this.stringify = stringifyRecursion; +this.parse = parseRecursion; +},{}],583:[function(require,module,exports){ +'use strict'; +var isRegexp = require('is-regexp'); +var isSupportedRegexpFlag = require('is-supported-regexp-flag'); + +var flagMap = { + global: 'g', + ignoreCase: 'i', + multiline: 'm' +}; + +if (isSupportedRegexpFlag('y')) { + flagMap.sticky = 'y'; +} + +if (isSupportedRegexpFlag('u')) { + flagMap.unicode = 'u'; +} + +module.exports = function (re, opts) { + if (!isRegexp(re)) { + throw new TypeError('Expected a RegExp instance'); + } + + opts = opts || {}; + + var flags = Object.keys(flagMap).map(function (el) { + return (typeof opts[el] === 'boolean' ? opts[el] : re[el]) ? flagMap[el] : ''; + }).join(''); + + return new RegExp(opts.source || re.source, flags); +}; + +},{"is-regexp":654,"is-supported-regexp-flag":655}],584:[function(require,module,exports){ +/* MIT license */ +var cssKeywords = require('color-name'); + +// NOTE: conversions should only return primitive values (i.e. arrays, or +// values that give correct `typeof` results). +// do not use box values types (i.e. Number(), String(), etc.) + +var reverseKeywords = {}; +for (var key in cssKeywords) { + if (cssKeywords.hasOwnProperty(key)) { + reverseKeywords[cssKeywords[key]] = key; + } +} + +var convert = module.exports = { + rgb: {channels: 3, labels: 'rgb'}, + hsl: {channels: 3, labels: 'hsl'}, + hsv: {channels: 3, labels: 'hsv'}, + hwb: {channels: 3, labels: 'hwb'}, + cmyk: {channels: 4, labels: 'cmyk'}, + xyz: {channels: 3, labels: 'xyz'}, + lab: {channels: 3, labels: 'lab'}, + lch: {channels: 3, labels: 'lch'}, + hex: {channels: 1, labels: ['hex']}, + keyword: {channels: 1, labels: ['keyword']}, + ansi16: {channels: 1, labels: ['ansi16']}, + ansi256: {channels: 1, labels: ['ansi256']}, + hcg: {channels: 3, labels: ['h', 'c', 'g']}, + apple: {channels: 3, labels: ['r16', 'g16', 'b16']}, + gray: {channels: 1, labels: ['gray']} +}; + +// hide .channels and .labels properties +for (var model in convert) { + if (convert.hasOwnProperty(model)) { + if (!('channels' in convert[model])) { + throw new Error('missing channels property: ' + model); + } + + if (!('labels' in convert[model])) { + throw new Error('missing channel labels property: ' + model); + } + + if (convert[model].labels.length !== convert[model].channels) { + throw new Error('channel and label counts mismatch: ' + model); + } + + var channels = convert[model].channels; + var labels = convert[model].labels; + delete convert[model].channels; + delete convert[model].labels; + Object.defineProperty(convert[model], 'channels', {value: channels}); + Object.defineProperty(convert[model], 'labels', {value: labels}); + } +} + +convert.rgb.hsl = function (rgb) { + var r = rgb[0] / 255; + var g = rgb[1] / 255; + var b = rgb[2] / 255; + var min = Math.min(r, g, b); + var max = Math.max(r, g, b); + var delta = max - min; + var h; + var s; + var l; + + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + + h = Math.min(h * 60, 360); + + if (h < 0) { + h += 360; + } + + l = (min + max) / 2; + + if (max === min) { + s = 0; + } else if (l <= 0.5) { + s = delta / (max + min); + } else { + s = delta / (2 - max - min); + } + + return [h, s * 100, l * 100]; +}; + +convert.rgb.hsv = function (rgb) { + var r = rgb[0]; + var g = rgb[1]; + var b = rgb[2]; + var min = Math.min(r, g, b); + var max = Math.max(r, g, b); + var delta = max - min; + var h; + var s; + var v; + + if (max === 0) { + s = 0; + } else { + s = (delta / max * 1000) / 10; + } + + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + + h = Math.min(h * 60, 360); + + if (h < 0) { + h += 360; + } + + v = ((max / 255) * 1000) / 10; + + return [h, s, v]; +}; + +convert.rgb.hwb = function (rgb) { + var r = rgb[0]; + var g = rgb[1]; + var b = rgb[2]; + var h = convert.rgb.hsl(rgb)[0]; + var w = 1 / 255 * Math.min(r, Math.min(g, b)); + + b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); + + return [h, w * 100, b * 100]; +}; + +convert.rgb.cmyk = function (rgb) { + var r = rgb[0] / 255; + var g = rgb[1] / 255; + var b = rgb[2] / 255; + var c; + var m; + var y; + var k; + + k = Math.min(1 - r, 1 - g, 1 - b); + c = (1 - r - k) / (1 - k) || 0; + m = (1 - g - k) / (1 - k) || 0; + y = (1 - b - k) / (1 - k) || 0; + + return [c * 100, m * 100, y * 100, k * 100]; +}; + +/** + * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance + * */ +function comparativeDistance(x, y) { + return ( + Math.pow(x[0] - y[0], 2) + + Math.pow(x[1] - y[1], 2) + + Math.pow(x[2] - y[2], 2) + ); +} + +convert.rgb.keyword = function (rgb) { + var reversed = reverseKeywords[rgb]; + if (reversed) { + return reversed; + } + + var currentClosestDistance = Infinity; + var currentClosestKeyword; + + for (var keyword in cssKeywords) { + if (cssKeywords.hasOwnProperty(keyword)) { + var value = cssKeywords[keyword]; + + // Compute comparative distance + var distance = comparativeDistance(rgb, value); + + // Check if its less, if so set as closest + if (distance < currentClosestDistance) { + currentClosestDistance = distance; + currentClosestKeyword = keyword; + } + } + } + + return currentClosestKeyword; +}; + +convert.keyword.rgb = function (keyword) { + return cssKeywords[keyword]; +}; + +convert.rgb.xyz = function (rgb) { + var r = rgb[0] / 255; + var g = rgb[1] / 255; + var b = rgb[2] / 255; + + // assume sRGB + r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92); + g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92); + b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92); + + var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805); + var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722); + var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505); + + return [x * 100, y * 100, z * 100]; +}; + +convert.rgb.lab = function (rgb) { + var xyz = convert.rgb.xyz(rgb); + var x = xyz[0]; + var y = xyz[1]; + var z = xyz[2]; + var l; + var a; + var b; + + x /= 95.047; + y /= 100; + z /= 108.883; + + x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); + y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); + z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); + + l = (116 * y) - 16; + a = 500 * (x - y); + b = 200 * (y - z); + + return [l, a, b]; +}; + +convert.hsl.rgb = function (hsl) { + var h = hsl[0] / 360; + var s = hsl[1] / 100; + var l = hsl[2] / 100; + var t1; + var t2; + var t3; + var rgb; + var val; + + if (s === 0) { + val = l * 255; + return [val, val, val]; + } + + if (l < 0.5) { + t2 = l * (1 + s); + } else { + t2 = l + s - l * s; + } + + t1 = 2 * l - t2; + + rgb = [0, 0, 0]; + for (var i = 0; i < 3; i++) { + t3 = h + 1 / 3 * -(i - 1); + if (t3 < 0) { + t3++; + } + if (t3 > 1) { + t3--; + } + + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + + rgb[i] = val * 255; + } + + return rgb; +}; + +convert.hsl.hsv = function (hsl) { + var h = hsl[0]; + var s = hsl[1] / 100; + var l = hsl[2] / 100; + var smin = s; + var lmin = Math.max(l, 0.01); + var sv; + var v; + + l *= 2; + s *= (l <= 1) ? l : 2 - l; + smin *= lmin <= 1 ? lmin : 2 - lmin; + v = (l + s) / 2; + sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s); + + return [h, sv * 100, v * 100]; +}; + +convert.hsv.rgb = function (hsv) { + var h = hsv[0] / 60; + var s = hsv[1] / 100; + var v = hsv[2] / 100; + var hi = Math.floor(h) % 6; + + var f = h - Math.floor(h); + var p = 255 * v * (1 - s); + var q = 255 * v * (1 - (s * f)); + var t = 255 * v * (1 - (s * (1 - f))); + v *= 255; + + switch (hi) { + case 0: + return [v, t, p]; + case 1: + return [q, v, p]; + case 2: + return [p, v, t]; + case 3: + return [p, q, v]; + case 4: + return [t, p, v]; + case 5: + return [v, p, q]; + } +}; + +convert.hsv.hsl = function (hsv) { + var h = hsv[0]; + var s = hsv[1] / 100; + var v = hsv[2] / 100; + var vmin = Math.max(v, 0.01); + var lmin; + var sl; + var l; + + l = (2 - s) * v; + lmin = (2 - s) * vmin; + sl = s * vmin; + sl /= (lmin <= 1) ? lmin : 2 - lmin; + sl = sl || 0; + l /= 2; + + return [h, sl * 100, l * 100]; +}; + +// http://dev.w3.org/csswg/css-color/#hwb-to-rgb +convert.hwb.rgb = function (hwb) { + var h = hwb[0] / 360; + var wh = hwb[1] / 100; + var bl = hwb[2] / 100; + var ratio = wh + bl; + var i; + var v; + var f; + var n; + + // wh + bl cant be > 1 + if (ratio > 1) { + wh /= ratio; + bl /= ratio; + } + + i = Math.floor(6 * h); + v = 1 - bl; + f = 6 * h - i; + + if ((i & 0x01) !== 0) { + f = 1 - f; + } + + n = wh + f * (v - wh); // linear interpolation + + var r; + var g; + var b; + switch (i) { + default: + case 6: + case 0: r = v; g = n; b = wh; break; + case 1: r = n; g = v; b = wh; break; + case 2: r = wh; g = v; b = n; break; + case 3: r = wh; g = n; b = v; break; + case 4: r = n; g = wh; b = v; break; + case 5: r = v; g = wh; b = n; break; + } + + return [r * 255, g * 255, b * 255]; +}; + +convert.cmyk.rgb = function (cmyk) { + var c = cmyk[0] / 100; + var m = cmyk[1] / 100; + var y = cmyk[2] / 100; + var k = cmyk[3] / 100; + var r; + var g; + var b; + + r = 1 - Math.min(1, c * (1 - k) + k); + g = 1 - Math.min(1, m * (1 - k) + k); + b = 1 - Math.min(1, y * (1 - k) + k); + + return [r * 255, g * 255, b * 255]; +}; + +convert.xyz.rgb = function (xyz) { + var x = xyz[0] / 100; + var y = xyz[1] / 100; + var z = xyz[2] / 100; + var r; + var g; + var b; + + r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986); + g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415); + b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570); + + // assume sRGB + r = r > 0.0031308 + ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055) + : r * 12.92; + + g = g > 0.0031308 + ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055) + : g * 12.92; + + b = b > 0.0031308 + ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055) + : b * 12.92; + + r = Math.min(Math.max(0, r), 1); + g = Math.min(Math.max(0, g), 1); + b = Math.min(Math.max(0, b), 1); + + return [r * 255, g * 255, b * 255]; +}; + +convert.xyz.lab = function (xyz) { + var x = xyz[0]; + var y = xyz[1]; + var z = xyz[2]; + var l; + var a; + var b; + + x /= 95.047; + y /= 100; + z /= 108.883; + + x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116); + y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116); + z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116); + + l = (116 * y) - 16; + a = 500 * (x - y); + b = 200 * (y - z); + + return [l, a, b]; +}; + +convert.lab.xyz = function (lab) { + var l = lab[0]; + var a = lab[1]; + var b = lab[2]; + var x; + var y; + var z; + + y = (l + 16) / 116; + x = a / 500 + y; + z = y - b / 200; + + var y2 = Math.pow(y, 3); + var x2 = Math.pow(x, 3); + var z2 = Math.pow(z, 3); + y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787; + x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787; + z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787; + + x *= 95.047; + y *= 100; + z *= 108.883; + + return [x, y, z]; +}; + +convert.lab.lch = function (lab) { + var l = lab[0]; + var a = lab[1]; + var b = lab[2]; + var hr; + var h; + var c; + + hr = Math.atan2(b, a); + h = hr * 360 / 2 / Math.PI; + + if (h < 0) { + h += 360; + } + + c = Math.sqrt(a * a + b * b); + + return [l, c, h]; +}; + +convert.lch.lab = function (lch) { + var l = lch[0]; + var c = lch[1]; + var h = lch[2]; + var a; + var b; + var hr; + + hr = h / 360 * 2 * Math.PI; + a = c * Math.cos(hr); + b = c * Math.sin(hr); + + return [l, a, b]; +}; + +convert.rgb.ansi16 = function (args) { + var r = args[0]; + var g = args[1]; + var b = args[2]; + var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization + + value = Math.round(value / 50); + + if (value === 0) { + return 30; + } + + var ansi = 30 + + ((Math.round(b / 255) << 2) + | (Math.round(g / 255) << 1) + | Math.round(r / 255)); + + if (value === 2) { + ansi += 60; + } + + return ansi; +}; + +convert.hsv.ansi16 = function (args) { + // optimization here; we already know the value and don't need to get + // it converted for us. + return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); +}; + +convert.rgb.ansi256 = function (args) { + var r = args[0]; + var g = args[1]; + var b = args[2]; + + // we use the extended greyscale palette here, with the exception of + // black and white. normal palette only has 4 greyscale shades. + if (r === g && g === b) { + if (r < 8) { + return 16; + } + + if (r > 248) { + return 231; + } + + return Math.round(((r - 8) / 247) * 24) + 232; + } + + var ansi = 16 + + (36 * Math.round(r / 255 * 5)) + + (6 * Math.round(g / 255 * 5)) + + Math.round(b / 255 * 5); + + return ansi; +}; + +convert.ansi16.rgb = function (args) { + var color = args % 10; + + // handle greyscale + if (color === 0 || color === 7) { + if (args > 50) { + color += 3.5; + } + + color = color / 10.5 * 255; + + return [color, color, color]; + } + + var mult = (~~(args > 50) + 1) * 0.5; + var r = ((color & 1) * mult) * 255; + var g = (((color >> 1) & 1) * mult) * 255; + var b = (((color >> 2) & 1) * mult) * 255; + + return [r, g, b]; +}; + +convert.ansi256.rgb = function (args) { + // handle greyscale + if (args >= 232) { + var c = (args - 232) * 10 + 8; + return [c, c, c]; + } + + args -= 16; + + var rem; + var r = Math.floor(args / 36) / 5 * 255; + var g = Math.floor((rem = args % 36) / 6) / 5 * 255; + var b = (rem % 6) / 5 * 255; + + return [r, g, b]; +}; + +convert.rgb.hex = function (args) { + var integer = ((Math.round(args[0]) & 0xFF) << 16) + + ((Math.round(args[1]) & 0xFF) << 8) + + (Math.round(args[2]) & 0xFF); + + var string = integer.toString(16).toUpperCase(); + return '000000'.substring(string.length) + string; +}; + +convert.hex.rgb = function (args) { + var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!match) { + return [0, 0, 0]; + } + + var colorString = match[0]; + + if (match[0].length === 3) { + colorString = colorString.split('').map(function (char) { + return char + char; + }).join(''); + } + + var integer = parseInt(colorString, 16); + var r = (integer >> 16) & 0xFF; + var g = (integer >> 8) & 0xFF; + var b = integer & 0xFF; + + return [r, g, b]; +}; + +convert.rgb.hcg = function (rgb) { + var r = rgb[0] / 255; + var g = rgb[1] / 255; + var b = rgb[2] / 255; + var max = Math.max(Math.max(r, g), b); + var min = Math.min(Math.min(r, g), b); + var chroma = (max - min); + var grayscale; + var hue; + + if (chroma < 1) { + grayscale = min / (1 - chroma); + } else { + grayscale = 0; + } + + if (chroma <= 0) { + hue = 0; + } else + if (max === r) { + hue = ((g - b) / chroma) % 6; + } else + if (max === g) { + hue = 2 + (b - r) / chroma; + } else { + hue = 4 + (r - g) / chroma + 4; + } + + hue /= 6; + hue %= 1; + + return [hue * 360, chroma * 100, grayscale * 100]; +}; + +convert.hsl.hcg = function (hsl) { + var s = hsl[1] / 100; + var l = hsl[2] / 100; + var c = 1; + var f = 0; + + if (l < 0.5) { + c = 2.0 * s * l; + } else { + c = 2.0 * s * (1.0 - l); + } + + if (c < 1.0) { + f = (l - 0.5 * c) / (1.0 - c); + } + + return [hsl[0], c * 100, f * 100]; +}; + +convert.hsv.hcg = function (hsv) { + var s = hsv[1] / 100; + var v = hsv[2] / 100; + + var c = s * v; + var f = 0; + + if (c < 1.0) { + f = (v - c) / (1 - c); + } + + return [hsv[0], c * 100, f * 100]; +}; + +convert.hcg.rgb = function (hcg) { + var h = hcg[0] / 360; + var c = hcg[1] / 100; + var g = hcg[2] / 100; + + if (c === 0.0) { + return [g * 255, g * 255, g * 255]; + } + + var pure = [0, 0, 0]; + var hi = (h % 1) * 6; + var v = hi % 1; + var w = 1 - v; + var mg = 0; + + switch (Math.floor(hi)) { + case 0: + pure[0] = 1; pure[1] = v; pure[2] = 0; break; + case 1: + pure[0] = w; pure[1] = 1; pure[2] = 0; break; + case 2: + pure[0] = 0; pure[1] = 1; pure[2] = v; break; + case 3: + pure[0] = 0; pure[1] = w; pure[2] = 1; break; + case 4: + pure[0] = v; pure[1] = 0; pure[2] = 1; break; + default: + pure[0] = 1; pure[1] = 0; pure[2] = w; + } + + mg = (1.0 - c) * g; + + return [ + (c * pure[0] + mg) * 255, + (c * pure[1] + mg) * 255, + (c * pure[2] + mg) * 255 + ]; +}; + +convert.hcg.hsv = function (hcg) { + var c = hcg[1] / 100; + var g = hcg[2] / 100; + + var v = c + g * (1.0 - c); + var f = 0; + + if (v > 0.0) { + f = c / v; + } + + return [hcg[0], f * 100, v * 100]; +}; + +convert.hcg.hsl = function (hcg) { + var c = hcg[1] / 100; + var g = hcg[2] / 100; + + var l = g * (1.0 - c) + 0.5 * c; + var s = 0; + + if (l > 0.0 && l < 0.5) { + s = c / (2 * l); + } else + if (l >= 0.5 && l < 1.0) { + s = c / (2 * (1 - l)); + } + + return [hcg[0], s * 100, l * 100]; +}; + +convert.hcg.hwb = function (hcg) { + var c = hcg[1] / 100; + var g = hcg[2] / 100; + var v = c + g * (1.0 - c); + return [hcg[0], (v - c) * 100, (1 - v) * 100]; +}; + +convert.hwb.hcg = function (hwb) { + var w = hwb[1] / 100; + var b = hwb[2] / 100; + var v = 1 - b; + var c = v - w; + var g = 0; + + if (c < 1) { + g = (v - c) / (1 - c); + } + + return [hwb[0], c * 100, g * 100]; +}; + +convert.apple.rgb = function (apple) { + return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255]; +}; + +convert.rgb.apple = function (rgb) { + return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535]; +}; + +convert.gray.rgb = function (args) { + return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; +}; + +convert.gray.hsl = convert.gray.hsv = function (args) { + return [0, 0, args[0]]; +}; + +convert.gray.hwb = function (gray) { + return [0, 100, gray[0]]; +}; + +convert.gray.cmyk = function (gray) { + return [0, 0, 0, gray[0]]; +}; + +convert.gray.lab = function (gray) { + return [gray[0], 0, 0]; +}; + +convert.gray.hex = function (gray) { + var val = Math.round(gray[0] / 100 * 255) & 0xFF; + var integer = (val << 16) + (val << 8) + val; + + var string = integer.toString(16).toUpperCase(); + return '000000'.substring(string.length) + string; +}; + +convert.rgb.gray = function (rgb) { + var val = (rgb[0] + rgb[1] + rgb[2]) / 3; + return [val / 255 * 100]; +}; + +},{"color-name":587}],585:[function(require,module,exports){ +var conversions = require('./conversions'); +var route = require('./route'); + +var convert = {}; + +var models = Object.keys(conversions); + +function wrapRaw(fn) { + var wrappedFn = function (args) { + if (args === undefined || args === null) { + return args; + } + + if (arguments.length > 1) { + args = Array.prototype.slice.call(arguments); + } + + return fn(args); + }; + + // preserve .conversion property if there is one + if ('conversion' in fn) { + wrappedFn.conversion = fn.conversion; + } + + return wrappedFn; +} + +function wrapRounded(fn) { + var wrappedFn = function (args) { + if (args === undefined || args === null) { + return args; + } + + if (arguments.length > 1) { + args = Array.prototype.slice.call(arguments); + } + + var result = fn(args); + + // we're assuming the result is an array here. + // see notice in conversions.js; don't use box types + // in conversion functions. + if (typeof result === 'object') { + for (var len = result.length, i = 0; i < len; i++) { + result[i] = Math.round(result[i]); + } + } + + return result; + }; + + // preserve .conversion property if there is one + if ('conversion' in fn) { + wrappedFn.conversion = fn.conversion; + } + + return wrappedFn; +} + +models.forEach(function (fromModel) { + convert[fromModel] = {}; + + Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels}); + Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels}); + + var routes = route(fromModel); + var routeModels = Object.keys(routes); + + routeModels.forEach(function (toModel) { + var fn = routes[toModel]; + + convert[fromModel][toModel] = wrapRounded(fn); + convert[fromModel][toModel].raw = wrapRaw(fn); + }); +}); + +module.exports = convert; + +},{"./conversions":584,"./route":586}],586:[function(require,module,exports){ +var conversions = require('./conversions'); + +/* + this function routes a model to all other models. + + all functions that are routed have a property `.conversion` attached + to the returned synthetic function. This property is an array + of strings, each with the steps in between the 'from' and 'to' + color models (inclusive). + + conversions that are not possible simply are not included. +*/ + +// https://jsperf.com/object-keys-vs-for-in-with-closure/3 +var models = Object.keys(conversions); + +function buildGraph() { + var graph = {}; + + for (var len = models.length, i = 0; i < len; i++) { + graph[models[i]] = { + // http://jsperf.com/1-vs-infinity + // micro-opt, but this is simple. + distance: -1, + parent: null + }; + } + + return graph; +} + +// https://en.wikipedia.org/wiki/Breadth-first_search +function deriveBFS(fromModel) { + var graph = buildGraph(); + var queue = [fromModel]; // unshift -> queue -> pop + + graph[fromModel].distance = 0; + + while (queue.length) { + var current = queue.pop(); + var adjacents = Object.keys(conversions[current]); + + for (var len = adjacents.length, i = 0; i < len; i++) { + var adjacent = adjacents[i]; + var node = graph[adjacent]; + + if (node.distance === -1) { + node.distance = graph[current].distance + 1; + node.parent = current; + queue.unshift(adjacent); + } + } + } + + return graph; +} + +function link(from, to) { + return function (args) { + return to(from(args)); + }; +} + +function wrapConversion(toModel, graph) { + var path = [graph[toModel].parent, toModel]; + var fn = conversions[graph[toModel].parent][toModel]; + + var cur = graph[toModel].parent; + while (graph[cur].parent) { + path.unshift(graph[cur].parent); + fn = link(conversions[graph[cur].parent][cur], fn); + cur = graph[cur].parent; + } + + fn.conversion = path; + return fn; +} + +module.exports = function (fromModel) { + var graph = deriveBFS(fromModel); + var conversion = {}; + + var models = Object.keys(graph); + for (var len = models.length, i = 0; i < len; i++) { + var toModel = models[i]; + var node = graph[toModel]; + + if (node.parent === null) { + // no possible conversion, or this node is the source model. + continue; + } + + conversion[toModel] = wrapConversion(toModel, graph); + } + + return conversion; +}; + + +},{"./conversions":584}],587:[function(require,module,exports){ +'use strict' + +module.exports = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] +}; + +},{}],588:[function(require,module,exports){ +module.exports = function (xs, fn) { + var res = []; + for (var i = 0; i < xs.length; i++) { + var x = fn(xs[i], i); + if (isArray(x)) res.push.apply(res, x); + else res.push(x); + } + return res; +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + +},{}],589:[function(require,module,exports){ +(function (process){ +'use strict'; + +var path = require('path'); +var oshomedir = require('os-homedir'); +var minimist = require('minimist'); +var assign = require('object-assign'); +var createExplorer = require('./lib/createExplorer'); + +var parsedCliArgs = minimist(process.argv); + +module.exports = function (moduleName, options) { + options = assign({ + packageProp: moduleName, + rc: '.' + moduleName + 'rc', + js: moduleName + '.config.js', + argv: 'config', + rcStrictJson: false, + stopDir: oshomedir(), + cache: true, + }, options); + + if (options.argv && parsedCliArgs[options.argv]) { + options.configPath = path.resolve(parsedCliArgs[options.argv]); + } + + return createExplorer(options); +}; + +}).call(this,require('_process')) +},{"./lib/createExplorer":590,"_process":16,"minimist":704,"object-assign":711,"os-homedir":714,"path":14}],590:[function(require,module,exports){ +(function (process){ +'use strict'; + +var path = require('path'); +var isDir = require('is-directory'); +var loadPackageProp = require('./loadPackageProp'); +var loadRc = require('./loadRc'); +var loadJs = require('./loadJs'); +var loadDefinedFile = require('./loadDefinedFile'); + +module.exports = function (options) { + // These cache Promises that resolve with results, not the results themselves + var fileCache = (options.cache) ? new Map() : null; + var directoryCache = (options.cache) ? new Map() : null; + var transform = options.transform || identityPromise; + + function clearFileCache() { + if (fileCache) fileCache.clear(); + } + + function clearDirectoryCache() { + if (directoryCache) directoryCache.clear(); + } + + function clearCaches() { + clearFileCache(); + clearDirectoryCache(); + } + + function load(searchPath, configPath) { + if (!configPath && options.configPath) { + configPath = options.configPath; + } + + if (configPath) { + var absoluteConfigPath = path.resolve(process.cwd(), configPath); + if (fileCache && fileCache.has(absoluteConfigPath)) { + return fileCache.get(absoluteConfigPath); + } + var result = loadDefinedFile(absoluteConfigPath, options) + .then(transform); + if (fileCache) fileCache.set(absoluteConfigPath, result); + return result; + } + + if (!searchPath) return Promise.resolve(null); + + var absoluteSearchPath = path.resolve(process.cwd(), searchPath); + + return isDirectory(absoluteSearchPath) + .then(function (searchPathIsDirectory) { + var directory = (searchPathIsDirectory) + ? absoluteSearchPath + : path.dirname(absoluteSearchPath); + return searchDirectory(directory); + }); + } + + function searchDirectory(directory) { + if (directoryCache && directoryCache.has(directory)) { + return directoryCache.get(directory); + } + + var result = Promise.resolve() + .then(function () { + if (!options.packageProp) return; + return loadPackageProp(directory, options); + }) + .then(function (result) { + if (result || !options.rc) return result; + return loadRc(path.join(directory, options.rc), options); + }) + .then(function (result) { + if (result || !options.js) return result; + return loadJs(path.join(directory, options.js)); + }) + .then(function (result) { + if (result) return result; + + var splitPath = directory.split(path.sep); + var nextDirectory = (splitPath.length > 1) + ? splitPath.slice(0, -1).join(path.sep) + : null; + + if (!nextDirectory || directory === options.stopDir) return null; + + return searchDirectory(nextDirectory); + }) + .then(transform); + + if (directoryCache) directoryCache.set(directory, result); + return result; + } + + return { + load: load, + clearFileCache: clearFileCache, + clearDirectoryCache: clearDirectoryCache, + clearCaches: clearCaches, + }; +}; + +function isDirectory(filepath) { + return new Promise(function (resolve, reject) { + return isDir(filepath, function (err, dir) { + if (err) return reject(err); + return resolve(dir); + }); + }); +} + +function identityPromise(x) { + return Promise.resolve(x); +} + +}).call(this,require('_process')) +},{"./loadDefinedFile":591,"./loadJs":592,"./loadPackageProp":593,"./loadRc":594,"_process":16,"is-directory":641,"path":14}],591:[function(require,module,exports){ +'use strict'; + +var yaml = require('js-yaml'); +var requireFromString = require('require-from-string'); +var readFile = require('./readFile'); +var parseJson = require('./parseJson'); + +module.exports = function (filepath, options) { + return readFile(filepath, { throwNotFound: true }).then(function (content) { + var parsedConfig = (function () { + switch (options.format) { + case 'json': + return parseJson(content, filepath); + case 'yaml': + return yaml.safeLoad(content, { + filename: filepath, + }); + case 'js': + return requireFromString(content, filepath); + default: + return tryAllParsing(content, filepath); + } + })(); + + if (!parsedConfig) { + throw new Error( + 'Failed to parse "' + filepath + '" as JSON, JS, or YAML.' + ); + } + + return { + config: parsedConfig, + filepath: filepath, + }; + }); +}; + +function tryAllParsing(content, filepath) { + return tryYaml(content, filepath, function () { + return tryRequire(content, filepath, function () { + return null; + }); + }); +} + +function tryYaml(content, filepath, cb) { + try { + var result = yaml.safeLoad(content, { + filename: filepath, + }); + if (typeof result === 'string') { + return cb(); + } + return result; + } catch (e) { + return cb(); + } +} + +function tryRequire(content, filepath, cb) { + try { + return requireFromString(content, filepath); + } catch (e) { + return cb(); + } +} + +},{"./parseJson":595,"./readFile":596,"js-yaml":659,"require-from-string":850}],592:[function(require,module,exports){ +'use strict'; + +var requireFromString = require('require-from-string'); +var readFile = require('./readFile'); + +module.exports = function (filepath) { + return readFile(filepath).then(function (content) { + if (!content) return null; + + return { + config: requireFromString(content, filepath), + filepath: filepath, + }; + }); +}; + +},{"./readFile":596,"require-from-string":850}],593:[function(require,module,exports){ +'use strict'; + +var path = require('path'); +var readFile = require('./readFile'); +var parseJson = require('./parseJson'); + +module.exports = function (packageDir, options) { + var packagePath = path.join(packageDir, 'package.json'); + + return readFile(packagePath).then(function (content) { + if (!content) return null; + var parsedContent = parseJson(content, packagePath); + var packagePropValue = parsedContent[options.packageProp]; + if (!packagePropValue) return null; + + return { + config: packagePropValue, + filepath: packagePath, + }; + }); +}; + +},{"./parseJson":595,"./readFile":596,"path":14}],594:[function(require,module,exports){ +'use strict'; + +var yaml = require('js-yaml'); +var requireFromString = require('require-from-string'); +var readFile = require('./readFile'); +var parseJson = require('./parseJson'); + +module.exports = function (filepath, options) { + return loadExtensionlessRc().then(function (result) { + if (result) return result; + if (options.rcExtensions) return loadRcWithExtensions(); + return null; + }); + + function loadExtensionlessRc() { + return readRcFile().then(function (content) { + if (!content) return null; + + var pasedConfig = (options.rcStrictJson) + ? parseJson(content, filepath) + : yaml.safeLoad(content, { + filename: filepath, + }); + return { + config: pasedConfig, + filepath: filepath, + }; + }); + } + + function loadRcWithExtensions() { + return readRcFile('json').then(function (content) { + if (content) { + var successFilepath = filepath + '.json'; + return { + config: parseJson(content, successFilepath), + filepath: successFilepath, + }; + } + // If not content was found in the file with extension, + // try the next possible extension + return readRcFile('yaml'); + }).then(function (content) { + if (content) { + // If the previous check returned an object with a config + // property, then it succeeded and this step can be skipped + if (content.config) return content; + // If it just returned a string, then *this* check succeeded + var successFilepath = filepath + '.yaml'; + return { + config: yaml.safeLoad(content, { filename: successFilepath }), + filepath: successFilepath, + }; + } + return readRcFile('yml'); + }).then(function (content) { + if (content) { + if (content.config) return content; + var successFilepath = filepath + '.yml'; + return { + config: yaml.safeLoad(content, { filename: successFilepath }), + filepath: successFilepath, + }; + } + return readRcFile('js'); + }).then(function (content) { + if (content) { + if (content.config) return content; + var successFilepath = filepath + '.js'; + return { + config: requireFromString(content, successFilepath), + filepath: successFilepath, + }; + } + return null; + }); + } + + function readRcFile(extension) { + var filepathWithExtension = (extension) + ? filepath + '.' + extension + : filepath; + return readFile(filepathWithExtension); + } +}; + +},{"./parseJson":595,"./readFile":596,"js-yaml":659,"require-from-string":850}],595:[function(require,module,exports){ +'use strict'; + +var parseJson = require('parse-json'); + +module.exports = function (json, filepath) { + try { + return parseJson(json); + } catch (err) { + err.message = 'JSON Error in ' + filepath + ':\n' + err.message; + throw err; + } +}; + +},{"parse-json":716}],596:[function(require,module,exports){ +'use strict'; + +var fs = require('fs'); + +module.exports = function (filepath, options) { + options = options || {}; + options.throwNotFound = options.throwNotFound || false; + + return new Promise(function (resolve, reject) { + fs.readFile(filepath, 'utf8', function (err, content) { + if (err && err.code === 'ENOENT' && !options.throwNotFound) { + return resolve(null); + } + + if (err) return reject(err); + + resolve(content); + }); + }); +}; + +},{"fs":1}],597:[function(require,module,exports){ +(function (process){ +/** + * This is the web browser implementation of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = require('./debug'); +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.storage = 'undefined' != typeof chrome + && 'undefined' != typeof chrome.storage + ? chrome.storage.local + : localstorage(); + +/** + * Colors. + */ + +exports.colors = [ + 'lightseagreen', + 'forestgreen', + 'goldenrod', + 'dodgerblue', + 'darkorchid', + 'crimson' +]; + +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') { + return true; + } + + // is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || + // is firebug? http://stackoverflow.com/a/398120/376773 + (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || + // is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || + // double check webkit in userAgent just in case we are in a worker + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); +} + +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + +exports.formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (err) { + return '[UnexpectedJSONParseError]: ' + err.message; + } +}; + + +/** + * Colorize log arguments if enabled. + * + * @api public + */ + +function formatArgs(args) { + var useColors = this.useColors; + + args[0] = (useColors ? '%c' : '') + + this.namespace + + (useColors ? ' %c' : ' ') + + args[0] + + (useColors ? '%c ' : ' ') + + '+' + exports.humanize(this.diff); + + if (!useColors) return; + + var c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit') + + // the final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + var index = 0; + var lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, function(match) { + if ('%%' === match) return; + index++; + if ('%c' === match) { + // we only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); +} + +/** + * Invokes `console.log()` when available. + * No-op when `console.log` is not a "function". + * + * @api public + */ + +function log() { + // this hackery is required for IE8/9, where + // the `console.log` function doesn't have 'apply' + return 'object' === typeof console + && console.log + && Function.prototype.apply.call(console.log, console, arguments); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ + +function save(namespaces) { + try { + if (null == namespaces) { + exports.storage.removeItem('debug'); + } else { + exports.storage.debug = namespaces; + } + } catch(e) {} +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + var r; + try { + r = exports.storage.debug; + } catch(e) {} + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (!r && typeof process !== 'undefined' && 'env' in process) { + r = process.env.DEBUG; + } + + return r; +} + +/** + * Enable namespaces listed in `localStorage.debug` initially. + */ + +exports.enable(load()); + +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage() { + try { + return window.localStorage; + } catch (e) {} +} + +}).call(this,require('_process')) +},{"./debug":598,"_process":16}],598:[function(require,module,exports){ + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = createDebug.debug = createDebug['default'] = createDebug; +exports.coerce = coerce; +exports.disable = disable; +exports.enable = enable; +exports.enabled = enabled; +exports.humanize = require('ms'); + +/** + * The currently active debug mode names, and names to skip. + */ + +exports.names = []; +exports.skips = []; + +/** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + +exports.formatters = {}; + +/** + * Previous log timestamp. + */ + +var prevTime; + +/** + * Select a color. + * @param {String} namespace + * @return {Number} + * @api private + */ + +function selectColor(namespace) { + var hash = 0, i; + + for (i in namespace) { + hash = ((hash << 5) - hash) + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + + return exports.colors[Math.abs(hash) % exports.colors.length]; +} + +/** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + +function createDebug(namespace) { + + function debug() { + // disabled? + if (!debug.enabled) return; + + var self = debug; + + // set `diff` timestamp + var curr = +new Date(); + var ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + // turn the `arguments` into a proper Array + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + + args[0] = exports.coerce(args[0]); + + if ('string' !== typeof args[0]) { + // anything else let's inspect with %O + args.unshift('%O'); + } + + // apply any `formatters` transformations + var index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) { + // if we encounter an escaped % then don't increase the array index + if (match === '%%') return match; + index++; + var formatter = exports.formatters[format]; + if ('function' === typeof formatter) { + var val = args[index]; + match = formatter.call(self, val); + + // now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // apply env-specific formatting (colors, etc.) + exports.formatArgs.call(self, args); + + var logFn = debug.log || exports.log || console.log.bind(console); + logFn.apply(self, args); + } + + debug.namespace = namespace; + debug.enabled = exports.enabled(namespace); + debug.useColors = exports.useColors(); + debug.color = selectColor(namespace); + + // env-specific initialization logic for debug instances + if ('function' === typeof exports.init) { + exports.init(debug); + } + + return debug; +} + +/** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + +function enable(namespaces) { + exports.save(namespaces); + + exports.names = []; + exports.skips = []; + + var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/); + var len = split.length; + + for (var i = 0; i < len; i++) { + if (!split[i]) continue; // ignore empty strings + namespaces = split[i].replace(/\*/g, '.*?'); + if (namespaces[0] === '-') { + exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); + } else { + exports.names.push(new RegExp('^' + namespaces + '$')); + } + } +} + +/** + * Disable debug output. + * + * @api public + */ + +function disable() { + exports.enable(''); +} + +/** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + +function enabled(name) { + var i, len; + for (i = 0, len = exports.skips.length; i < len; i++) { + if (exports.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = exports.names.length; i < len; i++) { + if (exports.names[i].test(name)) { + return true; + } + } + return false; +} + +/** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + +function coerce(val) { + if (val instanceof Error) return val.stack || val.message; + return val; +} + +},{"ms":706}],599:[function(require,module,exports){ +'use strict'; +var path = require('path'); +var globby = require('globby'); +var isPathCwd = require('is-path-cwd'); +var isPathInCwd = require('is-path-in-cwd'); +var objectAssign = require('object-assign'); +var Promise = require('pinkie-promise'); +var pify = require('pify'); +var rimraf = require('rimraf'); + +var rimrafP = pify(rimraf, Promise); + +function safeCheck(file) { + if (isPathCwd(file)) { + throw new Error('Cannot delete the current working directory. Can be overriden with the `force` option.'); + } + + if (!isPathInCwd(file)) { + throw new Error('Cannot delete files/folders outside the current working directory. Can be overriden with the `force` option.'); + } +} + +module.exports = function (patterns, opts) { + opts = objectAssign({}, opts); + + var force = opts.force; + delete opts.force; + + var dryRun = opts.dryRun; + delete opts.dryRun; + + return globby(patterns, opts).then(function (files) { + return Promise.all(files.map(function (file) { + if (!force) { + safeCheck(file); + } + + file = path.resolve(opts.cwd || '', file); + + if (dryRun) { + return Promise.resolve(file); + } + + return rimrafP(file).then(function () { + return file; + }); + })); + }); +}; + +module.exports.sync = function (patterns, opts) { + opts = objectAssign({}, opts); + + var force = opts.force; + delete opts.force; + + var dryRun = opts.dryRun; + delete opts.dryRun; + + return globby.sync(patterns, opts).map(function (file) { + if (!force) { + safeCheck(file); + } + + file = path.resolve(opts.cwd || '', file); + + if (!dryRun) { + rimraf.sync(file); + } + + return file; + }); +}; + +},{"globby":600,"is-path-cwd":649,"is-path-in-cwd":650,"object-assign":711,"path":14,"pify":601,"pinkie-promise":722,"rimraf":852}],600:[function(require,module,exports){ +'use strict'; +var Promise = require('pinkie-promise'); +var arrayUnion = require('array-union'); +var objectAssign = require('object-assign'); +var glob = require('glob'); +var arrify = require('arrify'); +var pify = require('pify'); + +var globP = pify(glob, Promise).bind(glob); + +function isNegative(pattern) { + return pattern[0] === '!'; +} + +function generateGlobTasks(patterns, opts) { + var globTasks = []; + + patterns = arrify(patterns); + opts = objectAssign({ + cache: Object.create(null), + statCache: Object.create(null), + realpathCache: Object.create(null), + symlinks: Object.create(null), + ignore: [] + }, opts); + + patterns.forEach(function (pattern, i) { + if (isNegative(pattern)) { + return; + } + + var ignore = patterns.slice(i).filter(isNegative).map(function (pattern) { + return pattern.slice(1); + }); + + globTasks.push({ + pattern: pattern, + opts: objectAssign({}, opts, { + ignore: opts.ignore.concat(ignore) + }) + }); + }); + + return globTasks; +} + +module.exports = function (patterns, opts) { + var globTasks = generateGlobTasks(patterns, opts); + + return Promise.all(globTasks.map(function (task) { + return globP(task.pattern, task.opts); + })).then(function (paths) { + return arrayUnion.apply(null, paths); + }); +}; + +module.exports.sync = function (patterns, opts) { + var globTasks = generateGlobTasks(patterns, opts); + + return globTasks.reduce(function (matches, task) { + return arrayUnion(matches, glob.sync(task.pattern, task.opts)); + }, []); +}; + +module.exports.generateGlobTasks = generateGlobTasks; + +},{"array-union":48,"arrify":51,"glob":622,"object-assign":711,"pify":601,"pinkie-promise":722}],601:[function(require,module,exports){ +'use strict'; + +var processFn = function (fn, P, opts) { + return function () { + var that = this; + var args = new Array(arguments.length); + + for (var i = 0; i < arguments.length; i++) { + args[i] = arguments[i]; + } + + return new P(function (resolve, reject) { + args.push(function (err, result) { + if (err) { + reject(err); + } else if (opts.multiArgs) { + var results = new Array(arguments.length - 1); + + for (var i = 1; i < arguments.length; i++) { + results[i - 1] = arguments[i]; + } + + resolve(results); + } else { + resolve(result); + } + }); + + fn.apply(that, args); + }); + }; +}; + +var pify = module.exports = function (obj, P, opts) { + if (typeof P !== 'function') { + opts = P; + P = Promise; + } + + opts = opts || {}; + opts.exclude = opts.exclude || [/.+Sync$/]; + + var filter = function (key) { + var match = function (pattern) { + return typeof pattern === 'string' ? key === pattern : pattern.test(key); + }; + + return opts.include ? opts.include.some(match) : !opts.exclude.some(match); + }; + + var ret = typeof obj === 'function' ? function () { + if (opts.excludeMain) { + return obj.apply(this, arguments); + } + + return processFn(obj, P, opts).apply(this, arguments); + } : {}; + + return Object.keys(obj).reduce(function (ret, key) { + var x = obj[key]; + + ret[key] = typeof x === 'function' && filter(key) ? processFn(x, P, opts) : x; + + return ret; + }, ret); +}; + +pify.all = pify; + +},{}],602:[function(require,module,exports){ +module.exports = { + "1.7": "58", + "1.6": "56", + "1.3": "52", + "1.4": "53", + "1.5": "54", + "1.2": "51", + "1.1": "50", + "1.0": "49", + "0.37": "49", + "0.36": "47", + "0.35": "45", + "0.34": "45", + "0.33": "45", + "0.32": "45", + "0.31": "44", + "0.30": "44", + "0.29": "43", + "0.28": "43", + "0.27": "42", + "0.26": "42", + "0.25": "42", + "0.24": "41", + "0.23": "41", + "0.22": "41", + "0.21": "40", + "0.20": "39" +}; +},{}],603:[function(require,module,exports){ +'use strict'; + +var util = require('util'); +var isArrayish = require('is-arrayish'); + +var errorEx = function errorEx(name, properties) { + if (!name || name.constructor !== String) { + properties = name || {}; + name = Error.name; + } + + var errorExError = function ErrorEXError(message) { + if (!this) { + return new ErrorEXError(message); + } + + message = message instanceof Error + ? message.message + : (message || this.message); + + Error.call(this, message); + Error.captureStackTrace(this, errorExError); + + this.name = name; + + Object.defineProperty(this, 'message', { + configurable: true, + enumerable: false, + get: function () { + var newMessage = message.split(/\r?\n/g); + + for (var key in properties) { + if (!properties.hasOwnProperty(key)) { + continue; + } + + var modifier = properties[key]; + + if ('message' in modifier) { + newMessage = modifier.message(this[key], newMessage) || newMessage; + if (!isArrayish(newMessage)) { + newMessage = [newMessage]; + } + } + } + + return newMessage.join('\n'); + }, + set: function (v) { + message = v; + } + }); + + var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack'); + var stackGetter = stackDescriptor.get; + var stackValue = stackDescriptor.value; + delete stackDescriptor.value; + delete stackDescriptor.writable; + + stackDescriptor.get = function () { + var stack = (stackGetter) + ? stackGetter.call(this).split(/\r?\n+/g) + : stackValue.split(/\r?\n+/g); + + // starting in Node 7, the stack builder caches the message. + // just replace it. + stack[0] = this.name + ': ' + this.message; + + var lineCount = 1; + for (var key in properties) { + if (!properties.hasOwnProperty(key)) { + continue; + } + + var modifier = properties[key]; + + if ('line' in modifier) { + var line = modifier.line(this[key]); + if (line) { + stack.splice(lineCount++, 0, ' ' + line); + } + } + + if ('stack' in modifier) { + modifier.stack(this[key], stack); + } + } + + return stack.join('\n'); + }; + + Object.defineProperty(this, 'stack', stackDescriptor); + }; + + if (Object.setPrototypeOf) { + Object.setPrototypeOf(errorExError.prototype, Error.prototype); + Object.setPrototypeOf(errorExError, Error); + } else { + util.inherits(errorExError, Error); + } + + return errorExError; +}; + +errorEx.append = function (str, def) { + return { + message: function (v, message) { + v = v || def; + + if (v) { + message[0] += ' ' + str.replace('%s', v.toString()); + } + + return message; + } + }; +}; + +errorEx.line = function (str, def) { + return { + line: function (v) { + v = v || def; + + if (v) { + return str.replace('%s', v.toString()); + } + + return null; + } + }; +}; + +module.exports = errorEx; + +},{"is-arrayish":639,"util":42}],604:[function(require,module,exports){ +'use strict'; + +var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g; + +module.exports = function (str) { + if (typeof str !== 'string') { + throw new TypeError('Expected a string'); + } + + return str.replace(matchOperatorsRe, '\\$&'); +}; + +},{}],605:[function(require,module,exports){ +'use strict'; +var cloneRegexp = require('clone-regexp'); + +module.exports = function (input, str) { + var match; + var matches = []; + var re = cloneRegexp(input); + var isGlobal = re.global; + + while (match = re.exec(str)) { + matches.push({ + match: match[0], + sub: match.slice(1), + index: match.index + }) + + if (!isGlobal) { + break; + } + } + + return matches; +}; + +},{"clone-regexp":583}],606:[function(require,module,exports){ +/*! + * expand-brackets + * + * Copyright (c) 2015 Jon Schlinkert. + * Licensed under the MIT license. + */ + +'use strict'; + +var isPosixBracket = require('is-posix-bracket'); + +/** + * POSIX character classes + */ + +var POSIX = { + alnum: 'a-zA-Z0-9', + alpha: 'a-zA-Z', + blank: ' \\t', + cntrl: '\\x00-\\x1F\\x7F', + digit: '0-9', + graph: '\\x21-\\x7E', + lower: 'a-z', + print: '\\x20-\\x7E', + punct: '-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', + space: ' \\t\\r\\n\\v\\f', + upper: 'A-Z', + word: 'A-Za-z0-9_', + xdigit: 'A-Fa-f0-9', +}; + +/** + * Expose `brackets` + */ + +module.exports = brackets; + +function brackets(str) { + if (!isPosixBracket(str)) { + return str; + } + + var negated = false; + if (str.indexOf('[^') !== -1) { + negated = true; + str = str.split('[^').join('['); + } + if (str.indexOf('[!') !== -1) { + negated = true; + str = str.split('[!').join('['); + } + + var a = str.split('['); + var b = str.split(']'); + var imbalanced = a.length !== b.length; + + var parts = str.split(/(?::\]\[:|\[?\[:|:\]\]?)/); + var len = parts.length, i = 0; + var end = '', beg = ''; + var res = []; + + // start at the end (innermost) first + while (len--) { + var inner = parts[i++]; + if (inner === '^[!' || inner === '[!') { + inner = ''; + negated = true; + } + + var prefix = negated ? '^' : ''; + var ch = POSIX[inner]; + + if (ch) { + res.push('[' + prefix + ch + ']'); + } else if (inner) { + if (/^\[?\w-\w\]?$/.test(inner)) { + if (i === parts.length) { + res.push('[' + prefix + inner); + } else if (i === 1) { + res.push(prefix + inner + ']'); + } else { + res.push(prefix + inner); + } + } else { + if (i === 1) { + beg += inner; + } else if (i === parts.length) { + end += inner; + } else { + res.push('[' + prefix + inner + ']'); + } + } + } + } + + var result = res.join('|'); + var rlen = res.length || 1; + if (rlen > 1) { + result = '(?:' + result + ')'; + rlen = 1; + } + if (beg) { + rlen++; + if (beg.charAt(0) === '[') { + if (imbalanced) { + beg = '\\[' + beg.slice(1); + } else { + beg += ']'; + } + } + result = beg + result; + } + if (end) { + rlen++; + if (end.slice(-1) === ']') { + if (imbalanced) { + end = end.slice(0, end.length - 1) + '\\]'; + } else { + end = '[' + end; + } + } + result += end; + } + + if (rlen > 1) { + result = result.split('][').join(']|['); + if (result.indexOf('|') !== -1 && !/\(\?/.test(result)) { + result = '(?:' + result + ')'; + } + } + + result = result.replace(/\[+=|=\]+/g, '\\b'); + return result; +} + +brackets.makeRe = function(pattern) { + try { + return new RegExp(brackets(pattern)); + } catch (err) {} +}; + +brackets.isMatch = function(str, pattern) { + try { + return brackets.makeRe(pattern).test(str); + } catch (err) { + return false; + } +}; + +brackets.match = function(arr, pattern) { + var len = arr.length, i = 0; + var res = arr.slice(); + + var re = brackets.makeRe(pattern); + while (i < len) { + var ele = arr[i++]; + if (!re.test(ele)) { + continue; + } + res.splice(i, 1); + } + return res; +}; + +},{"is-posix-bracket":652}],607:[function(require,module,exports){ +/*! + * expand-range + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT license. + */ + +'use strict'; + +var fill = require('fill-range'); + +module.exports = function expandRange(str, options, fn) { + if (typeof str !== 'string') { + throw new TypeError('expand-range expects a string.'); + } + + if (typeof options === 'function') { + fn = options; + options = {}; + } + + if (typeof options === 'boolean') { + options = {}; + options.makeRe = true; + } + + // create arguments to pass to fill-range + var opts = options || {}; + var args = str.split('..'); + var len = args.length; + if (len > 3) { return str; } + + // if only one argument, it can't expand so return it + if (len === 1) { return args; } + + // if `true`, tell fill-range to regexify the string + if (typeof fn === 'boolean' && fn === true) { + opts.makeRe = true; + } + + args.push(opts); + return fill.apply(null, args.concat(fn)); +}; + +},{"fill-range":611}],608:[function(require,module,exports){ +/*! + * extglob + * + * Copyright (c) 2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +/** + * Module dependencies + */ + +var isExtglob = require('is-extglob'); +var re, cache = {}; + +/** + * Expose `extglob` + */ + +module.exports = extglob; + +/** + * Convert the given extglob `string` to a regex-compatible + * string. + * + * ```js + * var extglob = require('extglob'); + * extglob('!(a?(b))'); + * //=> '(?!a(?:b)?)[^/]*?' + * ``` + * + * @param {String} `str` The string to convert. + * @param {Object} `options` + * @option {Boolean} [options] `esc` If `false` special characters will not be escaped. Defaults to `true`. + * @option {Boolean} [options] `regex` If `true` a regular expression is returned instead of a string. + * @return {String} + * @api public + */ + + +function extglob(str, opts) { + opts = opts || {}; + var o = {}, i = 0; + + // fix common character reversals + // '*!(.js)' => '*.!(js)' + str = str.replace(/!\(([^\w*()])/g, '$1!('); + + // support file extension negation + str = str.replace(/([*\/])\.!\([*]\)/g, function (m, ch) { + if (ch === '/') { + return escape('\\/[^.]+'); + } + return escape('[^.]+'); + }); + + // create a unique key for caching by + // combining the string and options + var key = str + + String(!!opts.regex) + + String(!!opts.contains) + + String(!!opts.escape); + + if (cache.hasOwnProperty(key)) { + return cache[key]; + } + + if (!(re instanceof RegExp)) { + re = regex(); + } + + opts.negate = false; + var m; + + while (m = re.exec(str)) { + var prefix = m[1]; + var inner = m[3]; + if (prefix === '!') { + opts.negate = true; + } + + var id = '__EXTGLOB_' + (i++) + '__'; + // use the prefix of the _last_ (outtermost) pattern + o[id] = wrap(inner, prefix, opts.escape); + str = str.split(m[0]).join(id); + } + + var keys = Object.keys(o); + var len = keys.length; + + // we have to loop again to allow us to convert + // patterns in reverse order (starting with the + // innermost/last pattern first) + while (len--) { + var prop = keys[len]; + str = str.split(prop).join(o[prop]); + } + + var result = opts.regex + ? toRegex(str, opts.contains, opts.negate) + : str; + + result = result.split('.').join('\\.'); + + // cache the result and return it + return (cache[key] = result); +} + +/** + * Convert `string` to a regex string. + * + * @param {String} `str` + * @param {String} `prefix` Character that determines how to wrap the string. + * @param {Boolean} `esc` If `false` special characters will not be escaped. Defaults to `true`. + * @return {String} + */ + +function wrap(inner, prefix, esc) { + if (esc) inner = escape(inner); + + switch (prefix) { + case '!': + return '(?!' + inner + ')[^/]' + (esc ? '%%%~' : '*?'); + case '@': + return '(?:' + inner + ')'; + case '+': + return '(?:' + inner + ')+'; + case '*': + return '(?:' + inner + ')' + (esc ? '%%' : '*') + case '?': + return '(?:' + inner + '|)'; + default: + return inner; + } +} + +function escape(str) { + str = str.split('*').join('[^/]%%%~'); + str = str.split('.').join('\\.'); + return str; +} + +/** + * extglob regex. + */ + +function regex() { + return /(\\?[@?!+*$]\\?)(\(([^()]*?)\))/; +} + +/** + * Negation regex + */ + +function negate(str) { + return '(?!^' + str + ').*$'; +} + +/** + * Create the regex to do the matching. If + * the leading character in the `pattern` is `!` + * a negation regex is returned. + * + * @param {String} `pattern` + * @param {Boolean} `contains` Allow loose matching. + * @param {Boolean} `isNegated` True if the pattern is a negation pattern. + */ + +function toRegex(pattern, contains, isNegated) { + var prefix = contains ? '^' : ''; + var after = contains ? '$' : ''; + pattern = ('(?:' + pattern + ')' + after); + if (isNegated) { + pattern = prefix + negate(pattern); + } + return new RegExp(prefix + pattern); +} + +},{"is-extglob":645}],609:[function(require,module,exports){ +var path = require( 'path' ); + +module.exports = { + createFromFile: function ( filePath ) { + var fname = path.basename( filePath ); + var dir = path.dirname( filePath ); + return this.create( fname, dir ); + }, + + create: function ( cacheId, _path ) { + var fs = require( 'fs' ); + var flatCache = require( 'flat-cache' ); + var cache = flatCache.load( cacheId, _path ); + var assign = require( 'object-assign' ); + var normalizedEntries = { }; + + var removeNotFoundFiles = function removeNotFoundFiles() { + const cachedEntries = cache.keys(); + // remove not found entries + cachedEntries.forEach( function remover( fPath ) { + try { + fs.statSync( fPath ); + } catch (err) { + if ( err.code === 'ENOENT' ) { + cache.removeKey( fPath ); + } + } + } ); + }; + + removeNotFoundFiles(); + + return { + /** + * the flat cache storage used to persist the metadata of the `files + * @type {Object} + */ + cache: cache, + /** + * Return whether or not a file has changed since last time reconcile was called. + * @method hasFileChanged + * @param {String} file the filepath to check + * @return {Boolean} wheter or not the file has changed + */ + hasFileChanged: function ( file ) { + return this.getFileDescriptor( file ).changed; + }, + + /** + * given an array of file paths it return and object with three arrays: + * - changedFiles: Files that changed since previous run + * - notChangedFiles: Files that haven't change + * - notFoundFiles: Files that were not found, probably deleted + * + * @param {Array} files the files to analyze and compare to the previous seen files + * @return {[type]} [description] + */ + analyzeFiles: function ( files ) { + var me = this; + files = files || [ ]; + + var res = { + changedFiles: [], + notFoundFiles: [], + notChangedFiles: [] + }; + + me.normalizeEntries( files ).forEach( function ( entry ) { + if ( entry.changed ) { + res.changedFiles.push( entry.key ); + return; + } + if ( entry.notFound ) { + res.notFoundFiles.push( entry.key ); + return; + } + res.notChangedFiles.push( entry.key ); + } ); + return res; + }, + + getFileDescriptor: function ( file ) { + var meta = cache.getKey( file ); + var cacheExists = !!meta; + var fstat; + var me = this; + + try { + fstat = fs.statSync( file ); + } catch (ex) { + me.removeEntry( file ); + return { key: file, notFound: true, err: ex }; + } + + var cSize = fstat.size; + var cTime = fstat.mtime.getTime(); + + if ( !meta ) { + meta = { size: cSize, mtime: cTime }; + } else { + var isDifferentDate = cTime !== meta.mtime; + var isDifferentSize = cSize !== meta.size; + } + + var nEntry = normalizedEntries[ file ] = { + key: file, + changed: !cacheExists || isDifferentDate || isDifferentSize, + meta: meta + }; + + return nEntry; + }, + + /** + * Return the list o the files that changed compared + * against the ones stored in the cache + * + * @method getUpdated + * @param files {Array} the array of files to compare against the ones in the cache + * @returns {Array} + */ + getUpdatedFiles: function ( files ) { + var me = this; + files = files || [ ]; + + return me.normalizeEntries( files ).filter( function ( entry ) { + return entry.changed; + } ).map( function ( entry ) { + return entry.key; + } ); + }, + + /** + * return the list of files + * @method normalizeEntries + * @param files + * @returns {*} + */ + normalizeEntries: function ( files ) { + files = files || [ ]; + + var me = this; + var nEntries = files.map( function ( file ) { + return me.getFileDescriptor( file ); + } ); + + //normalizeEntries = nEntries; + return nEntries; + }, + + /** + * Remove an entry from the file-entry-cache. Useful to force the file to still be considered + * modified the next time the process is run + * + * @method removeEntry + * @param entryName + */ + removeEntry: function ( entryName ) { + delete normalizedEntries[ entryName ]; + cache.removeKey( entryName ); + }, + + /** + * Delete the cache file from the disk + * @method deleteCacheFile + */ + deleteCacheFile: function () { + cache.removeCacheFile(); + }, + + /** + * remove the cache from the file and clear the memory cache + */ + destroy: function () { + normalizedEntries = { }; + cache.destroy(); + }, + /** + * Sync the files and persist them to the cache + * @method reconcile + */ + reconcile: function () { + removeNotFoundFiles(); + + var entries = normalizedEntries; + var keys = Object.keys( entries ); + + if ( keys.length === 0 ) { + return; + } + + keys.forEach( function ( entryName ) { + var cacheEntry = entries[ entryName ]; + + try { + var stat = fs.statSync( cacheEntry.key ); + var meta = assign( cacheEntry.meta, { + size: stat.size, + mtime: stat.mtime.getTime() + } ); + + cache.setKey( entryName, meta ); + } catch (err) { + // if the file does not exists we don't save it + // other errors are just thrown + if ( err.code !== 'ENOENT' ) { + throw err; + } + } + } ); + + cache.save( true ); + } + }; + } +}; + +},{"flat-cache":612,"fs":1,"object-assign":711,"path":14}],610:[function(require,module,exports){ +/*! + * filename-regex + * + * Copyright (c) 2014-2015, Jon Schlinkert + * Licensed under the MIT license. + */ + +module.exports = function filenameRegex() { + return /([^\\\/]+)$/; +}; + +},{}],611:[function(require,module,exports){ +/*! + * fill-range + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +var isObject = require('isobject'); +var isNumber = require('is-number'); +var randomize = require('randomatic'); +var repeatStr = require('repeat-string'); +var repeat = require('repeat-element'); + +/** + * Expose `fillRange` + */ + +module.exports = fillRange; + +/** + * Return a range of numbers or letters. + * + * @param {String} `a` Start of the range + * @param {String} `b` End of the range + * @param {String} `step` Increment or decrement to use. + * @param {Function} `fn` Custom function to modify each element in the range. + * @return {Array} + */ + +function fillRange(a, b, step, options, fn) { + if (a == null || b == null) { + throw new Error('fill-range expects the first and second args to be strings.'); + } + + if (typeof step === 'function') { + fn = step; options = {}; step = null; + } + + if (typeof options === 'function') { + fn = options; options = {}; + } + + if (isObject(step)) { + options = step; step = ''; + } + + var expand, regex = false, sep = ''; + var opts = options || {}; + + if (typeof opts.silent === 'undefined') { + opts.silent = true; + } + + step = step || opts.step; + + // store a ref to unmodified arg + var origA = a, origB = b; + + b = (b.toString() === '-0') ? 0 : b; + + if (opts.optimize || opts.makeRe) { + step = step ? (step += '~') : step; + expand = true; + regex = true; + sep = '~'; + } + + // handle special step characters + if (typeof step === 'string') { + var match = stepRe().exec(step); + + if (match) { + var i = match.index; + var m = match[0]; + + // repeat string + if (m === '+') { + return repeat(a, b); + + // randomize a, `b` times + } else if (m === '?') { + return [randomize(a, b)]; + + // expand right, no regex reduction + } else if (m === '>') { + step = step.substr(0, i) + step.substr(i + 1); + expand = true; + + // expand to an array, or if valid create a reduced + // string for a regex logic `or` + } else if (m === '|') { + step = step.substr(0, i) + step.substr(i + 1); + expand = true; + regex = true; + sep = m; + + // expand to an array, or if valid create a reduced + // string for a regex range + } else if (m === '~') { + step = step.substr(0, i) + step.substr(i + 1); + expand = true; + regex = true; + sep = m; + } + } else if (!isNumber(step)) { + if (!opts.silent) { + throw new TypeError('fill-range: invalid step.'); + } + return null; + } + } + + if (/[.&*()[\]^%$#@!]/.test(a) || /[.&*()[\]^%$#@!]/.test(b)) { + if (!opts.silent) { + throw new RangeError('fill-range: invalid range arguments.'); + } + return null; + } + + // has neither a letter nor number, or has both letters and numbers + // this needs to be after the step logic + if (!noAlphaNum(a) || !noAlphaNum(b) || hasBoth(a) || hasBoth(b)) { + if (!opts.silent) { + throw new RangeError('fill-range: invalid range arguments.'); + } + return null; + } + + // validate arguments + var isNumA = isNumber(zeros(a)); + var isNumB = isNumber(zeros(b)); + + if ((!isNumA && isNumB) || (isNumA && !isNumB)) { + if (!opts.silent) { + throw new TypeError('fill-range: first range argument is incompatible with second.'); + } + return null; + } + + // by this point both are the same, so we + // can use A to check going forward. + var isNum = isNumA; + var num = formatStep(step); + + // is the range alphabetical? or numeric? + if (isNum) { + // if numeric, coerce to an integer + a = +a; b = +b; + } else { + // otherwise, get the charCode to expand alpha ranges + a = a.charCodeAt(0); + b = b.charCodeAt(0); + } + + // is the pattern descending? + var isDescending = a > b; + + // don't create a character class if the args are < 0 + if (a < 0 || b < 0) { + expand = false; + regex = false; + } + + // detect padding + var padding = isPadded(origA, origB); + var res, pad, arr = []; + var ii = 0; + + // character classes, ranges and logical `or` + if (regex) { + if (shouldExpand(a, b, num, isNum, padding, opts)) { + // make sure the correct separator is used + if (sep === '|' || sep === '~') { + sep = detectSeparator(a, b, num, isNum, isDescending); + } + return wrap([origA, origB], sep, opts); + } + } + + while (isDescending ? (a >= b) : (a <= b)) { + if (padding && isNum) { + pad = padding(a); + } + + // custom function + if (typeof fn === 'function') { + res = fn(a, isNum, pad, ii++); + + // letters + } else if (!isNum) { + if (regex && isInvalidChar(a)) { + res = null; + } else { + res = String.fromCharCode(a); + } + + // numbers + } else { + res = formatPadding(a, pad); + } + + // add result to the array, filtering any nulled values + if (res !== null) arr.push(res); + + // increment or decrement + if (isDescending) { + a -= num; + } else { + a += num; + } + } + + // now that the array is expanded, we need to handle regex + // character classes, ranges or logical `or` that wasn't + // already handled before the loop + if ((regex || expand) && !opts.noexpand) { + // make sure the correct separator is used + if (sep === '|' || sep === '~') { + sep = detectSeparator(a, b, num, isNum, isDescending); + } + if (arr.length === 1 || a < 0 || b < 0) { return arr; } + return wrap(arr, sep, opts); + } + + return arr; +} + +/** + * Wrap the string with the correct regex + * syntax. + */ + +function wrap(arr, sep, opts) { + if (sep === '~') { sep = '-'; } + var str = arr.join(sep); + var pre = opts && opts.regexPrefix; + + // regex logical `or` + if (sep === '|') { + str = pre ? pre + str : str; + str = '(' + str + ')'; + } + + // regex character class + if (sep === '-') { + str = (pre && pre === '^') + ? pre + str + : str; + str = '[' + str + ']'; + } + return [str]; +} + +/** + * Check for invalid characters + */ + +function isCharClass(a, b, step, isNum, isDescending) { + if (isDescending) { return false; } + if (isNum) { return a <= 9 && b <= 9; } + if (a < b) { return step === 1; } + return false; +} + +/** + * Detect the correct separator to use + */ + +function shouldExpand(a, b, num, isNum, padding, opts) { + if (isNum && (a > 9 || b > 9)) { return false; } + return !padding && num === 1 && a < b; +} + +/** + * Detect the correct separator to use + */ + +function detectSeparator(a, b, step, isNum, isDescending) { + var isChar = isCharClass(a, b, step, isNum, isDescending); + if (!isChar) { + return '|'; + } + return '~'; +} + +/** + * Correctly format the step based on type + */ + +function formatStep(step) { + return Math.abs(step >> 0) || 1; +} + +/** + * Format padding, taking leading `-` into account + */ + +function formatPadding(ch, pad) { + var res = pad ? pad + ch : ch; + if (pad && ch.toString().charAt(0) === '-') { + res = '-' + pad + ch.toString().substr(1); + } + return res.toString(); +} + +/** + * Check for invalid characters + */ + +function isInvalidChar(str) { + var ch = toStr(str); + return ch === '\\' + || ch === '[' + || ch === ']' + || ch === '^' + || ch === '(' + || ch === ')' + || ch === '`'; +} + +/** + * Convert to a string from a charCode + */ + +function toStr(ch) { + return String.fromCharCode(ch); +} + + +/** + * Step regex + */ + +function stepRe() { + return /\?|>|\||\+|\~/g; +} + +/** + * Return true if `val` has either a letter + * or a number + */ + +function noAlphaNum(val) { + return /[a-z0-9]/i.test(val); +} + +/** + * Return true if `val` has both a letter and + * a number (invalid) + */ + +function hasBoth(val) { + return /[a-z][0-9]|[0-9][a-z]/i.test(val); +} + +/** + * Normalize zeros for checks + */ + +function zeros(val) { + if (/^-*0+$/.test(val.toString())) { + return '0'; + } + return val; +} + +/** + * Return true if `val` has leading zeros, + * or a similar valid pattern. + */ + +function hasZeros(val) { + return /[^.]\.|^-*0+[0-9]/.test(val); +} + +/** + * If the string is padded, returns a curried function with + * the a cached padding string, or `false` if no padding. + * + * @param {*} `origA` String or number. + * @return {String|Boolean} + */ + +function isPadded(origA, origB) { + if (hasZeros(origA) || hasZeros(origB)) { + var alen = length(origA); + var blen = length(origB); + + var len = alen >= blen + ? alen + : blen; + + return function (a) { + return repeatStr('0', len - length(a)); + }; + } + return false; +} + +/** + * Get the string length of `val` + */ + +function length(val) { + return val.toString().length; +} + +},{"is-number":648,"isobject":657,"randomatic":842,"repeat-element":848,"repeat-string":849}],612:[function(require,module,exports){ +(function (__dirname){ +var path = require( 'path' ); +var fs = require( 'graceful-fs' ); +var del = require( 'del' ).sync; +var utils = require( './utils' ); +var writeJSON = utils.writeJSON; + +var cache = { + /** + * Load a cache identified by the given Id. If the element does not exists, then initialize an empty + * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted + * then the cache module directory `./cache` will be used instead + * + * @method load + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param [cacheDir] {String} directory for the cache entry + */ + load: function ( docId, cacheDir ) { + var me = this; + + me._visited = { }; + me._persisted = { }; + me._pathToFile = cacheDir ? path.resolve( cacheDir, docId ) : path.resolve( __dirname, './.cache/', docId ); + + if ( fs.existsSync( me._pathToFile ) ) { + me._persisted = utils.tryParse( me._pathToFile, { } ); + } + }, + + /** + * Load the cache from the provided file + * @method loadFile + * @param {String} pathToFile the path to the file containing the info for the cache + */ + loadFile: function ( pathToFile ) { + var me = this; + var dir = path.dirname( pathToFile ); + var fName = path.basename( pathToFile ); + + me.load( fName, dir ); + }, + + keys: function () { + return Object.keys( this._persisted ); + }, + /** + * sets a key to a given value + * @method setKey + * @param key {string} the key to set + * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify + */ + setKey: function ( key, value ) { + this._visited[ key ] = true; + this._persisted[ key ] = value; + }, + /** + * remove a given key from the cache + * @method removeKey + * @param key {String} the key to remove from the object + */ + removeKey: function ( key ) { + delete this._visited[ key ]; // esfmt-ignore-line + delete this._persisted[ key ]; // esfmt-ignore-line + }, + /** + * Return the value of the provided key + * @method getKey + * @param key {String} the name of the key to retrieve + * @returns {*} the value from the key + */ + getKey: function ( key ) { + this._visited[ key ] = true; + return this._persisted[ key ]; + }, + + /** + * Remove keys that were not accessed/set since the + * last time the `prune` method was called. + * @method _prune + * @private + */ + _prune: function () { + var me = this; + var obj = { }; + + var keys = Object.keys( me._visited ); + + // no keys visited for either get or set value + if ( keys.length === 0 ) { + return; + } + + keys.forEach( function ( key ) { + obj[ key ] = me._persisted[ key ]; + } ); + + me._visited = { }; + me._persisted = obj; + }, + + /** + * Save the state of the cache identified by the docId to disk + * as a JSON structure + * @param [noPrune=false] {Boolean} whether to remove from cache the non visited files + * @method save + */ + save: function ( noPrune ) { + var me = this; + + (!noPrune) && me._prune(); + writeJSON( me._pathToFile, me._persisted ); + }, + + /** + * remove the file where the cache is persisted + * @method removeCacheFile + * @return {Boolean} true or false if the file was successfully deleted + */ + removeCacheFile: function () { + return del( this._pathToFile, { force: true } ); + }, + /** + * Destroy the file cache and cache content. + * @method destroy + */ + destroy: function () { + var me = this; + me._visited = { }; + me._persisted = { }; + + me.removeCacheFile(); + } +}; + +module.exports = { + /** + * Alias for create. Should be considered depreacted. Will be removed in next releases + * + * @method load + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param [cacheDir] {String} directory for the cache entry + * @returns {cache} cache instance + */ + load: function ( docId, cacheDir ) { + return this.create( docId, cacheDir ); + }, + + /** + * Load a cache identified by the given Id. If the element does not exists, then initialize an empty + * cache storage. + * + * @method create + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param [cacheDir] {String} directory for the cache entry + * @returns {cache} cache instance + */ + create: function ( docId, cacheDir ) { + var obj = Object.create( cache ); + obj.load( docId, cacheDir ); + return obj; + }, + + createFromFile: function ( filePath ) { + var obj = Object.create( cache ); + obj.loadFile( filePath ); + return obj; + }, + /** + * Clear the cache identified by the given id. Caches stored in a different cache directory can be deleted directly + * + * @method clearCache + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param cacheDir {String} the directory where the cache file was written + * @returns {Boolean} true if the cache folder was deleted. False otherwise + */ + clearCacheById: function ( docId, cacheDir ) { + var filePath = cacheDir ? path.resolve( cacheDir, docId ) : path.resolve( __dirname, './.cache/', docId ); + return del( filePath, { force: true } ).length > 0; + }, + /** + * Remove all cache stored in the cache directory + * @method clearAll + * @returns {Boolean} true if the cache folder was deleted. False otherwise + */ + clearAll: function ( cacheDir ) { + var filePath = cacheDir ? path.resolve( cacheDir ) : path.resolve( __dirname, './.cache/' ); + return del( filePath, { force: true } ).length > 0; + } +}; + +}).call(this,"/node_modules\\flat-cache") +},{"./utils":613,"del":599,"graceful-fs":628,"path":14}],613:[function(require,module,exports){ +var fs = require( 'graceful-fs' ); +var write = require( 'write' ); +var circularJson = require( 'circular-json' ); + +module.exports = { + + tryParse: function ( filePath, defaultValue) { + var result; + try { + result = this.readJSON( filePath ); + } catch (ex) { + result = defaultValue; + } + return result; + }, + + /** + * Read json file synchronously using circular-json + * + * @method readJSON + * @param {String} filePath Json filepath + * @returns {*} parse result + */ + readJSON: function ( filePath ) { + return circularJson.parse( fs.readFileSync( filePath ).toString() ); + }, + + /** + * Write json file synchronously using circular-json + * + * @method writeJSON + * @param {String} filePath Json filepath + * @param {*} data Object to serialize + */ + writeJSON: function (filePath, data ) { + write.sync( filePath, circularJson.stringify( data ) ); + } + +}; + +},{"circular-json":582,"graceful-fs":628,"write":1183}],614:[function(require,module,exports){ +module.exports = function flatten(list, depth) { + depth = (typeof depth == 'number') ? depth : Infinity; + + if (!depth) { + if (Array.isArray(list)) { + return list.map(function(i) { return i; }); + } + return list; + } + + return _flatten(list, 1); + + function _flatten(list, d) { + return list.reduce(function (acc, item) { + if (Array.isArray(item) && d < depth) { + return acc.concat(_flatten(item, d + 1)); + } + else { + return acc.concat(item); + } + }, []); + } +}; + +},{}],615:[function(require,module,exports){ +/*! + * for-in + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +'use strict'; + +module.exports = function forIn(obj, fn, thisArg) { + for (var key in obj) { + if (fn.call(thisArg, obj[key], key, obj) === false) { + break; + } + } +}; + +},{}],616:[function(require,module,exports){ +/*! + * for-own + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +'use strict'; + +var forIn = require('for-in'); +var hasOwn = Object.prototype.hasOwnProperty; + +module.exports = function forOwn(obj, fn, thisArg) { + forIn(obj, function(val, key) { + if (hasOwn.call(obj, key)) { + return fn.call(thisArg, obj[key], key, obj); + } + }); +}; + +},{"for-in":615}],617:[function(require,module,exports){ +(function (process){ +module.exports = realpath +realpath.realpath = realpath +realpath.sync = realpathSync +realpath.realpathSync = realpathSync +realpath.monkeypatch = monkeypatch +realpath.unmonkeypatch = unmonkeypatch + +var fs = require('fs') +var origRealpath = fs.realpath +var origRealpathSync = fs.realpathSync + +var version = process.version +var ok = /^v[0-5]\./.test(version) +var old = require('./old.js') + +function newError (er) { + return er && er.syscall === 'realpath' && ( + er.code === 'ELOOP' || + er.code === 'ENOMEM' || + er.code === 'ENAMETOOLONG' + ) +} + +function realpath (p, cache, cb) { + if (ok) { + return origRealpath(p, cache, cb) + } + + if (typeof cache === 'function') { + cb = cache + cache = null + } + origRealpath(p, cache, function (er, result) { + if (newError(er)) { + old.realpath(p, cache, cb) + } else { + cb(er, result) + } + }) +} + +function realpathSync (p, cache) { + if (ok) { + return origRealpathSync(p, cache) + } + + try { + return origRealpathSync(p, cache) + } catch (er) { + if (newError(er)) { + return old.realpathSync(p, cache) + } else { + throw er + } + } +} + +function monkeypatch () { + fs.realpath = realpath + fs.realpathSync = realpathSync +} + +function unmonkeypatch () { + fs.realpath = origRealpath + fs.realpathSync = origRealpathSync +} + +}).call(this,require('_process')) +},{"./old.js":618,"_process":16,"fs":1}],618:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var pathModule = require('path'); +var isWindows = process.platform === 'win32'; +var fs = require('fs'); + +// JavaScript implementation of realpath, ported from node pre-v6 + +var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG); + +function rethrow() { + // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and + // is fairly slow to generate. + var callback; + if (DEBUG) { + var backtrace = new Error; + callback = debugCallback; + } else + callback = missingCallback; + + return callback; + + function debugCallback(err) { + if (err) { + backtrace.message = err.message; + err = backtrace; + missingCallback(err); + } + } + + function missingCallback(err) { + if (err) { + if (process.throwDeprecation) + throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs + else if (!process.noDeprecation) { + var msg = 'fs: missing callback ' + (err.stack || err.message); + if (process.traceDeprecation) + console.trace(msg); + else + console.error(msg); + } + } + } +} + +function maybeCallback(cb) { + return typeof cb === 'function' ? cb : rethrow(); +} + +var normalize = pathModule.normalize; + +// Regexp that finds the next partion of a (partial) path +// result is [base_with_slash, base], e.g. ['somedir/', 'somedir'] +if (isWindows) { + var nextPartRe = /(.*?)(?:[\/\\]+|$)/g; +} else { + var nextPartRe = /(.*?)(?:[\/]+|$)/g; +} + +// Regex to find the device root, including trailing slash. E.g. 'c:\\'. +if (isWindows) { + var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/; +} else { + var splitRootRe = /^[\/]*/; +} + +exports.realpathSync = function realpathSync(p, cache) { + // make p is absolute + p = pathModule.resolve(p); + + if (cache && Object.prototype.hasOwnProperty.call(cache, p)) { + return cache[p]; + } + + var original = p, + seenLinks = {}, + knownHard = {}; + + // current character position in p + var pos; + // the partial path so far, including a trailing slash if any + var current; + // the partial path without a trailing slash (except when pointing at a root) + var base; + // the partial path scanned in the previous round, with slash + var previous; + + start(); + + function start() { + // Skip over roots + var m = splitRootRe.exec(p); + pos = m[0].length; + current = m[0]; + base = m[0]; + previous = ''; + + // On windows, check that the root exists. On unix there is no need. + if (isWindows && !knownHard[base]) { + fs.lstatSync(base); + knownHard[base] = true; + } + } + + // walk down the path, swapping out linked pathparts for their real + // values + // NB: p.length changes. + while (pos < p.length) { + // find the next part + nextPartRe.lastIndex = pos; + var result = nextPartRe.exec(p); + previous = current; + current += result[0]; + base = previous + result[1]; + pos = nextPartRe.lastIndex; + + // continue if not a symlink + if (knownHard[base] || (cache && cache[base] === base)) { + continue; + } + + var resolvedLink; + if (cache && Object.prototype.hasOwnProperty.call(cache, base)) { + // some known symbolic link. no need to stat again. + resolvedLink = cache[base]; + } else { + var stat = fs.lstatSync(base); + if (!stat.isSymbolicLink()) { + knownHard[base] = true; + if (cache) cache[base] = base; + continue; + } + + // read the link if it wasn't read before + // dev/ino always return 0 on windows, so skip the check. + var linkTarget = null; + if (!isWindows) { + var id = stat.dev.toString(32) + ':' + stat.ino.toString(32); + if (seenLinks.hasOwnProperty(id)) { + linkTarget = seenLinks[id]; + } + } + if (linkTarget === null) { + fs.statSync(base); + linkTarget = fs.readlinkSync(base); + } + resolvedLink = pathModule.resolve(previous, linkTarget); + // track this, if given a cache. + if (cache) cache[base] = resolvedLink; + if (!isWindows) seenLinks[id] = linkTarget; + } + + // resolve the link, then start over + p = pathModule.resolve(resolvedLink, p.slice(pos)); + start(); + } + + if (cache) cache[original] = p; + + return p; +}; + + +exports.realpath = function realpath(p, cache, cb) { + if (typeof cb !== 'function') { + cb = maybeCallback(cache); + cache = null; + } + + // make p is absolute + p = pathModule.resolve(p); + + if (cache && Object.prototype.hasOwnProperty.call(cache, p)) { + return process.nextTick(cb.bind(null, null, cache[p])); + } + + var original = p, + seenLinks = {}, + knownHard = {}; + + // current character position in p + var pos; + // the partial path so far, including a trailing slash if any + var current; + // the partial path without a trailing slash (except when pointing at a root) + var base; + // the partial path scanned in the previous round, with slash + var previous; + + start(); + + function start() { + // Skip over roots + var m = splitRootRe.exec(p); + pos = m[0].length; + current = m[0]; + base = m[0]; + previous = ''; + + // On windows, check that the root exists. On unix there is no need. + if (isWindows && !knownHard[base]) { + fs.lstat(base, function(err) { + if (err) return cb(err); + knownHard[base] = true; + LOOP(); + }); + } else { + process.nextTick(LOOP); + } + } + + // walk down the path, swapping out linked pathparts for their real + // values + function LOOP() { + // stop if scanned past end of path + if (pos >= p.length) { + if (cache) cache[original] = p; + return cb(null, p); + } + + // find the next part + nextPartRe.lastIndex = pos; + var result = nextPartRe.exec(p); + previous = current; + current += result[0]; + base = previous + result[1]; + pos = nextPartRe.lastIndex; + + // continue if not a symlink + if (knownHard[base] || (cache && cache[base] === base)) { + return process.nextTick(LOOP); + } + + if (cache && Object.prototype.hasOwnProperty.call(cache, base)) { + // known symbolic link. no need to stat again. + return gotResolvedLink(cache[base]); + } + + return fs.lstat(base, gotStat); + } + + function gotStat(err, stat) { + if (err) return cb(err); + + // if not a symlink, skip to the next path part + if (!stat.isSymbolicLink()) { + knownHard[base] = true; + if (cache) cache[base] = base; + return process.nextTick(LOOP); + } + + // stat & read the link if not read before + // call gotTarget as soon as the link target is known + // dev/ino always return 0 on windows, so skip the check. + if (!isWindows) { + var id = stat.dev.toString(32) + ':' + stat.ino.toString(32); + if (seenLinks.hasOwnProperty(id)) { + return gotTarget(null, seenLinks[id], base); + } + } + fs.stat(base, function(err) { + if (err) return cb(err); + + fs.readlink(base, function(err, target) { + if (!isWindows) seenLinks[id] = target; + gotTarget(err, target); + }); + }); + } + + function gotTarget(err, target, base) { + if (err) return cb(err); + + var resolvedLink = pathModule.resolve(previous, target); + if (cache) cache[base] = resolvedLink; + gotResolvedLink(resolvedLink); + } + + function gotResolvedLink(resolvedLink) { + // resolve the link, then start over + p = pathModule.resolve(resolvedLink, p.slice(pos)); + start(); + } +}; + +}).call(this,require('_process')) +},{"_process":16,"fs":1,"path":14}],619:[function(require,module,exports){ +/*! + * glob-base + * + * Copyright (c) 2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +var path = require('path'); +var parent = require('glob-parent'); +var isGlob = require('is-glob'); + +module.exports = function globBase(pattern) { + if (typeof pattern !== 'string') { + throw new TypeError('glob-base expects a string.'); + } + + var res = {}; + res.base = parent(pattern); + res.isGlob = isGlob(pattern); + + if (res.base !== '.') { + res.glob = pattern.substr(res.base.length); + if (res.glob.charAt(0) === '/') { + res.glob = res.glob.substr(1); + } + } else { + res.glob = pattern; + } + + if (!res.isGlob) { + res.base = dirname(pattern); + res.glob = res.base !== '.' + ? pattern.substr(res.base.length) + : pattern; + } + + if (res.glob.substr(0, 2) === './') { + res.glob = res.glob.substr(2); + } + if (res.glob.charAt(0) === '/') { + res.glob = res.glob.substr(1); + } + return res; +}; + +function dirname(glob) { + if (glob.slice(-1) === '/') return glob; + return path.dirname(glob); +} + +},{"glob-parent":620,"is-glob":647,"path":14}],620:[function(require,module,exports){ +'use strict'; + +var path = require('path'); +var isglob = require('is-glob'); + +module.exports = function globParent(str) { + str += 'a'; // preserves full path in case of trailing path separator + do {str = path.dirname(str)} while (isglob(str)); + return str; +}; + +},{"is-glob":647,"path":14}],621:[function(require,module,exports){ +(function (process){ +exports.alphasort = alphasort +exports.alphasorti = alphasorti +exports.setopts = setopts +exports.ownProp = ownProp +exports.makeAbs = makeAbs +exports.finish = finish +exports.mark = mark +exports.isIgnored = isIgnored +exports.childrenIgnored = childrenIgnored + +function ownProp (obj, field) { + return Object.prototype.hasOwnProperty.call(obj, field) +} + +var path = require("path") +var minimatch = require("minimatch") +var isAbsolute = require("path-is-absolute") +var Minimatch = minimatch.Minimatch + +function alphasorti (a, b) { + return a.toLowerCase().localeCompare(b.toLowerCase()) +} + +function alphasort (a, b) { + return a.localeCompare(b) +} + +function setupIgnores (self, options) { + self.ignore = options.ignore || [] + + if (!Array.isArray(self.ignore)) + self.ignore = [self.ignore] + + if (self.ignore.length) { + self.ignore = self.ignore.map(ignoreMap) + } +} + +// ignore patterns are always in dot:true mode. +function ignoreMap (pattern) { + var gmatcher = null + if (pattern.slice(-3) === '/**') { + var gpattern = pattern.replace(/(\/\*\*)+$/, '') + gmatcher = new Minimatch(gpattern, { dot: true }) + } + + return { + matcher: new Minimatch(pattern, { dot: true }), + gmatcher: gmatcher + } +} + +function setopts (self, pattern, options) { + if (!options) + options = {} + + // base-matching: just use globstar for that. + if (options.matchBase && -1 === pattern.indexOf("/")) { + if (options.noglobstar) { + throw new Error("base matching requires globstar") + } + pattern = "**/" + pattern + } + + self.silent = !!options.silent + self.pattern = pattern + self.strict = options.strict !== false + self.realpath = !!options.realpath + self.realpathCache = options.realpathCache || Object.create(null) + self.follow = !!options.follow + self.dot = !!options.dot + self.mark = !!options.mark + self.nodir = !!options.nodir + if (self.nodir) + self.mark = true + self.sync = !!options.sync + self.nounique = !!options.nounique + self.nonull = !!options.nonull + self.nosort = !!options.nosort + self.nocase = !!options.nocase + self.stat = !!options.stat + self.noprocess = !!options.noprocess + self.absolute = !!options.absolute + + self.maxLength = options.maxLength || Infinity + self.cache = options.cache || Object.create(null) + self.statCache = options.statCache || Object.create(null) + self.symlinks = options.symlinks || Object.create(null) + + setupIgnores(self, options) + + self.changedCwd = false + var cwd = process.cwd() + if (!ownProp(options, "cwd")) + self.cwd = cwd + else { + self.cwd = path.resolve(options.cwd) + self.changedCwd = self.cwd !== cwd + } + + self.root = options.root || path.resolve(self.cwd, "/") + self.root = path.resolve(self.root) + if (process.platform === "win32") + self.root = self.root.replace(/\\/g, "/") + + // TODO: is an absolute `cwd` supposed to be resolved against `root`? + // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test') + self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd) + if (process.platform === "win32") + self.cwdAbs = self.cwdAbs.replace(/\\/g, "/") + self.nomount = !!options.nomount + + // disable comments and negation in Minimatch. + // Note that they are not supported in Glob itself anyway. + options.nonegate = true + options.nocomment = true + + self.minimatch = new Minimatch(pattern, options) + self.options = self.minimatch.options +} + +function finish (self) { + var nou = self.nounique + var all = nou ? [] : Object.create(null) + + for (var i = 0, l = self.matches.length; i < l; i ++) { + var matches = self.matches[i] + if (!matches || Object.keys(matches).length === 0) { + if (self.nonull) { + // do like the shell, and spit out the literal glob + var literal = self.minimatch.globSet[i] + if (nou) + all.push(literal) + else + all[literal] = true + } + } else { + // had matches + var m = Object.keys(matches) + if (nou) + all.push.apply(all, m) + else + m.forEach(function (m) { + all[m] = true + }) + } + } + + if (!nou) + all = Object.keys(all) + + if (!self.nosort) + all = all.sort(self.nocase ? alphasorti : alphasort) + + // at *some* point we statted all of these + if (self.mark) { + for (var i = 0; i < all.length; i++) { + all[i] = self._mark(all[i]) + } + if (self.nodir) { + all = all.filter(function (e) { + var notDir = !(/\/$/.test(e)) + var c = self.cache[e] || self.cache[makeAbs(self, e)] + if (notDir && c) + notDir = c !== 'DIR' && !Array.isArray(c) + return notDir + }) + } + } + + if (self.ignore.length) + all = all.filter(function(m) { + return !isIgnored(self, m) + }) + + self.found = all +} + +function mark (self, p) { + var abs = makeAbs(self, p) + var c = self.cache[abs] + var m = p + if (c) { + var isDir = c === 'DIR' || Array.isArray(c) + var slash = p.slice(-1) === '/' + + if (isDir && !slash) + m += '/' + else if (!isDir && slash) + m = m.slice(0, -1) + + if (m !== p) { + var mabs = makeAbs(self, m) + self.statCache[mabs] = self.statCache[abs] + self.cache[mabs] = self.cache[abs] + } + } + + return m +} + +// lotta situps... +function makeAbs (self, f) { + var abs = f + if (f.charAt(0) === '/') { + abs = path.join(self.root, f) + } else if (isAbsolute(f) || f === '') { + abs = f + } else if (self.changedCwd) { + abs = path.resolve(self.cwd, f) + } else { + abs = path.resolve(f) + } + + if (process.platform === 'win32') + abs = abs.replace(/\\/g, '/') + + return abs +} + + +// Return true, if pattern ends with globstar '**', for the accompanying parent directory. +// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents +function isIgnored (self, path) { + if (!self.ignore.length) + return false + + return self.ignore.some(function(item) { + return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path)) + }) +} + +function childrenIgnored (self, path) { + if (!self.ignore.length) + return false + + return self.ignore.some(function(item) { + return !!(item.gmatcher && item.gmatcher.match(path)) + }) +} + +}).call(this,require('_process')) +},{"_process":16,"minimatch":703,"path":14,"path-is-absolute":719}],622:[function(require,module,exports){ +(function (process){ +// Approach: +// +// 1. Get the minimatch set +// 2. For each pattern in the set, PROCESS(pattern, false) +// 3. Store matches per-set, then uniq them +// +// PROCESS(pattern, inGlobStar) +// Get the first [n] items from pattern that are all strings +// Join these together. This is PREFIX. +// If there is no more remaining, then stat(PREFIX) and +// add to matches if it succeeds. END. +// +// If inGlobStar and PREFIX is symlink and points to dir +// set ENTRIES = [] +// else readdir(PREFIX) as ENTRIES +// If fail, END +// +// with ENTRIES +// If pattern[n] is GLOBSTAR +// // handle the case where the globstar match is empty +// // by pruning it out, and testing the resulting pattern +// PROCESS(pattern[0..n] + pattern[n+1 .. $], false) +// // handle other cases. +// for ENTRY in ENTRIES (not dotfiles) +// // attach globstar + tail onto the entry +// // Mark that this entry is a globstar match +// PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true) +// +// else // not globstar +// for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot) +// Test ENTRY against pattern[n] +// If fails, continue +// If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $]) +// +// Caveat: +// Cache all stats and readdirs results to minimize syscall. Since all +// we ever care about is existence and directory-ness, we can just keep +// `true` for files, and [children,...] for directories, or `false` for +// things that don't exist. + +module.exports = glob + +var fs = require('fs') +var rp = require('fs.realpath') +var minimatch = require('minimatch') +var Minimatch = minimatch.Minimatch +var inherits = require('inherits') +var EE = require('events').EventEmitter +var path = require('path') +var assert = require('assert') +var isAbsolute = require('path-is-absolute') +var globSync = require('./sync.js') +var common = require('./common.js') +var alphasort = common.alphasort +var alphasorti = common.alphasorti +var setopts = common.setopts +var ownProp = common.ownProp +var inflight = require('inflight') +var util = require('util') +var childrenIgnored = common.childrenIgnored +var isIgnored = common.isIgnored + +var once = require('once') + +function glob (pattern, options, cb) { + if (typeof options === 'function') cb = options, options = {} + if (!options) options = {} + + if (options.sync) { + if (cb) + throw new TypeError('callback provided to sync glob') + return globSync(pattern, options) + } + + return new Glob(pattern, options, cb) +} + +glob.sync = globSync +var GlobSync = glob.GlobSync = globSync.GlobSync + +// old api surface +glob.glob = glob + +function extend (origin, add) { + if (add === null || typeof add !== 'object') { + return origin + } + + var keys = Object.keys(add) + var i = keys.length + while (i--) { + origin[keys[i]] = add[keys[i]] + } + return origin +} + +glob.hasMagic = function (pattern, options_) { + var options = extend({}, options_) + options.noprocess = true + + var g = new Glob(pattern, options) + var set = g.minimatch.set + + if (!pattern) + return false + + if (set.length > 1) + return true + + for (var j = 0; j < set[0].length; j++) { + if (typeof set[0][j] !== 'string') + return true + } + + return false +} + +glob.Glob = Glob +inherits(Glob, EE) +function Glob (pattern, options, cb) { + if (typeof options === 'function') { + cb = options + options = null + } + + if (options && options.sync) { + if (cb) + throw new TypeError('callback provided to sync glob') + return new GlobSync(pattern, options) + } + + if (!(this instanceof Glob)) + return new Glob(pattern, options, cb) + + setopts(this, pattern, options) + this._didRealPath = false + + // process each pattern in the minimatch set + var n = this.minimatch.set.length + + // The matches are stored as {: true,...} so that + // duplicates are automagically pruned. + // Later, we do an Object.keys() on these. + // Keep them as a list so we can fill in when nonull is set. + this.matches = new Array(n) + + if (typeof cb === 'function') { + cb = once(cb) + this.on('error', cb) + this.on('end', function (matches) { + cb(null, matches) + }) + } + + var self = this + this._processing = 0 + + this._emitQueue = [] + this._processQueue = [] + this.paused = false + + if (this.noprocess) + return this + + if (n === 0) + return done() + + var sync = true + for (var i = 0; i < n; i ++) { + this._process(this.minimatch.set[i], i, false, done) + } + sync = false + + function done () { + --self._processing + if (self._processing <= 0) { + if (sync) { + process.nextTick(function () { + self._finish() + }) + } else { + self._finish() + } + } + } +} + +Glob.prototype._finish = function () { + assert(this instanceof Glob) + if (this.aborted) + return + + if (this.realpath && !this._didRealpath) + return this._realpath() + + common.finish(this) + this.emit('end', this.found) +} + +Glob.prototype._realpath = function () { + if (this._didRealpath) + return + + this._didRealpath = true + + var n = this.matches.length + if (n === 0) + return this._finish() + + var self = this + for (var i = 0; i < this.matches.length; i++) + this._realpathSet(i, next) + + function next () { + if (--n === 0) + self._finish() + } +} + +Glob.prototype._realpathSet = function (index, cb) { + var matchset = this.matches[index] + if (!matchset) + return cb() + + var found = Object.keys(matchset) + var self = this + var n = found.length + + if (n === 0) + return cb() + + var set = this.matches[index] = Object.create(null) + found.forEach(function (p, i) { + // If there's a problem with the stat, then it means that + // one or more of the links in the realpath couldn't be + // resolved. just return the abs value in that case. + p = self._makeAbs(p) + rp.realpath(p, self.realpathCache, function (er, real) { + if (!er) + set[real] = true + else if (er.syscall === 'stat') + set[p] = true + else + self.emit('error', er) // srsly wtf right here + + if (--n === 0) { + self.matches[index] = set + cb() + } + }) + }) +} + +Glob.prototype._mark = function (p) { + return common.mark(this, p) +} + +Glob.prototype._makeAbs = function (f) { + return common.makeAbs(this, f) +} + +Glob.prototype.abort = function () { + this.aborted = true + this.emit('abort') +} + +Glob.prototype.pause = function () { + if (!this.paused) { + this.paused = true + this.emit('pause') + } +} + +Glob.prototype.resume = function () { + if (this.paused) { + this.emit('resume') + this.paused = false + if (this._emitQueue.length) { + var eq = this._emitQueue.slice(0) + this._emitQueue.length = 0 + for (var i = 0; i < eq.length; i ++) { + var e = eq[i] + this._emitMatch(e[0], e[1]) + } + } + if (this._processQueue.length) { + var pq = this._processQueue.slice(0) + this._processQueue.length = 0 + for (var i = 0; i < pq.length; i ++) { + var p = pq[i] + this._processing-- + this._process(p[0], p[1], p[2], p[3]) + } + } + } +} + +Glob.prototype._process = function (pattern, index, inGlobStar, cb) { + assert(this instanceof Glob) + assert(typeof cb === 'function') + + if (this.aborted) + return + + this._processing++ + if (this.paused) { + this._processQueue.push([pattern, index, inGlobStar, cb]) + return + } + + //console.error('PROCESS %d', this._processing, pattern) + + // Get the first [n] parts of pattern that are all strings. + var n = 0 + while (typeof pattern[n] === 'string') { + n ++ + } + // now n is the index of the first one that is *not* a string. + + // see if there's anything else + var prefix + switch (n) { + // if not, then this is rather simple + case pattern.length: + this._processSimple(pattern.join('/'), index, cb) + return + + case 0: + // pattern *starts* with some non-trivial item. + // going to readdir(cwd), but not include the prefix in matches. + prefix = null + break + + default: + // pattern has some string bits in the front. + // whatever it starts with, whether that's 'absolute' like /foo/bar, + // or 'relative' like '../baz' + prefix = pattern.slice(0, n).join('/') + break + } + + var remain = pattern.slice(n) + + // get the list of entries. + var read + if (prefix === null) + read = '.' + else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) { + if (!prefix || !isAbsolute(prefix)) + prefix = '/' + prefix + read = prefix + } else + read = prefix + + var abs = this._makeAbs(read) + + //if ignored, skip _processing + if (childrenIgnored(this, read)) + return cb() + + var isGlobStar = remain[0] === minimatch.GLOBSTAR + if (isGlobStar) + this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb) + else + this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb) +} + +Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) { + var self = this + this._readdir(abs, inGlobStar, function (er, entries) { + return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb) + }) +} + +Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) { + + // if the abs isn't a dir, then nothing can match! + if (!entries) + return cb() + + // It will only match dot entries if it starts with a dot, or if + // dot is set. Stuff like @(.foo|.bar) isn't allowed. + var pn = remain[0] + var negate = !!this.minimatch.negate + var rawGlob = pn._glob + var dotOk = this.dot || rawGlob.charAt(0) === '.' + + var matchedEntries = [] + for (var i = 0; i < entries.length; i++) { + var e = entries[i] + if (e.charAt(0) !== '.' || dotOk) { + var m + if (negate && !prefix) { + m = !e.match(pn) + } else { + m = e.match(pn) + } + if (m) + matchedEntries.push(e) + } + } + + //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries) + + var len = matchedEntries.length + // If there are no matched entries, then nothing matches. + if (len === 0) + return cb() + + // if this is the last remaining pattern bit, then no need for + // an additional stat *unless* the user has specified mark or + // stat explicitly. We know they exist, since readdir returned + // them. + + if (remain.length === 1 && !this.mark && !this.stat) { + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + if (prefix) { + if (prefix !== '/') + e = prefix + '/' + e + else + e = prefix + e + } + + if (e.charAt(0) === '/' && !this.nomount) { + e = path.join(this.root, e) + } + this._emitMatch(index, e) + } + // This was the last one, and no stats were needed + return cb() + } + + // now test all matched entries as stand-ins for that part + // of the pattern. + remain.shift() + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + var newPattern + if (prefix) { + if (prefix !== '/') + e = prefix + '/' + e + else + e = prefix + e + } + this._process([e].concat(remain), index, inGlobStar, cb) + } + cb() +} + +Glob.prototype._emitMatch = function (index, e) { + if (this.aborted) + return + + if (isIgnored(this, e)) + return + + if (this.paused) { + this._emitQueue.push([index, e]) + return + } + + var abs = isAbsolute(e) ? e : this._makeAbs(e) + + if (this.mark) + e = this._mark(e) + + if (this.absolute) + e = abs + + if (this.matches[index][e]) + return + + if (this.nodir) { + var c = this.cache[abs] + if (c === 'DIR' || Array.isArray(c)) + return + } + + this.matches[index][e] = true + + var st = this.statCache[abs] + if (st) + this.emit('stat', e, st) + + this.emit('match', e) +} + +Glob.prototype._readdirInGlobStar = function (abs, cb) { + if (this.aborted) + return + + // follow all symlinked directories forever + // just proceed as if this is a non-globstar situation + if (this.follow) + return this._readdir(abs, false, cb) + + var lstatkey = 'lstat\0' + abs + var self = this + var lstatcb = inflight(lstatkey, lstatcb_) + + if (lstatcb) + fs.lstat(abs, lstatcb) + + function lstatcb_ (er, lstat) { + if (er && er.code === 'ENOENT') + return cb() + + var isSym = lstat && lstat.isSymbolicLink() + self.symlinks[abs] = isSym + + // If it's not a symlink or a dir, then it's definitely a regular file. + // don't bother doing a readdir in that case. + if (!isSym && lstat && !lstat.isDirectory()) { + self.cache[abs] = 'FILE' + cb() + } else + self._readdir(abs, false, cb) + } +} + +Glob.prototype._readdir = function (abs, inGlobStar, cb) { + if (this.aborted) + return + + cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb) + if (!cb) + return + + //console.error('RD %j %j', +inGlobStar, abs) + if (inGlobStar && !ownProp(this.symlinks, abs)) + return this._readdirInGlobStar(abs, cb) + + if (ownProp(this.cache, abs)) { + var c = this.cache[abs] + if (!c || c === 'FILE') + return cb() + + if (Array.isArray(c)) + return cb(null, c) + } + + var self = this + fs.readdir(abs, readdirCb(this, abs, cb)) +} + +function readdirCb (self, abs, cb) { + return function (er, entries) { + if (er) + self._readdirError(abs, er, cb) + else + self._readdirEntries(abs, entries, cb) + } +} + +Glob.prototype._readdirEntries = function (abs, entries, cb) { + if (this.aborted) + return + + // if we haven't asked to stat everything, then just + // assume that everything in there exists, so we can avoid + // having to stat it a second time. + if (!this.mark && !this.stat) { + for (var i = 0; i < entries.length; i ++) { + var e = entries[i] + if (abs === '/') + e = abs + e + else + e = abs + '/' + e + this.cache[e] = true + } + } + + this.cache[abs] = entries + return cb(null, entries) +} + +Glob.prototype._readdirError = function (f, er, cb) { + if (this.aborted) + return + + // handle errors, and cache the information + switch (er.code) { + case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205 + case 'ENOTDIR': // totally normal. means it *does* exist. + var abs = this._makeAbs(f) + this.cache[abs] = 'FILE' + if (abs === this.cwdAbs) { + var error = new Error(er.code + ' invalid cwd ' + this.cwd) + error.path = this.cwd + error.code = er.code + this.emit('error', error) + this.abort() + } + break + + case 'ENOENT': // not terribly unusual + case 'ELOOP': + case 'ENAMETOOLONG': + case 'UNKNOWN': + this.cache[this._makeAbs(f)] = false + break + + default: // some unusual error. Treat as failure. + this.cache[this._makeAbs(f)] = false + if (this.strict) { + this.emit('error', er) + // If the error is handled, then we abort + // if not, we threw out of here + this.abort() + } + if (!this.silent) + console.error('glob error', er) + break + } + + return cb() +} + +Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) { + var self = this + this._readdir(abs, inGlobStar, function (er, entries) { + self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb) + }) +} + + +Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) { + //console.error('pgs2', prefix, remain[0], entries) + + // no entries means not a dir, so it can never have matches + // foo.txt/** doesn't match foo.txt + if (!entries) + return cb() + + // test without the globstar, and with every child both below + // and replacing the globstar. + var remainWithoutGlobStar = remain.slice(1) + var gspref = prefix ? [ prefix ] : [] + var noGlobStar = gspref.concat(remainWithoutGlobStar) + + // the noGlobStar pattern exits the inGlobStar state + this._process(noGlobStar, index, false, cb) + + var isSym = this.symlinks[abs] + var len = entries.length + + // If it's a symlink, and we're in a globstar, then stop + if (isSym && inGlobStar) + return cb() + + for (var i = 0; i < len; i++) { + var e = entries[i] + if (e.charAt(0) === '.' && !this.dot) + continue + + // these two cases enter the inGlobStar state + var instead = gspref.concat(entries[i], remainWithoutGlobStar) + this._process(instead, index, true, cb) + + var below = gspref.concat(entries[i], remain) + this._process(below, index, true, cb) + } + + cb() +} + +Glob.prototype._processSimple = function (prefix, index, cb) { + // XXX review this. Shouldn't it be doing the mounting etc + // before doing stat? kinda weird? + var self = this + this._stat(prefix, function (er, exists) { + self._processSimple2(prefix, index, er, exists, cb) + }) +} +Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) { + + //console.error('ps2', prefix, exists) + + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + // If it doesn't exist, then just mark the lack of results + if (!exists) + return cb() + + if (prefix && isAbsolute(prefix) && !this.nomount) { + var trail = /[\/\\]$/.test(prefix) + if (prefix.charAt(0) === '/') { + prefix = path.join(this.root, prefix) + } else { + prefix = path.resolve(this.root, prefix) + if (trail) + prefix += '/' + } + } + + if (process.platform === 'win32') + prefix = prefix.replace(/\\/g, '/') + + // Mark this as a match + this._emitMatch(index, prefix) + cb() +} + +// Returns either 'DIR', 'FILE', or false +Glob.prototype._stat = function (f, cb) { + var abs = this._makeAbs(f) + var needDir = f.slice(-1) === '/' + + if (f.length > this.maxLength) + return cb() + + if (!this.stat && ownProp(this.cache, abs)) { + var c = this.cache[abs] + + if (Array.isArray(c)) + c = 'DIR' + + // It exists, but maybe not how we need it + if (!needDir || c === 'DIR') + return cb(null, c) + + if (needDir && c === 'FILE') + return cb() + + // otherwise we have to stat, because maybe c=true + // if we know it exists, but not what it is. + } + + var exists + var stat = this.statCache[abs] + if (stat !== undefined) { + if (stat === false) + return cb(null, stat) + else { + var type = stat.isDirectory() ? 'DIR' : 'FILE' + if (needDir && type === 'FILE') + return cb() + else + return cb(null, type, stat) + } + } + + var self = this + var statcb = inflight('stat\0' + abs, lstatcb_) + if (statcb) + fs.lstat(abs, statcb) + + function lstatcb_ (er, lstat) { + if (lstat && lstat.isSymbolicLink()) { + // If it's a symlink, then treat it as the target, unless + // the target does not exist, then treat it as a file. + return fs.stat(abs, function (er, stat) { + if (er) + self._stat2(f, abs, null, lstat, cb) + else + self._stat2(f, abs, er, stat, cb) + }) + } else { + self._stat2(f, abs, er, lstat, cb) + } + } +} + +Glob.prototype._stat2 = function (f, abs, er, stat, cb) { + if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) { + this.statCache[abs] = false + return cb() + } + + var needDir = f.slice(-1) === '/' + this.statCache[abs] = stat + + if (abs.slice(-1) === '/' && stat && !stat.isDirectory()) + return cb(null, false, stat) + + var c = true + if (stat) + c = stat.isDirectory() ? 'DIR' : 'FILE' + this.cache[abs] = this.cache[abs] || c + + if (needDir && c === 'FILE') + return cb() + + return cb(null, c, stat) +} + +}).call(this,require('_process')) +},{"./common.js":621,"./sync.js":623,"_process":16,"assert":2,"events":8,"fs":1,"fs.realpath":617,"inflight":637,"inherits":638,"minimatch":703,"once":713,"path":14,"path-is-absolute":719,"util":42}],623:[function(require,module,exports){ +(function (process){ +module.exports = globSync +globSync.GlobSync = GlobSync + +var fs = require('fs') +var rp = require('fs.realpath') +var minimatch = require('minimatch') +var Minimatch = minimatch.Minimatch +var Glob = require('./glob.js').Glob +var util = require('util') +var path = require('path') +var assert = require('assert') +var isAbsolute = require('path-is-absolute') +var common = require('./common.js') +var alphasort = common.alphasort +var alphasorti = common.alphasorti +var setopts = common.setopts +var ownProp = common.ownProp +var childrenIgnored = common.childrenIgnored +var isIgnored = common.isIgnored + +function globSync (pattern, options) { + if (typeof options === 'function' || arguments.length === 3) + throw new TypeError('callback provided to sync glob\n'+ + 'See: https://github.com/isaacs/node-glob/issues/167') + + return new GlobSync(pattern, options).found +} + +function GlobSync (pattern, options) { + if (!pattern) + throw new Error('must provide pattern') + + if (typeof options === 'function' || arguments.length === 3) + throw new TypeError('callback provided to sync glob\n'+ + 'See: https://github.com/isaacs/node-glob/issues/167') + + if (!(this instanceof GlobSync)) + return new GlobSync(pattern, options) + + setopts(this, pattern, options) + + if (this.noprocess) + return this + + var n = this.minimatch.set.length + this.matches = new Array(n) + for (var i = 0; i < n; i ++) { + this._process(this.minimatch.set[i], i, false) + } + this._finish() +} + +GlobSync.prototype._finish = function () { + assert(this instanceof GlobSync) + if (this.realpath) { + var self = this + this.matches.forEach(function (matchset, index) { + var set = self.matches[index] = Object.create(null) + for (var p in matchset) { + try { + p = self._makeAbs(p) + var real = rp.realpathSync(p, self.realpathCache) + set[real] = true + } catch (er) { + if (er.syscall === 'stat') + set[self._makeAbs(p)] = true + else + throw er + } + } + }) + } + common.finish(this) +} + + +GlobSync.prototype._process = function (pattern, index, inGlobStar) { + assert(this instanceof GlobSync) + + // Get the first [n] parts of pattern that are all strings. + var n = 0 + while (typeof pattern[n] === 'string') { + n ++ + } + // now n is the index of the first one that is *not* a string. + + // See if there's anything else + var prefix + switch (n) { + // if not, then this is rather simple + case pattern.length: + this._processSimple(pattern.join('/'), index) + return + + case 0: + // pattern *starts* with some non-trivial item. + // going to readdir(cwd), but not include the prefix in matches. + prefix = null + break + + default: + // pattern has some string bits in the front. + // whatever it starts with, whether that's 'absolute' like /foo/bar, + // or 'relative' like '../baz' + prefix = pattern.slice(0, n).join('/') + break + } + + var remain = pattern.slice(n) + + // get the list of entries. + var read + if (prefix === null) + read = '.' + else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) { + if (!prefix || !isAbsolute(prefix)) + prefix = '/' + prefix + read = prefix + } else + read = prefix + + var abs = this._makeAbs(read) + + //if ignored, skip processing + if (childrenIgnored(this, read)) + return + + var isGlobStar = remain[0] === minimatch.GLOBSTAR + if (isGlobStar) + this._processGlobStar(prefix, read, abs, remain, index, inGlobStar) + else + this._processReaddir(prefix, read, abs, remain, index, inGlobStar) +} + + +GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) { + var entries = this._readdir(abs, inGlobStar) + + // if the abs isn't a dir, then nothing can match! + if (!entries) + return + + // It will only match dot entries if it starts with a dot, or if + // dot is set. Stuff like @(.foo|.bar) isn't allowed. + var pn = remain[0] + var negate = !!this.minimatch.negate + var rawGlob = pn._glob + var dotOk = this.dot || rawGlob.charAt(0) === '.' + + var matchedEntries = [] + for (var i = 0; i < entries.length; i++) { + var e = entries[i] + if (e.charAt(0) !== '.' || dotOk) { + var m + if (negate && !prefix) { + m = !e.match(pn) + } else { + m = e.match(pn) + } + if (m) + matchedEntries.push(e) + } + } + + var len = matchedEntries.length + // If there are no matched entries, then nothing matches. + if (len === 0) + return + + // if this is the last remaining pattern bit, then no need for + // an additional stat *unless* the user has specified mark or + // stat explicitly. We know they exist, since readdir returned + // them. + + if (remain.length === 1 && !this.mark && !this.stat) { + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + if (prefix) { + if (prefix.slice(-1) !== '/') + e = prefix + '/' + e + else + e = prefix + e + } + + if (e.charAt(0) === '/' && !this.nomount) { + e = path.join(this.root, e) + } + this._emitMatch(index, e) + } + // This was the last one, and no stats were needed + return + } + + // now test all matched entries as stand-ins for that part + // of the pattern. + remain.shift() + for (var i = 0; i < len; i ++) { + var e = matchedEntries[i] + var newPattern + if (prefix) + newPattern = [prefix, e] + else + newPattern = [e] + this._process(newPattern.concat(remain), index, inGlobStar) + } +} + + +GlobSync.prototype._emitMatch = function (index, e) { + if (isIgnored(this, e)) + return + + var abs = this._makeAbs(e) + + if (this.mark) + e = this._mark(e) + + if (this.absolute) { + e = abs + } + + if (this.matches[index][e]) + return + + if (this.nodir) { + var c = this.cache[abs] + if (c === 'DIR' || Array.isArray(c)) + return + } + + this.matches[index][e] = true + + if (this.stat) + this._stat(e) +} + + +GlobSync.prototype._readdirInGlobStar = function (abs) { + // follow all symlinked directories forever + // just proceed as if this is a non-globstar situation + if (this.follow) + return this._readdir(abs, false) + + var entries + var lstat + var stat + try { + lstat = fs.lstatSync(abs) + } catch (er) { + if (er.code === 'ENOENT') { + // lstat failed, doesn't exist + return null + } + } + + var isSym = lstat && lstat.isSymbolicLink() + this.symlinks[abs] = isSym + + // If it's not a symlink or a dir, then it's definitely a regular file. + // don't bother doing a readdir in that case. + if (!isSym && lstat && !lstat.isDirectory()) + this.cache[abs] = 'FILE' + else + entries = this._readdir(abs, false) + + return entries +} + +GlobSync.prototype._readdir = function (abs, inGlobStar) { + var entries + + if (inGlobStar && !ownProp(this.symlinks, abs)) + return this._readdirInGlobStar(abs) + + if (ownProp(this.cache, abs)) { + var c = this.cache[abs] + if (!c || c === 'FILE') + return null + + if (Array.isArray(c)) + return c + } + + try { + return this._readdirEntries(abs, fs.readdirSync(abs)) + } catch (er) { + this._readdirError(abs, er) + return null + } +} + +GlobSync.prototype._readdirEntries = function (abs, entries) { + // if we haven't asked to stat everything, then just + // assume that everything in there exists, so we can avoid + // having to stat it a second time. + if (!this.mark && !this.stat) { + for (var i = 0; i < entries.length; i ++) { + var e = entries[i] + if (abs === '/') + e = abs + e + else + e = abs + '/' + e + this.cache[e] = true + } + } + + this.cache[abs] = entries + + // mark and cache dir-ness + return entries +} + +GlobSync.prototype._readdirError = function (f, er) { + // handle errors, and cache the information + switch (er.code) { + case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205 + case 'ENOTDIR': // totally normal. means it *does* exist. + var abs = this._makeAbs(f) + this.cache[abs] = 'FILE' + if (abs === this.cwdAbs) { + var error = new Error(er.code + ' invalid cwd ' + this.cwd) + error.path = this.cwd + error.code = er.code + throw error + } + break + + case 'ENOENT': // not terribly unusual + case 'ELOOP': + case 'ENAMETOOLONG': + case 'UNKNOWN': + this.cache[this._makeAbs(f)] = false + break + + default: // some unusual error. Treat as failure. + this.cache[this._makeAbs(f)] = false + if (this.strict) + throw er + if (!this.silent) + console.error('glob error', er) + break + } +} + +GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) { + + var entries = this._readdir(abs, inGlobStar) + + // no entries means not a dir, so it can never have matches + // foo.txt/** doesn't match foo.txt + if (!entries) + return + + // test without the globstar, and with every child both below + // and replacing the globstar. + var remainWithoutGlobStar = remain.slice(1) + var gspref = prefix ? [ prefix ] : [] + var noGlobStar = gspref.concat(remainWithoutGlobStar) + + // the noGlobStar pattern exits the inGlobStar state + this._process(noGlobStar, index, false) + + var len = entries.length + var isSym = this.symlinks[abs] + + // If it's a symlink, and we're in a globstar, then stop + if (isSym && inGlobStar) + return + + for (var i = 0; i < len; i++) { + var e = entries[i] + if (e.charAt(0) === '.' && !this.dot) + continue + + // these two cases enter the inGlobStar state + var instead = gspref.concat(entries[i], remainWithoutGlobStar) + this._process(instead, index, true) + + var below = gspref.concat(entries[i], remain) + this._process(below, index, true) + } +} + +GlobSync.prototype._processSimple = function (prefix, index) { + // XXX review this. Shouldn't it be doing the mounting etc + // before doing stat? kinda weird? + var exists = this._stat(prefix) + + if (!this.matches[index]) + this.matches[index] = Object.create(null) + + // If it doesn't exist, then just mark the lack of results + if (!exists) + return + + if (prefix && isAbsolute(prefix) && !this.nomount) { + var trail = /[\/\\]$/.test(prefix) + if (prefix.charAt(0) === '/') { + prefix = path.join(this.root, prefix) + } else { + prefix = path.resolve(this.root, prefix) + if (trail) + prefix += '/' + } + } + + if (process.platform === 'win32') + prefix = prefix.replace(/\\/g, '/') + + // Mark this as a match + this._emitMatch(index, prefix) +} + +// Returns either 'DIR', 'FILE', or false +GlobSync.prototype._stat = function (f) { + var abs = this._makeAbs(f) + var needDir = f.slice(-1) === '/' + + if (f.length > this.maxLength) + return false + + if (!this.stat && ownProp(this.cache, abs)) { + var c = this.cache[abs] + + if (Array.isArray(c)) + c = 'DIR' + + // It exists, but maybe not how we need it + if (!needDir || c === 'DIR') + return c + + if (needDir && c === 'FILE') + return false + + // otherwise we have to stat, because maybe c=true + // if we know it exists, but not what it is. + } + + var exists + var stat = this.statCache[abs] + if (!stat) { + var lstat + try { + lstat = fs.lstatSync(abs) + } catch (er) { + if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) { + this.statCache[abs] = false + return false + } + } + + if (lstat && lstat.isSymbolicLink()) { + try { + stat = fs.statSync(abs) + } catch (er) { + stat = lstat + } + } else { + stat = lstat + } + } + + this.statCache[abs] = stat + + var c = true + if (stat) + c = stat.isDirectory() ? 'DIR' : 'FILE' + + this.cache[abs] = this.cache[abs] || c + + if (needDir && c === 'FILE') + return false + + return c +} + +GlobSync.prototype._mark = function (p) { + return common.mark(this, p) +} + +GlobSync.prototype._makeAbs = function (f) { + return common.makeAbs(this, f) +} + +}).call(this,require('_process')) +},{"./common.js":621,"./glob.js":622,"_process":16,"assert":2,"fs":1,"fs.realpath":617,"minimatch":703,"path":14,"path-is-absolute":719,"util":42}],624:[function(require,module,exports){ +'use strict'; +var Promise = require('pinkie-promise'); +var arrayUnion = require('array-union'); +var objectAssign = require('object-assign'); +var glob = require('glob'); +var pify = require('pify'); + +var globP = pify(glob, Promise).bind(glob); + +function isNegative(pattern) { + return pattern[0] === '!'; +} + +function isString(value) { + return typeof value === 'string'; +} + +function assertPatternsInput(patterns) { + if (!patterns.every(isString)) { + throw new TypeError('patterns must be a string or an array of strings'); + } +} + +function generateGlobTasks(patterns, opts) { + patterns = [].concat(patterns); + assertPatternsInput(patterns); + + var globTasks = []; + + opts = objectAssign({ + cache: Object.create(null), + statCache: Object.create(null), + realpathCache: Object.create(null), + symlinks: Object.create(null), + ignore: [] + }, opts); + + patterns.forEach(function (pattern, i) { + if (isNegative(pattern)) { + return; + } + + var ignore = patterns.slice(i).filter(isNegative).map(function (pattern) { + return pattern.slice(1); + }); + + globTasks.push({ + pattern: pattern, + opts: objectAssign({}, opts, { + ignore: opts.ignore.concat(ignore) + }) + }); + }); + + return globTasks; +} + +module.exports = function (patterns, opts) { + var globTasks; + + try { + globTasks = generateGlobTasks(patterns, opts); + } catch (err) { + return Promise.reject(err); + } + + return Promise.all(globTasks.map(function (task) { + return globP(task.pattern, task.opts); + })).then(function (paths) { + return arrayUnion.apply(null, paths); + }); +}; + +module.exports.sync = function (patterns, opts) { + var globTasks = generateGlobTasks(patterns, opts); + + return globTasks.reduce(function (matches, task) { + return arrayUnion(matches, glob.sync(task.pattern, task.opts)); + }, []); +}; + +module.exports.generateGlobTasks = generateGlobTasks; + +module.exports.hasMagic = function (patterns, opts) { + return [].concat(patterns).some(function (pattern) { + return glob.hasMagic(pattern, opts); + }); +}; + +},{"array-union":48,"glob":622,"object-assign":711,"pify":625,"pinkie-promise":722}],625:[function(require,module,exports){ +arguments[4][601][0].apply(exports,arguments) +},{"dup":601}],626:[function(require,module,exports){ +'use strict'; + +var Path = require('path'); +var slice = Array.prototype.slice; + +function join(/* globs */) { + var args; + + args = slice.call(arguments, 0); + return args.reduce(function (result, globs) { + return _apply(result, function (path) { + return _apply(globs, function (glob) { + return _join(path, glob); + }); + }); + }, ''); +} + +function _apply(values, fn) { + if (Array.isArray(values)) { + return values.reduce(function (result, value) { + return result.concat(fn(value)); + }, []); + } + return fn(values); +} + +function _join(path, glob) { + var negative, positive; + + if (glob[0] === '!') { + positive = glob.substr(1); + if (path[0] === '!') { + negative = ''; + } else { + negative = '!'; + } + return negative + Path.join(path, positive); + } + return Path.join(path, glob); +} + +module.exports = join; + +},{"path":14}],627:[function(require,module,exports){ +'use strict' + +var fs = require('fs') + +module.exports = clone(fs) + +function clone (obj) { + if (obj === null || typeof obj !== 'object') + return obj + + if (obj instanceof Object) + var copy = { __proto__: obj.__proto__ } + else + var copy = Object.create(null) + + Object.getOwnPropertyNames(obj).forEach(function (key) { + Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)) + }) + + return copy +} + +},{"fs":1}],628:[function(require,module,exports){ +(function (process){ +var fs = require('fs') +var polyfills = require('./polyfills.js') +var legacy = require('./legacy-streams.js') +var queue = [] + +var util = require('util') + +function noop () {} + +var debug = noop +if (util.debuglog) + debug = util.debuglog('gfs4') +else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) + debug = function() { + var m = util.format.apply(util, arguments) + m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ') + console.error(m) + } + +if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) { + process.on('exit', function() { + debug(queue) + require('assert').equal(queue.length, 0) + }) +} + +module.exports = patch(require('./fs.js')) +if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH) { + module.exports = patch(fs) +} + +// Always patch fs.close/closeSync, because we want to +// retry() whenever a close happens *anywhere* in the program. +// This is essential when multiple graceful-fs instances are +// in play at the same time. +module.exports.close = +fs.close = (function (fs$close) { return function (fd, cb) { + return fs$close.call(fs, fd, function (err) { + if (!err) + retry() + + if (typeof cb === 'function') + cb.apply(this, arguments) + }) +}})(fs.close) + +module.exports.closeSync = +fs.closeSync = (function (fs$closeSync) { return function (fd) { + // Note that graceful-fs also retries when fs.closeSync() fails. + // Looks like a bug to me, although it's probably a harmless one. + var rval = fs$closeSync.apply(fs, arguments) + retry() + return rval +}})(fs.closeSync) + +function patch (fs) { + // Everything that references the open() function needs to be in here + polyfills(fs) + fs.gracefulify = patch + fs.FileReadStream = ReadStream; // Legacy name. + fs.FileWriteStream = WriteStream; // Legacy name. + fs.createReadStream = createReadStream + fs.createWriteStream = createWriteStream + var fs$readFile = fs.readFile + fs.readFile = readFile + function readFile (path, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + return go$readFile(path, options, cb) + + function go$readFile (path, options, cb) { + return fs$readFile(path, options, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$readFile, [path, options, cb]]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + retry() + } + }) + } + } + + var fs$writeFile = fs.writeFile + fs.writeFile = writeFile + function writeFile (path, data, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + return go$writeFile(path, data, options, cb) + + function go$writeFile (path, data, options, cb) { + return fs$writeFile(path, data, options, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$writeFile, [path, data, options, cb]]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + retry() + } + }) + } + } + + var fs$appendFile = fs.appendFile + if (fs$appendFile) + fs.appendFile = appendFile + function appendFile (path, data, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + return go$appendFile(path, data, options, cb) + + function go$appendFile (path, data, options, cb) { + return fs$appendFile(path, data, options, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$appendFile, [path, data, options, cb]]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + retry() + } + }) + } + } + + var fs$readdir = fs.readdir + fs.readdir = readdir + function readdir (path, options, cb) { + var args = [path] + if (typeof options !== 'function') { + args.push(options) + } else { + cb = options + } + args.push(go$readdir$cb) + + return go$readdir(args) + + function go$readdir$cb (err, files) { + if (files && files.sort) + files.sort() + + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$readdir, [args]]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + retry() + } + } + } + + function go$readdir (args) { + return fs$readdir.apply(fs, args) + } + + if (process.version.substr(0, 4) === 'v0.8') { + var legStreams = legacy(fs) + ReadStream = legStreams.ReadStream + WriteStream = legStreams.WriteStream + } + + var fs$ReadStream = fs.ReadStream + ReadStream.prototype = Object.create(fs$ReadStream.prototype) + ReadStream.prototype.open = ReadStream$open + + var fs$WriteStream = fs.WriteStream + WriteStream.prototype = Object.create(fs$WriteStream.prototype) + WriteStream.prototype.open = WriteStream$open + + fs.ReadStream = ReadStream + fs.WriteStream = WriteStream + + function ReadStream (path, options) { + if (this instanceof ReadStream) + return fs$ReadStream.apply(this, arguments), this + else + return ReadStream.apply(Object.create(ReadStream.prototype), arguments) + } + + function ReadStream$open () { + var that = this + open(that.path, that.flags, that.mode, function (err, fd) { + if (err) { + if (that.autoClose) + that.destroy() + + that.emit('error', err) + } else { + that.fd = fd + that.emit('open', fd) + that.read() + } + }) + } + + function WriteStream (path, options) { + if (this instanceof WriteStream) + return fs$WriteStream.apply(this, arguments), this + else + return WriteStream.apply(Object.create(WriteStream.prototype), arguments) + } + + function WriteStream$open () { + var that = this + open(that.path, that.flags, that.mode, function (err, fd) { + if (err) { + that.destroy() + that.emit('error', err) + } else { + that.fd = fd + that.emit('open', fd) + } + }) + } + + function createReadStream (path, options) { + return new ReadStream(path, options) + } + + function createWriteStream (path, options) { + return new WriteStream(path, options) + } + + var fs$open = fs.open + fs.open = open + function open (path, flags, mode, cb) { + if (typeof mode === 'function') + cb = mode, mode = null + + return go$open(path, flags, mode, cb) + + function go$open (path, flags, mode, cb) { + return fs$open(path, flags, mode, function (err, fd) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$open, [path, flags, mode, cb]]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + retry() + } + }) + } + } + + return fs +} + +function enqueue (elem) { + debug('ENQUEUE', elem[0].name, elem[1]) + queue.push(elem) +} + +function retry () { + var elem = queue.shift() + if (elem) { + debug('RETRY', elem[0].name, elem[1]) + elem[0].apply(null, elem[1]) + } +} + +}).call(this,require('_process')) +},{"./fs.js":627,"./legacy-streams.js":629,"./polyfills.js":630,"_process":16,"assert":2,"fs":1,"util":42}],629:[function(require,module,exports){ +(function (process){ +var Stream = require('stream').Stream + +module.exports = legacy + +function legacy (fs) { + return { + ReadStream: ReadStream, + WriteStream: WriteStream + } + + function ReadStream (path, options) { + if (!(this instanceof ReadStream)) return new ReadStream(path, options); + + Stream.call(this); + + var self = this; + + this.path = path; + this.fd = null; + this.readable = true; + this.paused = false; + + this.flags = 'r'; + this.mode = 438; /*=0666*/ + this.bufferSize = 64 * 1024; + + options = options || {}; + + // Mixin options into this + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + + if (this.encoding) this.setEncoding(this.encoding); + + if (this.start !== undefined) { + if ('number' !== typeof this.start) { + throw TypeError('start must be a Number'); + } + if (this.end === undefined) { + this.end = Infinity; + } else if ('number' !== typeof this.end) { + throw TypeError('end must be a Number'); + } + + if (this.start > this.end) { + throw new Error('start must be <= end'); + } + + this.pos = this.start; + } + + if (this.fd !== null) { + process.nextTick(function() { + self._read(); + }); + return; + } + + fs.open(this.path, this.flags, this.mode, function (err, fd) { + if (err) { + self.emit('error', err); + self.readable = false; + return; + } + + self.fd = fd; + self.emit('open', fd); + self._read(); + }) + } + + function WriteStream (path, options) { + if (!(this instanceof WriteStream)) return new WriteStream(path, options); + + Stream.call(this); + + this.path = path; + this.fd = null; + this.writable = true; + + this.flags = 'w'; + this.encoding = 'binary'; + this.mode = 438; /*=0666*/ + this.bytesWritten = 0; + + options = options || {}; + + // Mixin options into this + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + + if (this.start !== undefined) { + if ('number' !== typeof this.start) { + throw TypeError('start must be a Number'); + } + if (this.start < 0) { + throw new Error('start must be >= zero'); + } + + this.pos = this.start; + } + + this.busy = false; + this._queue = []; + + if (this.fd === null) { + this._open = fs.open; + this._queue.push([this._open, this.path, this.flags, this.mode, undefined]); + this.flush(); + } + } +} + +}).call(this,require('_process')) +},{"_process":16,"stream":35}],630:[function(require,module,exports){ +(function (process){ +var fs = require('./fs.js') +var constants = require('constants') + +var origCwd = process.cwd +var cwd = null + +var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform + +process.cwd = function() { + if (!cwd) + cwd = origCwd.call(process) + return cwd +} +try { + process.cwd() +} catch (er) {} + +var chdir = process.chdir +process.chdir = function(d) { + cwd = null + chdir.call(process, d) +} + +module.exports = patch + +function patch (fs) { + // (re-)implement some things that are known busted or missing. + + // lchmod, broken prior to 0.6.2 + // back-port the fix here. + if (constants.hasOwnProperty('O_SYMLINK') && + process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { + patchLchmod(fs) + } + + // lutimes implementation, or no-op + if (!fs.lutimes) { + patchLutimes(fs) + } + + // https://github.com/isaacs/node-graceful-fs/issues/4 + // Chown should not fail on einval or eperm if non-root. + // It should not fail on enosys ever, as this just indicates + // that a fs doesn't support the intended operation. + + fs.chown = chownFix(fs.chown) + fs.fchown = chownFix(fs.fchown) + fs.lchown = chownFix(fs.lchown) + + fs.chmod = chmodFix(fs.chmod) + fs.fchmod = chmodFix(fs.fchmod) + fs.lchmod = chmodFix(fs.lchmod) + + fs.chownSync = chownFixSync(fs.chownSync) + fs.fchownSync = chownFixSync(fs.fchownSync) + fs.lchownSync = chownFixSync(fs.lchownSync) + + fs.chmodSync = chmodFixSync(fs.chmodSync) + fs.fchmodSync = chmodFixSync(fs.fchmodSync) + fs.lchmodSync = chmodFixSync(fs.lchmodSync) + + fs.stat = statFix(fs.stat) + fs.fstat = statFix(fs.fstat) + fs.lstat = statFix(fs.lstat) + + fs.statSync = statFixSync(fs.statSync) + fs.fstatSync = statFixSync(fs.fstatSync) + fs.lstatSync = statFixSync(fs.lstatSync) + + // if lchmod/lchown do not exist, then make them no-ops + if (!fs.lchmod) { + fs.lchmod = function (path, mode, cb) { + if (cb) process.nextTick(cb) + } + fs.lchmodSync = function () {} + } + if (!fs.lchown) { + fs.lchown = function (path, uid, gid, cb) { + if (cb) process.nextTick(cb) + } + fs.lchownSync = function () {} + } + + // on Windows, A/V software can lock the directory, causing this + // to fail with an EACCES or EPERM if the directory contains newly + // created files. Try again on failure, for up to 60 seconds. + + // Set the timeout this long because some Windows Anti-Virus, such as Parity + // bit9, may lock files for up to a minute, causing npm package install + // failures. Also, take care to yield the scheduler. Windows scheduling gives + // CPU to a busy looping process, which can cause the program causing the lock + // contention to be starved of CPU by node, so the contention doesn't resolve. + if (platform === "win32") { + fs.rename = (function (fs$rename) { return function (from, to, cb) { + var start = Date.now() + var backoff = 0; + fs$rename(from, to, function CB (er) { + if (er + && (er.code === "EACCES" || er.code === "EPERM") + && Date.now() - start < 60000) { + setTimeout(function() { + fs.stat(to, function (stater, st) { + if (stater && stater.code === "ENOENT") + fs$rename(from, to, CB); + else + cb(er) + }) + }, backoff) + if (backoff < 100) + backoff += 10; + return; + } + if (cb) cb(er) + }) + }})(fs.rename) + } + + // if read() returns EAGAIN, then just try it again. + fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) { + var callback + if (callback_ && typeof callback_ === 'function') { + var eagCounter = 0 + callback = function (er, _, __) { + if (er && er.code === 'EAGAIN' && eagCounter < 10) { + eagCounter ++ + return fs$read.call(fs, fd, buffer, offset, length, position, callback) + } + callback_.apply(this, arguments) + } + } + return fs$read.call(fs, fd, buffer, offset, length, position, callback) + }})(fs.read) + + fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) { + var eagCounter = 0 + while (true) { + try { + return fs$readSync.call(fs, fd, buffer, offset, length, position) + } catch (er) { + if (er.code === 'EAGAIN' && eagCounter < 10) { + eagCounter ++ + continue + } + throw er + } + } + }})(fs.readSync) +} + +function patchLchmod (fs) { + fs.lchmod = function (path, mode, callback) { + fs.open( path + , constants.O_WRONLY | constants.O_SYMLINK + , mode + , function (err, fd) { + if (err) { + if (callback) callback(err) + return + } + // prefer to return the chmod error, if one occurs, + // but still try to close, and report closing errors if they occur. + fs.fchmod(fd, mode, function (err) { + fs.close(fd, function(err2) { + if (callback) callback(err || err2) + }) + }) + }) + } + + fs.lchmodSync = function (path, mode) { + var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode) + + // prefer to return the chmod error, if one occurs, + // but still try to close, and report closing errors if they occur. + var threw = true + var ret + try { + ret = fs.fchmodSync(fd, mode) + threw = false + } finally { + if (threw) { + try { + fs.closeSync(fd) + } catch (er) {} + } else { + fs.closeSync(fd) + } + } + return ret + } +} + +function patchLutimes (fs) { + if (constants.hasOwnProperty("O_SYMLINK")) { + fs.lutimes = function (path, at, mt, cb) { + fs.open(path, constants.O_SYMLINK, function (er, fd) { + if (er) { + if (cb) cb(er) + return + } + fs.futimes(fd, at, mt, function (er) { + fs.close(fd, function (er2) { + if (cb) cb(er || er2) + }) + }) + }) + } + + fs.lutimesSync = function (path, at, mt) { + var fd = fs.openSync(path, constants.O_SYMLINK) + var ret + var threw = true + try { + ret = fs.futimesSync(fd, at, mt) + threw = false + } finally { + if (threw) { + try { + fs.closeSync(fd) + } catch (er) {} + } else { + fs.closeSync(fd) + } + } + return ret + } + + } else { + fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) } + fs.lutimesSync = function () {} + } +} + +function chmodFix (orig) { + if (!orig) return orig + return function (target, mode, cb) { + return orig.call(fs, target, mode, function (er) { + if (chownErOk(er)) er = null + if (cb) cb.apply(this, arguments) + }) + } +} + +function chmodFixSync (orig) { + if (!orig) return orig + return function (target, mode) { + try { + return orig.call(fs, target, mode) + } catch (er) { + if (!chownErOk(er)) throw er + } + } +} + + +function chownFix (orig) { + if (!orig) return orig + return function (target, uid, gid, cb) { + return orig.call(fs, target, uid, gid, function (er) { + if (chownErOk(er)) er = null + if (cb) cb.apply(this, arguments) + }) + } +} + +function chownFixSync (orig) { + if (!orig) return orig + return function (target, uid, gid) { + try { + return orig.call(fs, target, uid, gid) + } catch (er) { + if (!chownErOk(er)) throw er + } + } +} + + +function statFix (orig) { + if (!orig) return orig + // Older versions of Node erroneously returned signed integers for + // uid + gid. + return function (target, cb) { + return orig.call(fs, target, function (er, stats) { + if (!stats) return cb.apply(this, arguments) + if (stats.uid < 0) stats.uid += 0x100000000 + if (stats.gid < 0) stats.gid += 0x100000000 + if (cb) cb.apply(this, arguments) + }) + } +} + +function statFixSync (orig) { + if (!orig) return orig + // Older versions of Node erroneously returned signed integers for + // uid + gid. + return function (target) { + var stats = orig.call(fs, target) + if (stats.uid < 0) stats.uid += 0x100000000 + if (stats.gid < 0) stats.gid += 0x100000000 + return stats; + } +} + +// ENOSYS means that the fs doesn't support the op. Just ignore +// that, because it doesn't matter. +// +// if there's no getuid, or if getuid() is something other +// than 0, and the error is EINVAL or EPERM, then just ignore +// it. +// +// This specific case is a silent failure in cp, install, tar, +// and most other unix tools that manage permissions. +// +// When running as root, or if other types of errors are +// encountered, then it's strict. +function chownErOk (er) { + if (!er) + return true + + if (er.code === "ENOSYS") + return true + + var nonroot = !process.getuid || process.getuid() !== 0 + if (nonroot) { + if (er.code === "EINVAL" || er.code === "EPERM") + return true + } + + return false +} + +}).call(this,require('_process')) +},{"./fs.js":627,"_process":16,"constants":6}],631:[function(require,module,exports){ +'use strict'; +var ansiRegex = require('ansi-regex'); +var re = new RegExp(ansiRegex().source); // remove the `g` flag +module.exports = re.test.bind(re); + +},{"ansi-regex":44}],632:[function(require,module,exports){ +module.exports=[ + "a", + "abbr", + "address", + "area", + "article", + "aside", + "audio", + "b", + "base", + "bdi", + "bdo", + "blockquote", + "body", + "br", + "button", + "canvas", + "caption", + "cite", + "code", + "col", + "colgroup", + "data", + "datalist", + "dd", + "del", + "details", + "dfn", + "dialog", + "div", + "dl", + "dt", + "em", + "embed", + "fieldset", + "figcaption", + "figure", + "footer", + "form", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "head", + "header", + "hgroup", + "hr", + "html", + "i", + "iframe", + "img", + "input", + "ins", + "kbd", + "keygen", + "label", + "legend", + "li", + "link", + "main", + "map", + "mark", + "math", + "menu", + "menuitem", + "meta", + "meter", + "nav", + "noscript", + "object", + "ol", + "optgroup", + "option", + "output", + "p", + "param", + "picture", + "pre", + "progress", + "q", + "rb", + "rp", + "rt", + "rtc", + "ruby", + "s", + "samp", + "script", + "section", + "select", + "slot", + "small", + "source", + "span", + "strong", + "style", + "sub", + "summary", + "sup", + "svg", + "table", + "tbody", + "td", + "template", + "textarea", + "tfoot", + "th", + "thead", + "time", + "title", + "tr", + "track", + "u", + "ul", + "var", + "video", + "wbr" +] + +},{}],633:[function(require,module,exports){ +'use strict'; +module.exports = require('./html-tags.json'); + +},{"./html-tags.json":632}],634:[function(require,module,exports){ +(function (process){ +'use strict'; + +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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +module.exports = function () { + return new IgnoreBase(); +}; + +// A simple implementation of make-array +function make_array(subject) { + return Array.isArray(subject) ? subject : [subject]; +} + +var REGEX_BLANK_LINE = /^\s+$/; +var REGEX_LEADING_EXCAPED_EXCLAMATION = /^\\\!/; +var REGEX_LEADING_EXCAPED_HASH = /^\\#/; +var SLASH = '/'; + +var IgnoreBase = function () { + function IgnoreBase() { + _classCallCheck(this, IgnoreBase); + + this._rules = []; + this._initCache(); + } + + _createClass(IgnoreBase, [{ + key: '_initCache', + value: function _initCache() { + this._cache = {}; + } + + // @param {Array.|string|Ignore} pattern + + }, { + key: 'add', + value: function add(pattern) { + this._added = false; + + if (typeof pattern === 'string') { + pattern = pattern.split(/\r?\n/g); + } + + make_array(pattern).forEach(this._addPattern, this); + + // Some rules have just added to the ignore, + // making the behavior changed. + if (this._added) { + this._initCache(); + } + + return this; + } + + // legacy + + }, { + key: 'addPattern', + value: function addPattern(pattern) { + return this.add(pattern); + } + }, { + key: '_addPattern', + value: function _addPattern(pattern) { + if (pattern instanceof IgnoreBase) { + this._rules = this._rules.concat(pattern._rules); + this._added = true; + return; + } + + if (this._checkPattern(pattern)) { + var rule = this._createRule(pattern); + this._added = true; + this._rules.push(rule); + } + } + }, { + key: '_checkPattern', + value: function _checkPattern(pattern) { + // > A blank line matches no files, so it can serve as a separator for readability. + return pattern && typeof pattern === 'string' && !REGEX_BLANK_LINE.test(pattern) + + // > A line starting with # serves as a comment. + && pattern.indexOf('#') !== 0; + } + }, { + key: 'filter', + value: function filter(paths) { + var _this = this; + + return make_array(paths).filter(function (path) { + return _this._filter(path); + }); + } + }, { + key: 'createFilter', + value: function createFilter() { + var _this2 = this; + + return function (path) { + return _this2._filter(path); + }; + } + }, { + key: 'ignores', + value: function ignores(path) { + return !this._filter(path); + } + }, { + key: '_createRule', + value: function _createRule(pattern) { + var origin = pattern; + var negative = false; + + // > An optional prefix "!" which negates the pattern; + if (pattern.indexOf('!') === 0) { + negative = true; + pattern = pattern.substr(1); + } + + pattern = pattern + // > Put a backslash ("\") in front of the first "!" for patterns that begin with a literal "!", for example, `"\!important!.txt"`. + .replace(REGEX_LEADING_EXCAPED_EXCLAMATION, '!') + // > Put a backslash ("\") in front of the first hash for patterns that begin with a hash. + .replace(REGEX_LEADING_EXCAPED_HASH, '#'); + + var regex = make_regex(pattern, negative); + + return { + origin: origin, + pattern: pattern, + negative: negative, + regex: regex + }; + } + + // @returns `Boolean` true if the `path` is NOT ignored + + }, { + key: '_filter', + value: function _filter(path, slices) { + if (!path) { + return false; + } + + if (path in this._cache) { + return this._cache[path]; + } + + if (!slices) { + // path/to/a.js + // ['path', 'to', 'a.js'] + slices = path.split(SLASH); + + // '/b/a.js' -> ['', 'b', 'a.js'] -> [''] + if (slices.length && !slices[0]) { + slices = slices.slice(1); + slices[0] = SLASH + slices[0]; + } + } + + slices.pop(); + + return this._cache[path] = slices.length + // > It is not possible to re-include a file if a parent directory of that file is excluded. + // If the path contains a parent directory, check the parent first + ? this._filter(slices.join(SLASH) + SLASH, slices) && this._test(path) + + // Or only test the path + : this._test(path); + } + + // @returns {Boolean} true if a file is NOT ignored + + }, { + key: '_test', + value: function _test(path) { + // Explicitly define variable type by setting matched to `0` + var matched = 0; + + this._rules.forEach(function (rule) { + // if matched = true, then we only test negative rules + // if matched = false, then we test non-negative rules + if (!(matched ^ rule.negative)) { + matched = rule.negative ^ rule.regex.test(path); + } + }); + + return !matched; + } + }]); + + return IgnoreBase; +}(); + +// > If the pattern ends with a slash, +// > it is removed for the purpose of the following description, +// > but it would only find a match with a directory. +// > In other words, foo/ will match a directory foo and paths underneath it, +// > but will not match a regular file or a symbolic link foo +// > (this is consistent with the way how pathspec works in general in Git). +// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`' +// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call +// you could use option `mark: true` with `glob` + +// '`foo/`' should not continue with the '`..`' + + +var DEFAULT_REPLACER_PREFIX = [ + +// > Trailing spaces are ignored unless they are quoted with backslash ("\") +[ +// (a\ ) -> (a ) +// (a ) -> (a) +// (a \ ) -> (a ) +/\\?\s+$/, function (match) { + return match.indexOf('\\') === 0 ? ' ' : ''; +}], + +// replace (\ ) with ' ' +[/\\\s/g, function () { + return ' '; +}], + +// Escape metacharacters +// which is written down by users but means special for regular expressions. + +// > There are 12 characters with special meanings: +// > - the backslash \, +// > - the caret ^, +// > - the dollar sign $, +// > - the period or dot ., +// > - the vertical bar or pipe symbol |, +// > - the question mark ?, +// > - the asterisk or star *, +// > - the plus sign +, +// > - the opening parenthesis (, +// > - the closing parenthesis ), +// > - and the opening square bracket [, +// > - the opening curly brace {, +// > These special characters are often called "metacharacters". +[/[\\\^$.|?*+()\[{]/g, function (match) { + return '\\' + match; +}], + +// leading slash +[ + +// > A leading slash matches the beginning of the pathname. +// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c". +// A leading slash matches the beginning of the pathname +/^\//, function () { + return '^'; +}], + +// replace special metacharacter slash after the leading slash +[/\//g, function () { + return '\\/'; +}], [ +// > A leading "**" followed by a slash means match in all directories. +// > For example, "**/foo" matches file or directory "foo" anywhere, +// > the same as pattern "foo". +// > "**/foo/bar" matches file or directory "bar" anywhere that is directly under directory "foo". +// Notice that the '*'s have been replaced as '\\*' +/^\^*\\\*\\\*\\\//, + +// '**/foo' <-> 'foo' +function () { + return '^(?:.*\\/)?'; +}]]; + +var DEFAULT_REPLACER_SUFFIX = [ +// starting +[ +// there will be no leading '/' (which has been replaced by section "leading slash") +// If starts with '**', adding a '^' to the regular expression also works +/^(?=[^\^])/, function () { + return !/\/(?!$)/.test(this) + // > If the pattern does not contain a slash /, Git treats it as a shell glob pattern + // Actually, if there is only a trailing slash, git also treats it as a shell glob pattern + ? '(?:^|\\/)' + + // > Otherwise, Git treats the pattern as a shell glob suitable for consumption by fnmatch(3) + : '^'; +}], + +// two globstars +[ +// Use lookahead assertions so that we could match more than one `'/**'` +/\\\/\\\*\\\*(?=\\\/|$)/g, + +// Zero, one or several directories +// should not use '*', or it will be replaced by the next replacer + +// Check if it is not the last `'/**'` +function (match, index, str) { + return index + 6 < str.length + + // case: /**/ + // > A slash followed by two consecutive asterisks then a slash matches zero or more directories. + // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on. + // '/**/' + ? '(?:\\/[^\\/]+)*' + + // case: /** + // > A trailing `"/**"` matches everything inside. + + // #21: everything inside but it should not include the current folder + : '\\/.+'; +}], + +// intermediate wildcards +[ +// Never replace escaped '*' +// ignore rule '\*' will match the path '*' + +// 'abc.*/' -> go +// 'abc.*' -> skip this rule +/(^|[^\\]+)\\\*(?=.+)/g, + +// '*.js' matches '.js' +// '*.js' doesn't match 'abc' +function (match, p1) { + return p1 + '[^\\/]*'; +}], + +// trailing wildcard +[/(\^|\\\/)?\\\*$/, function (match, p1) { + return (p1 + // '\^': + // '/*' does not match '' + // '/*' does not match everything + + // '\\\/': + // 'abc/*' does not match 'abc/' + ? p1 + '[^/]+' + + // 'a*' matches 'a' + // 'a*' matches 'aa' + : '[^/]*') + '(?=$|\\/$)'; +}], [ +// unescape +/\\\\\\/g, function () { + return '\\'; +}]]; + +var POSITIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [ + +// 'f' +// matches +// - /f(end) +// - /f/ +// - (start)f(end) +// - (start)f/ +// doesn't match +// - oof +// - foo +// pseudo: +// -> (^|/)f(/|$) + +// ending +[ +// 'js' will not match 'js.' +// 'ab' will not match 'abc' +/(?:[^*\/])$/, + +// 'js*' will not match 'a.js' +// 'js/' will not match 'a.js' +// 'js' will match 'a.js' and 'a.js/' +function (match) { + return match + '(?=$|\\/)'; +}]], DEFAULT_REPLACER_SUFFIX); + +var NEGATIVE_REPLACERS = [].concat(DEFAULT_REPLACER_PREFIX, [ + +// #24 +// The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore) +// A negative pattern without a trailing wildcard should not +// re-include the things inside that directory. + +// eg: +// ['node_modules/*', '!node_modules'] +// should ignore `node_modules/a.js` +[/(?:[^*\/])$/, function (match) { + return match + '(?=$|\\/$)'; +}]], DEFAULT_REPLACER_SUFFIX); + +// A simple cache, because an ignore rule only has only one certain meaning +var cache = {}; + +// @param {pattern} +function make_regex(pattern, negative) { + var r = cache[pattern]; + if (r) { + return r; + } + + var replacers = negative ? NEGATIVE_REPLACERS : POSITIVE_REPLACERS; + + var source = replacers.reduce(function (prev, current) { + return prev.replace(current[0], current[1].bind(pattern)); + }, pattern); + + return cache[pattern] = new RegExp(source, 'i'); +} + +// Windows +// -------------------------------------------------------------- +/* istanbul ignore if */ +if (process.env.IGNORE_TEST_WIN32 || process.platform === 'win32') { + + var filter = IgnoreBase.prototype._filter; + var make_posix = function make_posix(str) { + return (/^\\\\\?\\/.test(str) || /[^\x00-\x80]+/.test(str) ? str : str.replace(/\\/g, '/') + ); + }; + + IgnoreBase.prototype._filter = function (path, slices) { + path = make_posix(path); + return filter.call(this, path, slices); + }; +} + +}).call(this,require('_process')) +},{"_process":16}],635:[function(require,module,exports){ +/** + * @preserve + * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013) + * + * @author Jens Taylor + * @see http://github.com/homebrewing/brauhaus-diff + * @author Gary Court + * @see http://github.com/garycourt/murmurhash-js + * @author Austin Appleby + * @see http://sites.google.com/site/murmurhash/ + */ +(function(){ + var cache; + + // Call this function without `new` to use the cached object (good for + // single-threaded environments), or with `new` to create a new object. + // + // @param {string} key A UTF-16 or ASCII string + // @param {number} seed An optional positive integer + // @return {object} A MurmurHash3 object for incremental hashing + function MurmurHash3(key, seed) { + var m = this instanceof MurmurHash3 ? this : cache; + m.reset(seed) + if (typeof key === 'string' && key.length > 0) { + m.hash(key); + } + + if (m !== this) { + return m; + } + }; + + // Incrementally add a string to this hash + // + // @param {string} key A UTF-16 or ASCII string + // @return {object} this + MurmurHash3.prototype.hash = function(key) { + var h1, k1, i, top, len; + + len = key.length; + this.len += len; + + k1 = this.k1; + i = 0; + switch (this.rem) { + case 0: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) : 0; + case 1: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 8 : 0; + case 2: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 16 : 0; + case 3: + k1 ^= len > i ? (key.charCodeAt(i) & 0xff) << 24 : 0; + k1 ^= len > i ? (key.charCodeAt(i++) & 0xff00) >> 8 : 0; + } + + this.rem = (len + this.rem) & 3; // & 3 is same as % 4 + len -= this.rem; + if (len > 0) { + h1 = this.h1; + while (1) { + k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff; + k1 = (k1 << 15) | (k1 >>> 17); + k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff; + + h1 ^= k1; + h1 = (h1 << 13) | (h1 >>> 19); + h1 = (h1 * 5 + 0xe6546b64) & 0xffffffff; + + if (i >= len) { + break; + } + + k1 = ((key.charCodeAt(i++) & 0xffff)) ^ + ((key.charCodeAt(i++) & 0xffff) << 8) ^ + ((key.charCodeAt(i++) & 0xffff) << 16); + top = key.charCodeAt(i++); + k1 ^= ((top & 0xff) << 24) ^ + ((top & 0xff00) >> 8); + } + + k1 = 0; + switch (this.rem) { + case 3: k1 ^= (key.charCodeAt(i + 2) & 0xffff) << 16; + case 2: k1 ^= (key.charCodeAt(i + 1) & 0xffff) << 8; + case 1: k1 ^= (key.charCodeAt(i) & 0xffff); + } + + this.h1 = h1; + } + + this.k1 = k1; + return this; + }; + + // Get the result of this hash + // + // @return {number} The 32-bit hash + MurmurHash3.prototype.result = function() { + var k1, h1; + + k1 = this.k1; + h1 = this.h1; + + if (k1 > 0) { + k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff; + k1 = (k1 << 15) | (k1 >>> 17); + k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff; + h1 ^= k1; + } + + h1 ^= this.len; + + h1 ^= h1 >>> 16; + h1 = (h1 * 0xca6b + (h1 & 0xffff) * 0x85eb0000) & 0xffffffff; + h1 ^= h1 >>> 13; + h1 = (h1 * 0xae35 + (h1 & 0xffff) * 0xc2b20000) & 0xffffffff; + h1 ^= h1 >>> 16; + + return h1 >>> 0; + }; + + // Reset the hash object for reuse + // + // @param {number} seed An optional positive integer + MurmurHash3.prototype.reset = function(seed) { + this.h1 = typeof seed === 'number' ? seed : 0; + this.rem = this.k1 = this.len = 0; + return this; + }; + + // A cached object to use. This can be safely used if you're in a single- + // threaded environment, otherwise you need to create new hashes to use. + cache = new MurmurHash3(); + + if (typeof(module) != 'undefined') { + module.exports = MurmurHash3; + } else { + this.MurmurHash3 = MurmurHash3; + } +}()); + +},{}],636:[function(require,module,exports){ +module.exports = function (ary, item) { + var i = -1, indexes = [] + while((i = ary.indexOf(item, i + 1)) !== -1) + indexes.push(i) + return indexes +} + +},{}],637:[function(require,module,exports){ +(function (process){ +var wrappy = require('wrappy') +var reqs = Object.create(null) +var once = require('once') + +module.exports = wrappy(inflight) + +function inflight (key, cb) { + if (reqs[key]) { + reqs[key].push(cb) + return null + } else { + reqs[key] = [cb] + return makeres(key) + } +} + +function makeres (key) { + return once(function RES () { + var cbs = reqs[key] + var len = cbs.length + var args = slice(arguments) + + // XXX It's somewhat ambiguous whether a new callback added in this + // pass should be queued for later execution if something in the + // list of callbacks throws, or if it should just be discarded. + // However, it's such an edge case that it hardly matters, and either + // choice is likely as surprising as the other. + // As it happens, we do go ahead and schedule it for later execution. + try { + for (var i = 0; i < len; i++) { + cbs[i].apply(null, args) + } + } finally { + if (cbs.length > len) { + // added more in the interim. + // de-zalgo, just in case, but don't call again. + cbs.splice(0, len) + process.nextTick(function () { + RES.apply(null, args) + }) + } else { + delete reqs[key] + } + } + }) +} + +function slice (args) { + var length = args.length + var array = [] + + for (var i = 0; i < length; i++) array[i] = args[i] + return array +} + +}).call(this,require('_process')) +},{"_process":16,"once":713,"wrappy":1182}],638:[function(require,module,exports){ +arguments[4][10][0].apply(exports,arguments) +},{"dup":10}],639:[function(require,module,exports){ +'use strict'; + +module.exports = function isArrayish(obj) { + if (!obj) { + return false; + } + + return obj instanceof Array || Array.isArray(obj) || + (obj.length >= 0 && obj.splice instanceof Function); +}; + +},{}],640:[function(require,module,exports){ +arguments[4][11][0].apply(exports,arguments) +},{"dup":11}],641:[function(require,module,exports){ +/*! + * is-directory + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +var fs = require('fs'); + +/** + * async + */ + +function isDirectory(filepath, cb) { + if (typeof cb !== 'function') { + throw new Error('expected a callback function'); + } + + if (typeof filepath !== 'string') { + cb(new Error('expected filepath to be a string')); + return; + } + + fs.stat(filepath, function(err, stats) { + if (err) { + if (err.code === 'ENOENT') { + cb(null, false); + return; + } + cb(err); + return; + } + cb(null, stats.isDirectory()); + }); +} + +/** + * sync + */ + +isDirectory.sync = function isDirectorySync(filepath) { + if (typeof filepath !== 'string') { + throw new Error('expected filepath to be a string'); + } + + try { + var stat = fs.statSync(filepath); + return stat.isDirectory(); + } catch (err) { + if (err.code === 'ENOENT') { + return false; + } else { + throw err; + } + } + return false; +}; + +/** + * Expose `isDirectory` + */ + +module.exports = isDirectory; + +},{"fs":1}],642:[function(require,module,exports){ +/*! + * is-dotfile + * + * Copyright (c) 2015-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +module.exports = function(str) { + if (str.charCodeAt(0) === 46 /* . */ && str.indexOf('/', 1) === -1) { + return true; + } + var slash = str.lastIndexOf('/'); + return slash !== -1 ? str.charCodeAt(slash + 1) === 46 /* . */ : false; +}; + +},{}],643:[function(require,module,exports){ +/*! + * is-equal-shallow + * + * Copyright (c) 2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +var isPrimitive = require('is-primitive'); + +module.exports = function isEqual(a, b) { + if (!a && !b) { return true; } + if (!a && b || a && !b) { return false; } + + var numKeysA = 0, numKeysB = 0, key; + for (key in b) { + numKeysB++; + if (!isPrimitive(b[key]) || !a.hasOwnProperty(key) || (a[key] !== b[key])) { + return false; + } + } + for (key in a) { + numKeysA++; + } + return numKeysA === numKeysB; +}; + +},{"is-primitive":653}],644:[function(require,module,exports){ +/*! + * is-extendable + * + * Copyright (c) 2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +module.exports = function isExtendable(val) { + return typeof val !== 'undefined' && val !== null + && (typeof val === 'object' || typeof val === 'function'); +}; + +},{}],645:[function(require,module,exports){ +/*! + * is-extglob + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +module.exports = function isExtglob(str) { + return typeof str === 'string' + && /[@?!+*]\(/.test(str); +}; + +},{}],646:[function(require,module,exports){ +'use strict'; +/* eslint-disable yoda */ +module.exports = x => { + if (Number.isNaN(x)) { + return false; + } + + // code points are derived from: + // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt + if ( + x >= 0x1100 && ( + x <= 0x115f || // Hangul Jamo + x === 0x2329 || // LEFT-POINTING ANGLE BRACKET + x === 0x232a || // RIGHT-POINTING ANGLE BRACKET + // CJK Radicals Supplement .. Enclosed CJK Letters and Months + (0x2e80 <= x && x <= 0x3247 && x !== 0x303f) || + // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A + (0x3250 <= x && x <= 0x4dbf) || + // CJK Unified Ideographs .. Yi Radicals + (0x4e00 <= x && x <= 0xa4c6) || + // Hangul Jamo Extended-A + (0xa960 <= x && x <= 0xa97c) || + // Hangul Syllables + (0xac00 <= x && x <= 0xd7a3) || + // CJK Compatibility Ideographs + (0xf900 <= x && x <= 0xfaff) || + // Vertical Forms + (0xfe10 <= x && x <= 0xfe19) || + // CJK Compatibility Forms .. Small Form Variants + (0xfe30 <= x && x <= 0xfe6b) || + // Halfwidth and Fullwidth Forms + (0xff01 <= x && x <= 0xff60) || + (0xffe0 <= x && x <= 0xffe6) || + // Kana Supplement + (0x1b000 <= x && x <= 0x1b001) || + // Enclosed Ideographic Supplement + (0x1f200 <= x && x <= 0x1f251) || + // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane + (0x20000 <= x && x <= 0x3fffd) + ) + ) { + return true; + } + + return false; +}; + +},{}],647:[function(require,module,exports){ +/*! + * is-glob + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +var isExtglob = require('is-extglob'); + +module.exports = function isGlob(str) { + return typeof str === 'string' + && (/[*!?{}(|)[\]]/.test(str) + || isExtglob(str)); +}; +},{"is-extglob":645}],648:[function(require,module,exports){ +/*! + * is-number + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +var typeOf = require('kind-of'); + +module.exports = function isNumber(num) { + var type = typeOf(num); + if (type !== 'number' && type !== 'string') { + return false; + } + var n = +num; + return (n - n + 1) >= 0 && num !== ''; +}; + +},{"kind-of":689}],649:[function(require,module,exports){ +(function (process){ +'use strict'; +var path = require('path'); + +module.exports = function (str) { + return path.resolve(str) === path.resolve(process.cwd()); +}; + +}).call(this,require('_process')) +},{"_process":16,"path":14}],650:[function(require,module,exports){ +(function (process){ +'use strict'; +var isPathInside = require('is-path-inside'); + +module.exports = function (str) { + return isPathInside(str, process.cwd()); +}; + +}).call(this,require('_process')) +},{"_process":16,"is-path-inside":651}],651:[function(require,module,exports){ +'use strict'; +var path = require('path'); +var pathIsInside = require('path-is-inside'); + +module.exports = function (a, b) { + a = path.resolve(a); + b = path.resolve(b); + + if (a === b) { + return false; + } + + return pathIsInside(a, b); +}; + +},{"path":14,"path-is-inside":720}],652:[function(require,module,exports){ +/*! + * is-posix-bracket + * + * Copyright (c) 2015-2016, Jon Schlinkert. + * Licensed under the MIT License. + */ + +module.exports = function isPosixBracket(str) { + return typeof str === 'string' && /\[([:.=+])(?:[^\[\]]|)+\1\]/.test(str); +}; + +},{}],653:[function(require,module,exports){ +/*! + * is-primitive + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +// see http://jsperf.com/testing-value-is-primitive/7 +module.exports = function isPrimitive(value) { + return value == null || (typeof value !== 'function' && typeof value !== 'object'); +}; + +},{}],654:[function(require,module,exports){ +'use strict'; +module.exports = function (re) { + return Object.prototype.toString.call(re) === '[object RegExp]'; +}; + +},{}],655:[function(require,module,exports){ +'use strict'; +module.exports = function (flag) { + var supported = true; + + try { + new RegExp('', flag); + } catch (err) { + supported = false; + } + + return supported; +}; + +},{}],656:[function(require,module,exports){ +arguments[4][12][0].apply(exports,arguments) +},{"dup":12}],657:[function(require,module,exports){ +/*! + * isobject + * + * Copyright (c) 2014-2015, Jon Schlinkert. + * Licensed under the MIT License. + */ + +'use strict'; + +var isArray = require('isarray'); + +module.exports = function isObject(val) { + return val != null && typeof val === 'object' && isArray(val) === false; +}; + +},{"isarray":656}],658:[function(require,module,exports){ +/* + * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $ + * + * Licensed under the MIT license. + * http://opensource.org/licenses/mit-license + * + * References: + * http://en.wikipedia.org/wiki/Base64 + */ + +(function(global) { + 'use strict'; + // existing version for noConflict() + var _Base64 = global.Base64; + var version = "2.1.9"; + // if node.js, we use Buffer + var buffer; + if (typeof module !== 'undefined' && module.exports) { + try { + buffer = require('buffer').Buffer; + } catch (err) {} + } + // constants + var b64chars + = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + var b64tab = function(bin) { + var t = {}; + for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i; + return t; + }(b64chars); + var fromCharCode = String.fromCharCode; + // encoder stuff + var cb_utob = function(c) { + if (c.length < 2) { + var cc = c.charCodeAt(0); + return cc < 0x80 ? c + : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6)) + + fromCharCode(0x80 | (cc & 0x3f))) + : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) + + fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) + + fromCharCode(0x80 | ( cc & 0x3f))); + } else { + var cc = 0x10000 + + (c.charCodeAt(0) - 0xD800) * 0x400 + + (c.charCodeAt(1) - 0xDC00); + return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07)) + + fromCharCode(0x80 | ((cc >>> 12) & 0x3f)) + + fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) + + fromCharCode(0x80 | ( cc & 0x3f))); + } + }; + var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g; + var utob = function(u) { + return u.replace(re_utob, cb_utob); + }; + var cb_encode = function(ccc) { + var padlen = [0, 2, 1][ccc.length % 3], + ord = ccc.charCodeAt(0) << 16 + | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8) + | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)), + chars = [ + b64chars.charAt( ord >>> 18), + b64chars.charAt((ord >>> 12) & 63), + padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63), + padlen >= 1 ? '=' : b64chars.charAt(ord & 63) + ]; + return chars.join(''); + }; + var btoa = global.btoa ? function(b) { + return global.btoa(b); + } : function(b) { + return b.replace(/[\s\S]{1,3}/g, cb_encode); + }; + var _encode = buffer ? function (u) { + return (u.constructor === buffer.constructor ? u : new buffer(u)) + .toString('base64') + } + : function (u) { return btoa(utob(u)) } + ; + var encode = function(u, urisafe) { + return !urisafe + ? _encode(String(u)) + : _encode(String(u)).replace(/[+\/]/g, function(m0) { + return m0 == '+' ? '-' : '_'; + }).replace(/=/g, ''); + }; + var encodeURI = function(u) { return encode(u, true) }; + // decoder stuff + var re_btou = new RegExp([ + '[\xC0-\xDF][\x80-\xBF]', + '[\xE0-\xEF][\x80-\xBF]{2}', + '[\xF0-\xF7][\x80-\xBF]{3}' + ].join('|'), 'g'); + var cb_btou = function(cccc) { + switch(cccc.length) { + case 4: + var cp = ((0x07 & cccc.charCodeAt(0)) << 18) + | ((0x3f & cccc.charCodeAt(1)) << 12) + | ((0x3f & cccc.charCodeAt(2)) << 6) + | (0x3f & cccc.charCodeAt(3)), + offset = cp - 0x10000; + return (fromCharCode((offset >>> 10) + 0xD800) + + fromCharCode((offset & 0x3FF) + 0xDC00)); + case 3: + return fromCharCode( + ((0x0f & cccc.charCodeAt(0)) << 12) + | ((0x3f & cccc.charCodeAt(1)) << 6) + | (0x3f & cccc.charCodeAt(2)) + ); + default: + return fromCharCode( + ((0x1f & cccc.charCodeAt(0)) << 6) + | (0x3f & cccc.charCodeAt(1)) + ); + } + }; + var btou = function(b) { + return b.replace(re_btou, cb_btou); + }; + var cb_decode = function(cccc) { + var len = cccc.length, + padlen = len % 4, + n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0) + | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0) + | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0) + | (len > 3 ? b64tab[cccc.charAt(3)] : 0), + chars = [ + fromCharCode( n >>> 16), + fromCharCode((n >>> 8) & 0xff), + fromCharCode( n & 0xff) + ]; + chars.length -= [0, 0, 2, 1][padlen]; + return chars.join(''); + }; + var atob = global.atob ? function(a) { + return global.atob(a); + } : function(a){ + return a.replace(/[\s\S]{1,4}/g, cb_decode); + }; + var _decode = buffer ? function(a) { + return (a.constructor === buffer.constructor + ? a : new buffer(a, 'base64')).toString(); + } + : function(a) { return btou(atob(a)) }; + var decode = function(a){ + return _decode( + String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' }) + .replace(/[^A-Za-z0-9\+\/]/g, '') + ); + }; + var noConflict = function() { + var Base64 = global.Base64; + global.Base64 = _Base64; + return Base64; + }; + // export Base64 + global.Base64 = { + VERSION: version, + atob: atob, + btoa: btoa, + fromBase64: decode, + toBase64: encode, + utob: utob, + encode: encode, + encodeURI: encodeURI, + btou: btou, + decode: decode, + noConflict: noConflict + }; + // if ES5 is available, make Base64.extendString() available + if (typeof Object.defineProperty === 'function') { + var noEnum = function(v){ + return {value:v,enumerable:false,writable:true,configurable:true}; + }; + global.Base64.extendString = function () { + Object.defineProperty( + String.prototype, 'fromBase64', noEnum(function () { + return decode(this) + })); + Object.defineProperty( + String.prototype, 'toBase64', noEnum(function (urisafe) { + return encode(this, urisafe) + })); + Object.defineProperty( + String.prototype, 'toBase64URI', noEnum(function () { + return encode(this, true) + })); + }; + } + // that's it! + if (global['Meteor']) { + Base64 = global.Base64; // for normal export in Meteor.js + } +})(this); + +},{"buffer":5}],659:[function(require,module,exports){ +'use strict'; + + +var yaml = require('./lib/js-yaml.js'); + + +module.exports = yaml; + +},{"./lib/js-yaml.js":660}],660:[function(require,module,exports){ +'use strict'; + + +var loader = require('./js-yaml/loader'); +var dumper = require('./js-yaml/dumper'); + + +function deprecated(name) { + return function () { + throw new Error('Function ' + name + ' is deprecated and cannot be used.'); + }; +} + + +module.exports.Type = require('./js-yaml/type'); +module.exports.Schema = require('./js-yaml/schema'); +module.exports.FAILSAFE_SCHEMA = require('./js-yaml/schema/failsafe'); +module.exports.JSON_SCHEMA = require('./js-yaml/schema/json'); +module.exports.CORE_SCHEMA = require('./js-yaml/schema/core'); +module.exports.DEFAULT_SAFE_SCHEMA = require('./js-yaml/schema/default_safe'); +module.exports.DEFAULT_FULL_SCHEMA = require('./js-yaml/schema/default_full'); +module.exports.load = loader.load; +module.exports.loadAll = loader.loadAll; +module.exports.safeLoad = loader.safeLoad; +module.exports.safeLoadAll = loader.safeLoadAll; +module.exports.dump = dumper.dump; +module.exports.safeDump = dumper.safeDump; +module.exports.YAMLException = require('./js-yaml/exception'); + +// Deprecated schema names from JS-YAML 2.0.x +module.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/failsafe'); +module.exports.SAFE_SCHEMA = require('./js-yaml/schema/default_safe'); +module.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default_full'); + +// Deprecated functions from JS-YAML 1.x.x +module.exports.scan = deprecated('scan'); +module.exports.parse = deprecated('parse'); +module.exports.compose = deprecated('compose'); +module.exports.addConstructor = deprecated('addConstructor'); + +},{"./js-yaml/dumper":662,"./js-yaml/exception":663,"./js-yaml/loader":664,"./js-yaml/schema":666,"./js-yaml/schema/core":667,"./js-yaml/schema/default_full":668,"./js-yaml/schema/default_safe":669,"./js-yaml/schema/failsafe":670,"./js-yaml/schema/json":671,"./js-yaml/type":672}],661:[function(require,module,exports){ +'use strict'; + + +function isNothing(subject) { + return (typeof subject === 'undefined') || (subject === null); +} + + +function isObject(subject) { + return (typeof subject === 'object') && (subject !== null); +} + + +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + + return [ sequence ]; +} + + +function extend(target, source) { + var index, length, key, sourceKeys; + + if (source) { + sourceKeys = Object.keys(source); + + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + + return target; +} + + +function repeat(string, count) { + var result = '', cycle; + + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + + return result; +} + + +function isNegativeZero(number) { + return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); +} + + +module.exports.isNothing = isNothing; +module.exports.isObject = isObject; +module.exports.toArray = toArray; +module.exports.repeat = repeat; +module.exports.isNegativeZero = isNegativeZero; +module.exports.extend = extend; + +},{}],662:[function(require,module,exports){ +'use strict'; + +/*eslint-disable no-use-before-define*/ + +var common = require('./common'); +var YAMLException = require('./exception'); +var DEFAULT_FULL_SCHEMA = require('./schema/default_full'); +var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe'); + +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +var CHAR_TAB = 0x09; /* Tab */ +var CHAR_LINE_FEED = 0x0A; /* LF */ +var CHAR_SPACE = 0x20; /* Space */ +var CHAR_EXCLAMATION = 0x21; /* ! */ +var CHAR_DOUBLE_QUOTE = 0x22; /* " */ +var CHAR_SHARP = 0x23; /* # */ +var CHAR_PERCENT = 0x25; /* % */ +var CHAR_AMPERSAND = 0x26; /* & */ +var CHAR_SINGLE_QUOTE = 0x27; /* ' */ +var CHAR_ASTERISK = 0x2A; /* * */ +var CHAR_COMMA = 0x2C; /* , */ +var CHAR_MINUS = 0x2D; /* - */ +var CHAR_COLON = 0x3A; /* : */ +var CHAR_GREATER_THAN = 0x3E; /* > */ +var CHAR_QUESTION = 0x3F; /* ? */ +var CHAR_COMMERCIAL_AT = 0x40; /* @ */ +var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ +var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ +var CHAR_GRAVE_ACCENT = 0x60; /* ` */ +var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ +var CHAR_VERTICAL_LINE = 0x7C; /* | */ +var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ + +var ESCAPE_SEQUENCES = {}; + +ESCAPE_SEQUENCES[0x00] = '\\0'; +ESCAPE_SEQUENCES[0x07] = '\\a'; +ESCAPE_SEQUENCES[0x08] = '\\b'; +ESCAPE_SEQUENCES[0x09] = '\\t'; +ESCAPE_SEQUENCES[0x0A] = '\\n'; +ESCAPE_SEQUENCES[0x0B] = '\\v'; +ESCAPE_SEQUENCES[0x0C] = '\\f'; +ESCAPE_SEQUENCES[0x0D] = '\\r'; +ESCAPE_SEQUENCES[0x1B] = '\\e'; +ESCAPE_SEQUENCES[0x22] = '\\"'; +ESCAPE_SEQUENCES[0x5C] = '\\\\'; +ESCAPE_SEQUENCES[0x85] = '\\N'; +ESCAPE_SEQUENCES[0xA0] = '\\_'; +ESCAPE_SEQUENCES[0x2028] = '\\L'; +ESCAPE_SEQUENCES[0x2029] = '\\P'; + +var DEPRECATED_BOOLEANS_SYNTAX = [ + 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', + 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' +]; + +function compileStyleMap(schema, map) { + var result, keys, index, length, tag, style, type; + + if (map === null) return {}; + + result = {}; + keys = Object.keys(map); + + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map[tag]); + + if (tag.slice(0, 2) === '!!') { + tag = 'tag:yaml.org,2002:' + tag.slice(2); + } + type = schema.compiledTypeMap['fallback'][tag]; + + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } + + result[tag] = style; + } + + return result; +} + +function encodeHex(character) { + var string, handle, length; + + string = character.toString(16).toUpperCase(); + + if (character <= 0xFF) { + handle = 'x'; + length = 2; + } else if (character <= 0xFFFF) { + handle = 'u'; + length = 4; + } else if (character <= 0xFFFFFFFF) { + handle = 'U'; + length = 8; + } else { + throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); + } + + return '\\' + handle + common.repeat('0', length - string.length) + string; +} + +function State(options) { + this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; + this.indent = Math.max(1, (options['indent'] || 2)); + this.skipInvalid = options['skipInvalid'] || false; + this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); + this.styleMap = compileStyleMap(this.schema, options['styles'] || null); + this.sortKeys = options['sortKeys'] || false; + this.lineWidth = options['lineWidth'] || 80; + this.noRefs = options['noRefs'] || false; + this.noCompatMode = options['noCompatMode'] || false; + this.condenseFlow = options['condenseFlow'] || false; + + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + + this.tag = null; + this.result = ''; + + this.duplicates = []; + this.usedDuplicates = null; +} + +// Indents every line in a string. Empty lines (\n only) are not indented. +function indentString(string, spaces) { + var ind = common.repeat(' ', spaces), + position = 0, + next = -1, + result = '', + line, + length = string.length; + + while (position < length) { + next = string.indexOf('\n', position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + + if (line.length && line !== '\n') result += ind; + + result += line; + } + + return result; +} + +function generateNextLine(state, level) { + return '\n' + common.repeat(' ', state.indent * level); +} + +function testImplicitResolving(state, str) { + var index, length, type; + + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; + + if (type.resolve(str)) { + return true; + } + } + + return false; +} + +// [33] s-white ::= s-space | s-tab +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} + +// Returns true if the character can be printed without escaping. +// From YAML 1.2: "any allowed characters known to be non-printable +// should also be escaped. [However,] This isn’t mandatory" +// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. +function isPrintable(c) { + return (0x00020 <= c && c <= 0x00007E) + || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) + || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */) + || (0x10000 <= c && c <= 0x10FFFF); +} + +// Simplified test for values allowed after the first character in plain style. +function isPlainSafe(c) { + // Uses a subset of nb-char - c-flow-indicator - ":" - "#" + // where nb-char ::= c-printable - b-char - c-byte-order-mark. + return isPrintable(c) && c !== 0xFEFF + // - c-flow-indicator + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // - ":" - "#" + && c !== CHAR_COLON + && c !== CHAR_SHARP; +} + +// Simplified test for values allowed as the first character in plain style. +function isPlainSafeFirst(c) { + // Uses a subset of ns-char - c-indicator + // where ns-char = nb-char - s-white. + return isPrintable(c) && c !== 0xFEFF + && !isWhitespace(c) // - s-white + // - (c-indicator ::= + // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” + && c !== CHAR_MINUS + && c !== CHAR_QUESTION + && c !== CHAR_COLON + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // | “#” | “&” | “*” | “!” | “|” | “>” | “'” | “"” + && c !== CHAR_SHARP + && c !== CHAR_AMPERSAND + && c !== CHAR_ASTERISK + && c !== CHAR_EXCLAMATION + && c !== CHAR_VERTICAL_LINE + && c !== CHAR_GREATER_THAN + && c !== CHAR_SINGLE_QUOTE + && c !== CHAR_DOUBLE_QUOTE + // | “%” | “@” | “`”) + && c !== CHAR_PERCENT + && c !== CHAR_COMMERCIAL_AT + && c !== CHAR_GRAVE_ACCENT; +} + +var STYLE_PLAIN = 1, + STYLE_SINGLE = 2, + STYLE_LITERAL = 3, + STYLE_FOLDED = 4, + STYLE_DOUBLE = 5; + +// Determines which scalar styles are possible and returns the preferred style. +// lineWidth = -1 => no limit. +// Pre-conditions: str.length > 0. +// Post-conditions: +// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. +// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). +// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) { + var i; + var char; + var hasLineBreak = false; + var hasFoldableLine = false; // only checked if shouldTrackWidth + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; // count the first line correctly + var plain = isPlainSafeFirst(string.charCodeAt(0)) + && !isWhitespace(string.charCodeAt(string.length - 1)); + + if (singleLineOnly) { + // Case: no block styles. + // Check for disallowed characters to rule out plain and single. + for (i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char); + } + } else { + // Case: block styles permitted. + for (i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + // Check if any line can be folded. + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || + // Foldable line = too long, and not more-indented. + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' '); + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char); + } + // in case the end is missing a \n + hasFoldableLine = hasFoldableLine || (shouldTrackWidth && + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' ')); + } + // Although every style can represent \n without escaping, prefer block styles + // for multiline, since they're more readable and they don't add empty lines. + // Also prefer folding a super-long line. + if (!hasLineBreak && !hasFoldableLine) { + // Strings interpretable as another type have to be quoted; + // e.g. the string 'true' vs. the boolean true. + return plain && !testAmbiguousType(string) + ? STYLE_PLAIN : STYLE_SINGLE; + } + // Edge case: block indentation indicator can only have one digit. + if (string[0] === ' ' && indentPerLevel > 9) { + return STYLE_DOUBLE; + } + // At this point we know block styles are valid. + // Prefer literal style unless we want to fold. + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; +} + +// Note: line breaking/folding is implemented for only the folded style. +// NB. We drop the last trailing newline (if any) of a returned block scalar +// since the dumper adds its own newline. This always works: +// • No ending newline => unaffected; already using strip "-" chomping. +// • Ending newline => removed then restored. +// Importantly, this keeps the "+" chomp indicator from gaining an extra line. +function writeScalar(state, string, level, iskey) { + state.dump = (function () { + if (string.length === 0) { + return "''"; + } + if (!state.noCompatMode && + DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) { + return "'" + string + "'"; + } + + var indent = state.indent * Math.max(1, level); // no 0-indent scalars + // As indentation gets deeper, let the width decrease monotonically + // to the lower bound min(state.lineWidth, 40). + // Note that this implies + // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. + // state.lineWidth > 40 + state.indent: width decreases until the lower bound. + // This behaves better than a constant minimum width which disallows narrower options, + // or an indent threshold which causes the width to suddenly increase. + var lineWidth = state.lineWidth === -1 + ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + + // Without knowing if keys are implicit/explicit, assume implicit for safety. + var singleLineOnly = iskey + // No block styles in flow mode. + || (state.flowLevel > -1 && level >= state.flowLevel); + function testAmbiguity(string) { + return testImplicitResolving(state, string); + } + + switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) { + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return '|' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return '>' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string, lineWidth) + '"'; + default: + throw new YAMLException('impossible error: invalid scalar style'); + } + }()); +} + +// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. +function blockHeader(string, indentPerLevel) { + var indentIndicator = (string[0] === ' ') ? String(indentPerLevel) : ''; + + // note the special case: the string '\n' counts as a "trailing" empty line. + var clip = string[string.length - 1] === '\n'; + var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); + var chomp = keep ? '+' : (clip ? '' : '-'); + + return indentIndicator + chomp + '\n'; +} + +// (See the note for writeScalar.) +function dropEndingNewline(string) { + return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +} + +// Note: a long line without a suitable break point will exceed the width limit. +// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. +function foldString(string, width) { + // In folded style, $k$ consecutive newlines output as $k+1$ newlines— + // unless they're before or after a more-indented line, or at the very + // beginning or end, in which case $k$ maps to $k$. + // Therefore, parse each chunk as newline(s) followed by a content line. + var lineRe = /(\n+)([^\n]*)/g; + + // first line (possibly an empty line) + var result = (function () { + var nextLF = string.indexOf('\n'); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }()); + // If we haven't reached the first content line yet, don't add an extra \n. + var prevMoreIndented = string[0] === '\n' || string[0] === ' '; + var moreIndented; + + // rest of the lines + var match; + while ((match = lineRe.exec(string))) { + var prefix = match[1], line = match[2]; + moreIndented = (line[0] === ' '); + result += prefix + + (!prevMoreIndented && !moreIndented && line !== '' + ? '\n' : '') + + foldLine(line, width); + prevMoreIndented = moreIndented; + } + + return result; +} + +// Greedy line breaking. +// Picks the longest line under the limit each time, +// otherwise settles for the shortest line over the limit. +// NB. More-indented lines *cannot* be folded, as that would add an extra \n. +function foldLine(line, width) { + if (line === '' || line[0] === ' ') return line; + + // Since a more-indented line adds a \n, breaks can't be followed by a space. + var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. + var match; + // start is an inclusive index. end, curr, and next are exclusive. + var start = 0, end, curr = 0, next = 0; + var result = ''; + + // Invariants: 0 <= start <= length-1. + // 0 <= curr <= next <= max(0, length-2). curr - start <= width. + // Inside the loop: + // A match implies length >= 2, so curr and next are <= length-2. + while ((match = breakRe.exec(line))) { + next = match.index; + // maintain invariant: curr - start <= width + if (next - start > width) { + end = (curr > start) ? curr : next; // derive end <= length-2 + result += '\n' + line.slice(start, end); + // skip the space that was output as \n + start = end + 1; // derive start <= length-1 + } + curr = next; + } + + // By the invariants, start <= length-1, so there is something left over. + // It is either the whole string or a part starting from non-whitespace. + result += '\n'; + // Insert a break if the remainder is too long and there is a break available. + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + '\n' + line.slice(curr + 1); + } else { + result += line.slice(start); + } + + return result.slice(1); // drop extra \n joiner +} + +// Escapes a double-quoted string. +function escapeString(string) { + var result = ''; + var char; + var escapeSeq; + + for (var i = 0; i < string.length; i++) { + char = string.charCodeAt(i); + escapeSeq = ESCAPE_SEQUENCES[char]; + result += !escapeSeq && isPrintable(char) + ? string[i] + : escapeSeq || encodeHex(char); + } + + return result; +} + +function writeFlowSequence(state, level, object) { + var _result = '', + _tag = state.tag, + index, + length; + + for (index = 0, length = object.length; index < length; index += 1) { + // Write only valid elements. + if (writeNode(state, level, object[index], false, false)) { + if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : ''); + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = '[' + _result + ']'; +} + +function writeBlockSequence(state, level, object, compact) { + var _result = '', + _tag = state.tag, + index, + length; + + for (index = 0, length = object.length; index < length; index += 1) { + // Write only valid elements. + if (writeNode(state, level + 1, object[index], true, true)) { + if (!compact || index !== 0) { + _result += generateNextLine(state, level); + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += '-'; + } else { + _result += '- '; + } + + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = _result || '[]'; // Empty sequence if no valid values. +} + +function writeFlowMapping(state, level, object) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + pairBuffer; + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; + + if (index !== 0) pairBuffer += ', '; + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (!writeNode(state, level, objectKey, false, false)) { + continue; // Skip this pair because of invalid key; + } + + if (state.dump.length > 1024) pairBuffer += '? '; + + pairBuffer += state.dump + ':' + (state.condenseFlow ? '' : ' '); + + if (!writeNode(state, level, objectValue, false, false)) { + continue; // Skip this pair because of invalid value. + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = '{' + _result + '}'; +} + +function writeBlockMapping(state, level, object, compact) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + explicitPair, + pairBuffer; + + // Allow sorting keys so that the output file is deterministic + if (state.sortKeys === true) { + // Default sorting + objectKeyList.sort(); + } else if (typeof state.sortKeys === 'function') { + // Custom sort function + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + // Something is wrong + throw new YAMLException('sortKeys must be a boolean or a function'); + } + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; + + if (!compact || index !== 0) { + pairBuffer += generateNextLine(state, level); + } + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; // Skip this pair because of invalid key. + } + + explicitPair = (state.tag !== null && state.tag !== '?') || + (state.dump && state.dump.length > 1024); + + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += '?'; + } else { + pairBuffer += '? '; + } + } + + pairBuffer += state.dump; + + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; // Skip this pair because of invalid value. + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ':'; + } else { + pairBuffer += ': '; + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = _result || '{}'; // Empty mapping if no valid pairs. +} + +function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + + typeList = explicit ? state.explicitTypes : state.implicitTypes; + + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + + if ((type.instanceOf || type.predicate) && + (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && + (!type.predicate || type.predicate(object))) { + + state.tag = explicit ? type.tag : '?'; + + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + + if (_toString.call(type.represent) === '[object Function]') { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); + } + + state.dump = _result; + } + + return true; + } + } + + return false; +} + +// Serializes `object` and writes it to global `result`. +// Returns true on success, or false on invalid object. +// +function writeNode(state, level, object, block, compact, iskey) { + state.tag = null; + state.dump = object; + + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + + var type = _toString.call(state.dump); + + if (block) { + block = (state.flowLevel < 0 || state.flowLevel > level); + } + + var objectOrArray = type === '[object Object]' || type === '[object Array]', + duplicateIndex, + duplicate; + + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + + if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { + compact = false; + } + + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = '*ref_' + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === '[object Object]') { + if (block && (Object.keys(state.dump).length !== 0)) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object Array]') { + if (block && (state.dump.length !== 0)) { + writeBlockSequence(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object String]') { + if (state.tag !== '?') { + writeScalar(state, state.dump, level, iskey); + } + } else { + if (state.skipInvalid) return false; + throw new YAMLException('unacceptable kind of an object to dump ' + type); + } + + if (state.tag !== null && state.tag !== '?') { + state.dump = '!<' + state.tag + '> ' + state.dump; + } + } + + return true; +} + +function getDuplicateReferences(object, state) { + var objects = [], + duplicatesIndexes = [], + index, + length; + + inspectNode(object, objects, duplicatesIndexes); + + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} + +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, + index, + length; + + if (object !== null && typeof object === 'object') { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } +} + +function dump(input, options) { + options = options || {}; + + var state = new State(options); + + if (!state.noRefs) getDuplicateReferences(input, state); + + if (writeNode(state, 0, input, true, true)) return state.dump + '\n'; + + return ''; +} + +function safeDump(input, options) { + return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + +module.exports.dump = dump; +module.exports.safeDump = safeDump; + +},{"./common":661,"./exception":663,"./schema/default_full":668,"./schema/default_safe":669}],663:[function(require,module,exports){ +// YAML error class. http://stackoverflow.com/questions/8458984 +// +'use strict'; + +function YAMLException(reason, mark) { + // Super constructor + Error.call(this); + + this.name = 'YAMLException'; + this.reason = reason; + this.mark = mark; + this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : ''); + + // Include stack trace in error object + if (Error.captureStackTrace) { + // Chrome and NodeJS + Error.captureStackTrace(this, this.constructor); + } else { + // FF, IE 10+ and Safari 6+. Fallback for others + this.stack = (new Error()).stack || ''; + } +} + + +// Inherit from Error +YAMLException.prototype = Object.create(Error.prototype); +YAMLException.prototype.constructor = YAMLException; + + +YAMLException.prototype.toString = function toString(compact) { + var result = this.name + ': '; + + result += this.reason || '(unknown reason)'; + + if (!compact && this.mark) { + result += ' ' + this.mark.toString(); + } + + return result; +}; + + +module.exports = YAMLException; + +},{}],664:[function(require,module,exports){ +'use strict'; + +/*eslint-disable max-len,no-use-before-define*/ + +var common = require('./common'); +var YAMLException = require('./exception'); +var Mark = require('./mark'); +var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe'); +var DEFAULT_FULL_SCHEMA = require('./schema/default_full'); + + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + + +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; + + +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; + + +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + + +function is_EOL(c) { + return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +} + +function is_WHITE_SPACE(c) { + return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +} + +function is_WS_OR_EOL(c) { + return (c === 0x09/* Tab */) || + (c === 0x20/* Space */) || + (c === 0x0A/* LF */) || + (c === 0x0D/* CR */); +} + +function is_FLOW_INDICATOR(c) { + return c === 0x2C/* , */ || + c === 0x5B/* [ */ || + c === 0x5D/* ] */ || + c === 0x7B/* { */ || + c === 0x7D/* } */; +} + +function fromHexCode(c) { + var lc; + + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + /*eslint-disable no-bitwise*/ + lc = c | 0x20; + + if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { + return lc - 0x61 + 10; + } + + return -1; +} + +function escapedHexLen(c) { + if (c === 0x78/* x */) { return 2; } + if (c === 0x75/* u */) { return 4; } + if (c === 0x55/* U */) { return 8; } + return 0; +} + +function fromDecimalCode(c) { + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + return -1; +} + +function simpleEscapeSequence(c) { + /* eslint-disable indent */ + return (c === 0x30/* 0 */) ? '\x00' : + (c === 0x61/* a */) ? '\x07' : + (c === 0x62/* b */) ? '\x08' : + (c === 0x74/* t */) ? '\x09' : + (c === 0x09/* Tab */) ? '\x09' : + (c === 0x6E/* n */) ? '\x0A' : + (c === 0x76/* v */) ? '\x0B' : + (c === 0x66/* f */) ? '\x0C' : + (c === 0x72/* r */) ? '\x0D' : + (c === 0x65/* e */) ? '\x1B' : + (c === 0x20/* Space */) ? ' ' : + (c === 0x22/* " */) ? '\x22' : + (c === 0x2F/* / */) ? '/' : + (c === 0x5C/* \ */) ? '\x5C' : + (c === 0x4E/* N */) ? '\x85' : + (c === 0x5F/* _ */) ? '\xA0' : + (c === 0x4C/* L */) ? '\u2028' : + (c === 0x50/* P */) ? '\u2029' : ''; +} + +function charFromCodepoint(c) { + if (c <= 0xFFFF) { + return String.fromCharCode(c); + } + // Encode UTF-16 surrogate pair + // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF + return String.fromCharCode( + ((c - 0x010000) >> 10) + 0xD800, + ((c - 0x010000) & 0x03FF) + 0xDC00 + ); +} + +var simpleEscapeCheck = new Array(256); // integer, for fast access +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} + + +function State(input, options) { + this.input = input; + + this.filename = options['filename'] || null; + this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; + this.onWarning = options['onWarning'] || null; + this.legacy = options['legacy'] || false; + this.json = options['json'] || false; + this.listener = options['listener'] || null; + + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + + this.documents = []; + + /* + this.version; + this.checkLineBreaks; + this.tagMap; + this.anchorMap; + this.tag; + this.anchor; + this.kind; + this.result;*/ + +} + + +function generateError(state, message) { + return new YAMLException( + message, + new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart))); +} + +function throwError(state, message) { + throw generateError(state, message); +} + +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} + + +var directiveHandlers = { + + YAML: function handleYamlDirective(state, name, args) { + + var match, major, minor; + + if (state.version !== null) { + throwError(state, 'duplication of %YAML directive'); + } + + if (args.length !== 1) { + throwError(state, 'YAML directive accepts exactly one argument'); + } + + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + + if (match === null) { + throwError(state, 'ill-formed argument of the YAML directive'); + } + + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + + if (major !== 1) { + throwError(state, 'unacceptable YAML version of the document'); + } + + state.version = args[0]; + state.checkLineBreaks = (minor < 2); + + if (minor !== 1 && minor !== 2) { + throwWarning(state, 'unsupported YAML version of the document'); + } + }, + + TAG: function handleTagDirective(state, name, args) { + + var handle, prefix; + + if (args.length !== 2) { + throwError(state, 'TAG directive accepts exactly two arguments'); + } + + handle = args[0]; + prefix = args[1]; + + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); + } + + if (_hasOwnProperty.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); + } + + state.tagMap[handle] = prefix; + } +}; + + +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + + if (start < end) { + _result = state.input.slice(start, end); + + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 0x09 || + (0x20 <= _character && _character <= 0x10FFFF))) { + throwError(state, 'expected valid JSON character'); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, 'the stream contains non-printable characters'); + } + + state.result += _result; + } +} + +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + + if (!common.isObject(source)) { + throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); + } + + sourceKeys = Object.keys(source); + + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + + if (!_hasOwnProperty.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} + +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) { + var index, quantity; + + keyNode = String(keyNode); + + if (_result === null) { + _result = {}; + } + + if (keyTag === 'tag:yaml.org,2002:merge') { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && + !_hasOwnProperty.call(overridableKeys, keyNode) && + _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.position = startPos || state.position; + throwError(state, 'duplicated mapping key'); + } + _result[keyNode] = valueNode; + delete overridableKeys[keyNode]; + } + + return _result; +} + +function readLineBreak(state) { + var ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x0A/* LF */) { + state.position++; + } else if (ch === 0x0D/* CR */) { + state.position++; + if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { + state.position++; + } + } else { + throwError(state, 'a line break is expected'); + } + + state.line += 1; + state.lineStart = state.position; +} + +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (allowComments && ch === 0x23/* # */) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); + } + + if (is_EOL(ch)) { + readLineBreak(state); + + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + + while (ch === 0x20/* Space */) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, 'deficient indentation'); + } + + return lineBreaks; +} + +function testDocumentSeparator(state) { + var _position = state.position, + ch; + + ch = state.input.charCodeAt(_position); + + // Condition state.position === state.lineStart is tested + // in parent on each call, for efficiency. No needs to test here again. + if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && + ch === state.input.charCodeAt(_position + 1) && + ch === state.input.charCodeAt(_position + 2)) { + + _position += 3; + + ch = state.input.charCodeAt(_position); + + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + + return false; +} + +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += ' '; + } else if (count > 1) { + state.result += common.repeat('\n', count - 1); + } +} + + +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, + following, + captureStart, + captureEnd, + hasPendingContent, + _line, + _lineStart, + _lineIndent, + _kind = state.kind, + _result = state.result, + ch; + + ch = state.input.charCodeAt(state.position); + + if (is_WS_OR_EOL(ch) || + is_FLOW_INDICATOR(ch) || + ch === 0x23/* # */ || + ch === 0x26/* & */ || + ch === 0x2A/* * */ || + ch === 0x21/* ! */ || + ch === 0x7C/* | */ || + ch === 0x3E/* > */ || + ch === 0x27/* ' */ || + ch === 0x22/* " */ || + ch === 0x25/* % */ || + ch === 0x40/* @ */ || + ch === 0x60/* ` */) { + return false; + } + + if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + + state.kind = 'scalar'; + state.result = ''; + captureStart = captureEnd = state.position; + hasPendingContent = false; + + while (ch !== 0) { + if (ch === 0x3A/* : */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + + } else if (ch === 0x23/* # */) { + preceding = state.input.charCodeAt(state.position - 1); + + if (is_WS_OR_EOL(preceding)) { + break; + } + + } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || + withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, captureEnd, false); + + if (state.result) { + return true; + } + + state.kind = _kind; + state.result = _result; + return false; +} + +function readSingleQuotedScalar(state, nodeIndent) { + var ch, + captureStart, captureEnd; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x27/* ' */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x27/* ' */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x27/* ' */) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a single quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a single quoted scalar'); +} + +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, + captureEnd, + hexLength, + hexResult, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x22/* " */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x22/* " */) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + + } else if (ch === 0x5C/* \ */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + + // TODO: rework to inline fn with no type cast? + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + + } else { + throwError(state, 'expected hexadecimal character'); + } + } + + state.result += charFromCodepoint(hexResult); + + state.position++; + + } else { + throwError(state, 'unknown escape sequence'); + } + + captureStart = captureEnd = state.position; + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a double quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a double quoted scalar'); +} + +function readFlowCollection(state, nodeIndent) { + var readNext = true, + _line, + _tag = state.tag, + _result, + _anchor = state.anchor, + following, + terminator, + isPair, + isExplicitPair, + isMapping, + overridableKeys = {}, + keyNode, + keyTag, + valueNode, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x5B/* [ */) { + terminator = 0x5D;/* ] */ + isMapping = false; + _result = []; + } else if (ch === 0x7B/* { */) { + terminator = 0x7D;/* } */ + isMapping = true; + _result = {}; + } else { + return false; + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(++state.position); + + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? 'mapping' : 'sequence'; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, 'missed comma between flow collection entries'); + } + + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + + if (ch === 0x3F/* ? */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode)); + } else { + _result.push(keyNode); + } + + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x2C/* , */) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + + throwError(state, 'unexpected end of the stream within a flow collection'); +} + +function readBlockScalar(state, nodeIndent) { + var captureStart, + folding, + chomping = CHOMPING_CLIP, + didReadContent = false, + detectedIndent = false, + textIndent = nodeIndent, + emptyLines = 0, + atMoreIndented = false, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x7C/* | */) { + folding = false; + } else if (ch === 0x3E/* > */) { + folding = true; + } else { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { + if (CHOMPING_CLIP === chomping) { + chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, 'repeat of a chomping mode identifier'); + } + + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, 'repeat of an indentation width identifier'); + } + + } else { + break; + } + } + + if (is_WHITE_SPACE(ch)) { + do { ch = state.input.charCodeAt(++state.position); } + while (is_WHITE_SPACE(ch)); + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (!is_EOL(ch) && (ch !== 0)); + } + } + + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + + ch = state.input.charCodeAt(state.position); + + while ((!detectedIndent || state.lineIndent < textIndent) && + (ch === 0x20/* Space */)) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + + if (is_EOL(ch)) { + emptyLines++; + continue; + } + + // End of the scalar. + if (state.lineIndent < textIndent) { + + // Perform the chomping. + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { // i.e. only if the scalar is not empty. + state.result += '\n'; + } + } + + // Break this `while` cycle and go to the funciton's epilogue. + break; + } + + // Folded style: use fancy rules to handle line breaks. + if (folding) { + + // Lines starting with white space characters (more-indented lines) are not folded. + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + // except for the first content line (cf. Example 8.1) + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + + // End of more-indented block. + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat('\n', emptyLines + 1); + + // Just one line break - perceive as the same line. + } else if (emptyLines === 0) { + if (didReadContent) { // i.e. only if we have already read some scalar content. + state.result += ' '; + } + + // Several line breaks - perceive as different lines. + } else { + state.result += common.repeat('\n', emptyLines); + } + + // Literal style: just add exact number of line breaks between content lines. + } else { + // Keep all line breaks except the header line break. + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } + + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + + while (!is_EOL(ch) && (ch !== 0)) { + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, state.position, false); + } + + return true; +} + +function readBlockSequence(state, nodeIndent) { + var _line, + _tag = state.tag, + _anchor = state.anchor, + _result = [], + following, + detected = false, + ch; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + + if (ch !== 0x2D/* - */) { + break; + } + + following = state.input.charCodeAt(state.position + 1); + + if (!is_WS_OR_EOL(following)) { + break; + } + + detected = true; + state.position++; + + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a sequence entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'sequence'; + state.result = _result; + return true; + } + return false; +} + +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, + allowCompact, + _line, + _pos, + _tag = state.tag, + _anchor = state.anchor, + _result = {}, + overridableKeys = {}, + keyTag = null, + keyNode = null, + valueNode = null, + atExplicitKey = false, + detected = false, + ch; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + following = state.input.charCodeAt(state.position + 1); + _line = state.line; // Save the current line. + _pos = state.position; + + // + // Explicit notation case. There are two separate blocks: + // first for the key (denoted by "?") and second for the value (denoted by ":") + // + if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { + + if (ch === 0x3F/* ? */) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = true; + allowCompact = true; + + } else if (atExplicitKey) { + // i.e. 0x3A/* : */ === character after the explicit key. + atExplicitKey = false; + allowCompact = true; + + } else { + throwError(state, 'incomplete explicit mapping pair; a key node is missed'); + } + + state.position += 1; + ch = following; + + // + // Implicit notation case. Flow-style node as the key first, then ":", and the value. + // + } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x3A/* : */) { + ch = state.input.charCodeAt(++state.position); + + if (!is_WS_OR_EOL(ch)) { + throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); + } + + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + + } else if (detected) { + throwError(state, 'can not read an implicit mapping pair; a colon is missed'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else if (detected) { + throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else { + break; // Reading is done. Go to the epilogue. + } + + // + // Common reading code for both explicit and implicit notations. + // + if (state.line === _line || state.lineIndent > nodeIndent) { + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos); + keyTag = keyNode = valueNode = null; + } + + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + + if (state.lineIndent > nodeIndent && (ch !== 0)) { + throwError(state, 'bad indentation of a mapping entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + // + // Epilogue. + // + + // Special case: last mapping's node contains only the key in explicit notation. + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); + } + + // Expose the resulting mapping. + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'mapping'; + state.result = _result; + } + + return detected; +} + +function readTagProperty(state) { + var _position, + isVerbatim = false, + isNamed = false, + tagHandle, + tagName, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x21/* ! */) return false; + + if (state.tag !== null) { + throwError(state, 'duplication of a tag property'); + } + + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x3C/* < */) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + + } else if (ch === 0x21/* ! */) { + isNamed = true; + tagHandle = '!!'; + ch = state.input.charCodeAt(++state.position); + + } else { + tagHandle = '!'; + } + + _position = state.position; + + if (isVerbatim) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && ch !== 0x3E/* > */); + + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, 'unexpected end of the stream within a verbatim tag'); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + + if (ch === 0x21/* ! */) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, 'named tag handle cannot contain such characters'); + } + + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, 'tag suffix cannot contain exclamation marks'); + } + } + + ch = state.input.charCodeAt(++state.position); + } + + tagName = state.input.slice(_position, state.position); + + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, 'tag suffix cannot contain flow indicator characters'); + } + } + + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, 'tag name cannot contain such characters: ' + tagName); + } + + if (isVerbatim) { + state.tag = tagName; + + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + + } else if (tagHandle === '!') { + state.tag = '!' + tagName; + + } else if (tagHandle === '!!') { + state.tag = 'tag:yaml.org,2002:' + tagName; + + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + + return true; +} + +function readAnchorProperty(state) { + var _position, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x26/* & */) return false; + + if (state.anchor !== null) { + throwError(state, 'duplication of an anchor property'); + } + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an anchor node must contain at least one character'); + } + + state.anchor = state.input.slice(_position, state.position); + return true; +} + +function readAlias(state) { + var _position, alias, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x2A/* * */) return false; + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an alias node must contain at least one character'); + } + + alias = state.input.slice(_position, state.position); + + if (!state.anchorMap.hasOwnProperty(alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} + +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, + allowBlockScalars, + allowBlockCollections, + indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + + blockIndent = state.position - state.lineStart; + + if (indentStatus === 1) { + if (allowBlockCollections && + (readBlockSequence(state, blockIndent) || + readBlockMapping(state, blockIndent, flowIndent)) || + readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || + readSingleQuotedScalar(state, flowIndent) || + readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + + } else if (readAlias(state)) { + hasContent = true; + + if (state.tag !== null || state.anchor !== null) { + throwError(state, 'alias node should not have any properties'); + } + + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + + if (state.tag === null) { + state.tag = '?'; + } + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + // Special case: block sequences are allowed to have same indentation level as the parent. + // http://www.yaml.org/spec/1.2/spec.html#id2799784 + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + + if (state.tag !== null && state.tag !== '!') { + if (state.tag === '?') { + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; + + // Implicit resolving is not allowed for non-scalar types, and '?' + // non-specific tag is only assigned to plain scalars. So, it isn't + // needed to check for 'kind' conformity. + + if (type.resolve(state.result)) { // `state.result` updated in resolver if matched + state.result = type.construct(state.result); + state.tag = type.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { + type = state.typeMap[state.kind || 'fallback'][state.tag]; + + if (state.result !== null && type.kind !== state.kind) { + throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); + } + + if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched + throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); + } else { + state.result = type.construct(state.result); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else { + throwError(state, 'unknown tag !<' + state.tag + '>'); + } + } + + if (state.listener !== null) { + state.listener('close', state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} + +function readDocument(state) { + var documentStart = state.position, + _position, + directiveName, + directiveArgs, + hasDirectives = false, + ch; + + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = {}; + state.anchorMap = {}; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if (state.lineIndent > 0 || ch !== 0x25/* % */) { + break; + } + + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + + if (directiveName.length < 1) { + throwError(state, 'directive name must not be less than one character in length'); + } + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && !is_EOL(ch)); + break; + } + + if (is_EOL(ch)) break; + + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveArgs.push(state.input.slice(_position, state.position)); + } + + if (ch !== 0) readLineBreak(state); + + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + + skipSeparationSpace(state, true, -1); + + if (state.lineIndent === 0 && + state.input.charCodeAt(state.position) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + + } else if (hasDirectives) { + throwError(state, 'directives end mark is expected'); + } + + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + + if (state.checkLineBreaks && + PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, 'non-ASCII line breaks are interpreted as content'); + } + + state.documents.push(state.result); + + if (state.position === state.lineStart && testDocumentSeparator(state)) { + + if (state.input.charCodeAt(state.position) === 0x2E/* . */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + + if (state.position < (state.length - 1)) { + throwError(state, 'end of the stream or a document separator is expected'); + } else { + return; + } +} + + +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + + if (input.length !== 0) { + + // Add tailing `\n` if not exists + if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && + input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { + input += '\n'; + } + + // Strip BOM + if (input.charCodeAt(0) === 0xFEFF) { + input = input.slice(1); + } + } + + var state = new State(input, options); + + // Use 0 as string terminator. That significantly simplifies bounds check. + state.input += '\0'; + + while (state.input.charCodeAt(state.position) === 0x20/* Space */) { + state.lineIndent += 1; + state.position += 1; + } + + while (state.position < (state.length - 1)) { + readDocument(state); + } + + return state.documents; +} + + +function loadAll(input, iterator, options) { + var documents = loadDocuments(input, options), index, length; + + if (typeof iterator !== 'function') { + return documents; + } + + for (index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} + + +function load(input, options) { + var documents = loadDocuments(input, options); + + if (documents.length === 0) { + /*eslint-disable no-undefined*/ + return undefined; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException('expected a single document in the stream, but found more'); +} + + +function safeLoadAll(input, output, options) { + if (typeof output === 'function') { + loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } else { + return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); + } +} + + +function safeLoad(input, options) { + return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +} + + +module.exports.loadAll = loadAll; +module.exports.load = load; +module.exports.safeLoadAll = safeLoadAll; +module.exports.safeLoad = safeLoad; + +},{"./common":661,"./exception":663,"./mark":665,"./schema/default_full":668,"./schema/default_safe":669}],665:[function(require,module,exports){ +'use strict'; + + +var common = require('./common'); + + +function Mark(name, buffer, position, line, column) { + this.name = name; + this.buffer = buffer; + this.position = position; + this.line = line; + this.column = column; +} + + +Mark.prototype.getSnippet = function getSnippet(indent, maxLength) { + var head, start, tail, end, snippet; + + if (!this.buffer) return null; + + indent = indent || 4; + maxLength = maxLength || 75; + + head = ''; + start = this.position; + + while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) { + start -= 1; + if (this.position - start > (maxLength / 2 - 1)) { + head = ' ... '; + start += 5; + break; + } + } + + tail = ''; + end = this.position; + + while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) { + end += 1; + if (end - this.position > (maxLength / 2 - 1)) { + tail = ' ... '; + end -= 5; + break; + } + } + + snippet = this.buffer.slice(start, end); + + return common.repeat(' ', indent) + head + snippet + tail + '\n' + + common.repeat(' ', indent + this.position - start + head.length) + '^'; +}; + + +Mark.prototype.toString = function toString(compact) { + var snippet, where = ''; + + if (this.name) { + where += 'in "' + this.name + '" '; + } + + where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1); + + if (!compact) { + snippet = this.getSnippet(); + + if (snippet) { + where += ':\n' + snippet; + } + } + + return where; +}; + + +module.exports = Mark; + +},{"./common":661}],666:[function(require,module,exports){ +'use strict'; + +/*eslint-disable max-len*/ + +var common = require('./common'); +var YAMLException = require('./exception'); +var Type = require('./type'); + + +function compileList(schema, name, result) { + var exclude = []; + + schema.include.forEach(function (includedSchema) { + result = compileList(includedSchema, name, result); + }); + + schema[name].forEach(function (currentType) { + result.forEach(function (previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) { + exclude.push(previousIndex); + } + }); + + result.push(currentType); + }); + + return result.filter(function (type, index) { + return exclude.indexOf(index) === -1; + }); +} + + +function compileMap(/* lists... */) { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {} + }, index, length; + + function collectType(type) { + result[type.kind][type.tag] = result['fallback'][type.tag] = type; + } + + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} + + +function Schema(definition) { + this.include = definition.include || []; + this.implicit = definition.implicit || []; + this.explicit = definition.explicit || []; + + this.implicit.forEach(function (type) { + if (type.loadKind && type.loadKind !== 'scalar') { + throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); + } + }); + + this.compiledImplicit = compileList(this, 'implicit', []); + this.compiledExplicit = compileList(this, 'explicit', []); + this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit); +} + + +Schema.DEFAULT = null; + + +Schema.create = function createSchema() { + var schemas, types; + + switch (arguments.length) { + case 1: + schemas = Schema.DEFAULT; + types = arguments[0]; + break; + + case 2: + schemas = arguments[0]; + types = arguments[1]; + break; + + default: + throw new YAMLException('Wrong number of arguments for Schema.create function'); + } + + schemas = common.toArray(schemas); + types = common.toArray(types); + + if (!schemas.every(function (schema) { return schema instanceof Schema; })) { + throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.'); + } + + if (!types.every(function (type) { return type instanceof Type; })) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + + return new Schema({ + include: schemas, + explicit: types + }); +}; + + +module.exports = Schema; + +},{"./common":661,"./exception":663,"./type":672}],667:[function(require,module,exports){ +// Standard YAML's Core schema. +// http://www.yaml.org/spec/1.2/spec.html#id2804923 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, Core schema has no distinctions from JSON schema is JS-YAML. + + +'use strict'; + + +var Schema = require('../schema'); + + +module.exports = new Schema({ + include: [ + require('./json') + ] +}); + +},{"../schema":666,"./json":671}],668:[function(require,module,exports){ +// JS-YAML's default schema for `load` function. +// It is not described in the YAML specification. +// +// This schema is based on JS-YAML's default safe schema and includes +// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function. +// +// Also this schema is used as default base schema at `Schema.create` function. + + +'use strict'; + + +var Schema = require('../schema'); + + +module.exports = Schema.DEFAULT = new Schema({ + include: [ + require('./default_safe') + ], + explicit: [ + require('../type/js/undefined'), + require('../type/js/regexp'), + require('../type/js/function') + ] +}); + +},{"../schema":666,"../type/js/function":677,"../type/js/regexp":678,"../type/js/undefined":679,"./default_safe":669}],669:[function(require,module,exports){ +// JS-YAML's default schema for `safeLoad` function. +// It is not described in the YAML specification. +// +// This schema is based on standard YAML's Core schema and includes most of +// extra types described at YAML tag repository. (http://yaml.org/type/) + + +'use strict'; + + +var Schema = require('../schema'); + + +module.exports = new Schema({ + include: [ + require('./core') + ], + implicit: [ + require('../type/timestamp'), + require('../type/merge') + ], + explicit: [ + require('../type/binary'), + require('../type/omap'), + require('../type/pairs'), + require('../type/set') + ] +}); + +},{"../schema":666,"../type/binary":673,"../type/merge":681,"../type/omap":683,"../type/pairs":684,"../type/set":686,"../type/timestamp":688,"./core":667}],670:[function(require,module,exports){ +// Standard YAML's Failsafe schema. +// http://www.yaml.org/spec/1.2/spec.html#id2802346 + + +'use strict'; + + +var Schema = require('../schema'); + + +module.exports = new Schema({ + explicit: [ + require('../type/str'), + require('../type/seq'), + require('../type/map') + ] +}); + +},{"../schema":666,"../type/map":680,"../type/seq":685,"../type/str":687}],671:[function(require,module,exports){ +// Standard YAML's JSON schema. +// http://www.yaml.org/spec/1.2/spec.html#id2803231 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, this schema is not such strict as defined in the YAML specification. +// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. + + +'use strict'; + + +var Schema = require('../schema'); + + +module.exports = new Schema({ + include: [ + require('./failsafe') + ], + implicit: [ + require('../type/null'), + require('../type/bool'), + require('../type/int'), + require('../type/float') + ] +}); + +},{"../schema":666,"../type/bool":674,"../type/float":675,"../type/int":676,"../type/null":682,"./failsafe":670}],672:[function(require,module,exports){ +'use strict'; + +var YAMLException = require('./exception'); + +var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'defaultStyle', + 'styleAliases' +]; + +var YAML_NODE_KINDS = [ + 'scalar', + 'sequence', + 'mapping' +]; + +function compileStyleAliases(map) { + var result = {}; + + if (map !== null) { + Object.keys(map).forEach(function (style) { + map[style].forEach(function (alias) { + result[String(alias)] = style; + }); + }); + } + + return result; +} + +function Type(tag, options) { + options = options || {}; + + Object.keys(options).forEach(function (name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + + // TODO: Add tag format check. + this.tag = tag; + this.kind = options['kind'] || null; + this.resolve = options['resolve'] || function () { return true; }; + this.construct = options['construct'] || function (data) { return data; }; + this.instanceOf = options['instanceOf'] || null; + this.predicate = options['predicate'] || null; + this.represent = options['represent'] || null; + this.defaultStyle = options['defaultStyle'] || null; + this.styleAliases = compileStyleAliases(options['styleAliases'] || null); + + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} + +module.exports = Type; + +},{"./exception":663}],673:[function(require,module,exports){ +'use strict'; + +/*eslint-disable no-bitwise*/ + +var NodeBuffer; + +try { + // A trick for browserified version, to not include `Buffer` shim + var _require = require; + NodeBuffer = _require('buffer').Buffer; +} catch (__) {} + +var Type = require('../type'); + + +// [ 64, 65, 66 ] -> [ padding, CR, LF ] +var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; + + +function resolveYamlBinary(data) { + if (data === null) return false; + + var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; + + // Convert one by one. + for (idx = 0; idx < max; idx++) { + code = map.indexOf(data.charAt(idx)); + + // Skip CR/LF + if (code > 64) continue; + + // Fail on illegal characters + if (code < 0) return false; + + bitlen += 6; + } + + // If there are any bits left, source was corrupted + return (bitlen % 8) === 0; +} + +function constructYamlBinary(data) { + var idx, tailbits, + input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan + max = input.length, + map = BASE64_MAP, + bits = 0, + result = []; + + // Collect by 6*4 bits (3 bytes) + + for (idx = 0; idx < max; idx++) { + if ((idx % 4 === 0) && idx) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } + + bits = (bits << 6) | map.indexOf(input.charAt(idx)); + } + + // Dump tail + + tailbits = (max % 4) * 6; + + if (tailbits === 0) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } else if (tailbits === 18) { + result.push((bits >> 10) & 0xFF); + result.push((bits >> 2) & 0xFF); + } else if (tailbits === 12) { + result.push((bits >> 4) & 0xFF); + } + + // Wrap into Buffer for NodeJS and leave Array for browser + if (NodeBuffer) { + // Support node 6.+ Buffer API when available + return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result); + } + + return result; +} + +function representYamlBinary(object /*, style*/) { + var result = '', bits = 0, idx, tail, + max = object.length, + map = BASE64_MAP; + + // Convert every three bytes to 4 ASCII characters. + + for (idx = 0; idx < max; idx++) { + if ((idx % 3 === 0) && idx) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } + + bits = (bits << 8) + object[idx]; + } + + // Dump tail + + tail = max % 3; + + if (tail === 0) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } else if (tail === 2) { + result += map[(bits >> 10) & 0x3F]; + result += map[(bits >> 4) & 0x3F]; + result += map[(bits << 2) & 0x3F]; + result += map[64]; + } else if (tail === 1) { + result += map[(bits >> 2) & 0x3F]; + result += map[(bits << 4) & 0x3F]; + result += map[64]; + result += map[64]; + } + + return result; +} + +function isBinary(object) { + return NodeBuffer && NodeBuffer.isBuffer(object); +} + +module.exports = new Type('tag:yaml.org,2002:binary', { + kind: 'scalar', + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); + +},{"../type":672}],674:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +function resolveYamlBoolean(data) { + if (data === null) return false; + + var max = data.length; + + return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || + (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); +} + +function constructYamlBoolean(data) { + return data === 'true' || + data === 'True' || + data === 'TRUE'; +} + +function isBoolean(object) { + return Object.prototype.toString.call(object) === '[object Boolean]'; +} + +module.exports = new Type('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function (object) { return object ? 'true' : 'false'; }, + uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, + camelcase: function (object) { return object ? 'True' : 'False'; } + }, + defaultStyle: 'lowercase' +}); + +},{"../type":672}],675:[function(require,module,exports){ +'use strict'; + +var common = require('../common'); +var Type = require('../type'); + +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + + // .2e4, .2 + // special case, seems not from spec + '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + + // 20:59 + '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' + + // .inf + '|[-+]?\\.(?:inf|Inf|INF)' + + // .nan + '|\\.(?:nan|NaN|NAN))$'); + +function resolveYamlFloat(data) { + if (data === null) return false; + + if (!YAML_FLOAT_PATTERN.test(data) || + // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === '_') { + return false; + } + + return true; +} + +function constructYamlFloat(data) { + var value, sign, base, digits; + + value = data.replace(/_/g, '').toLowerCase(); + sign = value[0] === '-' ? -1 : 1; + digits = []; + + if ('+-'.indexOf(value[0]) >= 0) { + value = value.slice(1); + } + + if (value === '.inf') { + return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + + } else if (value === '.nan') { + return NaN; + + } else if (value.indexOf(':') >= 0) { + value.split(':').forEach(function (v) { + digits.unshift(parseFloat(v, 10)); + }); + + value = 0.0; + base = 1; + + digits.forEach(function (d) { + value += d * base; + base *= 60; + }); + + return sign * value; + + } + return sign * parseFloat(value, 10); +} + + +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + +function representYamlFloat(object, style) { + var res; + + if (isNaN(object)) { + switch (style) { + case 'lowercase': return '.nan'; + case 'uppercase': return '.NAN'; + case 'camelcase': return '.NaN'; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '.inf'; + case 'uppercase': return '.INF'; + case 'camelcase': return '.Inf'; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '-.inf'; + case 'uppercase': return '-.INF'; + case 'camelcase': return '-.Inf'; + } + } else if (common.isNegativeZero(object)) { + return '-0.0'; + } + + res = object.toString(10); + + // JS stringifier can build scientific format without dots: 5e-100, + // while YAML requres dot: 5.e-100. Fix it with simple hack + + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; +} + +function isFloat(object) { + return (Object.prototype.toString.call(object) === '[object Number]') && + (object % 1 !== 0 || common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: 'lowercase' +}); + +},{"../common":661,"../type":672}],676:[function(require,module,exports){ +'use strict'; + +var common = require('../common'); +var Type = require('../type'); + +function isHexCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || + ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || + ((0x61/* a */ <= c) && (c <= 0x66/* f */)); +} + +function isOctCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); +} + +function isDecCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); +} + +function resolveYamlInteger(data) { + if (data === null) return false; + + var max = data.length, + index = 0, + hasDigits = false, + ch; + + if (!max) return false; + + ch = data[index]; + + // sign + if (ch === '-' || ch === '+') { + ch = data[++index]; + } + + if (ch === '0') { + // 0 + if (index + 1 === max) return true; + ch = data[++index]; + + // base 2, base 8, base 16 + + if (ch === 'b') { + // base 2 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch !== '0' && ch !== '1') return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'x') { + // base 16 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isHexCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + // base 8 + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isOctCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + // base 10 (except 0) or base 60 + + // value should not start with `_`; + if (ch === '_') return false; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch === ':') break; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + + // Should have digits and should not end with `_` + if (!hasDigits || ch === '_') return false; + + // if !base60 - done; + if (ch !== ':') return true; + + // base60 almost not used, no needs to optimize + return /^(:[0-5]?[0-9])+$/.test(data.slice(index)); +} + +function constructYamlInteger(data) { + var value = data, sign = 1, ch, base, digits = []; + + if (value.indexOf('_') !== -1) { + value = value.replace(/_/g, ''); + } + + ch = value[0]; + + if (ch === '-' || ch === '+') { + if (ch === '-') sign = -1; + value = value.slice(1); + ch = value[0]; + } + + if (value === '0') return 0; + + if (ch === '0') { + if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); + if (value[1] === 'x') return sign * parseInt(value, 16); + return sign * parseInt(value, 8); + } + + if (value.indexOf(':') !== -1) { + value.split(':').forEach(function (v) { + digits.unshift(parseInt(v, 10)); + }); + + value = 0; + base = 1; + + digits.forEach(function (d) { + value += (d * base); + base *= 60; + }); + + return sign * value; + + } + + return sign * parseInt(value, 10); +} + +function isInteger(object) { + return (Object.prototype.toString.call(object)) === '[object Number]' && + (object % 1 === 0 && !common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function (object) { return '0b' + object.toString(2); }, + octal: function (object) { return '0' + object.toString(8); }, + decimal: function (object) { return object.toString(10); }, + hexadecimal: function (object) { return '0x' + object.toString(16).toUpperCase(); } + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [ 2, 'bin' ], + octal: [ 8, 'oct' ], + decimal: [ 10, 'dec' ], + hexadecimal: [ 16, 'hex' ] + } +}); + +},{"../common":661,"../type":672}],677:[function(require,module,exports){ +'use strict'; + +var esprima; + +// Browserified version does not have esprima +// +// 1. For node.js just require module as deps +// 2. For browser try to require mudule via external AMD system. +// If not found - try to fallback to window.esprima. If not +// found too - then fail to parse. +// +try { + // workaround to exclude package from browserify list. + var _require = require; + esprima = _require('esprima'); +} catch (_) { + /*global window */ + if (typeof window !== 'undefined') esprima = window.esprima; +} + +var Type = require('../../type'); + +function resolveJavascriptFunction(data) { + if (data === null) return false; + + try { + var source = '(' + data + ')', + ast = esprima.parse(source, { range: true }); + + if (ast.type !== 'Program' || + ast.body.length !== 1 || + ast.body[0].type !== 'ExpressionStatement' || + ast.body[0].expression.type !== 'FunctionExpression') { + return false; + } + + return true; + } catch (err) { + return false; + } +} + +function constructJavascriptFunction(data) { + /*jslint evil:true*/ + + var source = '(' + data + ')', + ast = esprima.parse(source, { range: true }), + params = [], + body; + + if (ast.type !== 'Program' || + ast.body.length !== 1 || + ast.body[0].type !== 'ExpressionStatement' || + ast.body[0].expression.type !== 'FunctionExpression') { + throw new Error('Failed to resolve function'); + } + + ast.body[0].expression.params.forEach(function (param) { + params.push(param.name); + }); + + body = ast.body[0].expression.body.range; + + // Esprima's ranges include the first '{' and the last '}' characters on + // function expressions. So cut them out. + /*eslint-disable no-new-func*/ + return new Function(params, source.slice(body[0] + 1, body[1] - 1)); +} + +function representJavascriptFunction(object /*, style*/) { + return object.toString(); +} + +function isFunction(object) { + return Object.prototype.toString.call(object) === '[object Function]'; +} + +module.exports = new Type('tag:yaml.org,2002:js/function', { + kind: 'scalar', + resolve: resolveJavascriptFunction, + construct: constructJavascriptFunction, + predicate: isFunction, + represent: representJavascriptFunction +}); + +},{"../../type":672}],678:[function(require,module,exports){ +'use strict'; + +var Type = require('../../type'); + +function resolveJavascriptRegExp(data) { + if (data === null) return false; + if (data.length === 0) return false; + + var regexp = data, + tail = /\/([gim]*)$/.exec(data), + modifiers = ''; + + // if regexp starts with '/' it can have modifiers and must be properly closed + // `/foo/gim` - modifiers tail can be maximum 3 chars + if (regexp[0] === '/') { + if (tail) modifiers = tail[1]; + + if (modifiers.length > 3) return false; + // if expression starts with /, is should be properly terminated + if (regexp[regexp.length - modifiers.length - 1] !== '/') return false; + } + + return true; +} + +function constructJavascriptRegExp(data) { + var regexp = data, + tail = /\/([gim]*)$/.exec(data), + modifiers = ''; + + // `/foo/gim` - tail can be maximum 4 chars + if (regexp[0] === '/') { + if (tail) modifiers = tail[1]; + regexp = regexp.slice(1, regexp.length - modifiers.length - 1); + } + + return new RegExp(regexp, modifiers); +} + +function representJavascriptRegExp(object /*, style*/) { + var result = '/' + object.source + '/'; + + if (object.global) result += 'g'; + if (object.multiline) result += 'm'; + if (object.ignoreCase) result += 'i'; + + return result; +} + +function isRegExp(object) { + return Object.prototype.toString.call(object) === '[object RegExp]'; +} + +module.exports = new Type('tag:yaml.org,2002:js/regexp', { + kind: 'scalar', + resolve: resolveJavascriptRegExp, + construct: constructJavascriptRegExp, + predicate: isRegExp, + represent: representJavascriptRegExp +}); + +},{"../../type":672}],679:[function(require,module,exports){ +'use strict'; + +var Type = require('../../type'); + +function resolveJavascriptUndefined() { + return true; +} + +function constructJavascriptUndefined() { + /*eslint-disable no-undefined*/ + return undefined; +} + +function representJavascriptUndefined() { + return ''; +} + +function isUndefined(object) { + return typeof object === 'undefined'; +} + +module.exports = new Type('tag:yaml.org,2002:js/undefined', { + kind: 'scalar', + resolve: resolveJavascriptUndefined, + construct: constructJavascriptUndefined, + predicate: isUndefined, + represent: representJavascriptUndefined +}); + +},{"../../type":672}],680:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +module.exports = new Type('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (data) { return data !== null ? data : {}; } +}); + +},{"../type":672}],681:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +function resolveYamlMerge(data) { + return data === '<<' || data === null; +} + +module.exports = new Type('tag:yaml.org,2002:merge', { + kind: 'scalar', + resolve: resolveYamlMerge +}); + +},{"../type":672}],682:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +function resolveYamlNull(data) { + if (data === null) return true; + + var max = data.length; + + return (max === 1 && data === '~') || + (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +} + +function constructYamlNull() { + return null; +} + +function isNull(object) { + return object === null; +} + +module.exports = new Type('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function () { return '~'; }, + lowercase: function () { return 'null'; }, + uppercase: function () { return 'NULL'; }, + camelcase: function () { return 'Null'; } + }, + defaultStyle: 'lowercase' +}); + +},{"../type":672}],683:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var _toString = Object.prototype.toString; + +function resolveYamlOmap(data) { + if (data === null) return true; + + var objectKeys = [], index, length, pair, pairKey, pairHasKey, + object = data; + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + + if (_toString.call(pair) !== '[object Object]') return false; + + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } + + if (!pairHasKey) return false; + + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } + + return true; +} + +function constructYamlOmap(data) { + return data !== null ? data : []; +} + +module.exports = new Type('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); + +},{"../type":672}],684:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +var _toString = Object.prototype.toString; + +function resolveYamlPairs(data) { + if (data === null) return true; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + if (_toString.call(pair) !== '[object Object]') return false; + + keys = Object.keys(pair); + + if (keys.length !== 1) return false; + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return true; +} + +function constructYamlPairs(data) { + if (data === null) return []; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + keys = Object.keys(pair); + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return result; +} + +module.exports = new Type('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); + +},{"../type":672}],685:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +module.exports = new Type('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (data) { return data !== null ? data : []; } +}); + +},{"../type":672}],686:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +function resolveYamlSet(data) { + if (data === null) return true; + + var key, object = data; + + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) return false; + } + } + + return true; +} + +function constructYamlSet(data) { + return data !== null ? data : {}; +} + +module.exports = new Type('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: resolveYamlSet, + construct: constructYamlSet +}); + +},{"../type":672}],687:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +module.exports = new Type('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (data) { return data !== null ? data : ''; } +}); + +},{"../type":672}],688:[function(require,module,exports){ +'use strict'; + +var Type = require('../type'); + +var YAML_DATE_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9])' + // [2] month + '-([0-9][0-9])$'); // [3] day + +var YAML_TIMESTAMP_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9]?)' + // [2] month + '-([0-9][0-9]?)' + // [3] day + '(?:[Tt]|[ \\t]+)' + // ... + '([0-9][0-9]?)' + // [4] hour + ':([0-9][0-9])' + // [5] minute + ':([0-9][0-9])' + // [6] second + '(?:\\.([0-9]*))?' + // [7] fraction + '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour + '(?::([0-9][0-9]))?))?$'); // [11] tz_minute + +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; +} + +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, + delta = null, tz_hour, tz_minute, date; + + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); + + if (match === null) throw new Error('Date resolve error'); + + // match: [1] year [2] month [3] day + + year = +(match[1]); + month = +(match[2]) - 1; // JS month starts with 0 + day = +(match[3]); + + if (!match[4]) { // no hour + return new Date(Date.UTC(year, month, day)); + } + + // match: [4] hour [5] minute [6] second [7] fraction + + hour = +(match[4]); + minute = +(match[5]); + second = +(match[6]); + + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { // milli-seconds + fraction += '0'; + } + fraction = +fraction; + } + + // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute + + if (match[9]) { + tz_hour = +(match[10]); + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds + if (match[9] === '-') delta = -delta; + } + + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + + if (delta) date.setTime(date.getTime() - delta); + + return date; +} + +function representYamlTimestamp(object /*, style*/) { + return object.toISOString(); +} + +module.exports = new Type('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); + +},{"../type":672}],689:[function(require,module,exports){ +var isBuffer = require('is-buffer'); +var toString = Object.prototype.toString; + +/** + * Get the native `typeof` a value. + * + * @param {*} `val` + * @return {*} Native javascript type + */ + +module.exports = function kindOf(val) { + // primitivies + if (typeof val === 'undefined') { + return 'undefined'; + } + if (val === null) { + return 'null'; + } + if (val === true || val === false || val instanceof Boolean) { + return 'boolean'; + } + if (typeof val === 'string' || val instanceof String) { + return 'string'; + } + if (typeof val === 'number' || val instanceof Number) { + return 'number'; + } + + // functions + if (typeof val === 'function' || val instanceof Function) { + return 'function'; + } + + // array + if (typeof Array.isArray !== 'undefined' && Array.isArray(val)) { + return 'array'; + } + + // check for instances of RegExp and Date before calling `toString` + if (val instanceof RegExp) { + return 'regexp'; + } + if (val instanceof Date) { + return 'date'; + } + + // other objects + var type = toString.call(val); + + if (type === '[object RegExp]') { + return 'regexp'; + } + if (type === '[object Date]') { + return 'date'; + } + if (type === '[object Arguments]') { + return 'arguments'; + } + if (type === '[object Error]') { + return 'error'; + } + + // buffer + if (isBuffer(val)) { + return 'buffer'; + } + + // es6: Map, WeakMap, Set, WeakSet + if (type === '[object Set]') { + return 'set'; + } + if (type === '[object WeakSet]') { + return 'weakset'; + } + if (type === '[object Map]') { + return 'map'; + } + if (type === '[object WeakMap]') { + return 'weakmap'; + } + if (type === '[object Symbol]') { + return 'symbol'; + } + + // typed arrays + if (type === '[object Int8Array]') { + return 'int8array'; + } + if (type === '[object Uint8Array]') { + return 'uint8array'; + } + if (type === '[object Uint8ClampedArray]') { + return 'uint8clampedarray'; + } + if (type === '[object Int16Array]') { + return 'int16array'; + } + if (type === '[object Uint16Array]') { + return 'uint16array'; + } + if (type === '[object Int32Array]') { + return 'int32array'; + } + if (type === '[object Uint32Array]') { + return 'uint32array'; + } + if (type === '[object Float32Array]') { + return 'float32array'; + } + if (type === '[object Float64Array]') { + return 'float64array'; + } + + // must be a plain object + return 'object'; +}; + +},{"is-buffer":640}],690:[function(require,module,exports){ +module.exports={ + "properties": [ + "accelerator", + "-wap-accesskey", + "align-content", + "-webkit-align-content", + "align-items", + "-webkit-align-items", + "align-self", + "-webkit-align-self", + "alignment-baseline", + "all", + "alt", + "-webkit-alt", + "animation", + "animation-delay", + "-moz-animation-delay", + "-ms-animation-delay", + "-webkit-animation-delay", + "animation-direction", + "-moz-animation-direction", + "-ms-animation-direction", + "-webkit-animation-direction", + "animation-duration", + "-moz-animation-duration", + "-ms-animation-duration", + "-webkit-animation-duration", + "animation-fill-mode", + "-moz-animation-fill-mode", + "-ms-animation-fill-mode", + "-webkit-animation-fill-mode", + "animation-iteration-count", + "-moz-animation-iteration-count", + "-ms-animation-iteration-count", + "-webkit-animation-iteration-count", + "-moz-animation", + "-ms-animation", + "animation-name", + "-moz-animation-name", + "-ms-animation-name", + "-webkit-animation-name", + "animation-play-state", + "-moz-animation-play-state", + "-ms-animation-play-state", + "-webkit-animation-play-state", + "animation-timing-function", + "-moz-animation-timing-function", + "-ms-animation-timing-function", + "-webkit-animation-timing-function", + "-webkit-animation", + "-webkit-app-region", + "appearance", + "-moz-appearance", + "-webkit-appearance", + "-webkit-aspect-ratio", + "audio-level", + "azimuth", + "backdrop-filter", + "-webkit-backdrop-filter", + "backface-visibility", + "-moz-backface-visibility", + "-ms-backface-visibility", + "-webkit-backface-visibility", + "background", + "background-attachment", + "-webkit-background-attachment", + "background-blend-mode", + "background-clip", + "-moz-background-clip", + "-webkit-background-clip", + "background-color", + "-webkit-background-color", + "-webkit-background-composite", + "background-image", + "-webkit-background-image", + "-moz-background-inline-policy", + "background-origin", + "-moz-background-origin", + "-webkit-background-origin", + "background-position", + "-webkit-background-position", + "background-position-x", + "-webkit-background-position-x", + "background-position-y", + "-webkit-background-position-y", + "background-repeat", + "-webkit-background-repeat", + "background-repeat-x", + "background-repeat-y", + "background-size", + "-moz-background-size", + "-webkit-background-size", + "-webkit-background", + "baseline-shift", + "behavior", + "-moz-binding", + "-ms-block-progression", + "block-size", + "bookmark-label", + "bookmark-level", + "bookmark-state", + "border", + "-webkit-border-after-color", + "-webkit-border-after-style", + "-webkit-border-after", + "-webkit-border-after-width", + "-webkit-border-before-color", + "-webkit-border-before-style", + "-webkit-border-before", + "-webkit-border-before-width", + "border-block-end", + "border-block-end-color", + "border-block-end-style", + "border-block-end-width", + "border-block-start", + "border-block-start-color", + "border-block-start-style", + "border-block-start-width", + "border-bottom", + "border-bottom-color", + "-moz-border-bottom-colors", + "border-bottom-left-radius", + "-webkit-border-bottom-left-radius", + "border-bottom-right-radius", + "-webkit-border-bottom-right-radius", + "border-bottom-style", + "border-bottom-width", + "border-boundary", + "border-collapse", + "border-color", + "-moz-border-end-color", + "-webkit-border-end-color", + "-moz-border-end", + "-moz-border-end-style", + "-webkit-border-end-style", + "-webkit-border-end", + "-moz-border-end-width", + "-webkit-border-end-width", + "-webkit-border-fit", + "-webkit-border-horizontal-spacing", + "border-image", + "-moz-border-image", + "-o-border-image", + "border-image-outset", + "-webkit-border-image-outset", + "border-image-repeat", + "-webkit-border-image-repeat", + "border-image-slice", + "-webkit-border-image-slice", + "border-image-source", + "-webkit-border-image-source", + "-webkit-border-image", + "border-image-width", + "-webkit-border-image-width", + "border-inline-end", + "border-inline-end-color", + "border-inline-end-style", + "border-inline-end-width", + "border-inline-start", + "border-inline-start-color", + "border-inline-start-style", + "border-inline-start-width", + "border-left", + "border-left-color", + "-moz-border-left-colors", + "border-left-style", + "border-left-width", + "border-radius", + "-moz-border-radius-bottomleft", + "-moz-border-radius-bottomright", + "-moz-border-radius", + "-moz-border-radius-topleft", + "-moz-border-radius-topright", + "-webkit-border-radius", + "border-right", + "border-right-color", + "-moz-border-right-colors", + "border-right-style", + "border-right-width", + "border-spacing", + "-moz-border-start-color", + "-webkit-border-start-color", + "-moz-border-start", + "-moz-border-start-style", + "-webkit-border-start-style", + "-webkit-border-start", + "-moz-border-start-width", + "-webkit-border-start-width", + "border-style", + "border-top", + "border-top-color", + "-moz-border-top-colors", + "border-top-left-radius", + "-webkit-border-top-left-radius", + "border-top-right-radius", + "-webkit-border-top-right-radius", + "border-top-style", + "border-top-width", + "-webkit-border-vertical-spacing", + "border-width", + "bottom", + "-moz-box-align", + "-webkit-box-align", + "box-decoration-break", + "-webkit-box-decoration-break", + "-moz-box-direction", + "-webkit-box-direction", + "-webkit-box-flex-group", + "-moz-box-flex", + "-webkit-box-flex", + "-webkit-box-lines", + "-moz-box-ordinal-group", + "-webkit-box-ordinal-group", + "-moz-box-orient", + "-webkit-box-orient", + "-moz-box-pack", + "-webkit-box-pack", + "-webkit-box-reflect", + "box-shadow", + "-moz-box-shadow", + "-webkit-box-shadow", + "box-sizing", + "-moz-box-sizing", + "-webkit-box-sizing", + "box-snap", + "box-suppress", + "break-after", + "break-before", + "break-inside", + "buffered-rendering", + "caption-side", + "caret", + "caret-animation", + "caret-color", + "caret-shape", + "clear", + "clip", + "clip-path", + "-webkit-clip-path", + "clip-rule", + "color", + "color-adjust", + "-webkit-color-correction", + "color-interpolation", + "color-interpolation-filters", + "color-profile", + "color-rendering", + "-webkit-column-axis", + "-webkit-column-break-after", + "-webkit-column-break-before", + "-webkit-column-break-inside", + "column-count", + "-moz-column-count", + "-webkit-column-count", + "column-fill", + "-moz-column-fill", + "-webkit-column-fill", + "column-gap", + "-moz-column-gap", + "-webkit-column-gap", + "column-progression", + "-webkit-column-progression", + "column-rule", + "column-rule-color", + "-moz-column-rule-color", + "-webkit-column-rule-color", + "-moz-column-rule", + "column-rule-style", + "-moz-column-rule-style", + "-webkit-column-rule-style", + "-webkit-column-rule", + "column-rule-width", + "-moz-column-rule-width", + "-webkit-column-rule-width", + "column-span", + "-webkit-column-span", + "column-width", + "-moz-column-width", + "-webkit-column-width", + "columns", + "-moz-columns", + "-webkit-columns", + "-webkit-composition-fill-color", + "-webkit-composition-frame-color", + "contain", + "content", + "-ms-content-zoom-chaining", + "-ms-content-zoom-limit-max", + "-ms-content-zoom-limit-min", + "-ms-content-zoom-limit", + "-ms-content-zoom-snap", + "-ms-content-zoom-snap-points", + "-ms-content-zoom-snap-type", + "-ms-content-zooming", + "counter-increment", + "counter-reset", + "counter-set", + "cue", + "cue-after", + "cue-before", + "cursor", + "-webkit-cursor-visibility", + "cx", + "cy", + "d", + "-apple-dashboard-region", + "-webkit-dashboard-region", + "direction", + "display", + "display-align", + "dominant-baseline", + "elevation", + "empty-cells", + "enable-background", + "fill", + "fill-opacity", + "fill-rule", + "filter", + "-ms-filter", + "-webkit-filter", + "flex", + "-ms-flex-align", + "-webkit-flex-align", + "flex-basis", + "-webkit-flex-basis", + "flex-direction", + "-ms-flex-direction", + "-webkit-flex-direction", + "flex-flow", + "-ms-flex-flow", + "-webkit-flex-flow", + "flex-grow", + "-webkit-flex-grow", + "-ms-flex-item-align", + "-webkit-flex-item-align", + "-ms-flex-line-pack", + "-webkit-flex-line-pack", + "-ms-flex", + "-ms-flex-negative", + "-ms-flex-order", + "-webkit-flex-order", + "-ms-flex-pack", + "-webkit-flex-pack", + "-ms-flex-positive", + "-ms-flex-preferred-size", + "flex-shrink", + "-webkit-flex-shrink", + "-webkit-flex", + "flex-wrap", + "-ms-flex-wrap", + "-webkit-flex-wrap", + "float", + "float-defer", + "-moz-float-edge", + "float-offset", + "float-reference", + "flood-color", + "flood-opacity", + "flow-from", + "-ms-flow-from", + "-webkit-flow-from", + "flow-into", + "-ms-flow-into", + "-webkit-flow-into", + "font", + "font-display", + "font-family", + "font-feature-settings", + "-moz-font-feature-settings", + "-ms-font-feature-settings", + "-webkit-font-feature-settings", + "font-kerning", + "-webkit-font-kerning", + "font-language-override", + "-moz-font-language-override", + "font-size", + "font-size-adjust", + "-webkit-font-size-delta", + "-webkit-font-smoothing", + "font-stretch", + "font-style", + "font-synthesis", + "font-variant", + "font-variant-alternates", + "font-variant-caps", + "font-variant-east-asian", + "font-variant-ligatures", + "-webkit-font-variant-ligatures", + "font-variant-numeric", + "font-variant-position", + "font-variation-settings", + "font-weight", + "footnote-display", + "footnote-policy", + "-moz-force-broken-image-icon", + "glyph-orientation-horizontal", + "glyph-orientation-vertical", + "grid", + "-webkit-grid-after", + "grid-area", + "grid-auto-columns", + "-webkit-grid-auto-columns", + "grid-auto-flow", + "-webkit-grid-auto-flow", + "grid-auto-rows", + "-webkit-grid-auto-rows", + "-webkit-grid-before", + "grid-column", + "-ms-grid-column-align", + "grid-column-end", + "grid-column-gap", + "-ms-grid-column", + "-ms-grid-column-span", + "grid-column-start", + "-webkit-grid-column", + "-ms-grid-columns", + "-webkit-grid-columns", + "-webkit-grid-end", + "grid-gap", + "grid-row", + "-ms-grid-row-align", + "grid-row-end", + "grid-row-gap", + "-ms-grid-row", + "-ms-grid-row-span", + "grid-row-start", + "-webkit-grid-row", + "-ms-grid-rows", + "-webkit-grid-rows", + "-webkit-grid-start", + "grid-template", + "grid-template-areas", + "grid-template-columns", + "grid-template-rows", + "hanging-punctuation", + "height", + "-ms-high-contrast-adjust", + "-webkit-highlight", + "hyphenate-character", + "-webkit-hyphenate-character", + "-webkit-hyphenate-limit-after", + "-webkit-hyphenate-limit-before", + "hyphenate-limit-chars", + "-ms-hyphenate-limit-chars", + "hyphenate-limit-last", + "hyphenate-limit-lines", + "-ms-hyphenate-limit-lines", + "-webkit-hyphenate-limit-lines", + "hyphenate-limit-zone", + "-ms-hyphenate-limit-zone", + "hyphens", + "-moz-hyphens", + "-ms-hyphens", + "-webkit-hyphens", + "image-orientation", + "-moz-image-region", + "image-rendering", + "image-resolution", + "-ms-ime-align", + "ime-mode", + "initial-letter", + "initial-letter-align", + "-webkit-initial-letter", + "initial-letter-wrap", + "inline-size", + "input-format", + "-wap-input-format", + "-wap-input-required", + "-ms-interpolation-mode", + "isolation", + "justify-content", + "-webkit-justify-content", + "justify-items", + "justify-self", + "-webkit-justify-self", + "kerning", + "layout-flow", + "layout-grid", + "layout-grid-char", + "layout-grid-line", + "layout-grid-mode", + "layout-grid-type", + "left", + "letter-spacing", + "lighting-color", + "-webkit-line-align", + "-webkit-line-box-contain", + "line-break", + "-webkit-line-break", + "-webkit-line-clamp", + "line-grid", + "-webkit-line-grid-snap", + "-webkit-line-grid", + "line-height", + "line-height-step", + "line-increment", + "line-snap", + "-webkit-line-snap", + "-o-link", + "-o-link-source", + "list-style", + "list-style-image", + "list-style-position", + "list-style-type", + "-webkit-locale", + "-webkit-logical-height", + "-webkit-logical-width", + "margin", + "-webkit-margin-after-collapse", + "-webkit-margin-after", + "-webkit-margin-before-collapse", + "-webkit-margin-before", + "margin-block-end", + "margin-block-start", + "margin-bottom", + "-webkit-margin-bottom-collapse", + "-webkit-margin-collapse", + "-moz-margin-end", + "-webkit-margin-end", + "margin-inline-end", + "margin-inline-start", + "margin-left", + "margin-right", + "-moz-margin-start", + "-webkit-margin-start", + "margin-top", + "-webkit-margin-top-collapse", + "marker", + "marker-end", + "marker-knockout-left", + "marker-knockout-right", + "marker-mid", + "marker-offset", + "marker-pattern", + "marker-segment", + "marker-side", + "marker-start", + "marks", + "-wap-marquee-dir", + "marquee-direction", + "-webkit-marquee-direction", + "-webkit-marquee-increment", + "marquee-loop", + "-wap-marquee-loop", + "-webkit-marquee-repetition", + "marquee-speed", + "-wap-marquee-speed", + "-webkit-marquee-speed", + "marquee-style", + "-wap-marquee-style", + "-webkit-marquee-style", + "-webkit-marquee", + "mask", + "-webkit-mask-attachment", + "mask-border", + "mask-border-mode", + "mask-border-outset", + "mask-border-repeat", + "mask-border-slice", + "mask-border-source", + "mask-border-width", + "-webkit-mask-box-image-outset", + "-webkit-mask-box-image-repeat", + "-webkit-mask-box-image-slice", + "-webkit-mask-box-image-source", + "-webkit-mask-box-image", + "-webkit-mask-box-image-width", + "mask-clip", + "-webkit-mask-clip", + "mask-composite", + "-webkit-mask-composite", + "mask-image", + "-webkit-mask-image", + "mask-mode", + "mask-origin", + "-webkit-mask-origin", + "mask-position", + "-webkit-mask-position", + "mask-position-x", + "-webkit-mask-position-x", + "mask-position-y", + "-webkit-mask-position-y", + "mask-repeat", + "-webkit-mask-repeat", + "-webkit-mask-repeat-x", + "-webkit-mask-repeat-y", + "mask-size", + "-webkit-mask-size", + "mask-source-type", + "-webkit-mask-source-type", + "mask-type", + "-webkit-mask", + "-webkit-match-nearest-mail-blockquote-color", + "max-block-size", + "max-height", + "max-inline-size", + "max-lines", + "-webkit-max-logical-height", + "-webkit-max-logical-width", + "max-width", + "max-zoom", + "min-block-size", + "min-height", + "min-inline-size", + "-webkit-min-logical-height", + "-webkit-min-logical-width", + "min-width", + "min-zoom", + "mix-blend-mode", + "motion", + "motion-offset", + "motion-path", + "motion-rotation", + "nav-down", + "nav-index", + "nav-left", + "nav-right", + "nav-up", + "-webkit-nbsp-mode", + "object-fit", + "-o-object-fit", + "object-position", + "-o-object-position", + "offset", + "offset-after", + "offset-anchor", + "offset-before", + "offset-block-end", + "offset-block-start", + "offset-distance", + "offset-end", + "offset-inline-end", + "offset-inline-start", + "offset-path", + "offset-position", + "offset-rotate", + "offset-rotation", + "offset-start", + "opacity", + "-moz-opacity", + "order", + "-webkit-order", + "-moz-orient", + "orientation", + "orphans", + "-moz-osx-font-smoothing", + "outline", + "outline-color", + "-moz-outline-color", + "-moz-outline", + "outline-offset", + "-moz-outline-offset", + "-moz-outline-radius-bottomleft", + "-moz-outline-radius-bottomright", + "-moz-outline-radius", + "-moz-outline-radius-topleft", + "-moz-outline-radius-topright", + "outline-style", + "-moz-outline-style", + "outline-width", + "-moz-outline-width", + "overflow", + "overflow-anchor", + "-webkit-overflow-scrolling", + "overflow-style", + "-ms-overflow-style", + "overflow-wrap", + "overflow-x", + "overflow-y", + "padding", + "-webkit-padding-after", + "-webkit-padding-before", + "padding-block-end", + "padding-block-start", + "padding-bottom", + "-moz-padding-end", + "-webkit-padding-end", + "padding-inline-end", + "padding-inline-start", + "padding-left", + "padding-right", + "-moz-padding-start", + "-webkit-padding-start", + "padding-top", + "page", + "page-break-after", + "page-break-before", + "page-break-inside", + "paint-order", + "pause", + "pause-after", + "pause-before", + "perspective", + "-moz-perspective", + "-ms-perspective", + "perspective-origin", + "-moz-perspective-origin", + "-ms-perspective-origin", + "-webkit-perspective-origin", + "perspective-origin-x", + "-webkit-perspective-origin-x", + "perspective-origin-y", + "-webkit-perspective-origin-y", + "-webkit-perspective", + "pitch", + "pitch-range", + "place-content", + "place-items", + "place-self", + "play-during", + "pointer-events", + "polar-anchor", + "polar-angle", + "polar-distance", + "polar-origin", + "position", + "-webkit-print-color-adjust", + "quotes", + "r", + "-webkit-region-break-after", + "-webkit-region-break-before", + "-webkit-region-break-inside", + "region-fragment", + "-webkit-region-fragment", + "-webkit-region-overflow", + "resize", + "rest", + "rest-after", + "rest-before", + "richness", + "right", + "rotate", + "rotation", + "rotation-point", + "-webkit-rtl-ordering", + "ruby-align", + "ruby-merge", + "ruby-overhang", + "ruby-position", + "-webkit-ruby-position", + "running", + "rx", + "ry", + "scale", + "scroll-behavior", + "-ms-scroll-chaining", + "-ms-scroll-limit", + "-ms-scroll-limit-x-max", + "-ms-scroll-limit-x-min", + "-ms-scroll-limit-y-max", + "-ms-scroll-limit-y-min", + "-ms-scroll-rails", + "scroll-snap-align", + "scroll-snap-coordinate", + "-webkit-scroll-snap-coordinate", + "scroll-snap-destination", + "-webkit-scroll-snap-destination", + "scroll-snap-margin", + "scroll-snap-padding", + "scroll-snap-points-x", + "-ms-scroll-snap-points-x", + "-webkit-scroll-snap-points-x", + "scroll-snap-points-y", + "-ms-scroll-snap-points-y", + "-webkit-scroll-snap-points-y", + "scroll-snap-type", + "-ms-scroll-snap-type", + "-webkit-scroll-snap-type", + "scroll-snap-type-x", + "scroll-snap-type-y", + "-ms-scroll-snap-x", + "-ms-scroll-snap-y", + "-ms-scroll-translation", + "scrollbar-arrow-color", + "scrollbar-base-color", + "scrollbar-dark-shadow-color", + "scrollbar-darkshadow-color", + "scrollbar-face-color", + "scrollbar-highlight-color", + "scrollbar-shadow-color", + "scrollbar-track-color", + "scrollbar3d-light-color", + "scrollbar3dlight-color", + "shape-image-threshold", + "-webkit-shape-image-threshold", + "shape-inside", + "-webkit-shape-inside", + "shape-margin", + "-webkit-shape-margin", + "shape-outside", + "-webkit-shape-outside", + "-webkit-shape-padding", + "shape-rendering", + "size", + "snap-height", + "solid-color", + "solid-opacity", + "speak", + "speak-as", + "speak-header", + "speak-numeral", + "speak-punctuation", + "speech-rate", + "src", + "-moz-stack-sizing", + "stop-color", + "stop-opacity", + "stress", + "string-set", + "stroke", + "stroke-alignment", + "stroke-dashadjust", + "stroke-dasharray", + "stroke-dashcorner", + "stroke-dashoffset", + "stroke-linecap", + "stroke-linejoin", + "stroke-miterlimit", + "stroke-opacity", + "stroke-width", + "-webkit-svg-shadow", + "tab-size", + "-moz-tab-size", + "-o-tab-size", + "-o-table-baseline", + "table-layout", + "-webkit-tap-highlight-color", + "text-align", + "text-align-last", + "-moz-text-align-last", + "text-anchor", + "text-autospace", + "-moz-text-blink", + "-ms-text-combine-horizontal", + "text-combine-upright", + "-webkit-text-combine", + "text-decoration", + "text-decoration-blink", + "text-decoration-color", + "-moz-text-decoration-color", + "-webkit-text-decoration-color", + "text-decoration-line", + "-moz-text-decoration-line", + "text-decoration-line-through", + "-webkit-text-decoration-line", + "text-decoration-none", + "text-decoration-overline", + "text-decoration-skip", + "-webkit-text-decoration-skip", + "text-decoration-style", + "-moz-text-decoration-style", + "-webkit-text-decoration-style", + "text-decoration-underline", + "-webkit-text-decoration", + "-webkit-text-decorations-in-effect", + "text-emphasis", + "text-emphasis-color", + "-webkit-text-emphasis-color", + "text-emphasis-position", + "-webkit-text-emphasis-position", + "text-emphasis-style", + "-webkit-text-emphasis-style", + "-webkit-text-emphasis", + "-webkit-text-fill-color", + "text-indent", + "text-justify", + "text-justify-trim", + "text-kashida", + "text-kashida-space", + "text-line-through", + "text-line-through-color", + "text-line-through-mode", + "text-line-through-style", + "text-line-through-width", + "text-orientation", + "-webkit-text-orientation", + "text-overflow", + "text-overline", + "text-overline-color", + "text-overline-mode", + "text-overline-style", + "text-overline-width", + "text-rendering", + "-webkit-text-security", + "text-shadow", + "text-size-adjust", + "-moz-text-size-adjust", + "-ms-text-size-adjust", + "-webkit-text-size-adjust", + "text-space-collapse", + "text-space-trim", + "text-spacing", + "-webkit-text-stroke-color", + "-webkit-text-stroke", + "-webkit-text-stroke-width", + "text-transform", + "text-underline", + "text-underline-color", + "text-underline-mode", + "text-underline-position", + "-webkit-text-underline-position", + "text-underline-style", + "text-underline-width", + "text-wrap", + "-webkit-text-zoom", + "top", + "touch-action", + "touch-action-delay", + "-ms-touch-action", + "-webkit-touch-callout", + "-ms-touch-select", + "transform", + "transform-box", + "-moz-transform", + "-ms-transform", + "-o-transform", + "transform-origin", + "-moz-transform-origin", + "-ms-transform-origin", + "-o-transform-origin", + "-webkit-transform-origin", + "transform-origin-x", + "-webkit-transform-origin-x", + "transform-origin-y", + "-webkit-transform-origin-y", + "transform-origin-z", + "-webkit-transform-origin-z", + "transform-style", + "-moz-transform-style", + "-ms-transform-style", + "-webkit-transform-style", + "-webkit-transform", + "transition", + "transition-delay", + "-moz-transition-delay", + "-ms-transition-delay", + "-o-transition-delay", + "-webkit-transition-delay", + "transition-duration", + "-moz-transition-duration", + "-ms-transition-duration", + "-o-transition-duration", + "-webkit-transition-duration", + "-moz-transition", + "-ms-transition", + "-o-transition", + "transition-property", + "-moz-transition-property", + "-ms-transition-property", + "-o-transition-property", + "-webkit-transition-property", + "transition-timing-function", + "-moz-transition-timing-function", + "-ms-transition-timing-function", + "-o-transition-timing-function", + "-webkit-transition-timing-function", + "-webkit-transition", + "translate", + "uc-alt-skin", + "uc-skin", + "unicode-bidi", + "unicode-range", + "-webkit-user-drag", + "-moz-user-focus", + "-moz-user-input", + "-moz-user-modify", + "-webkit-user-modify", + "user-select", + "-moz-user-select", + "-ms-user-select", + "-webkit-user-select", + "user-zoom", + "vector-effect", + "vertical-align", + "viewport-fill", + "viewport-fill-opacity", + "visibility", + "voice-balance", + "voice-duration", + "voice-family", + "voice-pitch", + "voice-range", + "voice-rate", + "voice-stress", + "voice-volume", + "volume", + "white-space", + "-webkit-widget-region", + "widows", + "width", + "will-change", + "-moz-window-dragging", + "-moz-window-shadow", + "word-break", + "word-spacing", + "word-wrap", + "wrap-after", + "wrap-before", + "wrap-flow", + "-ms-wrap-flow", + "-webkit-wrap-flow", + "wrap-inside", + "-ms-wrap-margin", + "-webkit-wrap-margin", + "-webkit-wrap-padding", + "-webkit-wrap-shape-inside", + "-webkit-wrap-shape-outside", + "wrap-through", + "-ms-wrap-through", + "-webkit-wrap-through", + "-webkit-wrap", + "writing-mode", + "-webkit-writing-mode", + "x", + "y", + "z-index", + "zoom" + ] +} +},{}],691:[function(require,module,exports){ +module.exports.all = require('./data/all').properties; + +},{"./data/all":690}],692:[function(require,module,exports){ +(function (global){ +/** + * @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.4'; + + /** 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*$/, + reLeadingDot = /^\./, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, + 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)', + rsOrdUpper = '\\d*(?:(?:1ST|2ND|3RD|(?![123])\\dTH)\\b)', + 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 { + 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; + + /*--------------------------------------------------------------------------*/ + + /** + * Adds the key-value `pair` to `map`. + * + * @private + * @param {Object} map The map to modify. + * @param {Array} pair The key-value pair to add. + * @returns {Object} Returns `map`. + */ + function addMapEntry(map, pair) { + // Don't return `map.set` because it's not chainable in IE 11. + map.set(pair[0], pair[1]); + return map; + } + + /** + * Adds `value` to `set`. + * + * @private + * @param {Object} set The set to modify. + * @param {*} value The value to add. + * @returns {Object} Returns `set`. + */ + function addSetEntry(set, value) { + // Don't return `set.add` because it's not chainable in IE 11. + set.add(value); + return set; + } + + /** + * 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; + } + + /** + * 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, baseClone, 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); + + 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(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 = object[key], + srcValue = 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 `map`. + * + * @private + * @param {Object} map The map to clone. + * @param {Function} cloneFunc The function to clone values. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned map. + */ + function cloneMap(map, isDeep, cloneFunc) { + var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map); + return arrayReduce(array, addMapEntry, new map.constructor); + } + + /** + * 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 `set`. + * + * @private + * @param {Object} set The set to clone. + * @param {Function} cloneFunc The function to clone values. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned set. + */ + function cloneSet(set, isDeep, cloneFunc) { + var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set); + return arrayReduce(array, addSetEntry, new set.constructor); + } + + /** + * 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 = 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`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {string} tag The `toStringTag` of the object to clone. + * @param {Function} cloneFunc The function to clone values. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneByTag(object, tag, cloneFunc, 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 cloneMap(object, isDeep, cloneFunc); + + case numberTag: + case stringTag: + return new Ctor(object); + + case regexpTag: + return cloneRegExp(object); + + case setTag: + return cloneSet(object, isDeep, cloneFunc); + + 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) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || 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 (reLeadingDot.test(string)) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + }); + + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to 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, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + 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(args) { + args.push(undefined, customDefaultsAssignIn); + return apply(assignInWith, undefined, args); + }); + + /** + * 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) { + 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 (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': '