(https://github.com/drpizza)"
+ ],
+ "repository": "micromatch/micromatch",
+ "bugs": {
+ "url": "https://github.com/micromatch/micromatch/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=8"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "dependencies": {
+ "braces": "^3.0.1",
+ "picomatch": "^2.0.5"
+ },
+ "devDependencies": {
+ "fill-range": "^7.0.1",
+ "gulp-format-md": "^2.0.0",
+ "minimatch": "^3.0.4",
+ "mocha": "^5.2.0",
+ "time-require": "github:jonschlinkert/time-require"
+ },
+ "keywords": [
+ "bash",
+ "bracket",
+ "character-class",
+ "expand",
+ "expansion",
+ "expression",
+ "extglob",
+ "extglobs",
+ "file",
+ "files",
+ "filter",
+ "find",
+ "glob",
+ "globbing",
+ "globs",
+ "globstar",
+ "lookahead",
+ "lookaround",
+ "lookbehind",
+ "match",
+ "matcher",
+ "matches",
+ "matching",
+ "micromatch",
+ "minimatch",
+ "multimatch",
+ "negate",
+ "negation",
+ "path",
+ "pattern",
+ "patterns",
+ "posix",
+ "regex",
+ "regexp",
+ "regular",
+ "shell",
+ "star",
+ "wildcard"
+ ],
+ "verb": {
+ "toc": "collapsible",
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "related": {
+ "list": [
+ "braces",
+ "expand-brackets",
+ "extglob",
+ "fill-range",
+ "nanomatch"
+ ]
+ },
+ "reflinks": [
+ "extglob",
+ "fill-range",
+ "glob-object",
+ "minimatch",
+ "multimatch"
+ ]
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/CHANGELOG.md b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/CHANGELOG.md
new file mode 100644
index 00000000..91ef4dcf
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/CHANGELOG.md
@@ -0,0 +1,69 @@
+# Release history
+
+**All notable changes to this project will be documented in this file.**
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+
+ Guiding Principles
+
+
+ Types of changes
+
+## [2.0.4] - 2019-04-10
+
+### Fixed
+
+- Readme link [fixed](https://github.com/micromatch/picomatch/pull/13/commits/a96ab3aa2b11b6861c23289964613d85563b05df) by @danez.
+- `options.capture` now works as expected when fastpaths are enabled. See https://github.com/micromatch/picomatch/pull/12/commits/26aefd71f1cfaf95c37f1c1fcab68a693b037304. Thanks to @DrPizza.
+
+## [2.0.0] - 2019-04-10
+
+### Added
+
+- Adds support for `options.onIgnore`. See the readme for details
+- Adds support for `options.onResult`. See the readme for details
+
+### Breaking changes
+
+- The unixify option was renamed to `windows`
+- caching and all related options and methods have been removed
+
+## [1.0.0] - 2018-11-05
+
+- adds `.onMatch` option
+- improvements to `.scan` method
+- numerous improvements and optimizations for matching and parsing
+- better windows path handling
+
+## 0.1.0 - 2017-04-13
+
+First release.
+
+
+[2.0.4]: https://github.com/jonschlinkert/micromatch/compare/2.0.0...2.0.4
+[2.0.0]: https://github.com/jonschlinkert/micromatch/compare/1.0.0...2.0.0
+[1.0.0]: https://github.com/jonschlinkert/micromatch/compare/0.1.0...1.0.0
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/LICENSE b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/LICENSE
new file mode 100644
index 00000000..3608dca2
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present, Jon Schlinkert.
+
+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.
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/README.md b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/README.md
new file mode 100644
index 00000000..03ba961d
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/README.md
@@ -0,0 +1,605 @@
+Picomatch
+
+
+
+
+
+
+
+
+
+
+
+Blazing fast and accurate glob matcher written in JavaScript.
+No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.
+
+
+
+Contributing
+
+
+Running Tests
+
+
+Building docs
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2017-present, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/index.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/index.js
new file mode 100644
index 00000000..d2f2bc59
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/index.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/picomatch');
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/constants.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/constants.js
new file mode 100644
index 00000000..96618a35
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/constants.js
@@ -0,0 +1,179 @@
+'use strict';
+
+const path = require('path');
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+/**
+ * Posix glob regex
+ */
+
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR = `${QMARK}*?`;
+
+const POSIX_CHARS = {
+ DOT_LITERAL,
+ PLUS_LITERAL,
+ QMARK_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ QMARK,
+ END_ANCHOR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOT_SLASH,
+ NO_DOTS_SLASH,
+ QMARK_NO_DOT,
+ STAR,
+ START_ANCHOR
+};
+
+/**
+ * Windows glob regex
+ */
+
+const WINDOWS_CHARS = {
+ ...POSIX_CHARS,
+
+ SLASH_LITERAL: `[${WIN_SLASH}]`,
+ QMARK: WIN_NO_SLASH,
+ STAR: `${WIN_NO_SLASH}*?`,
+ DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+ NO_DOT: `(?!${DOT_LITERAL})`,
+ NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+ NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+ NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+ QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+ START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+ END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+};
+
+/**
+ * POSIX Bracket Regex
+ */
+
+const POSIX_REGEX_SOURCE = {
+ alnum: 'a-zA-Z0-9',
+ alpha: 'a-zA-Z',
+ ascii: '\\x00-\\x7F',
+ 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'
+};
+
+module.exports = {
+ MAX_LENGTH: 1024 * 64,
+ POSIX_REGEX_SOURCE,
+
+ // regular expressions
+ REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+ REGEX_NON_SPECIAL_CHAR: /^[^@![\].,$*+?^{}()|\\/]+/,
+ REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+ REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+ REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+ REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+ // Replace globs with equivalent patterns to reduce parsing time.
+ REPLACEMENTS: {
+ '***': '*',
+ '**/**': '**',
+ '**/**/**': '**'
+ },
+
+ // Digits
+ CHAR_0: 48, /* 0 */
+ CHAR_9: 57, /* 9 */
+
+ // Alphabet chars.
+ CHAR_UPPERCASE_A: 65, /* A */
+ CHAR_LOWERCASE_A: 97, /* a */
+ CHAR_UPPERCASE_Z: 90, /* Z */
+ CHAR_LOWERCASE_Z: 122, /* z */
+
+ CHAR_LEFT_PARENTHESES: 40, /* ( */
+ CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+ CHAR_ASTERISK: 42, /* * */
+
+ // Non-alphabetic chars.
+ CHAR_AMPERSAND: 38, /* & */
+ CHAR_AT: 64, /* @ */
+ CHAR_BACKWARD_SLASH: 92, /* \ */
+ CHAR_CARRIAGE_RETURN: 13, /* \r */
+ CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+ CHAR_COLON: 58, /* : */
+ CHAR_COMMA: 44, /* , */
+ CHAR_DOT: 46, /* . */
+ CHAR_DOUBLE_QUOTE: 34, /* " */
+ CHAR_EQUAL: 61, /* = */
+ CHAR_EXCLAMATION_MARK: 33, /* ! */
+ CHAR_FORM_FEED: 12, /* \f */
+ CHAR_FORWARD_SLASH: 47, /* / */
+ CHAR_GRAVE_ACCENT: 96, /* ` */
+ CHAR_HASH: 35, /* # */
+ CHAR_HYPHEN_MINUS: 45, /* - */
+ CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+ CHAR_LEFT_CURLY_BRACE: 123, /* { */
+ CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+ CHAR_LINE_FEED: 10, /* \n */
+ CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+ CHAR_PERCENT: 37, /* % */
+ CHAR_PLUS: 43, /* + */
+ CHAR_QUESTION_MARK: 63, /* ? */
+ CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+ CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+ CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+ CHAR_SEMICOLON: 59, /* ; */
+ CHAR_SINGLE_QUOTE: 39, /* ' */
+ CHAR_SPACE: 32, /* */
+ CHAR_TAB: 9, /* \t */
+ CHAR_UNDERSCORE: 95, /* _ */
+ CHAR_VERTICAL_LINE: 124, /* | */
+ CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+ SEP: path.sep,
+
+ /**
+ * Create EXTGLOB_CHARS
+ */
+
+ extglobChars(chars) {
+ return {
+ '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+ '?': { type: 'qmark', open: '(?:', close: ')?' },
+ '+': { type: 'plus', open: '(?:', close: ')+' },
+ '*': { type: 'star', open: '(?:', close: ')*' },
+ '@': { type: 'at', open: '(?:', close: ')' }
+ };
+ },
+
+ /**
+ * Create GLOB_CHARS
+ */
+
+ globChars(win32) {
+ return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+ }
+};
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/parse.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/parse.js
new file mode 100644
index 00000000..ccb41def
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/parse.js
@@ -0,0 +1,1011 @@
+'use strict';
+
+const utils = require('./utils');
+const constants = require('./constants');
+
+/**
+ * Constants
+ */
+
+const {
+ MAX_LENGTH,
+ POSIX_REGEX_SOURCE,
+ REGEX_NON_SPECIAL_CHAR,
+ REGEX_SPECIAL_CHARS_BACKREF,
+ REPLACEMENTS
+} = constants;
+
+/**
+ * Helpers
+ */
+
+const expandRange = (args, options) => {
+ if (typeof options.expandRange === 'function') {
+ return options.expandRange(...args, options);
+ }
+
+ args.sort();
+ let value = `[${args.join('-')}]`;
+
+ try {
+ /* eslint-disable no-new */
+ new RegExp(value);
+ } catch (ex) {
+ return args.map(v => utils.escapeRegex(v)).join('..');
+ }
+
+ return value;
+};
+
+const negate = state => {
+ let count = 1;
+
+ while (state.peek() === '!' && (state.peek(2) !== '(' || state.peek(3) === '?')) {
+ state.advance();
+ state.start++;
+ count++;
+ }
+
+ if (count % 2 === 0) {
+ return false;
+ }
+
+ state.negated = true;
+ state.start++;
+ return true;
+};
+
+/**
+ * Create the message for a syntax error
+ */
+
+const syntaxError = (type, char) => {
+ return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+};
+
+/**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */
+
+const parse = (input, options) => {
+ if (typeof input !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+
+ input = REPLACEMENTS[input] || input;
+
+ let opts = { ...options };
+ let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ let len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
+
+ let bos = { type: 'bos', value: '', output: opts.prepend || '' };
+ let tokens = [bos];
+
+ let capture = opts.capture ? '' : '?:';
+ let win32 = utils.isWindows(options);
+
+ // create constants based on platform, for windows or posix
+ const PLATFORM_CHARS = constants.globChars(win32);
+ const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+ const {
+ DOT_LITERAL,
+ PLUS_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOT_SLASH,
+ NO_DOTS_SLASH,
+ QMARK,
+ QMARK_NO_DOT,
+ STAR,
+ START_ANCHOR
+ } = PLATFORM_CHARS;
+
+ const globstar = (opts) => {
+ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+
+ let nodot = opts.dot ? '' : NO_DOT;
+ let star = opts.bash === true ? globstar(opts) : STAR;
+ let qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+
+ // minimatch options support
+ if (typeof opts.noext === 'boolean') {
+ opts.noextglob = opts.noext;
+ }
+
+ let state = {
+ index: -1,
+ start: 0,
+ consumed: '',
+ output: '',
+ backtrack: false,
+ brackets: 0,
+ braces: 0,
+ parens: 0,
+ quotes: 0,
+ tokens
+ };
+
+ let extglobs = [];
+ let stack = [];
+ let prev = bos;
+ let value;
+
+ /**
+ * Tokenizing helpers
+ */
+
+ const eos = () => state.index === len - 1;
+ const peek = state.peek = (n = 1) => input[state.index + n];
+ const advance = state.advance = () => input[++state.index];
+ const append = token => {
+ state.output += token.output != null ? token.output : token.value;
+ state.consumed += token.value || '';
+ };
+
+ const increment = type => {
+ state[type]++;
+ stack.push(type);
+ };
+
+ const decrement = type => {
+ state[type]--;
+ stack.pop();
+ };
+
+ /**
+ * Push tokens onto the tokens array. This helper speeds up
+ * tokenizing by 1) helping us avoid backtracking as much as possible,
+ * and 2) helping us avoid creating extra tokens when consecutive
+ * characters are plain text. This improves performance and simplifies
+ * lookbehinds.
+ */
+
+ const push = tok => {
+ if (prev.type === 'globstar') {
+ let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+ let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren');
+ if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+ state.output = state.output.slice(0, -prev.output.length);
+ prev.type = 'star';
+ prev.value = '*';
+ prev.output = star;
+ state.output += prev.output;
+ }
+ }
+
+ if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
+ extglobs[extglobs.length - 1].inner += tok.value;
+ }
+
+ if (tok.value || tok.output) append(tok);
+ if (prev && prev.type === 'text' && tok.type === 'text') {
+ prev.value += tok.value;
+ return;
+ }
+
+ tok.prev = prev;
+ tokens.push(tok);
+ prev = tok;
+ };
+
+ const extglobOpen = (type, value) => {
+ let token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+ token.prev = prev;
+ token.parens = state.parens;
+ token.output = state.output;
+ let output = (opts.capture ? '(' : '') + token.open;
+
+ push({ type, value, output: state.output ? '' : ONE_CHAR });
+ push({ type: 'paren', extglob: true, value: advance(), output });
+ increment('parens');
+ extglobs.push(token);
+ };
+
+ const extglobClose = token => {
+ let output = token.close + (opts.capture ? ')' : '');
+
+ if (token.type === 'negate') {
+ let extglobStar = star;
+
+ if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+ extglobStar = globstar(opts);
+ }
+
+ if (extglobStar !== star || eos() || /^\)+$/.test(input.slice(state.index + 1))) {
+ output = token.close = ')$))' + extglobStar;
+ }
+
+ if (token.prev.type === 'bos' && eos()) {
+ state.negatedExtglob = true;
+ }
+ }
+
+ push({ type: 'paren', extglob: true, value, output });
+ decrement('parens');
+ };
+
+ if (opts.fastpaths !== false && !/(^[*!]|[/{[()\]}"])/.test(input)) {
+ let backslashes = false;
+
+ let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+ if (first === '\\') {
+ backslashes = true;
+ return m;
+ }
+
+ if (first === '?') {
+ if (esc) {
+ return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+ }
+ if (index === 0) {
+ return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+ }
+ return QMARK.repeat(chars.length);
+ }
+
+ if (first === '.') {
+ return DOT_LITERAL.repeat(chars.length);
+ }
+
+ if (first === '*') {
+ if (esc) {
+ return esc + first + (rest ? star : '');
+ }
+ return star;
+ }
+ return esc ? m : '\\' + m;
+ });
+
+ if (backslashes === true) {
+ if (opts.unescape === true) {
+ output = output.replace(/\\/g, '');
+ } else {
+ output = output.replace(/\\+/g, m => {
+ return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+ });
+ }
+ }
+
+ state.output = output;
+ return state;
+ }
+
+ /**
+ * Tokenize input until we reach end-of-string
+ */
+
+ while (!eos()) {
+ value = advance();
+
+ if (value === '\u0000') {
+ continue;
+ }
+
+ /**
+ * Escaped characters
+ */
+
+ if (value === '\\') {
+ let next = peek();
+
+ if (next === '/' && opts.bash !== true) {
+ continue;
+ }
+
+ if (next === '.' || next === ';') {
+ continue;
+ }
+
+ if (!next) {
+ value += '\\';
+ push({ type: 'text', value });
+ continue;
+ }
+
+ // collapse slashes to reduce potential for exploits
+ let match = /^\\+/.exec(input.slice(state.index + 1));
+ let slashes = 0;
+
+ if (match && match[0].length > 2) {
+ slashes = match[0].length;
+ state.index += slashes;
+ if (slashes % 2 !== 0) {
+ value += '\\';
+ }
+ }
+
+ if (opts.unescape === true) {
+ value = advance() || '';
+ } else {
+ value += advance() || '';
+ }
+
+ if (state.brackets === 0) {
+ push({ type: 'text', value });
+ continue;
+ }
+ }
+
+ /**
+ * If we're inside a regex character class, continue
+ * until we reach the closing bracket.
+ */
+
+ if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+ if (opts.posix !== false && value === ':') {
+ let inner = prev.value.slice(1);
+ if (inner.includes('[')) {
+ prev.posix = true;
+
+ if (inner.includes(':')) {
+ let idx = prev.value.lastIndexOf('[');
+ let pre = prev.value.slice(0, idx);
+ let rest = prev.value.slice(idx + 2);
+ let posix = POSIX_REGEX_SOURCE[rest];
+ if (posix) {
+ prev.value = pre + posix;
+ state.backtrack = true;
+ advance();
+
+ if (!bos.output && tokens.indexOf(prev) === 1) {
+ bos.output = ONE_CHAR;
+ }
+ continue;
+ }
+ }
+ }
+ }
+
+ if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+ value = '\\' + value;
+ }
+
+ if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+ value = '\\' + value;
+ }
+
+ if (opts.posix === true && value === '!' && prev.value === '[') {
+ value = '^';
+ }
+
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+
+ /**
+ * If we're inside a quoted string, continue
+ * until we reach the closing double quote.
+ */
+
+ if (state.quotes === 1 && value !== '"') {
+ value = utils.escapeRegex(value);
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+
+ /**
+ * Double quotes
+ */
+
+ if (value === '"') {
+ state.quotes = state.quotes === 1 ? 0 : 1;
+ if (opts.keepQuotes === true) {
+ push({ type: 'text', value });
+ }
+ continue;
+ }
+
+ /**
+ * Parentheses
+ */
+
+ if (value === '(') {
+ push({ type: 'paren', value });
+ increment('parens');
+ continue;
+ }
+
+ if (value === ')') {
+ if (state.parens === 0 && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError('opening', '('));
+ }
+
+ let extglob = extglobs[extglobs.length - 1];
+ if (extglob && state.parens === extglob.parens + 1) {
+ extglobClose(extglobs.pop());
+ continue;
+ }
+
+ push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+ decrement('parens');
+ continue;
+ }
+
+ /**
+ * Brackets
+ */
+
+ if (value === '[') {
+ if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) {
+ if (opts.nobracket !== true && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError('closing', ']'));
+ }
+
+ value = '\\' + value;
+ } else {
+ increment('brackets');
+ }
+
+ push({ type: 'bracket', value });
+ continue;
+ }
+
+ if (value === ']') {
+ if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+ push({ type: 'text', value, output: '\\' + value });
+ continue;
+ }
+
+ if (state.brackets === 0) {
+ if (opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError('opening', '['));
+ }
+
+ push({ type: 'text', value, output: '\\' + value });
+ continue;
+ }
+
+ decrement('brackets');
+
+ let prevValue = prev.value.slice(1);
+ if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+ value = '/' + value;
+ }
+
+ prev.value += value;
+ append({ value });
+
+ // when literal brackets are explicitly disabled
+ // assume we should match with a regex character class
+ if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+ continue;
+ }
+
+ let escaped = utils.escapeRegex(prev.value);
+ state.output = state.output.slice(0, -prev.value.length);
+
+ // when literal brackets are explicitly enabled
+ // assume we should escape the brackets to match literal characters
+ if (opts.literalBrackets === true) {
+ state.output += escaped;
+ prev.value = escaped;
+ continue;
+ }
+
+ // when the user specifies nothing, try to match both
+ prev.value = `(${capture}${escaped}|${prev.value})`;
+ state.output += prev.value;
+ continue;
+ }
+
+ /**
+ * Braces
+ */
+
+ if (value === '{' && opts.nobrace !== true) {
+ push({ type: 'brace', value, output: '(' });
+ increment('braces');
+ continue;
+ }
+
+ if (value === '}') {
+ if (opts.nobrace === true || state.braces === 0) {
+ push({ type: 'text', value, output: '\\' + value });
+ continue;
+ }
+
+ let output = ')';
+
+ if (state.dots === true) {
+ let arr = tokens.slice();
+ let range = [];
+
+ for (let i = arr.length - 1; i >= 0; i--) {
+ tokens.pop();
+ if (arr[i].type === 'brace') {
+ break;
+ }
+ if (arr[i].type !== 'dots') {
+ range.unshift(arr[i].value);
+ }
+ }
+
+ output = expandRange(range, opts);
+ state.backtrack = true;
+ }
+
+ push({ type: 'brace', value, output });
+ decrement('braces');
+ continue;
+ }
+
+ /**
+ * Pipes
+ */
+
+ if (value === '|') {
+ if (extglobs.length > 0) {
+ extglobs[extglobs.length - 1].conditions++;
+ }
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Commas
+ */
+
+ if (value === ',') {
+ let output = value;
+
+ if (state.braces > 0 && stack[stack.length - 1] === 'braces') {
+ output = '|';
+ }
+
+ push({ type: 'comma', value, output });
+ continue;
+ }
+
+ /**
+ * Slashes
+ */
+
+ if (value === '/') {
+ // if the beginning of the glob is "./", advance the start
+ // to the current index, and don't add the "./" characters
+ // to the state. This greatly simplifies lookbehinds when
+ // checking for BOS characters like "!" and "." (not "./")
+ if (prev.type === 'dot' && state.index === 1) {
+ state.start = state.index + 1;
+ state.consumed = '';
+ state.output = '';
+ tokens.pop();
+ prev = bos; // reset "prev" to the first token
+ continue;
+ }
+
+ push({ type: 'slash', value, output: SLASH_LITERAL });
+ continue;
+ }
+
+ /**
+ * Dots
+ */
+
+ if (value === '.') {
+ if (state.braces > 0 && prev.type === 'dot') {
+ if (prev.value === '.') prev.output = DOT_LITERAL;
+ prev.type = 'dots';
+ prev.output += value;
+ prev.value += value;
+ state.dots = true;
+ continue;
+ }
+
+ push({ type: 'dot', value, output: DOT_LITERAL });
+ continue;
+ }
+
+ /**
+ * Question marks
+ */
+
+ if (value === '?') {
+ if (prev && prev.type === 'paren') {
+ let next = peek();
+ let output = value;
+
+ if (next === '<' && !utils.supportsLookbehinds()) {
+ throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+ }
+
+ if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) {
+ output = '\\' + value;
+ }
+
+ push({ type: 'text', value, output });
+ continue;
+ }
+
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('qmark', value);
+ continue;
+ }
+
+ if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+ push({ type: 'qmark', value, output: QMARK_NO_DOT });
+ continue;
+ }
+
+ push({ type: 'qmark', value, output: QMARK });
+ continue;
+ }
+
+ /**
+ * Exclamation
+ */
+
+ if (value === '!') {
+ if (opts.noextglob !== true && peek() === '(') {
+ if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+ extglobOpen('negate', value);
+ continue;
+ }
+ }
+
+ if (opts.nonegate !== true && state.index === 0) {
+ negate(state);
+ continue;
+ }
+ }
+
+ /**
+ * Plus
+ */
+
+ if (value === '+') {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('plus', value);
+ continue;
+ }
+
+ if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) {
+ let output = prev.extglob === true ? '\\' + value : value;
+ push({ type: 'plus', value, output });
+ continue;
+ }
+
+ // use regex behavior inside parens
+ if (state.parens > 0 && opts.regex !== false) {
+ push({ type: 'plus', value });
+ continue;
+ }
+
+ push({ type: 'plus', value: PLUS_LITERAL });
+ continue;
+ }
+
+ /**
+ * Plain text
+ */
+
+ if (value === '@') {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ push({ type: 'at', value, output: '' });
+ continue;
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Plain text
+ */
+
+ if (value !== '*') {
+ if (value === '$' || value === '^') {
+ value = '\\' + value;
+ }
+
+ let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1));
+ if (match) {
+ value += match[0];
+ state.index += match[0].length;
+ }
+
+ push({ type: 'text', value });
+ continue;
+ }
+
+ /**
+ * Stars
+ */
+
+ if (prev && (prev.type === 'globstar' || prev.star === true)) {
+ prev.type = 'star';
+ prev.star = true;
+ prev.value += value;
+ prev.output = star;
+ state.backtrack = true;
+ state.consumed += value;
+ continue;
+ }
+
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('star', value);
+ continue;
+ }
+
+ if (prev.type === 'star') {
+ if (opts.noglobstar === true) {
+ state.consumed += value;
+ continue;
+ }
+
+ let prior = prev.prev;
+ let before = prior.prev;
+ let isStart = prior.type === 'slash' || prior.type === 'bos';
+ let afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+ if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) {
+ push({ type: 'star', value, output: '' });
+ continue;
+ }
+
+ let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+ let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+ if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+ push({ type: 'star', value, output: '' });
+ continue;
+ }
+
+ // strip consecutive `/**/`
+ while (input.slice(state.index + 1, state.index + 4) === '/**') {
+ let after = input[state.index + 4];
+ if (after && after !== '/') {
+ break;
+ }
+ state.consumed += '/**';
+ state.index += 3;
+ }
+
+ if (prior.type === 'bos' && eos()) {
+ prev.type = 'globstar';
+ prev.value += value;
+ prev.output = globstar(opts);
+ state.output = prev.output;
+ state.consumed += value;
+ continue;
+ }
+
+ if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = '(?:' + prior.output;
+
+ prev.type = 'globstar';
+ prev.output = globstar(opts) + '|$)';
+ prev.value += value;
+
+ state.output += prior.output + prev.output;
+ state.consumed += value;
+ continue;
+ }
+
+ let next = peek();
+ if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') {
+ let end = peek(2) !== void 0 ? '|$' : '';
+
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = '(?:' + prior.output;
+
+ prev.type = 'globstar';
+ prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+ prev.value += value;
+
+ state.output += prior.output + prev.output;
+ state.consumed += value + advance();
+
+ push({ type: 'slash', value, output: '' });
+ continue;
+ }
+
+ if (prior.type === 'bos' && next === '/') {
+ prev.type = 'globstar';
+ prev.value += value;
+ prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+ state.output = prev.output;
+ state.consumed += value + advance();
+ push({ type: 'slash', value, output: '' });
+ continue;
+ }
+
+ // remove single star from output
+ state.output = state.output.slice(0, -prev.output.length);
+
+ // reset previous token to globstar
+ prev.type = 'globstar';
+ prev.output = globstar(opts);
+ prev.value += value;
+
+ // reset output with globstar
+ state.output += prev.output;
+ state.consumed += value;
+ continue;
+ }
+
+ let token = { type: 'star', value, output: star };
+
+ if (opts.bash === true) {
+ token.output = '.*?';
+ if (prev.type === 'bos' || prev.type === 'slash') {
+ token.output = nodot + token.output;
+ }
+ push(token);
+ continue;
+ }
+
+ if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+ token.output = value;
+ push(token);
+ continue;
+ }
+
+ if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+ if (prev.type === 'dot') {
+ state.output += NO_DOT_SLASH;
+ prev.output += NO_DOT_SLASH;
+
+ } else if (opts.dot === true) {
+ state.output += NO_DOTS_SLASH;
+ prev.output += NO_DOTS_SLASH;
+
+ } else {
+ state.output += nodot;
+ prev.output += nodot;
+ }
+
+ if (peek() !== '*') {
+ state.output += ONE_CHAR;
+ prev.output += ONE_CHAR;
+ }
+ }
+
+ push(token);
+ }
+
+ while (state.brackets > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+ state.output = utils.escapeLast(state.output, '[');
+ decrement('brackets');
+ }
+
+ while (state.parens > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+ state.output = utils.escapeLast(state.output, '(');
+ decrement('parens');
+ }
+
+ while (state.braces > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+ state.output = utils.escapeLast(state.output, '{');
+ decrement('braces');
+ }
+
+ if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+ push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+ }
+
+ // rebuild the output if we had to backtrack at any point
+ if (state.backtrack === true) {
+ state.output = '';
+
+ for (let token of state.tokens) {
+ state.output += token.output != null ? token.output : token.value;
+
+ if (token.suffix) {
+ state.output += token.suffix;
+ }
+ }
+ }
+
+ return state;
+};
+
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
+
+parse.fastpaths = (input, options) => {
+ let opts = { ...options };
+ let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ let len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
+
+ input = REPLACEMENTS[input] || input;
+ let win32 = utils.isWindows(options);
+
+ // create constants based on platform, for windows or posix
+ const {
+ DOT_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOTS_SLASH,
+ STAR,
+ START_ANCHOR
+ } = constants.globChars(win32);
+
+ let capture = opts.capture ? '' : '?:';
+ let star = opts.bash === true ? '.*?' : STAR;
+ let nodot = opts.dot ? NO_DOTS : NO_DOT;
+ let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+
+ const globstar = (opts) => {
+ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+
+ const create = str => {
+ switch (str) {
+ case '*':
+ return `${nodot}${ONE_CHAR}${star}`;
+
+ case '.*':
+ return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '*.*':
+ return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '*/*':
+ return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+ case '**':
+ return nodot + globstar(opts);
+
+ case '**/*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+ case '**/*.*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '**/.*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ default: {
+ let match = /^(.*?)\.(\w+)$/.exec(str);
+ if (!match) return;
+
+ let source = create(match[1], options);
+ if (!source) return;
+
+ return source + DOT_LITERAL + match[2];
+ }
+ }
+ };
+
+ let output = create(input);
+ if (output && opts.strictSlashes !== true) {
+ output += `${SLASH_LITERAL}?`;
+ }
+
+ return output;
+};
+
+module.exports = parse;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/picomatch.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/picomatch.js
new file mode 100644
index 00000000..6a0affb4
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/picomatch.js
@@ -0,0 +1,315 @@
+'use strict';
+
+const path = require('path');
+const scan = require('./scan');
+const parse = require('./parse');
+const utils = require('./utils');
+
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
+
+const picomatch = (glob, options, returnState = false) => {
+ if (Array.isArray(glob)) {
+ let fns = glob.map(input => picomatch(input, options, returnState));
+ return str => {
+ for (let isMatch of fns) {
+ let state = isMatch(str);
+ if (state) return state;
+ }
+ return false;
+ };
+ }
+
+ if (typeof glob !== 'string' || glob === '') {
+ throw new TypeError('Expected pattern to be a non-empty string');
+ }
+
+ let opts = options || {};
+ let posix = utils.isWindows(options);
+ let regex = picomatch.makeRe(glob, options, false, true);
+ let state = regex.state;
+ delete regex.state;
+
+ let isIgnored = () => false;
+ if (opts.ignore) {
+ let ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+ isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+ }
+
+ const matcher = (input, returnObject = false) => {
+ let { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+ let result = { glob, state, regex, posix, input, output, match, isMatch };
+
+ if (typeof opts.onResult === 'function') {
+ opts.onResult(result);
+ }
+
+ if (isMatch === false) {
+ result.isMatch = false;
+ return returnObject ? result : false;
+ }
+
+ if (isIgnored(input)) {
+ if (typeof opts.onIgnore === 'function') {
+ opts.onIgnore(result);
+ }
+ result.isMatch = false;
+ return returnObject ? result : false;
+ }
+
+ if (typeof opts.onMatch === 'function') {
+ opts.onMatch(result);
+ }
+ return returnObject ? result : true;
+ };
+
+ if (returnState) {
+ matcher.state = state;
+ }
+
+ return matcher;
+};
+
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
+
+picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+ if (typeof input !== 'string') {
+ throw new TypeError('Expected input to be a string');
+ }
+
+ if (input === '') {
+ return { isMatch: false, output: '' };
+ }
+
+ let opts = options || {};
+ let format = opts.format || (posix ? utils.toPosixSlashes : null);
+ let match = input === glob;
+ let output = (match && format) ? format(input) : input;
+
+ if (match === false) {
+ output = format ? format(input) : input;
+ match = output === glob;
+ }
+
+ if (match === false || opts.capture === true) {
+ if (opts.matchBase === true || opts.basename === true) {
+ match = picomatch.matchBase(input, regex, options, posix);
+ } else {
+ match = regex.exec(output);
+ }
+ }
+
+ return { isMatch: !!match, match, output };
+};
+
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
+
+picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+ let regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+ return regex.test(path.basename(input));
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(glob[, options]);
+ * ```
+ * @param {String} `glob`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
+
+picomatch.parse = (glob, options) => parse(glob, options);
+
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * // { prefix: '!./',
+ * // input: '!./foo/*.js',
+ * // base: 'foo',
+ * // glob: '*.js',
+ * // negated: true,
+ * // isGlob: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+picomatch.scan = (input, options) => scan(input, options);
+
+/**
+ * Create a regular expression from a glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.makeRe(input[, options]);
+ *
+ * console.log(picomatch.makeRe('*.js'));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `input` A glob pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {
+ if (!input || typeof input !== 'string') {
+ throw new TypeError('Expected a non-empty string');
+ }
+
+ let opts = options || {};
+ let prepend = opts.contains ? '' : '^';
+ let append = opts.contains ? '' : '$';
+ let state = { negated: false, fastpaths: true };
+ let prefix = '';
+ let output;
+
+ if (input.startsWith('./')) {
+ input = input.slice(2);
+ prefix = state.prefix = './';
+ }
+
+ if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+ output = parse.fastpaths(input, options);
+ }
+
+ if (output === void 0) {
+ state = picomatch.parse(input, options);
+ state.prefix = prefix + (state.prefix || '');
+ output = state.output;
+ }
+
+ if (returnOutput === true) {
+ return output;
+ }
+
+ let source = `${prepend}(?:${output})${append}`;
+ if (state && state.negated === true) {
+ source = `^(?!${source}).*$`;
+ }
+
+ let regex = picomatch.toRegex(source, options);
+ if (returnState === true) {
+ regex.state = state;
+ }
+
+ return regex;
+};
+
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch.toRegex = (source, options) => {
+ try {
+ let opts = options || {};
+ return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+ } catch (err) {
+ if (options && options.debug === true) throw err;
+ return /$^/;
+ }
+};
+
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
+
+picomatch.constants = require('./constants');
+
+/**
+ * Expose "picomatch"
+ */
+
+module.exports = picomatch;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/scan.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/scan.js
new file mode 100644
index 00000000..e2ba6bae
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/scan.js
@@ -0,0 +1,219 @@
+'use strict';
+
+const utils = require('./utils');
+
+const {
+ CHAR_ASTERISK, /* * */
+ CHAR_AT, /* @ */
+ CHAR_BACKWARD_SLASH, /* \ */
+ CHAR_COMMA, /* , */
+ CHAR_DOT, /* . */
+ CHAR_EXCLAMATION_MARK, /* ! */
+ CHAR_FORWARD_SLASH, /* / */
+ CHAR_LEFT_CURLY_BRACE, /* { */
+ CHAR_LEFT_PARENTHESES, /* ( */
+ CHAR_LEFT_SQUARE_BRACKET, /* [ */
+ CHAR_PLUS, /* + */
+ CHAR_QUESTION_MARK, /* ? */
+ CHAR_RIGHT_CURLY_BRACE, /* } */
+ CHAR_RIGHT_PARENTHESES, /* ) */
+ CHAR_RIGHT_SQUARE_BRACKET /* ] */
+} = require('./constants');
+
+const isPathSeparator = code => {
+ return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
+
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
+
+module.exports = (input, options) => {
+ let opts = options || {};
+ let length = input.length - 1;
+ let index = -1;
+ let start = 0;
+ let lastIndex = 0;
+ let isGlob = false;
+ let backslashes = false;
+ let negated = false;
+ let braces = 0;
+ let prev;
+ let code;
+
+ let braceEscaped = false;
+
+ let eos = () => index >= length;
+ let advance = () => {
+ prev = code;
+ return input.charCodeAt(++index);
+ };
+
+ while (index < length) {
+ code = advance();
+ let next;
+
+ if (code === CHAR_BACKWARD_SLASH) {
+ backslashes = true;
+ next = advance();
+
+ if (next === CHAR_LEFT_CURLY_BRACE) {
+ braceEscaped = true;
+ }
+ continue;
+ }
+
+ if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+ braces++;
+
+ while (!eos() && (next = advance())) {
+ if (next === CHAR_BACKWARD_SLASH) {
+ backslashes = true;
+ next = advance();
+ continue;
+ }
+
+ if (next === CHAR_LEFT_CURLY_BRACE) {
+ braces++;
+ continue;
+ }
+
+ if (!braceEscaped && next === CHAR_DOT && (next = advance()) === CHAR_DOT) {
+ isGlob = true;
+ break;
+ }
+
+ if (!braceEscaped && next === CHAR_COMMA) {
+ isGlob = true;
+ break;
+ }
+
+ if (next === CHAR_RIGHT_CURLY_BRACE) {
+ braces--;
+ if (braces === 0) {
+ braceEscaped = false;
+ break;
+ }
+ }
+ }
+ }
+
+ if (code === CHAR_FORWARD_SLASH) {
+ if (prev === CHAR_DOT && index === (start + 1)) {
+ start += 2;
+ continue;
+ }
+
+ lastIndex = index + 1;
+ continue;
+ }
+
+ if (code === CHAR_ASTERISK) {
+ isGlob = true;
+ break;
+ }
+
+ if (code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK) {
+ isGlob = true;
+ break;
+ }
+
+ if (code === CHAR_LEFT_SQUARE_BRACKET) {
+ while (!eos() && (next = advance())) {
+ if (next === CHAR_BACKWARD_SLASH) {
+ backslashes = true;
+ next = advance();
+ continue;
+ }
+
+ if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+ isGlob = true;
+ break;
+ }
+ }
+ }
+
+ let isExtglobChar = code === CHAR_PLUS
+ || code === CHAR_AT
+ || code === CHAR_EXCLAMATION_MARK;
+
+ if (isExtglobChar && input.charCodeAt(index + 1) === CHAR_LEFT_PARENTHESES) {
+ isGlob = true;
+ break;
+ }
+
+ if (code === CHAR_EXCLAMATION_MARK && index === start) {
+ negated = true;
+ start++;
+ continue;
+ }
+
+ if (code === CHAR_LEFT_PARENTHESES) {
+ while (!eos() && (next = advance())) {
+ if (next === CHAR_BACKWARD_SLASH) {
+ backslashes = true;
+ next = advance();
+ continue;
+ }
+
+ if (next === CHAR_RIGHT_PARENTHESES) {
+ isGlob = true;
+ break;
+ }
+ }
+ }
+
+ if (isGlob) {
+ break;
+ }
+ }
+
+ let prefix = '';
+ let orig = input;
+ let base = input;
+ let glob = '';
+
+ if (start > 0) {
+ prefix = input.slice(0, start);
+ input = input.slice(start);
+ lastIndex -= start;
+ }
+
+ if (base && isGlob === true && lastIndex > 0) {
+ base = input.slice(0, lastIndex);
+ glob = input.slice(lastIndex);
+ } else if (isGlob === true) {
+ base = '';
+ glob = input;
+ } else {
+ base = input;
+ }
+
+ if (base && base !== '' && base !== '/' && base !== input) {
+ if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+ base = base.slice(0, -1);
+ }
+ }
+
+ if (opts.unescape === true) {
+ if (glob) glob = utils.removeBackslashes(glob);
+
+ if (base && backslashes === true) {
+ base = utils.removeBackslashes(base);
+ }
+ }
+
+ return { prefix, input: orig, base, glob, negated, isGlob };
+};
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/utils.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/utils.js
new file mode 100644
index 00000000..e99ae268
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/lib/utils.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const path = require('path');
+const win32 = process.platform === 'win32';
+const {
+ REGEX_SPECIAL_CHARS,
+ REGEX_SPECIAL_CHARS_GLOBAL,
+ REGEX_REMOVE_BACKSLASH
+} = require('./constants');
+
+exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+exports.toPosixSlashes = str => str.replace(/\\/g, '/');
+
+exports.removeBackslashes = str => {
+ return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+ return match === '\\' ? '' : match;
+ });
+}
+
+exports.supportsLookbehinds = () => {
+ let segs = process.version.slice(1).split('.');
+ if (segs.length === 3 && +segs[0] >= 9 || (+segs[0] === 8 && +segs[1] >= 10)) {
+ return true;
+ }
+ return false;
+};
+
+exports.isWindows = options => {
+ if (options && typeof options.windows === 'boolean') {
+ return options.windows;
+ }
+ return win32 === true || path.sep === '\\';
+};
+
+exports.escapeLast = (input, char, lastIdx) => {
+ let idx = input.lastIndexOf(char, lastIdx);
+ if (idx === -1) return input;
+ if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+ return input.slice(0, idx) + '\\' + input.slice(idx);
+};
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/package.json b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/package.json
new file mode 100644
index 00000000..7ddd3e75
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/picomatch/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "picomatch",
+ "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
+ "version": "2.0.7",
+ "homepage": "https://github.com/micromatch/picomatch",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "repository": "micromatch/picomatch",
+ "bugs": {
+ "url": "https://github.com/micromatch/picomatch/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js",
+ "lib"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=8"
+ },
+ "scripts": {
+ "test": "mocha",
+ "cover": "nyc --reporter=text --reporter=html mocha"
+ },
+ "devDependencies": {
+ "fill-range": "^7.0.1",
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.0.2",
+ "nyc": "^13.3.0",
+ "time-require": "github:jonschlinkert/time-require"
+ },
+ "keywords": [
+ "glob",
+ "match",
+ "picomatch"
+ ],
+ "verb": {
+ "toc": false,
+ "layout": false,
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "related": {
+ "list": [
+ "micromatch",
+ "braces"
+ ]
+ },
+ "reflinks": [
+ "braces",
+ "expand-brackets",
+ "extglob",
+ "fill-range",
+ "micromatch",
+ "minimatch",
+ "nanomatch",
+ "picomatch"
+ ]
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/LICENSE b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/LICENSE
new file mode 100644
index 00000000..7cccaf9e
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Jon Schlinkert.
+
+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.
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/README.md b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/README.md
new file mode 100644
index 00000000..38887daf
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/README.md
@@ -0,0 +1,305 @@
+# to-regex-range [](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=W8YFZ425KND68) [](https://www.npmjs.com/package/to-regex-range) [](https://npmjs.org/package/to-regex-range) [](https://npmjs.org/package/to-regex-range) [](https://travis-ci.org/micromatch/to-regex-range)
+
+> Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.
+
+Please consider following this project's author, [Jon Schlinkert](https://github.com/jonschlinkert), and consider starring the project to show your :heart: and support.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+$ npm install --save to-regex-range
+```
+
+
+What does this do?
+
+
+Why use this library?
+
+## Usage
+
+Add this library to your javascript application with the following line of code
+
+```js
+const toRegexRange = require('to-regex-range');
+```
+
+The main export is a function that takes two integers: the `min` value and `max` value (formatted as strings or numbers).
+
+```js
+const source = toRegexRange('15', '95');
+//=> 1[5-9]|[2-8][0-9]|9[0-5]
+
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('14')); //=> false
+console.log(regex.test('50')); //=> true
+console.log(regex.test('94')); //=> true
+console.log(regex.test('96')); //=> false
+```
+
+## Options
+
+### options.capture
+
+**Type**: `boolean`
+
+**Deafault**: `undefined`
+
+Wrap the returned value in parentheses when there is more than one regex condition. Useful when you're dynamically generating ranges.
+
+```js
+console.log(toRegexRange('-10', '10'));
+//=> -[1-9]|-?10|[0-9]
+
+console.log(toRegexRange('-10', '10', { capture: true }));
+//=> (-[1-9]|-?10|[0-9])
+```
+
+### options.shorthand
+
+**Type**: `boolean`
+
+**Deafault**: `undefined`
+
+Use the regex shorthand for `[0-9]`:
+
+```js
+console.log(toRegexRange('0', '999999'));
+//=> [0-9]|[1-9][0-9]{1,5}
+
+console.log(toRegexRange('0', '999999', { shorthand: true }));
+//=> \d|[1-9]\d{1,5}
+```
+
+### options.relaxZeros
+
+**Type**: `boolean`
+
+**Default**: `true`
+
+This option relaxes matching for leading zeros when when ranges are zero-padded.
+
+```js
+const source = toRegexRange('-0010', '0010');
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('-10')); //=> true
+console.log(regex.test('-010')); //=> true
+console.log(regex.test('-0010')); //=> true
+console.log(regex.test('10')); //=> true
+console.log(regex.test('010')); //=> true
+console.log(regex.test('0010')); //=> true
+```
+
+When `relaxZeros` is false, matching is strict:
+
+```js
+const source = toRegexRange('-0010', '0010', { relaxZeros: false });
+const regex = new RegExp(`^${source}$`);
+console.log(regex.test('-10')); //=> false
+console.log(regex.test('-010')); //=> false
+console.log(regex.test('-0010')); //=> true
+console.log(regex.test('10')); //=> false
+console.log(regex.test('010')); //=> false
+console.log(regex.test('0010')); //=> true
+```
+
+## Examples
+
+| **Range** | **Result** | **Compile time** |
+| --- | --- | --- |
+| `toRegexRange(-10, 10)` | `-[1-9]\|-?10\|[0-9]` | _132μs_ |
+| `toRegexRange(-100, -10)` | `-1[0-9]\|-[2-9][0-9]\|-100` | _50μs_ |
+| `toRegexRange(-100, 100)` | `-[1-9]\|-?[1-9][0-9]\|-?100\|[0-9]` | _42μs_ |
+| `toRegexRange(001, 100)` | `0{0,2}[1-9]\|0?[1-9][0-9]\|100` | _109μs_ |
+| `toRegexRange(001, 555)` | `0{0,2}[1-9]\|0?[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _51μs_ |
+| `toRegexRange(0010, 1000)` | `0{0,2}1[0-9]\|0{0,2}[2-9][0-9]\|0?[1-9][0-9]{2}\|1000` | _31μs_ |
+| `toRegexRange(1, 50)` | `[1-9]\|[1-4][0-9]\|50` | _24μs_ |
+| `toRegexRange(1, 55)` | `[1-9]\|[1-4][0-9]\|5[0-5]` | _23μs_ |
+| `toRegexRange(1, 555)` | `[1-9]\|[1-9][0-9]\|[1-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _30μs_ |
+| `toRegexRange(1, 5555)` | `[1-9]\|[1-9][0-9]{1,2}\|[1-4][0-9]{3}\|5[0-4][0-9]{2}\|55[0-4][0-9]\|555[0-5]` | _43μs_ |
+| `toRegexRange(111, 555)` | `11[1-9]\|1[2-9][0-9]\|[2-4][0-9]{2}\|5[0-4][0-9]\|55[0-5]` | _38μs_ |
+| `toRegexRange(29, 51)` | `29\|[34][0-9]\|5[01]` | _24μs_ |
+| `toRegexRange(31, 877)` | `3[1-9]\|[4-9][0-9]\|[1-7][0-9]{2}\|8[0-6][0-9]\|87[0-7]` | _32μs_ |
+| `toRegexRange(5, 5)` | `5` | _8μs_ |
+| `toRegexRange(5, 6)` | `5\|6` | _11μs_ |
+| `toRegexRange(1, 2)` | `1\|2` | _6μs_ |
+| `toRegexRange(1, 5)` | `[1-5]` | _15μs_ |
+| `toRegexRange(1, 10)` | `[1-9]\|10` | _22μs_ |
+| `toRegexRange(1, 100)` | `[1-9]\|[1-9][0-9]\|100` | _25μs_ |
+| `toRegexRange(1, 1000)` | `[1-9]\|[1-9][0-9]{1,2}\|1000` | _31μs_ |
+| `toRegexRange(1, 10000)` | `[1-9]\|[1-9][0-9]{1,3}\|10000` | _34μs_ |
+| `toRegexRange(1, 100000)` | `[1-9]\|[1-9][0-9]{1,4}\|100000` | _36μs_ |
+| `toRegexRange(1, 1000000)` | `[1-9]\|[1-9][0-9]{1,5}\|1000000` | _42μs_ |
+| `toRegexRange(1, 10000000)` | `[1-9]\|[1-9][0-9]{1,6}\|10000000` | _42μs_ |
+
+## Heads up!
+
+**Order of arguments**
+
+When the `min` is larger than the `max`, values will be flipped to create a valid range:
+
+```js
+toRegexRange('51', '29');
+```
+
+Is effectively flipped to:
+
+```js
+toRegexRange('29', '51');
+//=> 29|[3-4][0-9]|5[0-1]
+```
+
+**Steps / increments**
+
+This library does not support steps (increments). A pr to add support would be welcome.
+
+## History
+
+### v2.0.0 - 2017-04-21
+
+**New features**
+
+Adds support for zero-padding!
+
+### v1.0.0
+
+**Optimizations**
+
+Repeating ranges are now grouped using quantifiers. rocessing time is roughly the same, but the generated regex is much smaller, which should result in faster matching.
+
+## Attribution
+
+Inspired by the python library [range-regex](https://github.com/dimka665/range-regex).
+
+## About
+
+
+Contributing
+
+
+Running Tests
+
+
+Building docs
+
+### Related projects
+
+You might also be interested in these projects:
+
+* [expand-range](https://www.npmjs.com/package/expand-range): Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used… [more](https://github.com/jonschlinkert/expand-range) | [homepage](https://github.com/jonschlinkert/expand-range "Fast, bash-like range expansion. Expand a range of numbers or letters, uppercase or lowercase. Used by micromatch.")
+* [fill-range](https://www.npmjs.com/package/fill-range): Fill in a range of numbers or letters, optionally passing an increment or `step` to… [more](https://github.com/jonschlinkert/fill-range) | [homepage](https://github.com/jonschlinkert/fill-range "Fill in a range of numbers or letters, optionally passing an increment or `step` to use, or create a regex-compatible range with `options.toRegex`")
+* [micromatch](https://www.npmjs.com/package/micromatch): Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | [homepage](https://github.com/micromatch/micromatch "Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch.")
+* [repeat-element](https://www.npmjs.com/package/repeat-element): Create an array by repeating the given value n times. | [homepage](https://github.com/jonschlinkert/repeat-element "Create an array by repeating the given value n times.")
+* [repeat-string](https://www.npmjs.com/package/repeat-string): Repeat the given string n times. Fastest implementation for repeating a string. | [homepage](https://github.com/jonschlinkert/repeat-string "Repeat the given string n times. Fastest implementation for repeating a string.")
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| --- | --- |
+| 63 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 3 | [doowb](https://github.com/doowb) |
+| 2 | [realityking](https://github.com/realityking) |
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+Please consider supporting me on Patreon, or [start your own Patreon page](https://patreon.com/invite/bxpbvm)!
+
+
+
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 07, 2019._
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/index.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/index.js
new file mode 100644
index 00000000..77fbaced
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/index.js
@@ -0,0 +1,288 @@
+/*!
+ * to-regex-range
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+'use strict';
+
+const isNumber = require('is-number');
+
+const toRegexRange = (min, max, options) => {
+ if (isNumber(min) === false) {
+ throw new TypeError('toRegexRange: expected the first argument to be a number');
+ }
+
+ if (max === void 0 || min === max) {
+ return String(min);
+ }
+
+ if (isNumber(max) === false) {
+ throw new TypeError('toRegexRange: expected the second argument to be a number.');
+ }
+
+ let opts = { relaxZeros: true, ...options };
+ if (typeof opts.strictZeros === 'boolean') {
+ opts.relaxZeros = opts.strictZeros === false;
+ }
+
+ let relax = String(opts.relaxZeros);
+ let shorthand = String(opts.shorthand);
+ let capture = String(opts.capture);
+ let wrap = String(opts.wrap);
+ let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+ if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+ return toRegexRange.cache[cacheKey].result;
+ }
+
+ let a = Math.min(min, max);
+ let b = Math.max(min, max);
+
+ if (Math.abs(a - b) === 1) {
+ let result = min + '|' + max;
+ if (opts.capture) {
+ return `(${result})`;
+ }
+ if (opts.wrap === false) {
+ return result;
+ }
+ return `(?:${result})`;
+ }
+
+ let isPadded = hasPadding(min) || hasPadding(max);
+ let state = { min, max, a, b };
+ let positives = [];
+ let negatives = [];
+
+ if (isPadded) {
+ state.isPadded = isPadded;
+ state.maxLen = String(state.max).length;
+ }
+
+ if (a < 0) {
+ let newMin = b < 0 ? Math.abs(b) : 1;
+ negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+ a = state.a = 0;
+ }
+
+ if (b >= 0) {
+ positives = splitToPatterns(a, b, state, opts);
+ }
+
+ state.negatives = negatives;
+ state.positives = positives;
+ state.result = collatePatterns(negatives, positives, opts);
+
+ if (opts.capture === true) {
+ state.result = `(${state.result})`;
+ } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+ state.result = `(?:${state.result})`;
+ }
+
+ toRegexRange.cache[cacheKey] = state;
+ return state.result;
+};
+
+function collatePatterns(neg, pos, options) {
+ let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
+ let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
+ let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
+ let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+ return subpatterns.join('|');
+}
+
+function splitToRanges(min, max) {
+ let nines = 1;
+ let zeros = 1;
+
+ let stop = countNines(min, nines);
+ let stops = new Set([max]);
+
+ while (min <= stop && stop <= max) {
+ stops.add(stop);
+ nines += 1;
+ stop = countNines(min, nines);
+ }
+
+ stop = countZeros(max + 1, zeros) - 1;
+
+ while (min < stop && stop <= max) {
+ stops.add(stop);
+ zeros += 1;
+ stop = countZeros(max + 1, zeros) - 1;
+ }
+
+ stops = [...stops];
+ stops.sort(compare);
+ return stops;
+}
+
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
+
+function rangeToPattern(start, stop, options) {
+ if (start === stop) {
+ return { pattern: start, count: [], digits: 0 };
+ }
+
+ let zipped = zip(start, stop);
+ let digits = zipped.length;
+ let pattern = '';
+ let count = 0;
+
+ for (let i = 0; i < digits; i++) {
+ let [startDigit, stopDigit] = zipped[i];
+
+ if (startDigit === stopDigit) {
+ pattern += startDigit;
+
+ } else if (startDigit !== '0' || stopDigit !== '9') {
+ pattern += toCharacterClass(startDigit, stopDigit, options);
+
+ } else {
+ count++;
+ }
+ }
+
+ if (count) {
+ pattern += options.shorthand === true ? '\\d' : '[0-9]';
+ }
+
+ return { pattern, count: [count], digits };
+}
+
+function splitToPatterns(min, max, tok, options) {
+ let ranges = splitToRanges(min, max);
+ let tokens = [];
+ let start = min;
+ let prev;
+
+ for (let i = 0; i < ranges.length; i++) {
+ let max = ranges[i];
+ let obj = rangeToPattern(String(start), String(max), options);
+ let zeros = '';
+
+ if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+ if (prev.count.length > 1) {
+ prev.count.pop();
+ }
+
+ prev.count.push(obj.count[0]);
+ prev.string = prev.pattern + toQuantifier(prev.count);
+ start = max + 1;
+ continue;
+ }
+
+ if (tok.isPadded) {
+ zeros = padZeros(max, tok, options);
+ }
+
+ obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+ tokens.push(obj);
+ start = max + 1;
+ prev = obj;
+ }
+
+ return tokens;
+}
+
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+ let result = [];
+
+ for (let ele of arr) {
+ let { string } = ele;
+
+ // only push if _both_ are negative...
+ if (!intersection && !contains(comparison, 'string', string)) {
+ result.push(prefix + string);
+ }
+
+ // or _both_ are positive
+ if (intersection && contains(comparison, 'string', string)) {
+ result.push(prefix + string);
+ }
+ }
+ return result;
+}
+
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+ let arr = [];
+ for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+ return arr;
+}
+
+function compare(a, b) {
+ return a > b ? 1 : b > a ? -1 : 0;
+}
+
+function contains(arr, key, val) {
+ return arr.some(ele => ele[key] === val);
+}
+
+function countNines(min, len) {
+ return Number(String(min).slice(0, -len) + '9'.repeat(len));
+}
+
+function countZeros(integer, zeros) {
+ return integer - (integer % Math.pow(10, zeros));
+}
+
+function toQuantifier(digits) {
+ let [start = 0, stop = ''] = digits;
+ if (stop || start > 1) {
+ return `{${start + (stop ? ',' + stop : '')}}`;
+ }
+ return '';
+}
+
+function toCharacterClass(a, b, options) {
+ return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+}
+
+function hasPadding(str) {
+ return /^-?(0+)\d/.test(str);
+}
+
+function padZeros(value, tok, options) {
+ if (!tok.isPadded) {
+ return value;
+ }
+
+ let diff = Math.abs(tok.maxLen - String(value).length);
+ let relax = options.relaxZeros !== false;
+
+ switch (diff) {
+ case 0:
+ return '';
+ case 1:
+ return relax ? '0?' : '0';
+ case 2:
+ return relax ? '0{0,2}' : '00';
+ default: {
+ return relax ? `0{0,${diff}}` : `0{${diff}}`;
+ }
+ }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange.cache = {};
+toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+module.exports = toRegexRange;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/package.json b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/package.json
new file mode 100644
index 00000000..4ef194f3
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/to-regex-range/package.json
@@ -0,0 +1,88 @@
+{
+ "name": "to-regex-range",
+ "description": "Pass two numbers, get a regex-compatible source string for matching ranges. Validated against more than 2.78 million test assertions.",
+ "version": "5.0.1",
+ "homepage": "https://github.com/micromatch/to-regex-range",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "contributors": [
+ "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+ "Rouven Weßling (www.rouvenwessling.de)"
+ ],
+ "repository": "micromatch/to-regex-range",
+ "bugs": {
+ "url": "https://github.com/micromatch/to-regex-range/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=8.0"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "devDependencies": {
+ "fill-range": "^6.0.0",
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.0.2",
+ "text-table": "^0.2.0",
+ "time-diff": "^0.3.1"
+ },
+ "keywords": [
+ "bash",
+ "date",
+ "expand",
+ "expansion",
+ "expression",
+ "glob",
+ "match",
+ "match date",
+ "match number",
+ "match numbers",
+ "match year",
+ "matches",
+ "matching",
+ "number",
+ "numbers",
+ "numerical",
+ "range",
+ "ranges",
+ "regex",
+ "regexp",
+ "regular",
+ "regular expression",
+ "sequence"
+ ],
+ "verb": {
+ "layout": "default",
+ "toc": false,
+ "tasks": [
+ "readme"
+ ],
+ "plugins": [
+ "gulp-format-md"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "helpers": {
+ "examples": {
+ "displayName": "examples"
+ }
+ },
+ "related": {
+ "list": [
+ "expand-range",
+ "fill-range",
+ "micromatch",
+ "repeat-element",
+ "repeat-string"
+ ]
+ }
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/LICENSE b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/LICENSE
new file mode 100644
index 00000000..aa86c2df
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Peter Krumins
+
+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.
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/README.md b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/README.md
new file mode 100644
index 00000000..59a00ea1
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/README.md
@@ -0,0 +1,89 @@
+Tree Kill
+=========
+
+Kill all processes in the process tree, including the root process.
+
+Examples
+=======
+
+Kill all the descendent processes of the process with pid `1`, including the process with pid `1` itself:
+```js
+var kill = require('tree-kill');
+kill(1);
+```
+
+Send a signal other than SIGTERM.:
+```js
+var kill = require('tree-kill');
+kill(1, 'SIGKILL');
+```
+
+Run a callback when done killing the processes. Passes an error argument if there was an error.
+```js
+var kill = require('tree-kill');
+kill(1, 'SIGKILL', function(err) {
+ // Do things
+});
+```
+
+You can also install tree-kill globally and use it as a command:
+```sh
+tree-kill 1 # sends SIGTERM to process 1 and its descendents
+tree-kill 1 SIGTERM # same
+tree-kill 1 SIGKILL # sends KILL instead of TERMINATE
+```
+
+Methods
+=======
+
+## require('tree-kill')(pid, [signal], [callback]);
+
+Sends signal `signal` to all children processes of the process with pid `pid`, including `pid`. Signal defaults to `SIGTERM`.
+
+For Linux, this uses `ps -o pid --no-headers --ppid PID` to find the parent pids of `PID`.
+
+For Darwin/OSX, this uses `pgrep -P PID` to find the parent pids of `PID`.
+
+For Windows, this uses `'taskkill /pid PID /T /F'` to kill the process tree. Note that on Windows, sending the different kinds of POSIX signals is not possible.
+
+Install
+=======
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install tree-kill
+```
+
+License
+=======
+
+MIT
+
+Changelog
+=========
+
+
+## [1.2.2] - 2019-12-11
+### Changed
+- security fix: sanitize `pid` parameter to fix arbitrary code execution vulnerability
+
+## [1.2.1] - 2018-11-05
+### Changed
+- added missing LICENSE file
+- updated TypeScript definitions
+
+## [1.2.0] - 2017-09-19
+### Added
+- TypeScript definitions
+### Changed
+- `kill(pid, callback)` works. Before you had to use `kill(pid, signal, callback)`
+
+## [1.1.0] - 2016-05-13
+### Added
+- A `tree-kill` CLI
+
+## [1.0.0] - 2015-09-17
+### Added
+- optional callback
+- Darwin support
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/cli.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/cli.js
new file mode 100755
index 00000000..1acb8158
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/cli.js
@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+kill = require('.')
+try {
+ kill(process.argv[2], process.argv[3], function(err){
+ if (err) {
+ console.log(err.message)
+ process.exit(1)
+ }
+ })
+}
+catch (err) {
+ console.log(err.message)
+ process.exit(1)
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/index.d.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/index.d.ts
new file mode 100644
index 00000000..e0b13022
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/index.d.ts
@@ -0,0 +1,13 @@
+/**
+ * Kills process identified by `pid` and all its children
+ *
+ * @param pid
+ * @param signal 'SIGTERM' by default
+ * @param callback
+ */
+declare function treeKill(pid: number, callback?: (error?: Error) => void): void;
+declare function treeKill(pid: number, signal?: string | number, callback?: (error?: Error) => void): void;
+
+declare namespace treeKill {}
+
+export = treeKill;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/index.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/index.js
new file mode 100755
index 00000000..8df6a0fb
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/index.js
@@ -0,0 +1,118 @@
+'use strict';
+
+var childProcess = require('child_process');
+var spawn = childProcess.spawn;
+var exec = childProcess.exec;
+
+module.exports = function (pid, signal, callback) {
+ if (typeof signal === 'function' && callback === undefined) {
+ callback = signal;
+ signal = undefined;
+ }
+
+ pid = parseInt(pid);
+ if (Number.isNaN(pid)) {
+ if (callback) {
+ return callback(new Error("pid must be a number"));
+ } else {
+ throw new Error("pid must be a number");
+ }
+ }
+
+ var tree = {};
+ var pidsToProcess = {};
+ tree[pid] = [];
+ pidsToProcess[pid] = 1;
+
+ switch (process.platform) {
+ case 'win32':
+ exec('taskkill /pid ' + pid + ' /T /F', callback);
+ break;
+ case 'darwin':
+ buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+ return spawn('pgrep', ['-P', parentPid]);
+ }, function () {
+ killAll(tree, signal, callback);
+ });
+ break;
+ // case 'sunos':
+ // buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
+ // killAll(tree, signal, callback);
+ // });
+ // break;
+ default: // Linux
+ buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+ return spawn('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid]);
+ }, function () {
+ killAll(tree, signal, callback);
+ });
+ break;
+ }
+};
+
+function killAll (tree, signal, callback) {
+ var killed = {};
+ try {
+ Object.keys(tree).forEach(function (pid) {
+ tree[pid].forEach(function (pidpid) {
+ if (!killed[pidpid]) {
+ killPid(pidpid, signal);
+ killed[pidpid] = 1;
+ }
+ });
+ if (!killed[pid]) {
+ killPid(pid, signal);
+ killed[pid] = 1;
+ }
+ });
+ } catch (err) {
+ if (callback) {
+ return callback(err);
+ } else {
+ throw err;
+ }
+ }
+ if (callback) {
+ return callback();
+ }
+}
+
+function killPid(pid, signal) {
+ try {
+ process.kill(parseInt(pid, 10), signal);
+ }
+ catch (err) {
+ if (err.code !== 'ESRCH') throw err;
+ }
+}
+
+function buildProcessTree (parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+ var ps = spawnChildProcessesList(parentPid);
+ var allData = '';
+ ps.stdout.on('data', function (data) {
+ var data = data.toString('ascii');
+ allData += data;
+ });
+
+ var onClose = function (code) {
+ delete pidsToProcess[parentPid];
+
+ if (code != 0) {
+ // no more parent processes
+ if (Object.keys(pidsToProcess).length == 0) {
+ cb();
+ }
+ return;
+ }
+
+ allData.match(/\d+/g).forEach(function (pid) {
+ pid = parseInt(pid, 10);
+ tree[parentPid].push(pid);
+ tree[pid] = [];
+ pidsToProcess[pid] = 1;
+ buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+ });
+ };
+
+ ps.on('close', onClose);
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/package.json b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/package.json
new file mode 100644
index 00000000..fa37804f
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/tree-kill/package.json
@@ -0,0 +1,51 @@
+{
+ "name": "tree-kill",
+ "version": "1.2.2",
+ "description": "kill trees of processes",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "bin": {
+ "tree-kill": "cli.js"
+ },
+ "scripts": {
+ "test": "mocha"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/pkrumins/node-tree-kill.git"
+ },
+ "homepage": "https://github.com/pkrumins/node-tree-kill",
+ "keywords": [
+ "tree",
+ "trees",
+ "process",
+ "processes",
+ "kill",
+ "signal"
+ ],
+ "author": {
+ "name": "Peteris Krumins",
+ "email": "peteris.krumins@gmail.com",
+ "url": "http://www.catonmat.net"
+ },
+ "contributors": [
+ {
+ "name": "Todd Wolfson",
+ "email": "todd@twolfson.com",
+ "url": "http://twolfson.com/"
+ },
+ {
+ "name": "William Hilton",
+ "email": "wmhilton@gmail.com",
+ "url": "http://wmhilton.com/"
+ },
+ {
+ "name": "Fabrício Matté",
+ "url": "http://ultcombo.js.org/"
+ }
+ ],
+ "license": "MIT",
+ "devDependencies": {
+ "mocha": "^2.2.5"
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/CHANGELOG.md b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/CHANGELOG.md
new file mode 100644
index 00000000..0dbbd364
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/CHANGELOG.md
@@ -0,0 +1,760 @@
+0&&(t.push(n((new l).error)),c(t,e-1))}function o(){var t=[];c(t,2);for(var e=t[0],n=t[1],r=0;rthis.longStackTraceLimit&&(c.length=this.longStackTraceLimit),r.data||(r.data={}),r.data[f]=c,t.scheduleTask(n,r)},onHandleError:function(t,e,n,r){var c=Zone.currentTask||r.task;if(r instanceof Error&&c){var o=null;try{var i=Object.getOwnPropertyDescriptor(r,"stack");if(i&&i.configurable){var u=i.get,s=i.value;i={get:function(){return a(c.data&&c.data[f],u?u.apply(this):s)}},Object.defineProperty(r,"stack",i),o=!0}}catch(l){}var h=o?null:a(c.data&&c.data[f],r.stack);if(!o)try{o=r.stack=h}catch(l){}if(!o)try{o=r.longStack=h}catch(l){}}return t.handleError(n,r)}},o()});
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/mocha-patch.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/mocha-patch.js
new file mode 100644
index 00000000..e3da97cd
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/mocha-patch.js
@@ -0,0 +1,156 @@
+/**
+* @license
+* Copyright Google Inc. All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (factory());
+}(this, (function () { 'use strict';
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+(function (context) {
+ var Mocha = context.Mocha;
+ if (typeof Mocha === 'undefined') {
+ throw new Error('Missing Mocha.js');
+ }
+ if (typeof Zone === 'undefined') {
+ throw new Error('Missing Zone.js');
+ }
+ var ProxyZoneSpec = Zone['ProxyZoneSpec'];
+ var SyncTestZoneSpec = Zone['SyncTestZoneSpec'];
+ if (!ProxyZoneSpec) {
+ throw new Error('Missing ProxyZoneSpec');
+ }
+ if (Mocha['__zone_patch__']) {
+ throw new Error('"Mocha" has already been patched with "Zone".');
+ }
+ Mocha['__zone_patch__'] = true;
+ var rootZone = Zone.current;
+ var syncZone = rootZone.fork(new SyncTestZoneSpec('Mocha.describe'));
+ var testZone = null;
+ var suiteZone = rootZone.fork(new ProxyZoneSpec());
+ var mochaOriginal = {
+ after: Mocha.after,
+ afterEach: Mocha.afterEach,
+ before: Mocha.before,
+ beforeEach: Mocha.beforeEach,
+ describe: Mocha.describe,
+ it: Mocha.it
+ };
+ function modifyArguments(args, syncTest, asyncTest) {
+ var _loop_1 = function (i) {
+ var arg = args[i];
+ if (typeof arg === 'function') {
+ // The `done` callback is only passed through if the function expects at
+ // least one argument.
+ // Note we have to make a function with correct number of arguments,
+ // otherwise mocha will
+ // think that all functions are sync or async.
+ args[i] = (arg.length === 0) ? syncTest(arg) : asyncTest(arg);
+ // Mocha uses toString to view the test body in the result list, make sure we return the
+ // correct function body
+ args[i].toString = function () {
+ return arg.toString();
+ };
+ }
+ };
+ for (var i = 0; i < args.length; i++) {
+ _loop_1(i);
+ }
+ return args;
+ }
+ function wrapDescribeInZone(args) {
+ var syncTest = function (fn) {
+ return function () {
+ return syncZone.run(fn, this, arguments);
+ };
+ };
+ return modifyArguments(args, syncTest);
+ }
+ function wrapTestInZone(args) {
+ var asyncTest = function (fn) {
+ return function (done) {
+ return testZone.run(fn, this, [done]);
+ };
+ };
+ var syncTest = function (fn) {
+ return function () {
+ return testZone.run(fn, this);
+ };
+ };
+ return modifyArguments(args, syncTest, asyncTest);
+ }
+ function wrapSuiteInZone(args) {
+ var asyncTest = function (fn) {
+ return function (done) {
+ return suiteZone.run(fn, this, [done]);
+ };
+ };
+ var syncTest = function (fn) {
+ return function () {
+ return suiteZone.run(fn, this);
+ };
+ };
+ return modifyArguments(args, syncTest, asyncTest);
+ }
+
+ context.describe = context.suite = Mocha.describe = function () {
+ return mochaOriginal.describe.apply(this, wrapDescribeInZone(arguments));
+ };
+ context.xdescribe = context.suite.skip = Mocha.describe.skip = function () {
+ return mochaOriginal.describe.skip.apply(this, wrapDescribeInZone(arguments));
+ };
+ context.describe.only = context.suite.only = Mocha.describe.only = function () {
+ return mochaOriginal.describe.only.apply(this, wrapDescribeInZone(arguments));
+ };
+ context.it = context.specify = context.test = Mocha.it = function () {
+ return mochaOriginal.it.apply(this, wrapTestInZone(arguments));
+ };
+ context.xit = context.xspecify = Mocha.it.skip = function () {
+ return mochaOriginal.it.skip.apply(this, wrapTestInZone(arguments));
+ };
+ context.it.only = context.test.only = Mocha.it.only = function () {
+ return mochaOriginal.it.only.apply(this, wrapTestInZone(arguments));
+ };
+ context.after = context.suiteTeardown = Mocha.after = function () {
+ return mochaOriginal.after.apply(this, wrapSuiteInZone(arguments));
+ };
+ context.afterEach = context.teardown = Mocha.afterEach = function () {
+ return mochaOriginal.afterEach.apply(this, wrapTestInZone(arguments));
+ };
+ context.before = context.suiteSetup = Mocha.before = function () {
+ return mochaOriginal.before.apply(this, wrapSuiteInZone(arguments));
+ };
+ context.beforeEach = context.setup = Mocha.beforeEach = function () {
+ return mochaOriginal.beforeEach.apply(this, wrapTestInZone(arguments));
+ };
+ (function (originalRunTest, originalRun) {
+ Mocha.Runner.prototype.runTest = function (fn) {
+ var _this = this;
+ Zone.current.scheduleMicroTask('mocha.forceTask', function () {
+ originalRunTest.call(_this, fn);
+ });
+ };
+ Mocha.Runner.prototype.run = function (fn) {
+ this.on('test', function (e) {
+ if (Zone.current !== rootZone) {
+ throw new Error('Unexpected zone: ' + Zone.current.name);
+ }
+ testZone = rootZone.fork(new ProxyZoneSpec());
+ });
+ return originalRun.call(this, fn);
+ };
+ })(Mocha.Runner.prototype.runTest, Mocha.Runner.prototype.run);
+})(window);
+
+})));
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/mocha-patch.min.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/mocha-patch.min.js
new file mode 100644
index 00000000..0b72e405
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/mocha-patch.min.js
@@ -0,0 +1 @@
+!function(n,e){"object"==typeof exports&&"undefined"!=typeof module?e():"function"==typeof define&&define.amd?define(e):e()}(this,function(){"use strict";!function(n){function e(n,e,t){for(var r=function(r){var o=n[r];"function"==typeof o&&(n[r]=0===o.length?e(o):t(o),n[r].toString=function(){return o.toString()})},o=0;o';
+ this._properties = zoneSpec && zoneSpec.properties || {};
+ this._zoneDelegate =
+ new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
+ }
+ Zone.assertZonePatched = function () {
+ if (global.Promise !== ZoneAwarePromise) {
+ throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +
+ 'has been overwritten.\n' +
+ 'Most likely cause is that a Promise polyfill has been loaded ' +
+ 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +
+ 'If you must load one, do so before loading zone.js.)');
+ }
+ };
+ Object.defineProperty(Zone, "current", {
+ get: function () {
+ return _currentZoneFrame.zone;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Object.defineProperty(Zone, "currentTask", {
+ get: function () {
+ return _currentTask;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Object.defineProperty(Zone.prototype, "parent", {
+ get: function () {
+ return this._parent;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Object.defineProperty(Zone.prototype, "name", {
+ get: function () {
+ return this._name;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Zone.prototype.get = function (key) {
+ var zone = this.getZoneWith(key);
+ if (zone)
+ return zone._properties[key];
+ };
+ Zone.prototype.getZoneWith = function (key) {
+ var current = this;
+ while (current) {
+ if (current._properties.hasOwnProperty(key)) {
+ return current;
+ }
+ current = current._parent;
+ }
+ return null;
+ };
+ Zone.prototype.fork = function (zoneSpec) {
+ if (!zoneSpec)
+ throw new Error('ZoneSpec required!');
+ return this._zoneDelegate.fork(this, zoneSpec);
+ };
+ Zone.prototype.wrap = function (callback, source) {
+ if (typeof callback !== 'function') {
+ throw new Error('Expecting function got: ' + callback);
+ }
+ var _callback = this._zoneDelegate.intercept(this, callback, source);
+ var zone = this;
+ return function () {
+ return zone.runGuarded(_callback, this, arguments, source);
+ };
+ };
+ Zone.prototype.run = function (callback, applyThis, applyArgs, source) {
+ if (applyThis === void 0) { applyThis = null; }
+ if (applyArgs === void 0) { applyArgs = null; }
+ if (source === void 0) { source = null; }
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
+ }
+ finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ }
+ };
+ Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) {
+ if (applyThis === void 0) { applyThis = null; }
+ if (applyArgs === void 0) { applyArgs = null; }
+ if (source === void 0) { source = null; }
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ try {
+ return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
+ }
+ catch (error) {
+ if (this._zoneDelegate.handleError(this, error)) {
+ throw error;
+ }
+ }
+ }
+ finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ }
+ };
+ Zone.prototype.runTask = function (task, applyThis, applyArgs) {
+ task.runCount++;
+ if (task.zone != this)
+ throw new Error('A task can only be run in the zone which created it! (Creation: ' + task.zone.name +
+ '; Execution: ' + this.name + ')');
+ var previousTask = _currentTask;
+ _currentTask = task;
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ if (task.type == 'macroTask' && task.data && !task.data.isPeriodic) {
+ task.cancelFn = null;
+ }
+ try {
+ return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
+ }
+ catch (error) {
+ if (this._zoneDelegate.handleError(this, error)) {
+ throw error;
+ }
+ }
+ }
+ finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ _currentTask = previousTask;
+ }
+ };
+ Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) {
+ return this._zoneDelegate.scheduleTask(this, new ZoneTask('microTask', this, source, callback, data, customSchedule, null));
+ };
+ Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) {
+ return this._zoneDelegate.scheduleTask(this, new ZoneTask('macroTask', this, source, callback, data, customSchedule, customCancel));
+ };
+ Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) {
+ return this._zoneDelegate.scheduleTask(this, new ZoneTask('eventTask', this, source, callback, data, customSchedule, customCancel));
+ };
+ Zone.prototype.cancelTask = function (task) {
+ var value = this._zoneDelegate.cancelTask(this, task);
+ task.runCount = -1;
+ task.cancelFn = null;
+ return value;
+ };
+ return Zone;
+ }());
+ Zone.__symbol__ = __symbol__;
+
+ var ZoneDelegate = (function () {
+ function ZoneDelegate(zone, parentDelegate, zoneSpec) {
+ this._taskCounts = { microTask: 0, macroTask: 0, eventTask: 0 };
+ this.zone = zone;
+ this._parentDelegate = parentDelegate;
+ this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
+ this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
+ this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate.zone);
+ this._interceptZS =
+ zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
+ this._interceptDlgt =
+ zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
+ this._interceptCurrZone =
+ zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate.zone);
+ this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
+ this._invokeDlgt =
+ zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
+ this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate.zone);
+ this._handleErrorZS =
+ zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
+ this._handleErrorDlgt =
+ zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
+ this._handleErrorCurrZone =
+ zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate.zone);
+ this._scheduleTaskZS =
+ zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
+ this._scheduleTaskDlgt =
+ zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
+ this._scheduleTaskCurrZone =
+ zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate.zone);
+ this._invokeTaskZS =
+ zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
+ this._invokeTaskDlgt =
+ zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
+ this._invokeTaskCurrZone =
+ zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate.zone);
+ this._cancelTaskZS =
+ zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
+ this._cancelTaskDlgt =
+ zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
+ this._cancelTaskCurrZone =
+ zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate.zone);
+ this._hasTaskZS = zoneSpec && (zoneSpec.onHasTask ? zoneSpec : parentDelegate._hasTaskZS);
+ this._hasTaskDlgt =
+ zoneSpec && (zoneSpec.onHasTask ? parentDelegate : parentDelegate._hasTaskDlgt);
+ this._hasTaskCurrZone = zoneSpec && (zoneSpec.onHasTask ? this.zone : parentDelegate.zone);
+ }
+ ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {
+ return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
+ new Zone(targetZone, zoneSpec);
+ };
+ ZoneDelegate.prototype.intercept = function (targetZone, callback, source) {
+ return this._interceptZS ?
+ this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :
+ callback;
+ };
+ ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) {
+ return this._invokeZS ?
+ this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :
+ callback.apply(applyThis, applyArgs);
+ };
+ ZoneDelegate.prototype.handleError = function (targetZone, error) {
+ return this._handleErrorZS ?
+ this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :
+ true;
+ };
+ ZoneDelegate.prototype.scheduleTask = function (targetZone, task) {
+ try {
+ if (this._scheduleTaskZS) {
+ return this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
+ }
+ else if (task.scheduleFn) {
+ task.scheduleFn(task);
+ }
+ else if (task.type == 'microTask') {
+ scheduleMicroTask(task);
+ }
+ else {
+ throw new Error('Task is missing scheduleFn.');
+ }
+ return task;
+ }
+ finally {
+ if (targetZone == this.zone) {
+ this._updateTaskCount(task.type, 1);
+ }
+ }
+ };
+ ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) {
+ try {
+ return this._invokeTaskZS ?
+ this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :
+ task.callback.apply(applyThis, applyArgs);
+ }
+ finally {
+ if (targetZone == this.zone && (task.type != 'eventTask') &&
+ !(task.data && task.data.isPeriodic)) {
+ this._updateTaskCount(task.type, -1);
+ }
+ }
+ };
+ ZoneDelegate.prototype.cancelTask = function (targetZone, task) {
+ var value;
+ if (this._cancelTaskZS) {
+ value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
+ }
+ else if (!task.cancelFn) {
+ throw new Error('Task does not support cancellation, or is already canceled.');
+ }
+ else {
+ value = task.cancelFn(task);
+ }
+ if (targetZone == this.zone) {
+ // this should not be in the finally block, because exceptions assume not canceled.
+ this._updateTaskCount(task.type, -1);
+ }
+ return value;
+ };
+ ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) {
+ return this._hasTaskZS &&
+ this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
+ };
+ ZoneDelegate.prototype._updateTaskCount = function (type, count) {
+ var counts = this._taskCounts;
+ var prev = counts[type];
+ var next = counts[type] = prev + count;
+ if (next < 0) {
+ throw new Error('More tasks executed then were scheduled.');
+ }
+ if (prev == 0 || next == 0) {
+ var isEmpty = {
+ microTask: counts.microTask > 0,
+ macroTask: counts.macroTask > 0,
+ eventTask: counts.eventTask > 0,
+ change: type
+ };
+ try {
+ this.hasTask(this.zone, isEmpty);
+ }
+ finally {
+ if (this._parentDelegate) {
+ this._parentDelegate._updateTaskCount(type, count);
+ }
+ }
+ }
+ };
+ return ZoneDelegate;
+ }());
+ var ZoneTask = (function () {
+ function ZoneTask(type, zone, source, callback, options, scheduleFn, cancelFn) {
+ this.runCount = 0;
+ this.type = type;
+ this.zone = zone;
+ this.source = source;
+ this.data = options;
+ this.scheduleFn = scheduleFn;
+ this.cancelFn = cancelFn;
+ this.callback = callback;
+ var self = this;
+ this.invoke = function () {
+ _numberOfNestedTaskFrames++;
+ try {
+ return zone.runTask(self, this, arguments);
+ }
+ finally {
+ if (_numberOfNestedTaskFrames == 1) {
+ drainMicroTaskQueue();
+ }
+ _numberOfNestedTaskFrames--;
+ }
+ };
+ }
+ ZoneTask.prototype.toString = function () {
+ if (this.data && typeof this.data.handleId !== 'undefined') {
+ return this.data.handleId;
+ }
+ else {
+ return Object.prototype.toString.call(this);
+ }
+ };
+ // add toJSON method to prevent cyclic error when
+ // call JSON.stringify(zoneTask)
+ ZoneTask.prototype.toJSON = function () {
+ return {
+ type: this.type,
+ source: this.source,
+ data: this.data,
+ zone: this.zone.name,
+ invoke: this.invoke,
+ scheduleFn: this.scheduleFn,
+ cancelFn: this.cancelFn,
+ runCount: this.runCount,
+ callback: this.callback
+ };
+ };
+ return ZoneTask;
+ }());
+ var ZoneFrame = (function () {
+ function ZoneFrame(parent, zone) {
+ this.parent = parent;
+ this.zone = zone;
+ }
+ return ZoneFrame;
+ }());
+ function __symbol__(name) {
+ return '__zone_symbol__' + name;
+ }
+
+ var symbolSetTimeout = __symbol__('setTimeout');
+ var symbolPromise = __symbol__('Promise');
+ var symbolThen = __symbol__('then');
+ var _currentZoneFrame = new ZoneFrame(null, new Zone(null, null));
+ var _currentTask = null;
+ var _microTaskQueue = [];
+ var _isDrainingMicrotaskQueue = false;
+ var _uncaughtPromiseErrors = [];
+ var _numberOfNestedTaskFrames = 0;
+ function scheduleQueueDrain() {
+ // if we are not running in any task, and there has not been anything scheduled
+ // we must bootstrap the initial task creation by manually scheduling the drain
+ if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
+ // We are not running in Task, so we need to kickstart the microtask queue.
+ if (global[symbolPromise]) {
+ global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue);
+ }
+ else {
+ global[symbolSetTimeout](drainMicroTaskQueue, 0);
+ }
+ }
+ }
+ function scheduleMicroTask(task) {
+ scheduleQueueDrain();
+ _microTaskQueue.push(task);
+ }
+ function consoleError(e) {
+ var rejection = e && e.rejection;
+ if (rejection) {
+ console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);
+ }
+ console.error(e);
+ }
+ function drainMicroTaskQueue() {
+ if (!_isDrainingMicrotaskQueue) {
+ _isDrainingMicrotaskQueue = true;
+ while (_microTaskQueue.length) {
+ var queue = _microTaskQueue;
+ _microTaskQueue = [];
+ for (var i = 0; i < queue.length; i++) {
+ var task = queue[i];
+ try {
+ task.zone.runTask(task, null, null);
+ }
+ catch (e) {
+ consoleError(e);
+ }
+ }
+ }
+ while (_uncaughtPromiseErrors.length) {
+ var _loop_1 = function () {
+ var uncaughtPromiseError = _uncaughtPromiseErrors.shift();
+ try {
+ uncaughtPromiseError.zone.runGuarded(function () {
+ throw uncaughtPromiseError;
+ });
+ }
+ catch (e) {
+ consoleError(e);
+ }
+ };
+ while (_uncaughtPromiseErrors.length) {
+ _loop_1();
+ }
+ }
+ _isDrainingMicrotaskQueue = false;
+ }
+ }
+ function isThenable(value) {
+ return value && value.then;
+ }
+ function forwardResolution(value) {
+ return value;
+ }
+ function forwardRejection(rejection) {
+ return ZoneAwarePromise.reject(rejection);
+ }
+ var symbolState = __symbol__('state');
+ var symbolValue = __symbol__('value');
+ var source = 'Promise.then';
+ var UNRESOLVED = null;
+ var RESOLVED = true;
+ var REJECTED = false;
+ var REJECTED_NO_CATCH = 0;
+ function makeResolver(promise, state) {
+ return function (v) {
+ resolvePromise(promise, state, v);
+ // Do not return value or you will break the Promise spec.
+ };
+ }
+ function resolvePromise(promise, state, value) {
+ if (promise[symbolState] === UNRESOLVED) {
+ if (value instanceof ZoneAwarePromise && value.hasOwnProperty(symbolState) &&
+ value.hasOwnProperty(symbolValue) && value[symbolState] !== UNRESOLVED) {
+ clearRejectedNoCatch(value);
+ resolvePromise(promise, value[symbolState], value[symbolValue]);
+ }
+ else if (isThenable(value)) {
+ value.then(makeResolver(promise, state), makeResolver(promise, false));
+ }
+ else {
+ promise[symbolState] = state;
+ var queue = promise[symbolValue];
+ promise[symbolValue] = value;
+ for (var i = 0; i < queue.length;) {
+ scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
+ }
+ if (queue.length == 0 && state == REJECTED) {
+ promise[symbolState] = REJECTED_NO_CATCH;
+ try {
+ throw new Error('Uncaught (in promise): ' + value +
+ (value && value.stack ? '\n' + value.stack : ''));
+ }
+ catch (e) {
+ var error_1 = e;
+ error_1.rejection = value;
+ error_1.promise = promise;
+ error_1.zone = Zone.current;
+ error_1.task = Zone.currentTask;
+ _uncaughtPromiseErrors.push(error_1);
+ scheduleQueueDrain();
+ }
+ }
+ }
+ }
+ // Resolving an already resolved promise is a noop.
+ return promise;
+ }
+ function clearRejectedNoCatch(promise) {
+ if (promise[symbolState] === REJECTED_NO_CATCH) {
+ promise[symbolState] = REJECTED;
+ for (var i = 0; i < _uncaughtPromiseErrors.length; i++) {
+ if (promise === _uncaughtPromiseErrors[i].promise) {
+ _uncaughtPromiseErrors.splice(i, 1);
+ break;
+ }
+ }
+ }
+ }
+ function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {
+ clearRejectedNoCatch(promise);
+ var delegate = promise[symbolState] ? onFulfilled || forwardResolution : onRejected || forwardRejection;
+ zone.scheduleMicroTask(source, function () {
+ try {
+ resolvePromise(chainPromise, true, zone.run(delegate, null, [promise[symbolValue]]));
+ }
+ catch (error) {
+ resolvePromise(chainPromise, false, error);
+ }
+ });
+ }
+ var ZoneAwarePromise = (function () {
+ function ZoneAwarePromise(executor) {
+ var promise = this;
+ if (!(promise instanceof ZoneAwarePromise)) {
+ throw new Error('Must be an instanceof Promise.');
+ }
+ promise[symbolState] = UNRESOLVED;
+ promise[symbolValue] = []; // queue;
+ try {
+ executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));
+ }
+ catch (e) {
+ resolvePromise(promise, false, e);
+ }
+ }
+ ZoneAwarePromise.toString = function () {
+ return 'function ZoneAwarePromise() { [native code] }';
+ };
+ ZoneAwarePromise.resolve = function (value) {
+ return resolvePromise(new this(null), RESOLVED, value);
+ };
+ ZoneAwarePromise.reject = function (error) {
+ return resolvePromise(new this(null), REJECTED, error);
+ };
+ ZoneAwarePromise.race = function (values) {
+ var resolve;
+ var reject;
+ var promise = new this(function (res, rej) {
+ _a = [res, rej], resolve = _a[0], reject = _a[1];
+ var _a;
+ });
+ function onResolve(value) {
+ promise && (promise = null || resolve(value));
+ }
+ function onReject(error) {
+ promise && (promise = null || reject(error));
+ }
+ for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+ var value = values_1[_i];
+ if (!isThenable(value)) {
+ value = this.resolve(value);
+ }
+ value.then(onResolve, onReject);
+ }
+ return promise;
+ };
+ ZoneAwarePromise.all = function (values) {
+ var resolve;
+ var reject;
+ var promise = new this(function (res, rej) {
+ resolve = res;
+ reject = rej;
+ });
+ var count = 0;
+ var resolvedValues = [];
+ for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {
+ var value = values_2[_i];
+ if (!isThenable(value)) {
+ value = this.resolve(value);
+ }
+ value.then((function (index) { return function (value) {
+ resolvedValues[index] = value;
+ count--;
+ if (!count) {
+ resolve(resolvedValues);
+ }
+ }; })(count), reject);
+ count++;
+ }
+ if (!count)
+ resolve(resolvedValues);
+ return promise;
+ };
+ ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) {
+ var chainPromise = new this.constructor(null);
+ var zone = Zone.current;
+ if (this[symbolState] == UNRESOLVED) {
+ this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);
+ }
+ else {
+ scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
+ }
+ return chainPromise;
+ };
+ ZoneAwarePromise.prototype.catch = function (onRejected) {
+ return this.then(null, onRejected);
+ };
+ return ZoneAwarePromise;
+ }());
+ // Protect against aggressive optimizers dropping seemingly unused properties.
+ // E.g. Closure Compiler in advanced mode.
+ ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;
+ ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;
+ ZoneAwarePromise['race'] = ZoneAwarePromise.race;
+ ZoneAwarePromise['all'] = ZoneAwarePromise.all;
+ var NativePromise = global[__symbol__('Promise')] = global['Promise'];
+ global['Promise'] = ZoneAwarePromise;
+ function patchThen(NativePromise) {
+ var NativePromiseProtototype = NativePromise.prototype;
+ var NativePromiseThen = NativePromiseProtototype[__symbol__('then')] =
+ NativePromiseProtototype.then;
+ NativePromiseProtototype.then = function (onResolve, onReject) {
+ var nativePromise = this;
+ return new ZoneAwarePromise(function (resolve, reject) {
+ NativePromiseThen.call(nativePromise, resolve, reject);
+ })
+ .then(onResolve, onReject);
+ };
+ }
+ if (NativePromise) {
+ patchThen(NativePromise);
+ if (typeof global['fetch'] !== 'undefined') {
+ var fetchPromise = void 0;
+ try {
+ // In MS Edge this throws
+ fetchPromise = global['fetch']();
+ }
+ catch (e) {
+ // In Chrome this throws instead.
+ fetchPromise = global['fetch']('about:blank');
+ }
+ // ignore output to prevent error;
+ fetchPromise.then(function () { return null; }, function () { return null; });
+ if (fetchPromise.constructor != NativePromise &&
+ fetchPromise.constructor != ZoneAwarePromise) {
+ patchThen(fetchPromise.constructor);
+ }
+ }
+ }
+ // This is not part of public API, but it is usefull for tests, so we expose it.
+ Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;
+ /*
+ * This code patches Error so that:
+ * - It ignores un-needed stack frames.
+ * - It Shows the associated Zone for reach frame.
+ */
+ var FrameType;
+ (function (FrameType) {
+ /// Skip this frame when printing out stack
+ FrameType[FrameType["blackList"] = 0] = "blackList";
+ /// This frame marks zone transition
+ FrameType[FrameType["transition"] = 1] = "transition";
+ })(FrameType || (FrameType = {}));
+ var NativeError = global[__symbol__('Error')] = global.Error;
+ // Store the frames which should be removed from the stack frames
+ var blackListedStackFrames = {};
+ // We must find the frame where Error was created, otherwise we assume we don't understand stack
+ var zoneAwareFrame;
+ global.Error = ZoneAwareError;
+ // How should the stack frames be parsed.
+ var frameParserStrategy = null;
+ var stackRewrite = 'stackRewrite';
+ // fix #595, create property descriptor
+ // for error properties
+ var createProperty = function (props, key) {
+ // if property is already defined, skip it.
+ if (props[key]) {
+ return;
+ }
+ // define a local property
+ // in case error property is not settable
+ var name = __symbol__(key);
+ props[key] = {
+ configurable: true,
+ enumerable: true,
+ get: function () {
+ // if local property has no value
+ // use internal error's property value
+ if (!this[name]) {
+ var error_2 = this[__symbol__('error')];
+ if (error_2) {
+ this[name] = error_2[key];
+ }
+ }
+ return this[name];
+ },
+ set: function (value) {
+ // setter will set value to local property value
+ this[name] = value;
+ }
+ };
+ };
+ // fix #595, create property descriptor
+ // for error method properties
+ var createMethodProperty = function (props, key) {
+ if (props[key]) {
+ return;
+ }
+ props[key] = {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: function () {
+ var error = this[__symbol__('error')];
+ var errorMethod = (error && error[key]) || this[key];
+ if (errorMethod) {
+ return errorMethod.apply(error, arguments);
+ }
+ }
+ };
+ };
+ var createErrorProperties = function () {
+ var props = Object.create(null);
+ var error = new NativeError();
+ var keys = Object.getOwnPropertyNames(error);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ // Avoid bugs when hasOwnProperty is shadowed
+ if (Object.prototype.hasOwnProperty.call(error, key)) {
+ createProperty(props, key);
+ }
+ }
+ var proto = NativeError.prototype;
+ if (proto) {
+ var pKeys = Object.getOwnPropertyNames(proto);
+ for (var i = 0; i < pKeys.length; i++) {
+ var key = pKeys[i];
+ // skip constructor
+ if (key !== 'constructor' && key !== 'toString' && key !== 'toSource') {
+ createProperty(props, key);
+ }
+ }
+ }
+ // some other properties are not
+ // in NativeError
+ createProperty(props, 'originalStack');
+ createProperty(props, 'zoneAwareStack');
+ // define toString, toSource as method property
+ createMethodProperty(props, 'toString');
+ createMethodProperty(props, 'toSource');
+ return props;
+ };
+ var errorProperties = createErrorProperties();
+ // for derived Error class which extends ZoneAwareError
+ // we should not override the derived class's property
+ // so we create a new props object only copy the properties
+ // from errorProperties which not exist in derived Error's prototype
+ var getErrorPropertiesForPrototype = function (prototype) {
+ // if the prototype is ZoneAwareError.prototype
+ // we just return the prebuilt errorProperties.
+ if (prototype === ZoneAwareError.prototype) {
+ return errorProperties;
+ }
+ var newProps = Object.create(null);
+ var cKeys = Object.getOwnPropertyNames(errorProperties);
+ var keys = Object.getOwnPropertyNames(prototype);
+ cKeys.forEach(function (cKey) {
+ if (keys.filter(function (key) {
+ return key === cKey;
+ })
+ .length === 0) {
+ newProps[cKey] = errorProperties[cKey];
+ }
+ });
+ return newProps;
+ };
+ /**
+ * This is ZoneAwareError which processes the stack frame and cleans up extra frames as well as
+ * adds zone information to it.
+ */
+ function ZoneAwareError() {
+ // make sure we have a valid this
+ // if this is undefined(call Error without new) or this is global
+ // or this is some other objects, we should force to create a
+ // valid ZoneAwareError by call Object.create()
+ if (!(this instanceof ZoneAwareError)) {
+ return ZoneAwareError.apply(Object.create(ZoneAwareError.prototype), arguments);
+ }
+ // Create an Error.
+ var error = NativeError.apply(this, arguments);
+ this[__symbol__('error')] = error;
+ // Save original stack trace
+ error.originalStack = error.stack;
+ // Process the stack trace and rewrite the frames.
+ if (ZoneAwareError[stackRewrite] && error.originalStack) {
+ var frames_1 = error.originalStack.split('\n');
+ var zoneFrame = _currentZoneFrame;
+ var i = 0;
+ // Find the first frame
+ while (frames_1[i] !== zoneAwareFrame && i < frames_1.length) {
+ i++;
+ }
+ for (; i < frames_1.length && zoneFrame; i++) {
+ var frame = frames_1[i];
+ if (frame.trim()) {
+ var frameType = blackListedStackFrames.hasOwnProperty(frame) && blackListedStackFrames[frame];
+ if (frameType === FrameType.blackList) {
+ frames_1.splice(i, 1);
+ i--;
+ }
+ else if (frameType === FrameType.transition) {
+ if (zoneFrame.parent) {
+ // This is the special frame where zone changed. Print and process it accordingly
+ frames_1[i] += " [" + zoneFrame.parent.zone.name + " => " + zoneFrame.zone.name + "]";
+ zoneFrame = zoneFrame.parent;
+ }
+ else {
+ zoneFrame = null;
+ }
+ }
+ else {
+ frames_1[i] += " [" + zoneFrame.zone.name + "]";
+ }
+ }
+ }
+ error.stack = error.zoneAwareStack = frames_1.join('\n');
+ }
+ // use defineProperties here instead of copy property value
+ // because of issue #595 which will break angular2.
+ Object.defineProperties(this, getErrorPropertiesForPrototype(Object.getPrototypeOf(this)));
+ return this;
+ }
+ // Copy the prototype so that instanceof operator works as expected
+ ZoneAwareError.prototype = NativeError.prototype;
+ ZoneAwareError[Zone.__symbol__('blacklistedStackFrames')] = blackListedStackFrames;
+ ZoneAwareError[stackRewrite] = false;
+ if (NativeError.hasOwnProperty('stackTraceLimit')) {
+ // Extend default stack limit as we will be removing few frames.
+ NativeError.stackTraceLimit = Math.max(NativeError.stackTraceLimit, 15);
+ // make sure that ZoneAwareError has the same property which forwards to NativeError.
+ Object.defineProperty(ZoneAwareError, 'stackTraceLimit', {
+ get: function () {
+ return NativeError.stackTraceLimit;
+ },
+ set: function (value) {
+ return NativeError.stackTraceLimit = value;
+ }
+ });
+ }
+ if (NativeError.hasOwnProperty('captureStackTrace')) {
+ Object.defineProperty(ZoneAwareError, 'captureStackTrace', {
+ // add named function here because we need to remove this
+ // stack frame when prepareStackTrace below
+ value: function zoneCaptureStackTrace(targetObject, constructorOpt) {
+ NativeError.captureStackTrace(targetObject, constructorOpt);
+ }
+ });
+ }
+ Object.defineProperty(ZoneAwareError, 'prepareStackTrace', {
+ get: function () {
+ return NativeError.prepareStackTrace;
+ },
+ set: function (value) {
+ if (!value || typeof value !== 'function') {
+ return NativeError.prepareStackTrace = value;
+ }
+ return NativeError.prepareStackTrace = function (error, structuredStackTrace) {
+ // remove additional stack information from ZoneAwareError.captureStackTrace
+ if (structuredStackTrace) {
+ for (var i = 0; i < structuredStackTrace.length; i++) {
+ var st = structuredStackTrace[i];
+ // remove the first function which name is zoneCaptureStackTrace
+ if (st.getFunctionName() === 'zoneCaptureStackTrace') {
+ structuredStackTrace.splice(i, 1);
+ break;
+ }
+ }
+ }
+ return value.apply(this, [error, structuredStackTrace]);
+ };
+ }
+ });
+ // Now we need to populet the `blacklistedStackFrames` as well as find the
+ // run/runGuraded/runTask frames. This is done by creating a detect zone and then threading
+ // the execution through all of the above methods so that we can look at the stack trace and
+ // find the frames of interest.
+ var detectZone = Zone.current.fork({
+ name: 'detect',
+ onInvoke: function (parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
+ // Here only so that it will show up in the stack frame so that it can be black listed.
+ return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+ },
+ onHandleError: function (parentZD, current, target, error) {
+ if (error.originalStack && Error === ZoneAwareError) {
+ var frames_2 = error.originalStack.split(/\n/);
+ var runFrame = false, runGuardedFrame = false, runTaskFrame = false;
+ while (frames_2.length) {
+ var frame = frames_2.shift();
+ // On safari it is possible to have stack frame with no line number.
+ // This check makes sure that we don't filter frames on name only (must have
+ // linenumber)
+ if (/:\d+:\d+/.test(frame)) {
+ // Get rid of the path so that we don't accidintely find function name in path.
+ // In chrome the seperator is `(` and `@` in FF and safari
+ // Chrome: at Zone.run (zone.js:100)
+ // Chrome: at Zone.run (http://localhost:9876/base/build/lib/zone.js:100:24)
+ // FireFox: Zone.prototype.run@http://localhost:9876/base/build/lib/zone.js:101:24
+ // Safari: run@http://localhost:9876/base/build/lib/zone.js:101:24
+ var fnName = frame.split('(')[0].split('@')[0];
+ var frameType = FrameType.transition;
+ if (fnName.indexOf('ZoneAwareError') !== -1) {
+ zoneAwareFrame = frame;
+ }
+ if (fnName.indexOf('runGuarded') !== -1) {
+ runGuardedFrame = true;
+ }
+ else if (fnName.indexOf('runTask') !== -1) {
+ runTaskFrame = true;
+ }
+ else if (fnName.indexOf('run') !== -1) {
+ runFrame = true;
+ }
+ else {
+ frameType = FrameType.blackList;
+ }
+ blackListedStackFrames[frame] = frameType;
+ // Once we find all of the frames we can stop looking.
+ if (runFrame && runGuardedFrame && runTaskFrame) {
+ ZoneAwareError[stackRewrite] = true;
+ break;
+ }
+ }
+ }
+ }
+ return false;
+ }
+ });
+ // carefully constructor a stack frame which contains all of the frames of interest which
+ // need to be detected and blacklisted.
+ var detectRunFn = function () {
+ detectZone.run(function () {
+ detectZone.runGuarded(function () {
+ throw new Error('blacklistStackFrames');
+ });
+ });
+ };
+ // Cause the error to extract the stack frames.
+ detectZone.runTask(detectZone.scheduleMacroTask('detect', detectRunFn, null, function () { return null; }, null));
+ return global['Zone'] = Zone;
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Suppress closure compiler errors about unknown 'Zone' variable
+ * @fileoverview
+ * @suppress {undefinedVars}
+ */
+var zoneSymbol = function (n) { return "__zone_symbol__" + n; };
+var _global$1 = typeof window === 'object' && window || typeof self === 'object' && self || global;
+function bindArguments(args, source) {
+ for (var i = args.length - 1; i >= 0; i--) {
+ if (typeof args[i] === 'function') {
+ args[i] = Zone.current.wrap(args[i], source + '_' + i);
+ }
+ }
+ return args;
+}
+
+
+var isNode = (!('nw' in _global$1) && typeof process !== 'undefined' &&
+ {}.toString.call(process) === '[object process]');
+
+
+
+
+
+var EVENT_TASKS = zoneSymbol('eventTasks');
+// For EventTarget
+var ADD_EVENT_LISTENER = 'addEventListener';
+var REMOVE_EVENT_LISTENER = 'removeEventListener';
+function findExistingRegisteredTask(target, handler, name, capture, remove) {
+ var eventTasks = target[EVENT_TASKS];
+ if (eventTasks) {
+ for (var i = 0; i < eventTasks.length; i++) {
+ var eventTask = eventTasks[i];
+ var data = eventTask.data;
+ var listener = data.handler;
+ if ((data.handler === handler || listener.listener === handler) &&
+ data.useCapturing === capture && data.eventName === name) {
+ if (remove) {
+ eventTasks.splice(i, 1);
+ }
+ return eventTask;
+ }
+ }
+ }
+ return null;
+}
+function findAllExistingRegisteredTasks(target, name, capture, remove) {
+ var eventTasks = target[EVENT_TASKS];
+ if (eventTasks) {
+ var result = [];
+ for (var i = eventTasks.length - 1; i >= 0; i--) {
+ var eventTask = eventTasks[i];
+ var data = eventTask.data;
+ if (data.eventName === name && data.useCapturing === capture) {
+ result.push(eventTask);
+ if (remove) {
+ eventTasks.splice(i, 1);
+ }
+ }
+ }
+ return result;
+ }
+ return null;
+}
+function attachRegisteredEvent(target, eventTask, isPrepend) {
+ var eventTasks = target[EVENT_TASKS];
+ if (!eventTasks) {
+ eventTasks = target[EVENT_TASKS] = [];
+ }
+ if (isPrepend) {
+ eventTasks.unshift(eventTask);
+ }
+ else {
+ eventTasks.push(eventTask);
+ }
+}
+var defaultListenerMetaCreator = function (self, args) {
+ return {
+ useCapturing: args[2],
+ eventName: args[0],
+ handler: args[1],
+ target: self || _global$1,
+ name: args[0],
+ invokeAddFunc: function (addFnSymbol, delegate) {
+ if (delegate && delegate.invoke) {
+ return this.target[addFnSymbol](this.eventName, delegate.invoke, this.useCapturing);
+ }
+ else {
+ return this.target[addFnSymbol](this.eventName, delegate, this.useCapturing);
+ }
+ },
+ invokeRemoveFunc: function (removeFnSymbol, delegate) {
+ if (delegate && delegate.invoke) {
+ return this.target[removeFnSymbol](this.eventName, delegate.invoke, this.useCapturing);
+ }
+ else {
+ return this.target[removeFnSymbol](this.eventName, delegate, this.useCapturing);
+ }
+ }
+ };
+};
+function makeZoneAwareAddListener(addFnName, removeFnName, useCapturingParam, allowDuplicates, isPrepend, metaCreator) {
+ if (useCapturingParam === void 0) { useCapturingParam = true; }
+ if (allowDuplicates === void 0) { allowDuplicates = false; }
+ if (isPrepend === void 0) { isPrepend = false; }
+ if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
+ var addFnSymbol = zoneSymbol(addFnName);
+ var removeFnSymbol = zoneSymbol(removeFnName);
+ var defaultUseCapturing = useCapturingParam ? false : undefined;
+ function scheduleEventListener(eventTask) {
+ var meta = eventTask.data;
+ attachRegisteredEvent(meta.target, eventTask, isPrepend);
+ return meta.invokeAddFunc(addFnSymbol, eventTask);
+ }
+ function cancelEventListener(eventTask) {
+ var meta = eventTask.data;
+ findExistingRegisteredTask(meta.target, eventTask.invoke, meta.eventName, meta.useCapturing, true);
+ return meta.invokeRemoveFunc(removeFnSymbol, eventTask);
+ }
+ return function zoneAwareAddListener(self, args) {
+ var data = metaCreator(self, args);
+ data.useCapturing = data.useCapturing || defaultUseCapturing;
+ // - Inside a Web Worker, `this` is undefined, the context is `global`
+ // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+ // see https://github.com/angular/zone.js/issues/190
+ var delegate = null;
+ if (typeof data.handler == 'function') {
+ delegate = data.handler;
+ }
+ else if (data.handler && data.handler.handleEvent) {
+ delegate = function (event) { return data.handler.handleEvent(event); };
+ }
+ var validZoneHandler = false;
+ try {
+ // In cross site contexts (such as WebDriver frameworks like Selenium),
+ // accessing the handler object here will cause an exception to be thrown which
+ // will fail tests prematurely.
+ validZoneHandler = data.handler && data.handler.toString() === '[object FunctionWrapper]';
+ }
+ catch (e) {
+ // Returning nothing here is fine, because objects in a cross-site context are unusable
+ return;
+ }
+ // Ignore special listeners of IE11 & Edge dev tools, see
+ // https://github.com/angular/zone.js/issues/150
+ if (!delegate || validZoneHandler) {
+ return data.invokeAddFunc(addFnSymbol, data.handler);
+ }
+ if (!allowDuplicates) {
+ var eventTask = findExistingRegisteredTask(data.target, data.handler, data.eventName, data.useCapturing, false);
+ if (eventTask) {
+ // we already registered, so this will have noop.
+ return data.invokeAddFunc(addFnSymbol, eventTask);
+ }
+ }
+ var zone = Zone.current;
+ var source = data.target.constructor['name'] + '.' + addFnName + ':' + data.eventName;
+ zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener);
+ };
+}
+function makeZoneAwareRemoveListener(fnName, useCapturingParam, metaCreator) {
+ if (useCapturingParam === void 0) { useCapturingParam = true; }
+ if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
+ var symbol = zoneSymbol(fnName);
+ var defaultUseCapturing = useCapturingParam ? false : undefined;
+ return function zoneAwareRemoveListener(self, args) {
+ var data = metaCreator(self, args);
+ data.useCapturing = data.useCapturing || defaultUseCapturing;
+ // - Inside a Web Worker, `this` is undefined, the context is `global`
+ // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+ // see https://github.com/angular/zone.js/issues/190
+ var eventTask = findExistingRegisteredTask(data.target, data.handler, data.eventName, data.useCapturing, true);
+ if (eventTask) {
+ eventTask.zone.cancelTask(eventTask);
+ }
+ else {
+ data.invokeRemoveFunc(symbol, data.handler);
+ }
+ };
+}
+function makeZoneAwareRemoveAllListeners(fnName, useCapturingParam) {
+ if (useCapturingParam === void 0) { useCapturingParam = true; }
+ var symbol = zoneSymbol(fnName);
+ var defaultUseCapturing = useCapturingParam ? false : undefined;
+ return function zoneAwareRemoveAllListener(self, args) {
+ var target = self || _global$1;
+ if (args.length === 0) {
+ // remove all listeners without eventName
+ target[EVENT_TASKS] = [];
+ // we don't cancel Task either, because call native eventEmitter.removeAllListeners will
+ // will do remove listener(cancelTask) for us
+ target[symbol]();
+ return;
+ }
+ var eventName = args[0];
+ var useCapturing = args[1] || defaultUseCapturing;
+ // call this function just remove the related eventTask from target[EVENT_TASKS]
+ findAllExistingRegisteredTasks(target, eventName, useCapturing, true);
+ // we don't need useCapturing here because useCapturing is just for DOM, and
+ // removeAllListeners should only be called by node eventEmitter
+ // and we don't cancel Task either, because call native eventEmitter.removeAllListeners will
+ // will do remove listener(cancelTask) for us
+ target[symbol](eventName);
+ };
+}
+function makeZoneAwareListeners(fnName) {
+ var symbol = zoneSymbol(fnName);
+ return function zoneAwareEventListeners(self, args) {
+ var eventName = args[0];
+ var target = self || _global$1;
+ if (!target[EVENT_TASKS]) {
+ return [];
+ }
+ return target[EVENT_TASKS]
+ .filter(function (task) { return task.data.eventName === eventName; })
+ .map(function (task) { return task.data.handler; });
+ };
+}
+var zoneAwareAddEventListener = makeZoneAwareAddListener(ADD_EVENT_LISTENER, REMOVE_EVENT_LISTENER);
+var zoneAwareRemoveEventListener = makeZoneAwareRemoveListener(REMOVE_EVENT_LISTENER);
+
+var originalInstanceKey = zoneSymbol('originalInstance');
+// wrap some native API on `window`
+
+
+function createNamedFn(name, delegate) {
+ try {
+ return (Function('f', "return function " + name + "(){return f(this, arguments)}"))(delegate);
+ }
+ catch (e) {
+ // if we fail, we must be CSP, just return delegate.
+ return function () {
+ return delegate(this, arguments);
+ };
+ }
+}
+function patchMethod(target, name, patchFn) {
+ var proto = target;
+ while (proto && Object.getOwnPropertyNames(proto).indexOf(name) === -1) {
+ proto = Object.getPrototypeOf(proto);
+ }
+ if (!proto && target[name]) {
+ // somehow we did not find it, but we can see it. This happens on IE for Window properties.
+ proto = target;
+ }
+ var delegateName = zoneSymbol(name);
+ var delegate;
+ if (proto && !(delegate = proto[delegateName])) {
+ delegate = proto[delegateName] = proto[name];
+ proto[name] = createNamedFn(name, patchFn(delegate, delegateName, name));
+ }
+ return delegate;
+}
+// TODO: support cancel task later if necessary
+function patchMacroTask(obj, funcName, metaCreator) {
+ var setNative = null;
+ function scheduleTask(task) {
+ var data = task.data;
+ data.args[data.callbackIndex] = function () {
+ task.invoke.apply(this, arguments);
+ };
+ setNative.apply(data.target, data.args);
+ return task;
+ }
+ setNative = patchMethod(obj, funcName, function (delegate) { return function (self, args) {
+ var meta = metaCreator(self, args);
+ if (meta.callbackIndex >= 0 && typeof args[meta.callbackIndex] === 'function') {
+ var task = Zone.current.scheduleMacroTask(meta.name, args[meta.callbackIndex], meta, scheduleTask, null);
+ return task;
+ }
+ else {
+ // cause an error by calling it directly.
+ return delegate.apply(self, args);
+ }
+ }; });
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var callAndReturnFirstParam = function (fn) {
+ return function (self, args) {
+ fn(self, args);
+ return self;
+ };
+};
+// For EventEmitter
+var EE_ADD_LISTENER = 'addListener';
+var EE_PREPEND_LISTENER = 'prependListener';
+var EE_REMOVE_LISTENER = 'removeListener';
+var EE_REMOVE_ALL_LISTENER = 'removeAllListeners';
+var EE_LISTENERS = 'listeners';
+var EE_ON = 'on';
+var zoneAwareAddListener$1 = callAndReturnFirstParam(makeZoneAwareAddListener(EE_ADD_LISTENER, EE_REMOVE_LISTENER, false, true, false));
+var zoneAwarePrependListener = callAndReturnFirstParam(makeZoneAwareAddListener(EE_PREPEND_LISTENER, EE_REMOVE_LISTENER, false, true, true));
+var zoneAwareRemoveListener$1 = callAndReturnFirstParam(makeZoneAwareRemoveListener(EE_REMOVE_LISTENER, false));
+var zoneAwareRemoveAllListeners = callAndReturnFirstParam(makeZoneAwareRemoveAllListeners(EE_REMOVE_ALL_LISTENER, false));
+var zoneAwareListeners = makeZoneAwareListeners(EE_LISTENERS);
+function patchEventEmitterMethods(obj) {
+ if (obj && obj.addListener) {
+ patchMethod(obj, EE_ADD_LISTENER, function () { return zoneAwareAddListener$1; });
+ patchMethod(obj, EE_PREPEND_LISTENER, function () { return zoneAwarePrependListener; });
+ patchMethod(obj, EE_REMOVE_LISTENER, function () { return zoneAwareRemoveListener$1; });
+ patchMethod(obj, EE_REMOVE_ALL_LISTENER, function () { return zoneAwareRemoveAllListeners; });
+ patchMethod(obj, EE_LISTENERS, function () { return zoneAwareListeners; });
+ obj[EE_ON] = obj[EE_ADD_LISTENER];
+ return true;
+ }
+ else {
+ return false;
+ }
+}
+// EventEmitter
+var events;
+try {
+ events = require('events');
+}
+catch (err) {
+}
+if (events && events.EventEmitter) {
+ patchEventEmitterMethods(events.EventEmitter.prototype);
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var fs;
+try {
+ fs = require('fs');
+}
+catch (err) {
+}
+// watch, watchFile, unwatchFile has been patched
+// because EventEmitter has been patched
+var TO_PATCH_MACROTASK_METHODS = [
+ 'access', 'appendFile', 'chmod', 'chown', 'close', 'exists', 'fchmod',
+ 'fchown', 'fdatasync', 'fstat', 'fsync', 'ftruncate', 'futimes', 'lchmod',
+ 'lchown', 'link', 'lstat', 'mkdir', 'mkdtemp', 'open', 'read',
+ 'readdir', 'readFile', 'readlink', 'realpath', 'rename', 'rmdir', 'stat',
+ 'symlink', 'truncate', 'unlink', 'utimes', 'write', 'writeFile',
+];
+if (fs) {
+ TO_PATCH_MACROTASK_METHODS.filter(function (name) { return !!fs[name] && typeof fs[name] === 'function'; })
+ .forEach(function (name) {
+ patchMacroTask(fs, name, function (self, args) {
+ return {
+ name: 'fs.' + name,
+ args: args,
+ callbackIndex: args.length > 0 ? args.length - 1 : -1,
+ target: self
+ };
+ });
+ });
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function patchTimer(window, setName, cancelName, nameSuffix) {
+ var setNative = null;
+ var clearNative = null;
+ setName += nameSuffix;
+ cancelName += nameSuffix;
+ var tasksByHandleId = {};
+ function scheduleTask(task) {
+ var data = task.data;
+ data.args[0] = function () {
+ task.invoke.apply(this, arguments);
+ delete tasksByHandleId[data.handleId];
+ };
+ data.handleId = setNative.apply(window, data.args);
+ tasksByHandleId[data.handleId] = task;
+ return task;
+ }
+ function clearTask(task) {
+ delete tasksByHandleId[task.data.handleId];
+ return clearNative(task.data.handleId);
+ }
+ setNative =
+ patchMethod(window, setName, function (delegate) { return function (self, args) {
+ if (typeof args[0] === 'function') {
+ var zone = Zone.current;
+ var options = {
+ handleId: null,
+ isPeriodic: nameSuffix === 'Interval',
+ delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : null,
+ args: args
+ };
+ var task = zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask);
+ if (!task) {
+ return task;
+ }
+ // Node.js must additionally support the ref and unref functions.
+ var handle = task.data.handleId;
+ if (handle.ref && handle.unref) {
+ task.ref = handle.ref.bind(handle);
+ task.unref = handle.unref.bind(handle);
+ }
+ return task;
+ }
+ else {
+ // cause an error by calling it directly.
+ return delegate.apply(window, args);
+ }
+ }; });
+ clearNative =
+ patchMethod(window, cancelName, function (delegate) { return function (self, args) {
+ var task = typeof args[0] === 'number' ? tasksByHandleId[args[0]] : args[0];
+ if (task && typeof task.type === 'string') {
+ if (task.cancelFn && task.data.isPeriodic || task.runCount === 0) {
+ // Do not cancel already canceled functions
+ task.zone.cancelTask(task);
+ }
+ }
+ else {
+ // cause an error by calling it directly.
+ delegate.apply(window, args);
+ }
+ }; });
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var set = 'set';
+var clear = 'clear';
+var _global = typeof window === 'object' && window || typeof self === 'object' && self || global;
+// Timers
+var timers = require('timers');
+patchTimer(timers, set, clear, 'Timeout');
+patchTimer(timers, set, clear, 'Interval');
+patchTimer(timers, set, clear, 'Immediate');
+var shouldPatchGlobalTimers = global.setTimeout !== timers.setTimeout;
+if (shouldPatchGlobalTimers) {
+ patchTimer(_global, set, clear, 'Timeout');
+ patchTimer(_global, set, clear, 'Interval');
+ patchTimer(_global, set, clear, 'Immediate');
+}
+patchNextTick();
+// Crypto
+var crypto;
+try {
+ crypto = require('crypto');
+}
+catch (err) {
+}
+// TODO(gdi2290): implement a better way to patch these methods
+if (crypto) {
+ var nativeRandomBytes_1 = crypto.randomBytes;
+ crypto.randomBytes = function randomBytesZone(size, callback) {
+ if (!callback) {
+ return nativeRandomBytes_1(size);
+ }
+ else {
+ var zone = Zone.current;
+ var source = crypto.constructor.name + '.randomBytes';
+ return nativeRandomBytes_1(size, zone.wrap(callback, source));
+ }
+ }.bind(crypto);
+ var nativePbkdf2_1 = crypto.pbkdf2;
+ crypto.pbkdf2 = function pbkdf2Zone() {
+ var args = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ args[_i] = arguments[_i];
+ }
+ var fn = args[args.length - 1];
+ if (typeof fn === 'function') {
+ var zone = Zone.current;
+ var source = crypto.constructor.name + '.pbkdf2';
+ args[args.length - 1] = zone.wrap(fn, source);
+ return nativePbkdf2_1.apply(void 0, args);
+ }
+ else {
+ return nativePbkdf2_1.apply(void 0, args);
+ }
+ }.bind(crypto);
+}
+// HTTP Client
+var httpClient;
+try {
+ httpClient = require('_http_client');
+}
+catch (err) {
+}
+if (httpClient && httpClient.ClientRequest) {
+ var ClientRequest_1 = httpClient.ClientRequest.bind(httpClient);
+ httpClient.ClientRequest = function (options, callback) {
+ if (!callback) {
+ return new ClientRequest_1(options);
+ }
+ else {
+ var zone = Zone.current;
+ return new ClientRequest_1(options, zone.wrap(callback, 'http.ClientRequest'));
+ }
+ };
+}
+function patchNextTick() {
+ var setNative = null;
+ function scheduleTask(task) {
+ var args = task.data;
+ args[0] = function () {
+ task.invoke.apply(this, arguments);
+ };
+ setNative.apply(process, args);
+ return task;
+ }
+ setNative =
+ patchMethod(process, 'nextTick', function (delegate) { return function (self, args) {
+ if (typeof args[0] === 'function') {
+ var zone = Zone.current;
+ var task = zone.scheduleMicroTask('nextTick', args[0], args, scheduleTask);
+ return task;
+ }
+ else {
+ // cause an error by calling it directly.
+ return delegate.apply(process, args);
+ }
+ }; });
+}
+
+})));
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.js
new file mode 100644
index 00000000..a38f6e93
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.js
@@ -0,0 +1,1861 @@
+/**
+* @license
+* Copyright Google Inc. All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.io/license
+*/
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (factory());
+}(this, (function () { 'use strict';
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+var Zone$1 = (function (global) {
+ if (global['Zone']) {
+ throw new Error('Zone already loaded.');
+ }
+ var Zone = (function () {
+ function Zone(parent, zoneSpec) {
+ this._properties = null;
+ this._parent = parent;
+ this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '';
+ this._properties = zoneSpec && zoneSpec.properties || {};
+ this._zoneDelegate =
+ new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
+ }
+ Zone.assertZonePatched = function () {
+ if (global.Promise !== ZoneAwarePromise) {
+ throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +
+ 'has been overwritten.\n' +
+ 'Most likely cause is that a Promise polyfill has been loaded ' +
+ 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +
+ 'If you must load one, do so before loading zone.js.)');
+ }
+ };
+ Object.defineProperty(Zone, "current", {
+ get: function () {
+ return _currentZoneFrame.zone;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Object.defineProperty(Zone, "currentTask", {
+ get: function () {
+ return _currentTask;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Object.defineProperty(Zone.prototype, "parent", {
+ get: function () {
+ return this._parent;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Object.defineProperty(Zone.prototype, "name", {
+ get: function () {
+ return this._name;
+ },
+ enumerable: true,
+ configurable: true
+ });
+
+ Zone.prototype.get = function (key) {
+ var zone = this.getZoneWith(key);
+ if (zone)
+ return zone._properties[key];
+ };
+ Zone.prototype.getZoneWith = function (key) {
+ var current = this;
+ while (current) {
+ if (current._properties.hasOwnProperty(key)) {
+ return current;
+ }
+ current = current._parent;
+ }
+ return null;
+ };
+ Zone.prototype.fork = function (zoneSpec) {
+ if (!zoneSpec)
+ throw new Error('ZoneSpec required!');
+ return this._zoneDelegate.fork(this, zoneSpec);
+ };
+ Zone.prototype.wrap = function (callback, source) {
+ if (typeof callback !== 'function') {
+ throw new Error('Expecting function got: ' + callback);
+ }
+ var _callback = this._zoneDelegate.intercept(this, callback, source);
+ var zone = this;
+ return function () {
+ return zone.runGuarded(_callback, this, arguments, source);
+ };
+ };
+ Zone.prototype.run = function (callback, applyThis, applyArgs, source) {
+ if (applyThis === void 0) { applyThis = null; }
+ if (applyArgs === void 0) { applyArgs = null; }
+ if (source === void 0) { source = null; }
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
+ }
+ finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ }
+ };
+ Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) {
+ if (applyThis === void 0) { applyThis = null; }
+ if (applyArgs === void 0) { applyArgs = null; }
+ if (source === void 0) { source = null; }
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ try {
+ return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
+ }
+ catch (error) {
+ if (this._zoneDelegate.handleError(this, error)) {
+ throw error;
+ }
+ }
+ }
+ finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ }
+ };
+ Zone.prototype.runTask = function (task, applyThis, applyArgs) {
+ task.runCount++;
+ if (task.zone != this)
+ throw new Error('A task can only be run in the zone which created it! (Creation: ' + task.zone.name +
+ '; Execution: ' + this.name + ')');
+ var previousTask = _currentTask;
+ _currentTask = task;
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ if (task.type == 'macroTask' && task.data && !task.data.isPeriodic) {
+ task.cancelFn = null;
+ }
+ try {
+ return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
+ }
+ catch (error) {
+ if (this._zoneDelegate.handleError(this, error)) {
+ throw error;
+ }
+ }
+ }
+ finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ _currentTask = previousTask;
+ }
+ };
+ Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) {
+ return this._zoneDelegate.scheduleTask(this, new ZoneTask('microTask', this, source, callback, data, customSchedule, null));
+ };
+ Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) {
+ return this._zoneDelegate.scheduleTask(this, new ZoneTask('macroTask', this, source, callback, data, customSchedule, customCancel));
+ };
+ Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) {
+ return this._zoneDelegate.scheduleTask(this, new ZoneTask('eventTask', this, source, callback, data, customSchedule, customCancel));
+ };
+ Zone.prototype.cancelTask = function (task) {
+ var value = this._zoneDelegate.cancelTask(this, task);
+ task.runCount = -1;
+ task.cancelFn = null;
+ return value;
+ };
+ return Zone;
+ }());
+ Zone.__symbol__ = __symbol__;
+
+ var ZoneDelegate = (function () {
+ function ZoneDelegate(zone, parentDelegate, zoneSpec) {
+ this._taskCounts = { microTask: 0, macroTask: 0, eventTask: 0 };
+ this.zone = zone;
+ this._parentDelegate = parentDelegate;
+ this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
+ this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
+ this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate.zone);
+ this._interceptZS =
+ zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
+ this._interceptDlgt =
+ zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
+ this._interceptCurrZone =
+ zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate.zone);
+ this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
+ this._invokeDlgt =
+ zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
+ this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate.zone);
+ this._handleErrorZS =
+ zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
+ this._handleErrorDlgt =
+ zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
+ this._handleErrorCurrZone =
+ zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate.zone);
+ this._scheduleTaskZS =
+ zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
+ this._scheduleTaskDlgt =
+ zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
+ this._scheduleTaskCurrZone =
+ zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate.zone);
+ this._invokeTaskZS =
+ zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
+ this._invokeTaskDlgt =
+ zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
+ this._invokeTaskCurrZone =
+ zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate.zone);
+ this._cancelTaskZS =
+ zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
+ this._cancelTaskDlgt =
+ zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
+ this._cancelTaskCurrZone =
+ zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate.zone);
+ this._hasTaskZS = zoneSpec && (zoneSpec.onHasTask ? zoneSpec : parentDelegate._hasTaskZS);
+ this._hasTaskDlgt =
+ zoneSpec && (zoneSpec.onHasTask ? parentDelegate : parentDelegate._hasTaskDlgt);
+ this._hasTaskCurrZone = zoneSpec && (zoneSpec.onHasTask ? this.zone : parentDelegate.zone);
+ }
+ ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {
+ return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
+ new Zone(targetZone, zoneSpec);
+ };
+ ZoneDelegate.prototype.intercept = function (targetZone, callback, source) {
+ return this._interceptZS ?
+ this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :
+ callback;
+ };
+ ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) {
+ return this._invokeZS ?
+ this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) :
+ callback.apply(applyThis, applyArgs);
+ };
+ ZoneDelegate.prototype.handleError = function (targetZone, error) {
+ return this._handleErrorZS ?
+ this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :
+ true;
+ };
+ ZoneDelegate.prototype.scheduleTask = function (targetZone, task) {
+ try {
+ if (this._scheduleTaskZS) {
+ return this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
+ }
+ else if (task.scheduleFn) {
+ task.scheduleFn(task);
+ }
+ else if (task.type == 'microTask') {
+ scheduleMicroTask(task);
+ }
+ else {
+ throw new Error('Task is missing scheduleFn.');
+ }
+ return task;
+ }
+ finally {
+ if (targetZone == this.zone) {
+ this._updateTaskCount(task.type, 1);
+ }
+ }
+ };
+ ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) {
+ try {
+ return this._invokeTaskZS ?
+ this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) :
+ task.callback.apply(applyThis, applyArgs);
+ }
+ finally {
+ if (targetZone == this.zone && (task.type != 'eventTask') &&
+ !(task.data && task.data.isPeriodic)) {
+ this._updateTaskCount(task.type, -1);
+ }
+ }
+ };
+ ZoneDelegate.prototype.cancelTask = function (targetZone, task) {
+ var value;
+ if (this._cancelTaskZS) {
+ value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
+ }
+ else if (!task.cancelFn) {
+ throw new Error('Task does not support cancellation, or is already canceled.');
+ }
+ else {
+ value = task.cancelFn(task);
+ }
+ if (targetZone == this.zone) {
+ // this should not be in the finally block, because exceptions assume not canceled.
+ this._updateTaskCount(task.type, -1);
+ }
+ return value;
+ };
+ ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) {
+ return this._hasTaskZS &&
+ this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
+ };
+ ZoneDelegate.prototype._updateTaskCount = function (type, count) {
+ var counts = this._taskCounts;
+ var prev = counts[type];
+ var next = counts[type] = prev + count;
+ if (next < 0) {
+ throw new Error('More tasks executed then were scheduled.');
+ }
+ if (prev == 0 || next == 0) {
+ var isEmpty = {
+ microTask: counts.microTask > 0,
+ macroTask: counts.macroTask > 0,
+ eventTask: counts.eventTask > 0,
+ change: type
+ };
+ try {
+ this.hasTask(this.zone, isEmpty);
+ }
+ finally {
+ if (this._parentDelegate) {
+ this._parentDelegate._updateTaskCount(type, count);
+ }
+ }
+ }
+ };
+ return ZoneDelegate;
+ }());
+ var ZoneTask = (function () {
+ function ZoneTask(type, zone, source, callback, options, scheduleFn, cancelFn) {
+ this.runCount = 0;
+ this.type = type;
+ this.zone = zone;
+ this.source = source;
+ this.data = options;
+ this.scheduleFn = scheduleFn;
+ this.cancelFn = cancelFn;
+ this.callback = callback;
+ var self = this;
+ this.invoke = function () {
+ _numberOfNestedTaskFrames++;
+ try {
+ return zone.runTask(self, this, arguments);
+ }
+ finally {
+ if (_numberOfNestedTaskFrames == 1) {
+ drainMicroTaskQueue();
+ }
+ _numberOfNestedTaskFrames--;
+ }
+ };
+ }
+ ZoneTask.prototype.toString = function () {
+ if (this.data && typeof this.data.handleId !== 'undefined') {
+ return this.data.handleId;
+ }
+ else {
+ return Object.prototype.toString.call(this);
+ }
+ };
+ // add toJSON method to prevent cyclic error when
+ // call JSON.stringify(zoneTask)
+ ZoneTask.prototype.toJSON = function () {
+ return {
+ type: this.type,
+ source: this.source,
+ data: this.data,
+ zone: this.zone.name,
+ invoke: this.invoke,
+ scheduleFn: this.scheduleFn,
+ cancelFn: this.cancelFn,
+ runCount: this.runCount,
+ callback: this.callback
+ };
+ };
+ return ZoneTask;
+ }());
+ var ZoneFrame = (function () {
+ function ZoneFrame(parent, zone) {
+ this.parent = parent;
+ this.zone = zone;
+ }
+ return ZoneFrame;
+ }());
+ function __symbol__(name) {
+ return '__zone_symbol__' + name;
+ }
+
+ var symbolSetTimeout = __symbol__('setTimeout');
+ var symbolPromise = __symbol__('Promise');
+ var symbolThen = __symbol__('then');
+ var _currentZoneFrame = new ZoneFrame(null, new Zone(null, null));
+ var _currentTask = null;
+ var _microTaskQueue = [];
+ var _isDrainingMicrotaskQueue = false;
+ var _uncaughtPromiseErrors = [];
+ var _numberOfNestedTaskFrames = 0;
+ function scheduleQueueDrain() {
+ // if we are not running in any task, and there has not been anything scheduled
+ // we must bootstrap the initial task creation by manually scheduling the drain
+ if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
+ // We are not running in Task, so we need to kickstart the microtask queue.
+ if (global[symbolPromise]) {
+ global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue);
+ }
+ else {
+ global[symbolSetTimeout](drainMicroTaskQueue, 0);
+ }
+ }
+ }
+ function scheduleMicroTask(task) {
+ scheduleQueueDrain();
+ _microTaskQueue.push(task);
+ }
+ function consoleError(e) {
+ var rejection = e && e.rejection;
+ if (rejection) {
+ console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection, rejection instanceof Error ? rejection.stack : undefined);
+ }
+ console.error(e);
+ }
+ function drainMicroTaskQueue() {
+ if (!_isDrainingMicrotaskQueue) {
+ _isDrainingMicrotaskQueue = true;
+ while (_microTaskQueue.length) {
+ var queue = _microTaskQueue;
+ _microTaskQueue = [];
+ for (var i = 0; i < queue.length; i++) {
+ var task = queue[i];
+ try {
+ task.zone.runTask(task, null, null);
+ }
+ catch (e) {
+ consoleError(e);
+ }
+ }
+ }
+ while (_uncaughtPromiseErrors.length) {
+ var _loop_1 = function () {
+ var uncaughtPromiseError = _uncaughtPromiseErrors.shift();
+ try {
+ uncaughtPromiseError.zone.runGuarded(function () {
+ throw uncaughtPromiseError;
+ });
+ }
+ catch (e) {
+ consoleError(e);
+ }
+ };
+ while (_uncaughtPromiseErrors.length) {
+ _loop_1();
+ }
+ }
+ _isDrainingMicrotaskQueue = false;
+ }
+ }
+ function isThenable(value) {
+ return value && value.then;
+ }
+ function forwardResolution(value) {
+ return value;
+ }
+ function forwardRejection(rejection) {
+ return ZoneAwarePromise.reject(rejection);
+ }
+ var symbolState = __symbol__('state');
+ var symbolValue = __symbol__('value');
+ var source = 'Promise.then';
+ var UNRESOLVED = null;
+ var RESOLVED = true;
+ var REJECTED = false;
+ var REJECTED_NO_CATCH = 0;
+ function makeResolver(promise, state) {
+ return function (v) {
+ resolvePromise(promise, state, v);
+ // Do not return value or you will break the Promise spec.
+ };
+ }
+ function resolvePromise(promise, state, value) {
+ if (promise[symbolState] === UNRESOLVED) {
+ if (value instanceof ZoneAwarePromise && value.hasOwnProperty(symbolState) &&
+ value.hasOwnProperty(symbolValue) && value[symbolState] !== UNRESOLVED) {
+ clearRejectedNoCatch(value);
+ resolvePromise(promise, value[symbolState], value[symbolValue]);
+ }
+ else if (isThenable(value)) {
+ value.then(makeResolver(promise, state), makeResolver(promise, false));
+ }
+ else {
+ promise[symbolState] = state;
+ var queue = promise[symbolValue];
+ promise[symbolValue] = value;
+ for (var i = 0; i < queue.length;) {
+ scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
+ }
+ if (queue.length == 0 && state == REJECTED) {
+ promise[symbolState] = REJECTED_NO_CATCH;
+ try {
+ throw new Error('Uncaught (in promise): ' + value +
+ (value && value.stack ? '\n' + value.stack : ''));
+ }
+ catch (e) {
+ var error_1 = e;
+ error_1.rejection = value;
+ error_1.promise = promise;
+ error_1.zone = Zone.current;
+ error_1.task = Zone.currentTask;
+ _uncaughtPromiseErrors.push(error_1);
+ scheduleQueueDrain();
+ }
+ }
+ }
+ }
+ // Resolving an already resolved promise is a noop.
+ return promise;
+ }
+ function clearRejectedNoCatch(promise) {
+ if (promise[symbolState] === REJECTED_NO_CATCH) {
+ promise[symbolState] = REJECTED;
+ for (var i = 0; i < _uncaughtPromiseErrors.length; i++) {
+ if (promise === _uncaughtPromiseErrors[i].promise) {
+ _uncaughtPromiseErrors.splice(i, 1);
+ break;
+ }
+ }
+ }
+ }
+ function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) {
+ clearRejectedNoCatch(promise);
+ var delegate = promise[symbolState] ? onFulfilled || forwardResolution : onRejected || forwardRejection;
+ zone.scheduleMicroTask(source, function () {
+ try {
+ resolvePromise(chainPromise, true, zone.run(delegate, null, [promise[symbolValue]]));
+ }
+ catch (error) {
+ resolvePromise(chainPromise, false, error);
+ }
+ });
+ }
+ var ZoneAwarePromise = (function () {
+ function ZoneAwarePromise(executor) {
+ var promise = this;
+ if (!(promise instanceof ZoneAwarePromise)) {
+ throw new Error('Must be an instanceof Promise.');
+ }
+ promise[symbolState] = UNRESOLVED;
+ promise[symbolValue] = []; // queue;
+ try {
+ executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));
+ }
+ catch (e) {
+ resolvePromise(promise, false, e);
+ }
+ }
+ ZoneAwarePromise.toString = function () {
+ return 'function ZoneAwarePromise() { [native code] }';
+ };
+ ZoneAwarePromise.resolve = function (value) {
+ return resolvePromise(new this(null), RESOLVED, value);
+ };
+ ZoneAwarePromise.reject = function (error) {
+ return resolvePromise(new this(null), REJECTED, error);
+ };
+ ZoneAwarePromise.race = function (values) {
+ var resolve;
+ var reject;
+ var promise = new this(function (res, rej) {
+ _a = [res, rej], resolve = _a[0], reject = _a[1];
+ var _a;
+ });
+ function onResolve(value) {
+ promise && (promise = null || resolve(value));
+ }
+ function onReject(error) {
+ promise && (promise = null || reject(error));
+ }
+ for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+ var value = values_1[_i];
+ if (!isThenable(value)) {
+ value = this.resolve(value);
+ }
+ value.then(onResolve, onReject);
+ }
+ return promise;
+ };
+ ZoneAwarePromise.all = function (values) {
+ var resolve;
+ var reject;
+ var promise = new this(function (res, rej) {
+ resolve = res;
+ reject = rej;
+ });
+ var count = 0;
+ var resolvedValues = [];
+ for (var _i = 0, values_2 = values; _i < values_2.length; _i++) {
+ var value = values_2[_i];
+ if (!isThenable(value)) {
+ value = this.resolve(value);
+ }
+ value.then((function (index) { return function (value) {
+ resolvedValues[index] = value;
+ count--;
+ if (!count) {
+ resolve(resolvedValues);
+ }
+ }; })(count), reject);
+ count++;
+ }
+ if (!count)
+ resolve(resolvedValues);
+ return promise;
+ };
+ ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) {
+ var chainPromise = new this.constructor(null);
+ var zone = Zone.current;
+ if (this[symbolState] == UNRESOLVED) {
+ this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected);
+ }
+ else {
+ scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
+ }
+ return chainPromise;
+ };
+ ZoneAwarePromise.prototype.catch = function (onRejected) {
+ return this.then(null, onRejected);
+ };
+ return ZoneAwarePromise;
+ }());
+ // Protect against aggressive optimizers dropping seemingly unused properties.
+ // E.g. Closure Compiler in advanced mode.
+ ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;
+ ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;
+ ZoneAwarePromise['race'] = ZoneAwarePromise.race;
+ ZoneAwarePromise['all'] = ZoneAwarePromise.all;
+ var NativePromise = global[__symbol__('Promise')] = global['Promise'];
+ global['Promise'] = ZoneAwarePromise;
+ function patchThen(NativePromise) {
+ var NativePromiseProtototype = NativePromise.prototype;
+ var NativePromiseThen = NativePromiseProtototype[__symbol__('then')] =
+ NativePromiseProtototype.then;
+ NativePromiseProtototype.then = function (onResolve, onReject) {
+ var nativePromise = this;
+ return new ZoneAwarePromise(function (resolve, reject) {
+ NativePromiseThen.call(nativePromise, resolve, reject);
+ })
+ .then(onResolve, onReject);
+ };
+ }
+ if (NativePromise) {
+ patchThen(NativePromise);
+ if (typeof global['fetch'] !== 'undefined') {
+ var fetchPromise = void 0;
+ try {
+ // In MS Edge this throws
+ fetchPromise = global['fetch']();
+ }
+ catch (e) {
+ // In Chrome this throws instead.
+ fetchPromise = global['fetch']('about:blank');
+ }
+ // ignore output to prevent error;
+ fetchPromise.then(function () { return null; }, function () { return null; });
+ if (fetchPromise.constructor != NativePromise &&
+ fetchPromise.constructor != ZoneAwarePromise) {
+ patchThen(fetchPromise.constructor);
+ }
+ }
+ }
+ // This is not part of public API, but it is usefull for tests, so we expose it.
+ Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;
+ /*
+ * This code patches Error so that:
+ * - It ignores un-needed stack frames.
+ * - It Shows the associated Zone for reach frame.
+ */
+ var FrameType;
+ (function (FrameType) {
+ /// Skip this frame when printing out stack
+ FrameType[FrameType["blackList"] = 0] = "blackList";
+ /// This frame marks zone transition
+ FrameType[FrameType["transition"] = 1] = "transition";
+ })(FrameType || (FrameType = {}));
+ var NativeError = global[__symbol__('Error')] = global.Error;
+ // Store the frames which should be removed from the stack frames
+ var blackListedStackFrames = {};
+ // We must find the frame where Error was created, otherwise we assume we don't understand stack
+ var zoneAwareFrame;
+ global.Error = ZoneAwareError;
+ // How should the stack frames be parsed.
+ var frameParserStrategy = null;
+ var stackRewrite = 'stackRewrite';
+ // fix #595, create property descriptor
+ // for error properties
+ var createProperty = function (props, key) {
+ // if property is already defined, skip it.
+ if (props[key]) {
+ return;
+ }
+ // define a local property
+ // in case error property is not settable
+ var name = __symbol__(key);
+ props[key] = {
+ configurable: true,
+ enumerable: true,
+ get: function () {
+ // if local property has no value
+ // use internal error's property value
+ if (!this[name]) {
+ var error_2 = this[__symbol__('error')];
+ if (error_2) {
+ this[name] = error_2[key];
+ }
+ }
+ return this[name];
+ },
+ set: function (value) {
+ // setter will set value to local property value
+ this[name] = value;
+ }
+ };
+ };
+ // fix #595, create property descriptor
+ // for error method properties
+ var createMethodProperty = function (props, key) {
+ if (props[key]) {
+ return;
+ }
+ props[key] = {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: function () {
+ var error = this[__symbol__('error')];
+ var errorMethod = (error && error[key]) || this[key];
+ if (errorMethod) {
+ return errorMethod.apply(error, arguments);
+ }
+ }
+ };
+ };
+ var createErrorProperties = function () {
+ var props = Object.create(null);
+ var error = new NativeError();
+ var keys = Object.getOwnPropertyNames(error);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ // Avoid bugs when hasOwnProperty is shadowed
+ if (Object.prototype.hasOwnProperty.call(error, key)) {
+ createProperty(props, key);
+ }
+ }
+ var proto = NativeError.prototype;
+ if (proto) {
+ var pKeys = Object.getOwnPropertyNames(proto);
+ for (var i = 0; i < pKeys.length; i++) {
+ var key = pKeys[i];
+ // skip constructor
+ if (key !== 'constructor' && key !== 'toString' && key !== 'toSource') {
+ createProperty(props, key);
+ }
+ }
+ }
+ // some other properties are not
+ // in NativeError
+ createProperty(props, 'originalStack');
+ createProperty(props, 'zoneAwareStack');
+ // define toString, toSource as method property
+ createMethodProperty(props, 'toString');
+ createMethodProperty(props, 'toSource');
+ return props;
+ };
+ var errorProperties = createErrorProperties();
+ // for derived Error class which extends ZoneAwareError
+ // we should not override the derived class's property
+ // so we create a new props object only copy the properties
+ // from errorProperties which not exist in derived Error's prototype
+ var getErrorPropertiesForPrototype = function (prototype) {
+ // if the prototype is ZoneAwareError.prototype
+ // we just return the prebuilt errorProperties.
+ if (prototype === ZoneAwareError.prototype) {
+ return errorProperties;
+ }
+ var newProps = Object.create(null);
+ var cKeys = Object.getOwnPropertyNames(errorProperties);
+ var keys = Object.getOwnPropertyNames(prototype);
+ cKeys.forEach(function (cKey) {
+ if (keys.filter(function (key) {
+ return key === cKey;
+ })
+ .length === 0) {
+ newProps[cKey] = errorProperties[cKey];
+ }
+ });
+ return newProps;
+ };
+ /**
+ * This is ZoneAwareError which processes the stack frame and cleans up extra frames as well as
+ * adds zone information to it.
+ */
+ function ZoneAwareError() {
+ // make sure we have a valid this
+ // if this is undefined(call Error without new) or this is global
+ // or this is some other objects, we should force to create a
+ // valid ZoneAwareError by call Object.create()
+ if (!(this instanceof ZoneAwareError)) {
+ return ZoneAwareError.apply(Object.create(ZoneAwareError.prototype), arguments);
+ }
+ // Create an Error.
+ var error = NativeError.apply(this, arguments);
+ this[__symbol__('error')] = error;
+ // Save original stack trace
+ error.originalStack = error.stack;
+ // Process the stack trace and rewrite the frames.
+ if (ZoneAwareError[stackRewrite] && error.originalStack) {
+ var frames_1 = error.originalStack.split('\n');
+ var zoneFrame = _currentZoneFrame;
+ var i = 0;
+ // Find the first frame
+ while (frames_1[i] !== zoneAwareFrame && i < frames_1.length) {
+ i++;
+ }
+ for (; i < frames_1.length && zoneFrame; i++) {
+ var frame = frames_1[i];
+ if (frame.trim()) {
+ var frameType = blackListedStackFrames.hasOwnProperty(frame) && blackListedStackFrames[frame];
+ if (frameType === FrameType.blackList) {
+ frames_1.splice(i, 1);
+ i--;
+ }
+ else if (frameType === FrameType.transition) {
+ if (zoneFrame.parent) {
+ // This is the special frame where zone changed. Print and process it accordingly
+ frames_1[i] += " [" + zoneFrame.parent.zone.name + " => " + zoneFrame.zone.name + "]";
+ zoneFrame = zoneFrame.parent;
+ }
+ else {
+ zoneFrame = null;
+ }
+ }
+ else {
+ frames_1[i] += " [" + zoneFrame.zone.name + "]";
+ }
+ }
+ }
+ error.stack = error.zoneAwareStack = frames_1.join('\n');
+ }
+ // use defineProperties here instead of copy property value
+ // because of issue #595 which will break angular2.
+ Object.defineProperties(this, getErrorPropertiesForPrototype(Object.getPrototypeOf(this)));
+ return this;
+ }
+ // Copy the prototype so that instanceof operator works as expected
+ ZoneAwareError.prototype = NativeError.prototype;
+ ZoneAwareError[Zone.__symbol__('blacklistedStackFrames')] = blackListedStackFrames;
+ ZoneAwareError[stackRewrite] = false;
+ if (NativeError.hasOwnProperty('stackTraceLimit')) {
+ // Extend default stack limit as we will be removing few frames.
+ NativeError.stackTraceLimit = Math.max(NativeError.stackTraceLimit, 15);
+ // make sure that ZoneAwareError has the same property which forwards to NativeError.
+ Object.defineProperty(ZoneAwareError, 'stackTraceLimit', {
+ get: function () {
+ return NativeError.stackTraceLimit;
+ },
+ set: function (value) {
+ return NativeError.stackTraceLimit = value;
+ }
+ });
+ }
+ if (NativeError.hasOwnProperty('captureStackTrace')) {
+ Object.defineProperty(ZoneAwareError, 'captureStackTrace', {
+ // add named function here because we need to remove this
+ // stack frame when prepareStackTrace below
+ value: function zoneCaptureStackTrace(targetObject, constructorOpt) {
+ NativeError.captureStackTrace(targetObject, constructorOpt);
+ }
+ });
+ }
+ Object.defineProperty(ZoneAwareError, 'prepareStackTrace', {
+ get: function () {
+ return NativeError.prepareStackTrace;
+ },
+ set: function (value) {
+ if (!value || typeof value !== 'function') {
+ return NativeError.prepareStackTrace = value;
+ }
+ return NativeError.prepareStackTrace = function (error, structuredStackTrace) {
+ // remove additional stack information from ZoneAwareError.captureStackTrace
+ if (structuredStackTrace) {
+ for (var i = 0; i < structuredStackTrace.length; i++) {
+ var st = structuredStackTrace[i];
+ // remove the first function which name is zoneCaptureStackTrace
+ if (st.getFunctionName() === 'zoneCaptureStackTrace') {
+ structuredStackTrace.splice(i, 1);
+ break;
+ }
+ }
+ }
+ return value.apply(this, [error, structuredStackTrace]);
+ };
+ }
+ });
+ // Now we need to populet the `blacklistedStackFrames` as well as find the
+ // run/runGuraded/runTask frames. This is done by creating a detect zone and then threading
+ // the execution through all of the above methods so that we can look at the stack trace and
+ // find the frames of interest.
+ var detectZone = Zone.current.fork({
+ name: 'detect',
+ onInvoke: function (parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
+ // Here only so that it will show up in the stack frame so that it can be black listed.
+ return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+ },
+ onHandleError: function (parentZD, current, target, error) {
+ if (error.originalStack && Error === ZoneAwareError) {
+ var frames_2 = error.originalStack.split(/\n/);
+ var runFrame = false, runGuardedFrame = false, runTaskFrame = false;
+ while (frames_2.length) {
+ var frame = frames_2.shift();
+ // On safari it is possible to have stack frame with no line number.
+ // This check makes sure that we don't filter frames on name only (must have
+ // linenumber)
+ if (/:\d+:\d+/.test(frame)) {
+ // Get rid of the path so that we don't accidintely find function name in path.
+ // In chrome the seperator is `(` and `@` in FF and safari
+ // Chrome: at Zone.run (zone.js:100)
+ // Chrome: at Zone.run (http://localhost:9876/base/build/lib/zone.js:100:24)
+ // FireFox: Zone.prototype.run@http://localhost:9876/base/build/lib/zone.js:101:24
+ // Safari: run@http://localhost:9876/base/build/lib/zone.js:101:24
+ var fnName = frame.split('(')[0].split('@')[0];
+ var frameType = FrameType.transition;
+ if (fnName.indexOf('ZoneAwareError') !== -1) {
+ zoneAwareFrame = frame;
+ }
+ if (fnName.indexOf('runGuarded') !== -1) {
+ runGuardedFrame = true;
+ }
+ else if (fnName.indexOf('runTask') !== -1) {
+ runTaskFrame = true;
+ }
+ else if (fnName.indexOf('run') !== -1) {
+ runFrame = true;
+ }
+ else {
+ frameType = FrameType.blackList;
+ }
+ blackListedStackFrames[frame] = frameType;
+ // Once we find all of the frames we can stop looking.
+ if (runFrame && runGuardedFrame && runTaskFrame) {
+ ZoneAwareError[stackRewrite] = true;
+ break;
+ }
+ }
+ }
+ }
+ return false;
+ }
+ });
+ // carefully constructor a stack frame which contains all of the frames of interest which
+ // need to be detected and blacklisted.
+ var detectRunFn = function () {
+ detectZone.run(function () {
+ detectZone.runGuarded(function () {
+ throw new Error('blacklistStackFrames');
+ });
+ });
+ };
+ // Cause the error to extract the stack frames.
+ detectZone.runTask(detectZone.scheduleMacroTask('detect', detectRunFn, null, function () { return null; }, null));
+ return global['Zone'] = Zone;
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Suppress closure compiler errors about unknown 'Zone' variable
+ * @fileoverview
+ * @suppress {undefinedVars}
+ */
+var zoneSymbol = function (n) { return "__zone_symbol__" + n; };
+var _global$1 = typeof window === 'object' && window || typeof self === 'object' && self || global;
+function bindArguments(args, source) {
+ for (var i = args.length - 1; i >= 0; i--) {
+ if (typeof args[i] === 'function') {
+ args[i] = Zone.current.wrap(args[i], source + '_' + i);
+ }
+ }
+ return args;
+}
+function patchPrototype(prototype, fnNames) {
+ var source = prototype.constructor['name'];
+ var _loop_1 = function (i) {
+ var name_1 = fnNames[i];
+ var delegate = prototype[name_1];
+ if (delegate) {
+ prototype[name_1] = (function (delegate) {
+ return function () {
+ return delegate.apply(this, bindArguments(arguments, source + '.' + name_1));
+ };
+ })(delegate);
+ }
+ };
+ for (var i = 0; i < fnNames.length; i++) {
+ _loop_1(i);
+ }
+}
+var isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);
+var isNode = (!('nw' in _global$1) && typeof process !== 'undefined' &&
+ {}.toString.call(process) === '[object process]');
+var isBrowser = !isNode && !isWebWorker && !!(typeof window !== 'undefined' && window['HTMLElement']);
+function patchProperty(obj, prop) {
+ var desc = Object.getOwnPropertyDescriptor(obj, prop) || { enumerable: true, configurable: true };
+ var originalDesc = Object.getOwnPropertyDescriptor(obj, 'original' + prop);
+ if (!originalDesc && desc.get) {
+ Object.defineProperty(obj, 'original' + prop, { enumerable: false, configurable: true, get: desc.get });
+ }
+ // A property descriptor cannot have getter/setter and be writable
+ // deleting the writable and value properties avoids this error:
+ //
+ // TypeError: property descriptors must not specify a value or be writable when a
+ // getter or setter has been specified
+ delete desc.writable;
+ delete desc.value;
+ // substr(2) cuz 'onclick' -> 'click', etc
+ var eventName = prop.substr(2);
+ var _prop = '_' + prop;
+ desc.set = function (fn) {
+ if (this[_prop]) {
+ this.removeEventListener(eventName, this[_prop]);
+ }
+ if (typeof fn === 'function') {
+ var wrapFn = function (event) {
+ var result;
+ result = fn.apply(this, arguments);
+ if (result != undefined && !result)
+ event.preventDefault();
+ };
+ this[_prop] = wrapFn;
+ this.addEventListener(eventName, wrapFn, false);
+ }
+ else {
+ this[_prop] = null;
+ }
+ };
+ // The getter would return undefined for unassigned properties but the default value of an
+ // unassigned property is null
+ desc.get = function () {
+ var r = this[_prop] || null;
+ // result will be null when use inline event attribute,
+ // such as OK
+ // because the onclick function is internal raw uncompiled handler
+ // the onclick will be evaluated when first time event was triggered or
+ // the property is accessed, https://github.com/angular/zone.js/issues/525
+ // so we should use original native get to retrieve the handler
+ if (r === null) {
+ if (originalDesc && originalDesc.get) {
+ r = originalDesc.get.apply(this, arguments);
+ if (r) {
+ desc.set.apply(this, [r]);
+ if (typeof this['removeAttribute'] === 'function') {
+ this.removeAttribute(prop);
+ }
+ }
+ }
+ }
+ return this[_prop] || null;
+ };
+ Object.defineProperty(obj, prop, desc);
+}
+
+function patchOnProperties(obj, properties) {
+ var onProperties = [];
+ for (var prop in obj) {
+ if (prop.substr(0, 2) == 'on') {
+ onProperties.push(prop);
+ }
+ }
+ for (var j = 0; j < onProperties.length; j++) {
+ patchProperty(obj, onProperties[j]);
+ }
+ if (properties) {
+ for (var i = 0; i < properties.length; i++) {
+ patchProperty(obj, 'on' + properties[i]);
+ }
+ }
+}
+
+var EVENT_TASKS = zoneSymbol('eventTasks');
+// For EventTarget
+var ADD_EVENT_LISTENER = 'addEventListener';
+var REMOVE_EVENT_LISTENER = 'removeEventListener';
+function findExistingRegisteredTask(target, handler, name, capture, remove) {
+ var eventTasks = target[EVENT_TASKS];
+ if (eventTasks) {
+ for (var i = 0; i < eventTasks.length; i++) {
+ var eventTask = eventTasks[i];
+ var data = eventTask.data;
+ var listener = data.handler;
+ if ((data.handler === handler || listener.listener === handler) &&
+ data.useCapturing === capture && data.eventName === name) {
+ if (remove) {
+ eventTasks.splice(i, 1);
+ }
+ return eventTask;
+ }
+ }
+ }
+ return null;
+}
+function findAllExistingRegisteredTasks(target, name, capture, remove) {
+ var eventTasks = target[EVENT_TASKS];
+ if (eventTasks) {
+ var result = [];
+ for (var i = eventTasks.length - 1; i >= 0; i--) {
+ var eventTask = eventTasks[i];
+ var data = eventTask.data;
+ if (data.eventName === name && data.useCapturing === capture) {
+ result.push(eventTask);
+ if (remove) {
+ eventTasks.splice(i, 1);
+ }
+ }
+ }
+ return result;
+ }
+ return null;
+}
+function attachRegisteredEvent(target, eventTask, isPrepend) {
+ var eventTasks = target[EVENT_TASKS];
+ if (!eventTasks) {
+ eventTasks = target[EVENT_TASKS] = [];
+ }
+ if (isPrepend) {
+ eventTasks.unshift(eventTask);
+ }
+ else {
+ eventTasks.push(eventTask);
+ }
+}
+var defaultListenerMetaCreator = function (self, args) {
+ return {
+ useCapturing: args[2],
+ eventName: args[0],
+ handler: args[1],
+ target: self || _global$1,
+ name: args[0],
+ invokeAddFunc: function (addFnSymbol, delegate) {
+ if (delegate && delegate.invoke) {
+ return this.target[addFnSymbol](this.eventName, delegate.invoke, this.useCapturing);
+ }
+ else {
+ return this.target[addFnSymbol](this.eventName, delegate, this.useCapturing);
+ }
+ },
+ invokeRemoveFunc: function (removeFnSymbol, delegate) {
+ if (delegate && delegate.invoke) {
+ return this.target[removeFnSymbol](this.eventName, delegate.invoke, this.useCapturing);
+ }
+ else {
+ return this.target[removeFnSymbol](this.eventName, delegate, this.useCapturing);
+ }
+ }
+ };
+};
+function makeZoneAwareAddListener(addFnName, removeFnName, useCapturingParam, allowDuplicates, isPrepend, metaCreator) {
+ if (useCapturingParam === void 0) { useCapturingParam = true; }
+ if (allowDuplicates === void 0) { allowDuplicates = false; }
+ if (isPrepend === void 0) { isPrepend = false; }
+ if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
+ var addFnSymbol = zoneSymbol(addFnName);
+ var removeFnSymbol = zoneSymbol(removeFnName);
+ var defaultUseCapturing = useCapturingParam ? false : undefined;
+ function scheduleEventListener(eventTask) {
+ var meta = eventTask.data;
+ attachRegisteredEvent(meta.target, eventTask, isPrepend);
+ return meta.invokeAddFunc(addFnSymbol, eventTask);
+ }
+ function cancelEventListener(eventTask) {
+ var meta = eventTask.data;
+ findExistingRegisteredTask(meta.target, eventTask.invoke, meta.eventName, meta.useCapturing, true);
+ return meta.invokeRemoveFunc(removeFnSymbol, eventTask);
+ }
+ return function zoneAwareAddListener(self, args) {
+ var data = metaCreator(self, args);
+ data.useCapturing = data.useCapturing || defaultUseCapturing;
+ // - Inside a Web Worker, `this` is undefined, the context is `global`
+ // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+ // see https://github.com/angular/zone.js/issues/190
+ var delegate = null;
+ if (typeof data.handler == 'function') {
+ delegate = data.handler;
+ }
+ else if (data.handler && data.handler.handleEvent) {
+ delegate = function (event) { return data.handler.handleEvent(event); };
+ }
+ var validZoneHandler = false;
+ try {
+ // In cross site contexts (such as WebDriver frameworks like Selenium),
+ // accessing the handler object here will cause an exception to be thrown which
+ // will fail tests prematurely.
+ validZoneHandler = data.handler && data.handler.toString() === '[object FunctionWrapper]';
+ }
+ catch (e) {
+ // Returning nothing here is fine, because objects in a cross-site context are unusable
+ return;
+ }
+ // Ignore special listeners of IE11 & Edge dev tools, see
+ // https://github.com/angular/zone.js/issues/150
+ if (!delegate || validZoneHandler) {
+ return data.invokeAddFunc(addFnSymbol, data.handler);
+ }
+ if (!allowDuplicates) {
+ var eventTask = findExistingRegisteredTask(data.target, data.handler, data.eventName, data.useCapturing, false);
+ if (eventTask) {
+ // we already registered, so this will have noop.
+ return data.invokeAddFunc(addFnSymbol, eventTask);
+ }
+ }
+ var zone = Zone.current;
+ var source = data.target.constructor['name'] + '.' + addFnName + ':' + data.eventName;
+ zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener);
+ };
+}
+function makeZoneAwareRemoveListener(fnName, useCapturingParam, metaCreator) {
+ if (useCapturingParam === void 0) { useCapturingParam = true; }
+ if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
+ var symbol = zoneSymbol(fnName);
+ var defaultUseCapturing = useCapturingParam ? false : undefined;
+ return function zoneAwareRemoveListener(self, args) {
+ var data = metaCreator(self, args);
+ data.useCapturing = data.useCapturing || defaultUseCapturing;
+ // - Inside a Web Worker, `this` is undefined, the context is `global`
+ // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+ // see https://github.com/angular/zone.js/issues/190
+ var eventTask = findExistingRegisteredTask(data.target, data.handler, data.eventName, data.useCapturing, true);
+ if (eventTask) {
+ eventTask.zone.cancelTask(eventTask);
+ }
+ else {
+ data.invokeRemoveFunc(symbol, data.handler);
+ }
+ };
+}
+
+
+var zoneAwareAddEventListener = makeZoneAwareAddListener(ADD_EVENT_LISTENER, REMOVE_EVENT_LISTENER);
+var zoneAwareRemoveEventListener = makeZoneAwareRemoveListener(REMOVE_EVENT_LISTENER);
+function patchEventTargetMethods(obj, addFnName, removeFnName, metaCreator) {
+ if (addFnName === void 0) { addFnName = ADD_EVENT_LISTENER; }
+ if (removeFnName === void 0) { removeFnName = REMOVE_EVENT_LISTENER; }
+ if (metaCreator === void 0) { metaCreator = defaultListenerMetaCreator; }
+ if (obj && obj[addFnName]) {
+ patchMethod(obj, addFnName, function () { return makeZoneAwareAddListener(addFnName, removeFnName, true, false, false, metaCreator); });
+ patchMethod(obj, removeFnName, function () { return makeZoneAwareRemoveListener(removeFnName, true, metaCreator); });
+ return true;
+ }
+ else {
+ return false;
+ }
+}
+var originalInstanceKey = zoneSymbol('originalInstance');
+// wrap some native API on `window`
+function patchClass(className) {
+ var OriginalClass = _global$1[className];
+ if (!OriginalClass)
+ return;
+ _global$1[className] = function () {
+ var a = bindArguments(arguments, className);
+ switch (a.length) {
+ case 0:
+ this[originalInstanceKey] = new OriginalClass();
+ break;
+ case 1:
+ this[originalInstanceKey] = new OriginalClass(a[0]);
+ break;
+ case 2:
+ this[originalInstanceKey] = new OriginalClass(a[0], a[1]);
+ break;
+ case 3:
+ this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);
+ break;
+ case 4:
+ this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);
+ break;
+ default:
+ throw new Error('Arg list too long.');
+ }
+ };
+ var instance = new OriginalClass(function () { });
+ var prop;
+ for (prop in instance) {
+ // https://bugs.webkit.org/show_bug.cgi?id=44721
+ if (className === 'XMLHttpRequest' && prop === 'responseBlob')
+ continue;
+ (function (prop) {
+ if (typeof instance[prop] === 'function') {
+ _global$1[className].prototype[prop] = function () {
+ return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
+ };
+ }
+ else {
+ Object.defineProperty(_global$1[className].prototype, prop, {
+ set: function (fn) {
+ if (typeof fn === 'function') {
+ this[originalInstanceKey][prop] = Zone.current.wrap(fn, className + '.' + prop);
+ }
+ else {
+ this[originalInstanceKey][prop] = fn;
+ }
+ },
+ get: function () {
+ return this[originalInstanceKey][prop];
+ }
+ });
+ }
+ }(prop));
+ }
+ for (prop in OriginalClass) {
+ if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
+ _global$1[className][prop] = OriginalClass[prop];
+ }
+ }
+}
+
+function createNamedFn(name, delegate) {
+ try {
+ return (Function('f', "return function " + name + "(){return f(this, arguments)}"))(delegate);
+ }
+ catch (e) {
+ // if we fail, we must be CSP, just return delegate.
+ return function () {
+ return delegate(this, arguments);
+ };
+ }
+}
+function patchMethod(target, name, patchFn) {
+ var proto = target;
+ while (proto && Object.getOwnPropertyNames(proto).indexOf(name) === -1) {
+ proto = Object.getPrototypeOf(proto);
+ }
+ if (!proto && target[name]) {
+ // somehow we did not find it, but we can see it. This happens on IE for Window properties.
+ proto = target;
+ }
+ var delegateName = zoneSymbol(name);
+ var delegate;
+ if (proto && !(delegate = proto[delegateName])) {
+ delegate = proto[delegateName] = proto[name];
+ proto[name] = createNamedFn(name, patchFn(delegate, delegateName, name));
+ }
+ return delegate;
+}
+// TODO: support cancel task later if necessary
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function patchTimer(window, setName, cancelName, nameSuffix) {
+ var setNative = null;
+ var clearNative = null;
+ setName += nameSuffix;
+ cancelName += nameSuffix;
+ var tasksByHandleId = {};
+ function scheduleTask(task) {
+ var data = task.data;
+ data.args[0] = function () {
+ task.invoke.apply(this, arguments);
+ delete tasksByHandleId[data.handleId];
+ };
+ data.handleId = setNative.apply(window, data.args);
+ tasksByHandleId[data.handleId] = task;
+ return task;
+ }
+ function clearTask(task) {
+ delete tasksByHandleId[task.data.handleId];
+ return clearNative(task.data.handleId);
+ }
+ setNative =
+ patchMethod(window, setName, function (delegate) { return function (self, args) {
+ if (typeof args[0] === 'function') {
+ var zone = Zone.current;
+ var options = {
+ handleId: null,
+ isPeriodic: nameSuffix === 'Interval',
+ delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : null,
+ args: args
+ };
+ var task = zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask);
+ if (!task) {
+ return task;
+ }
+ // Node.js must additionally support the ref and unref functions.
+ var handle = task.data.handleId;
+ if (handle.ref && handle.unref) {
+ task.ref = handle.ref.bind(handle);
+ task.unref = handle.unref.bind(handle);
+ }
+ return task;
+ }
+ else {
+ // cause an error by calling it directly.
+ return delegate.apply(window, args);
+ }
+ }; });
+ clearNative =
+ patchMethod(window, cancelName, function (delegate) { return function (self, args) {
+ var task = typeof args[0] === 'number' ? tasksByHandleId[args[0]] : args[0];
+ if (task && typeof task.type === 'string') {
+ if (task.cancelFn && task.data.isPeriodic || task.runCount === 0) {
+ // Do not cancel already canceled functions
+ task.zone.cancelTask(task);
+ }
+ }
+ else {
+ // cause an error by calling it directly.
+ delegate.apply(window, args);
+ }
+ }; });
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/*
+ * This is necessary for Chrome and Chrome mobile, to enable
+ * things like redefining `createdCallback` on an element.
+ */
+var _defineProperty = Object[zoneSymbol('defineProperty')] = Object.defineProperty;
+var _getOwnPropertyDescriptor = Object[zoneSymbol('getOwnPropertyDescriptor')] =
+ Object.getOwnPropertyDescriptor;
+var _create = Object.create;
+var unconfigurablesKey = zoneSymbol('unconfigurables');
+function propertyPatch() {
+ Object.defineProperty = function (obj, prop, desc) {
+ if (isUnconfigurable(obj, prop)) {
+ throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj);
+ }
+ var originalConfigurableFlag = desc.configurable;
+ if (prop !== 'prototype') {
+ desc = rewriteDescriptor(obj, prop, desc);
+ }
+ return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
+ };
+ Object.defineProperties = function (obj, props) {
+ Object.keys(props).forEach(function (prop) {
+ Object.defineProperty(obj, prop, props[prop]);
+ });
+ return obj;
+ };
+ Object.create = function (obj, proto) {
+ if (typeof proto === 'object' && !Object.isFrozen(proto)) {
+ Object.keys(proto).forEach(function (prop) {
+ proto[prop] = rewriteDescriptor(obj, prop, proto[prop]);
+ });
+ }
+ return _create(obj, proto);
+ };
+ Object.getOwnPropertyDescriptor = function (obj, prop) {
+ var desc = _getOwnPropertyDescriptor(obj, prop);
+ if (isUnconfigurable(obj, prop)) {
+ desc.configurable = false;
+ }
+ return desc;
+ };
+}
+
+function _redefineProperty(obj, prop, desc) {
+ var originalConfigurableFlag = desc.configurable;
+ desc = rewriteDescriptor(obj, prop, desc);
+ return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
+}
+
+function isUnconfigurable(obj, prop) {
+ return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];
+}
+function rewriteDescriptor(obj, prop, desc) {
+ desc.configurable = true;
+ if (!desc.configurable) {
+ if (!obj[unconfigurablesKey]) {
+ _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} });
+ }
+ obj[unconfigurablesKey][prop] = true;
+ }
+ return desc;
+}
+function _tryDefineProperty(obj, prop, desc, originalConfigurableFlag) {
+ try {
+ return _defineProperty(obj, prop, desc);
+ }
+ catch (e) {
+ if (desc.configurable) {
+ // In case of errors, when the configurable flag was likely set by rewriteDescriptor(), let's
+ // retry with the original flag value
+ if (typeof originalConfigurableFlag == 'undefined') {
+ delete desc.configurable;
+ }
+ else {
+ desc.configurable = originalConfigurableFlag;
+ }
+ try {
+ return _defineProperty(obj, prop, desc);
+ }
+ catch (e) {
+ var descJson = null;
+ try {
+ descJson = JSON.stringify(desc);
+ }
+ catch (e) {
+ descJson = descJson.toString();
+ }
+ console.log("Attempting to configure '" + prop + "' with descriptor '" + descJson + "' on object '" + obj + "' and got error, giving up: " + e);
+ }
+ }
+ else {
+ throw e;
+ }
+ }
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';
+var NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket'
+ .split(',');
+var EVENT_TARGET = 'EventTarget';
+function eventTargetPatch(_global) {
+ var apis = [];
+ var isWtf = _global['wtf'];
+ if (isWtf) {
+ // Workaround for: https://github.com/google/tracing-framework/issues/555
+ apis = WTF_ISSUE_555.split(',').map(function (v) { return 'HTML' + v + 'Element'; }).concat(NO_EVENT_TARGET);
+ }
+ else if (_global[EVENT_TARGET]) {
+ apis.push(EVENT_TARGET);
+ }
+ else {
+ // Note: EventTarget is not available in all browsers,
+ // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget
+ apis = NO_EVENT_TARGET;
+ }
+ for (var i = 0; i < apis.length; i++) {
+ var type = _global[apis[i]];
+ patchEventTargetMethods(type && type.prototype);
+ }
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+// we have to patch the instance since the proto is non-configurable
+function apply(_global) {
+ var WS = _global.WebSocket;
+ // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener
+ // On older Chrome, no need since EventTarget was already patched
+ if (!_global.EventTarget) {
+ patchEventTargetMethods(WS.prototype);
+ }
+ _global.WebSocket = function (a, b) {
+ var socket = arguments.length > 1 ? new WS(a, b) : new WS(a);
+ var proxySocket;
+ // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance
+ var onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage');
+ if (onmessageDesc && onmessageDesc.configurable === false) {
+ proxySocket = Object.create(socket);
+ ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function (propName) {
+ proxySocket[propName] = function () {
+ return socket[propName].apply(socket, arguments);
+ };
+ });
+ }
+ else {
+ // we can patch the real socket
+ proxySocket = socket;
+ }
+ patchOnProperties(proxySocket, ['close', 'error', 'message', 'open']);
+ return proxySocket;
+ };
+ for (var prop in WS) {
+ _global.WebSocket[prop] = WS[prop];
+ }
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var eventNames = 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'
+ .split(' ');
+function propertyDescriptorPatch(_global) {
+ if (isNode) {
+ return;
+ }
+ var supportsWebSocket = typeof WebSocket !== 'undefined';
+ if (canPatchViaPropertyDescriptor()) {
+ // for browsers that we can patch the descriptor: Chrome & Firefox
+ if (isBrowser) {
+ patchOnProperties(HTMLElement.prototype, eventNames);
+ }
+ patchOnProperties(XMLHttpRequest.prototype, null);
+ if (typeof IDBIndex !== 'undefined') {
+ patchOnProperties(IDBIndex.prototype, null);
+ patchOnProperties(IDBRequest.prototype, null);
+ patchOnProperties(IDBOpenDBRequest.prototype, null);
+ patchOnProperties(IDBDatabase.prototype, null);
+ patchOnProperties(IDBTransaction.prototype, null);
+ patchOnProperties(IDBCursor.prototype, null);
+ }
+ if (supportsWebSocket) {
+ patchOnProperties(WebSocket.prototype, null);
+ }
+ }
+ else {
+ // Safari, Android browsers (Jelly Bean)
+ patchViaCapturingAllTheEvents();
+ patchClass('XMLHttpRequest');
+ if (supportsWebSocket) {
+ apply(_global);
+ }
+ }
+}
+function canPatchViaPropertyDescriptor() {
+ if (isBrowser && !Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') &&
+ typeof Element !== 'undefined') {
+ // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364
+ // IDL interface attributes are not configurable
+ var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick');
+ if (desc && !desc.configurable)
+ return false;
+ }
+ var xhrDesc = Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype, 'onreadystatechange');
+ // add enumerable and configurable here because in opera
+ // by default XMLHttpRequest.prototype.onreadystatechange is undefined
+ // without adding enumerable and configurable will cause onreadystatechange
+ // non-configurable
+ Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {
+ enumerable: true,
+ configurable: true,
+ get: function () {
+ return true;
+ }
+ });
+ var req = new XMLHttpRequest();
+ var result = !!req.onreadystatechange;
+ // restore original desc
+ Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', xhrDesc || {});
+ return result;
+}
+
+var unboundKey = zoneSymbol('unbound');
+// Whenever any eventListener fires, we check the eventListener target and all parents
+// for `onwhatever` properties and replace them with zone-bound functions
+// - Chrome (for now)
+function patchViaCapturingAllTheEvents() {
+ var _loop_1 = function (i) {
+ var property = eventNames[i];
+ var onproperty = 'on' + property;
+ self.addEventListener(property, function (event) {
+ var elt = event.target, bound, source;
+ if (elt) {
+ source = elt.constructor['name'] + '.' + onproperty;
+ }
+ else {
+ source = 'unknown.' + onproperty;
+ }
+ while (elt) {
+ if (elt[onproperty] && !elt[onproperty][unboundKey]) {
+ bound = Zone.current.wrap(elt[onproperty], source);
+ bound[unboundKey] = elt[onproperty];
+ elt[onproperty] = bound;
+ }
+ elt = elt.parentElement;
+ }
+ }, true);
+ };
+ for (var i = 0; i < eventNames.length; i++) {
+ _loop_1(i);
+ }
+
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function registerElementPatch(_global) {
+ if (!isBrowser || !('registerElement' in _global.document)) {
+ return;
+ }
+ var _registerElement = document.registerElement;
+ var callbacks = ['createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback'];
+ document.registerElement = function (name, opts) {
+ if (opts && opts.prototype) {
+ callbacks.forEach(function (callback) {
+ var source = 'Document.registerElement::' + callback;
+ if (opts.prototype.hasOwnProperty(callback)) {
+ var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback);
+ if (descriptor && descriptor.value) {
+ descriptor.value = Zone.current.wrap(descriptor.value, source);
+ _redefineProperty(opts.prototype, callback, descriptor);
+ }
+ else {
+ opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
+ }
+ }
+ else if (opts.prototype[callback]) {
+ opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
+ }
+ });
+ }
+ return _registerElement.apply(document, [name, opts]);
+ };
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var set = 'set';
+var clear = 'clear';
+var blockingMethods = ['alert', 'prompt', 'confirm'];
+var _global = typeof window === 'object' && window || typeof self === 'object' && self || global;
+patchTimer(_global, set, clear, 'Timeout');
+patchTimer(_global, set, clear, 'Interval');
+patchTimer(_global, set, clear, 'Immediate');
+patchTimer(_global, 'request', 'cancel', 'AnimationFrame');
+patchTimer(_global, 'mozRequest', 'mozCancel', 'AnimationFrame');
+patchTimer(_global, 'webkitRequest', 'webkitCancel', 'AnimationFrame');
+for (var i = 0; i < blockingMethods.length; i++) {
+ var name_1 = blockingMethods[i];
+ patchMethod(_global, name_1, function (delegate, symbol, name) {
+ return function (s, args) {
+ return Zone.current.run(delegate, _global, args, name);
+ };
+ });
+}
+eventTargetPatch(_global);
+propertyDescriptorPatch(_global);
+patchClass('MutationObserver');
+patchClass('WebKitMutationObserver');
+patchClass('FileReader');
+propertyPatch();
+registerElementPatch(_global);
+// Treat XMLHTTPRequest as a macrotask.
+patchXHR(_global);
+var XHR_TASK = zoneSymbol('xhrTask');
+var XHR_SYNC = zoneSymbol('xhrSync');
+var XHR_LISTENER = zoneSymbol('xhrListener');
+var XHR_SCHEDULED = zoneSymbol('xhrScheduled');
+function patchXHR(window) {
+ function findPendingTask(target) {
+ var pendingTask = target[XHR_TASK];
+ return pendingTask;
+ }
+ function scheduleTask(task) {
+ self[XHR_SCHEDULED] = false;
+ var data = task.data;
+ // remove existing event listener
+ var listener = data.target[XHR_LISTENER];
+ if (listener) {
+ data.target.removeEventListener('readystatechange', listener);
+ }
+ var newListener = data.target[XHR_LISTENER] = function () {
+ if (data.target.readyState === data.target.DONE) {
+ if (!data.aborted && self[XHR_SCHEDULED]) {
+ task.invoke();
+ }
+ }
+ };
+ data.target.addEventListener('readystatechange', newListener);
+ var storedTask = data.target[XHR_TASK];
+ if (!storedTask) {
+ data.target[XHR_TASK] = task;
+ }
+ sendNative.apply(data.target, data.args);
+ self[XHR_SCHEDULED] = true;
+ return task;
+ }
+ function placeholderCallback() { }
+ function clearTask(task) {
+ var data = task.data;
+ // Note - ideally, we would call data.target.removeEventListener here, but it's too late
+ // to prevent it from firing. So instead, we store info for the event listener.
+ data.aborted = true;
+ return abortNative.apply(data.target, data.args);
+ }
+ var openNative = patchMethod(window.XMLHttpRequest.prototype, 'open', function () { return function (self, args) {
+ self[XHR_SYNC] = args[2] == false;
+ return openNative.apply(self, args);
+ }; });
+ var sendNative = patchMethod(window.XMLHttpRequest.prototype, 'send', function () { return function (self, args) {
+ var zone = Zone.current;
+ if (self[XHR_SYNC]) {
+ // if the XHR is sync there is no task to schedule, just execute the code.
+ return sendNative.apply(self, args);
+ }
+ else {
+ var options = { target: self, isPeriodic: false, delay: null, args: args, aborted: false };
+ return zone.scheduleMacroTask('XMLHttpRequest.send', placeholderCallback, options, scheduleTask, clearTask);
+ }
+ }; });
+ var abortNative = patchMethod(window.XMLHttpRequest.prototype, 'abort', function (delegate) { return function (self, args) {
+ var task = findPendingTask(self);
+ if (task && typeof task.type == 'string') {
+ // If the XHR has already completed, do nothing.
+ // If the XHR has already been aborted, do nothing.
+ // Fix #569, call abort multiple times before done will cause
+ // macroTask task count be negative number
+ if (task.cancelFn == null || (task.data && task.data.aborted)) {
+ return;
+ }
+ task.zone.cancelTask(task);
+ }
+ // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no task
+ // to cancel. Do nothing.
+ }; });
+}
+/// GEO_LOCATION
+if (_global['navigator'] && _global['navigator'].geolocation) {
+ patchPrototype(_global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);
+}
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+})));
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.js.d.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.js.d.ts
new file mode 100644
index 00000000..c66bdaae
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.js.d.ts
@@ -0,0 +1,482 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Zone is a mechanism for intercepting and keeping track of asynchronous work.
+ *
+ * A Zone is a global object which is configured with rules about how to intercept and keep track
+ * of the asynchronous callbacks. Zone has these responsibilities:
+ *
+ * 1. Intercept asynchronous task scheduling
+ * 2. Wrap callbacks for error-handling and zone tracking across async operations.
+ * 3. Provide a way to attach data to zones
+ * 4. Provide a context specific last frame error handling
+ * 5. (Intercept blocking methods)
+ *
+ * A zone by itself does not do anything, instead it relies on some other code to route existing
+ * platform API through it. (The zone library ships with code which monkey patches all of the
+ * browsers's asynchronous API and redirects them through the zone for interception.)
+ *
+ * In its simplest form a zone allows one to intercept the scheduling and calling of asynchronous
+ * operations, and execute additional code before as well as after the asynchronous task. The rules
+ * of interception are configured using [ZoneConfig]. There can be many different zone instances in
+ * a system, but only one zone is active at any given time which can be retrieved using
+ * [Zone#current].
+ *
+ *
+ *
+ * ## Callback Wrapping
+ *
+ * An important aspect of the zones is that they should persist across asynchronous operations. To
+ * achieve this, when a future work is scheduled through async API, it is necessary to capture, and
+ * subsequently restore the current zone. For example if a code is running in zone `b` and it
+ * invokes `setTimeout` to scheduleTask work later, the `setTimeout` method needs to 1) capture the
+ * current zone and 2) wrap the `wrapCallback` in code which will restore the current zone `b` once
+ * the wrapCallback executes. In this way the rules which govern the current code are preserved in
+ * all future asynchronous tasks. There could be a different zone `c` which has different rules and
+ * is associated with different asynchronous tasks. As these tasks are processed, each asynchronous
+ * wrapCallback correctly restores the correct zone, as well as preserves the zone for future
+ * asynchronous callbacks.
+ *
+ * Example: Suppose a browser page consist of application code as well as third-party
+ * advertisement code. (These two code bases are independent, developed by different mutually
+ * unaware developers.) The application code may be interested in doing global error handling and
+ * so it configures the `app` zone to send all of the errors to the server for analysis, and then
+ * executes the application in the `app` zone. The advertising code is interested in the same
+ * error processing but it needs to send the errors to a different third-party. So it creates the
+ * `ads` zone with a different error handler. Now both advertising as well as application code
+ * create many asynchronous operations, but the [Zone] will ensure that all of the asynchronous
+ * operations created from the application code will execute in `app` zone with its error
+ * handler and all of the advertisement code will execute in the `ads` zone with its error handler.
+ * This will not only work for the async operations created directly, but also for all subsequent
+ * asynchronous operations.
+ *
+ * If you think of chain of asynchronous operations as a thread of execution (bit of a stretch)
+ * then [Zone#current] will act as a thread local variable.
+ *
+ *
+ *
+ * ## Asynchronous operation scheduling
+ *
+ * In addition to wrapping the callbacks to restore the zone, all operations which cause a
+ * scheduling of work for later are routed through the current zone which is allowed to intercept
+ * them by adding work before or after the wrapCallback as well as using different means of
+ * achieving the request. (Useful for unit testing, or tracking of requests). In some instances
+ * such as `setTimeout` the wrapping of the wrapCallback and scheduling is done in the same
+ * wrapCallback, but there are other examples such as `Promises` where the `then` wrapCallback is
+ * wrapped, but the execution of `then` in triggered by `Promise` scheduling `resolve` work.
+ *
+ * Fundamentally there are three kinds of tasks which can be scheduled:
+ *
+ * 1. [MicroTask] used for doing work right after the current task. This is non-cancelable which is
+ * guaranteed to run exactly once and immediately.
+ * 2. [MacroTask] used for doing work later. Such as `setTimeout`. This is typically cancelable
+ * which is guaranteed to execute at least once after some well understood delay.
+ * 3. [EventTask] used for listening on some future event. This may execute zero or more times, with
+ * an unknown delay.
+ *
+ * Each asynchronous API is modeled and routed through one of these APIs.
+ *
+ *
+ * ### [MicroTask]
+ *
+ * [MicroTask]s represent work which will be done in current VM turn as soon as possible, before VM
+ * yielding.
+ *
+ *
+ * ### [TimerTask]
+ *
+ * [TimerTask]s represent work which will be done after some delay. (Sometimes the delay is
+ * approximate such as on next available animation frame). Typically these methods include:
+ * `setTimeout`, `setImmediate`, `setInterval`, `requestAnimationFrame`, and all browser specif
+ * variants.
+ *
+ *
+ * ### [EventTask]
+ *
+ * [EventTask]s represent a request to create a listener on an event. Unlike the other task
+ * events may never be executed, but typically execute more than once. There is no queue of
+ * events, rather their callbacks are unpredictable both in order and time.
+ *
+ *
+ * ## Global Error Handling
+ *
+ *
+ * ## Composability
+ *
+ * Zones can be composed together through [Zone.fork()]. A child zone may create its own set of
+ * rules. A child zone is expected to either:
+ *
+ * 1. Delegate the interception to a parent zone, and optionally add before and after wrapCallback
+ * hook.s
+ * 2) Or process the request itself without delegation.
+ *
+ * Composability allows zones to keep their concerns clean. For example a top most zone may chose
+ * to handle error handling, while child zones may chose to do user action tracking.
+ *
+ *
+ * ## Root Zone
+ *
+ * At the start the browser will run in a special root zone, which is configure to behave exactly
+ * like the platform, making any existing code which is not-zone aware behave as expected. All
+ * zones are children of the root zone.
+ *
+ */
+interface Zone {
+ /**
+ *
+ * @returns {Zone} The parent Zone.
+ */
+ parent: Zone;
+ /**
+ * @returns {string} The Zone name (useful for debugging)
+ */
+ name: string;
+ /**
+ * Returns a value associated with the `key`.
+ *
+ * If the current zone does not have a key, the request is delegated to the parent zone. Use
+ * [ZoneSpec.properties] to configure the set of properties associated with the current zone.
+ *
+ * @param key The key to retrieve.
+ * @returns {any} The value for the key, or `undefined` if not found.
+ */
+ get(key: string): any;
+ /**
+ * Returns a Zone which defines a `key`.
+ *
+ * Recursively search the parent Zone until a Zone which has a property `key` is found.
+ *
+ * @param key The key to use for identification of the returned zone.
+ * @returns {Zone} The Zone which defines the `key`, `null` if not found.
+ */
+ getZoneWith(key: string): Zone;
+ /**
+ * Used to create a child zone.
+ *
+ * @param zoneSpec A set of rules which the child zone should follow.
+ * @returns {Zone} A new child zone.
+ */
+ fork(zoneSpec: ZoneSpec): Zone;
+ /**
+ * Wraps a callback function in a new function which will properly restore the current zone upon
+ * invocation.
+ *
+ * The wrapped function will properly forward `this` as well as `arguments` to the `callback`.
+ *
+ * Before the function is wrapped the zone can intercept the `callback` by declaring
+ * [ZoneSpec.onIntercept].
+ *
+ * @param callback the function which will be wrapped in the zone.
+ * @param source A unique debug location of the API being wrapped.
+ * @returns {function(): *} A function which will invoke the `callback` through [Zone.runGuarded].
+ */
+ wrap(callback: F, source: string): F;
+ /**
+ * Invokes a function in a given zone.
+ *
+ * The invocation of `callback` can be intercepted be declaring [ZoneSpec.onInvoke].
+ *
+ * @param callback The function to invoke.
+ * @param applyThis
+ * @param applyArgs
+ * @param source A unique debug location of the API being invoked.
+ * @returns {any} Value from the `callback` function.
+ */
+ run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
+ /**
+ * Invokes a function in a given zone and catches any exceptions.
+ *
+ * Any exceptions thrown will be forwarded to [Zone.HandleError].
+ *
+ * The invocation of `callback` can be intercepted be declaring [ZoneSpec.onInvoke]. The
+ * handling of exceptions can intercepted by declaring [ZoneSpec.handleError].
+ *
+ * @param callback The function to invoke.
+ * @param applyThis
+ * @param applyArgs
+ * @param source A unique debug location of the API being invoked.
+ * @returns {any} Value from the `callback` function.
+ */
+ runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
+ /**
+ * Execute the Task by restoring the [Zone.currentTask] in the Task's zone.
+ *
+ * @param callback
+ * @param applyThis
+ * @param applyArgs
+ * @returns {*}
+ */
+ runTask(task: Task, applyThis?: any, applyArgs?: any): any;
+ scheduleMicroTask(source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void): MicroTask;
+ scheduleMacroTask(source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void, customCancel: (task: Task) => void): MacroTask;
+ scheduleEventTask(source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void, customCancel: (task: Task) => void): EventTask;
+ /**
+ * Allows the zone to intercept canceling of scheduled Task.
+ *
+ * The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes
+ * the [Task.cancelFn].
+ *
+ * @param task
+ * @returns {any}
+ */
+ cancelTask(task: Task): any;
+}
+interface ZoneType {
+ /**
+ * @returns {Zone} Returns the current [Zone]. Returns the current zone. The only way to change
+ * the current zone is by invoking a run() method, which will update the current zone for the
+ * duration of the run method callback.
+ */
+ current: Zone;
+ /**
+ * @returns {Task} The task associated with the current execution.
+ */
+ currentTask: Task;
+ /**
+ * Verify that Zone has been correctly patched. Specifically that Promise is zone aware.
+ */
+ assertZonePatched(): any;
+}
+/**
+ * Provides a way to configure the interception of zone events.
+ *
+ * Only the `name` property is required (all other are optional).
+ */
+interface ZoneSpec {
+ /**
+ * The name of the zone. Usefull when debugging Zones.
+ */
+ name: string;
+ /**
+ * A set of properties to be associated with Zone. Use [Zone.get] to retrive them.
+ */
+ properties?: {
+ [key: string]: any;
+ };
+ /**
+ * Allows the interception of zone forking.
+ *
+ * When the zone is being forked, the request is forwarded to this method for interception.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param zoneSpec The argument passed into the `fork` method.
+ */
+ onFork?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, zoneSpec: ZoneSpec) => Zone;
+ /**
+ * Allows interception of the wrapping of the callback.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param delegate The argument passed into the `warp` method.
+ * @param source The argument passed into the `warp` method.
+ */
+ onIntercept?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, source: string) => Function;
+ /**
+ * Allows interception of the callback invocation.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param delegate The argument passed into the `run` method.
+ * @param applyThis The argument passed into the `run` method.
+ * @param applyArgs The argument passed into the `run` method.
+ * @param source The argument passed into the `run` method.
+ */
+ onInvoke?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, applyThis: any, applyArgs: any[], source: string) => any;
+ /**
+ * Allows interception of the error handling.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param error The argument passed into the `handleError` method.
+ */
+ onHandleError?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any) => boolean;
+ /**
+ * Allows interception of task scheduling.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param task The argument passed into the `scheduleTask` method.
+ */
+ onScheduleTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => Task;
+ onInvokeTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task, applyThis: any, applyArgs: any) => any;
+ /**
+ * Allows interception of task cancelation.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param task The argument passed into the `cancelTask` method.
+ */
+ onCancelTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => any;
+ /**
+ * Notifies of changes to the task queue empty status.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param isEmpty
+ */
+ onHasTask?: (delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) => void;
+}
+/**
+ * A delegate when intercepting zone operations.
+ *
+ * A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. For
+ * example a child zone wrap can't just call parent zone wrap. Doing so would create a callback
+ * which is bound to the parent zone. What we are interested is intercepting the callback before it
+ * is bound to any zone. Furthermore, we also need to pass the targetZone (zone which received the
+ * original request) to the delegate.
+ *
+ * The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in
+ * the method signature. (The original Zone which received the request.) Some methods are renamed
+ * to prevent confusion, because they have slightly different semantics and arguments.
+ *
+ * - `wrap` => `intercept`: The `wrap` method delegates to `intercept`. The `wrap` method returns
+ * a callback which will run in a given zone, where as intercept allows wrapping the callback
+ * so that additional code can be run before and after, but does not associated the callback
+ * with the zone.
+ * - `run` => `invoke`: The `run` method delegates to `invoke` to perform the actual execution of
+ * the callback. The `run` method switches to new zone; saves and restores the `Zone.current`;
+ * and optionally performs error handling. The invoke is not responsible for error handling,
+ * or zone management.
+ *
+ * Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate
+ * stores the closest zone which overwrites this behavior along with the closest ZoneSpec.
+ *
+ * NOTE: We have tried to make this API analogous to Event bubbling with target and current
+ * properties.
+ *
+ * Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its `this` to
+ * store internal state.
+ */
+interface ZoneDelegate {
+ zone: Zone;
+ fork(targetZone: Zone, zoneSpec: ZoneSpec): Zone;
+ intercept(targetZone: Zone, callback: Function, source: string): Function;
+ invoke(targetZone: Zone, callback: Function, applyThis: any, applyArgs: any[], source: string): any;
+ handleError(targetZone: Zone, error: any): boolean;
+ scheduleTask(targetZone: Zone, task: Task): Task;
+ invokeTask(targetZone: Zone, task: Task, applyThis: any, applyArgs: any): any;
+ cancelTask(targetZone: Zone, task: Task): any;
+ hasTask(targetZone: Zone, isEmpty: HasTaskState): void;
+}
+declare type HasTaskState = {
+ microTask: boolean;
+ macroTask: boolean;
+ eventTask: boolean;
+ change: TaskType;
+};
+/**
+ * Task type: `microTask`, `macroTask`, `eventTask`.
+ */
+declare type TaskType = string;
+/**
+ */
+interface TaskData {
+ /**
+ * A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
+ */
+ isPeriodic?: boolean;
+ /**
+ * Delay in milliseconds when the Task will run.
+ */
+ delay?: number;
+ /**
+ * identifier returned by the native setTimeout.
+ */
+ handleId?: number;
+}
+/**
+ * Represents work which is executed with a clean stack.
+ *
+ * Tasks are used in Zones to mark work which is performed on clean stack frame. There are three
+ * kinds of task. [MicroTask], [MacroTask], and [EventTask].
+ *
+ * A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set.
+ *
+ * - [MicroTask] queue represents a set of tasks which are executing right after the current stack
+ * frame becomes clean and before a VM yield. All [MicroTask]s execute in order of insertion
+ * before VM yield and the next [MacroTask] is executed.
+ * - [MacroTask] queue represents a set of tasks which are executed one at a time after each VM
+ * yield. The queue is order by time, and insertions can happen in any location.
+ * - [EventTask] is a set of tasks which can at any time be inserted to the end of the [MacroTask]
+ * queue. This happens when the event fires.
+ *
+ */
+interface Task {
+ /**
+ * Task type: `microTask`, `macroTask`, `eventTask`.
+ */
+ type: TaskType;
+ /**
+ * Debug string representing the API which requested the scheduling of the task.
+ */
+ source: string;
+ /**
+ * The Function to be used by the VM on entering the [Task]. This function will delegate to
+ * [Zone.runTask] and delegate to `callback`.
+ */
+ invoke: Function;
+ /**
+ * Function which needs to be executed by the Task after the [Zone.currentTask] has been set to
+ * the current task.
+ */
+ callback: Function;
+ /**
+ * Task specific options associated with the current task. This is passed to the `scheduleFn`.
+ */
+ data: TaskData;
+ /**
+ * Represents the default work which needs to be done to schedule the Task by the VM.
+ *
+ * A zone may chose to intercept this function and perform its own scheduling.
+ */
+ scheduleFn: (task: Task) => void;
+ /**
+ * Represents the default work which needs to be done to un-schedule the Task from the VM. Not all
+ * Tasks are cancelable, and therefore this method is optional.
+ *
+ * A zone may chose to intercept this function and perform its own scheduling.
+ */
+ cancelFn: (task: Task) => void;
+ /**
+ * @type {Zone} The zone which will be used to invoke the `callback`. The Zone is captured
+ * at the time of Task creation.
+ */
+ zone: Zone;
+ /**
+ * Number of times the task has been executed, or -1 if canceled.
+ */
+ runCount: number;
+}
+interface MicroTask extends Task {
+}
+interface MacroTask extends Task {
+}
+interface EventTask extends Task {
+}
+/**
+ * Extend the Error with additional fields for rewritten stack frames
+ */
+interface Error {
+ /**
+ * Stack trace where extra frames have been removed and zone names added.
+ */
+ zoneAwareStack?: string;
+ /**
+ * Original stack trace with no modiffications
+ */
+ originalStack?: string;
+}
+declare const Zone: ZoneType;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.min.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.min.js
new file mode 100644
index 00000000..3c69b38f
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/dist/zone.min.js
@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t():"function"==typeof define&&define.amd?define(t):t()}(this,function(){"use strict";function e(e,t){for(var n=e.length-1;n>=0;n--)"function"==typeof e[n]&&(e[n]=Zone.current.wrap(e[n],t+"_"+n));return e}function t(t,n){for(var r=t.constructor.name,o=function(o){var a=n[o],i=t[a];i&&(t[a]=function(t){return function(){return t.apply(this,e(arguments,r+"."+a))}}(i))},a=0;a1?new t(e,n):new t(e),i=Object.getOwnPropertyDescriptor(a,"onmessage");return i&&i.configurable===!1?(o=Object.create(a),["addEventListener","removeEventListener","send","close"].forEach(function(e){o[e]=function(){return a[e].apply(a,arguments)}})):o=a,r(o,["close","error","message","open"]),o};for(var n in t)e.WebSocket[n]=t[n]}function m(e){if(!P){var t="undefined"!=typeof WebSocket;T()?(j&&r(HTMLElement.prototype,B),r(XMLHttpRequest.prototype,null),"undefined"!=typeof IDBIndex&&(r(IDBIndex.prototype,null),r(IDBRequest.prototype,null),r(IDBOpenDBRequest.prototype,null),r(IDBDatabase.prototype,null),r(IDBTransaction.prototype,null),r(IDBCursor.prototype,null)),t&&r(WebSocket.prototype,null)):(w(),u("XMLHttpRequest"),t&&b(e))}}function T(){if(j&&!Object.getOwnPropertyDescriptor(HTMLElement.prototype,"onclick")&&"undefined"!=typeof Element){var e=Object.getOwnPropertyDescriptor(Element.prototype,"onclick");if(e&&!e.configurable)return!1}var t=Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype,"onreadystatechange");Object.defineProperty(XMLHttpRequest.prototype,"onreadystatechange",{enumerable:!0,configurable:!0,get:function(){return!0}});var n=new XMLHttpRequest,r=!!n.onreadystatechange;return Object.defineProperty(XMLHttpRequest.prototype,"onreadystatechange",t||{}),r}function w(){for(var e=function(e){var t=B[e],n="on"+t;self.addEventListener(t,function(e){var t,r,o=e.target;for(r=o?o.constructor.name+"."+n:"unknown."+n;o;)o[n]&&!o[n][N]&&(t=Zone.current.wrap(o[n],r),t[N]=o[n],o[n]=t),o=o.parentElement},!0)},t=0;t "+r.zone.name+"]",r=r.parent):r=null:n[o]+=" ["+r.zone.name+"]"}}e.stack=e.zoneAwareStack=n.join("\n")}return Object.defineProperties(this,K(Object.getPrototypeOf(this))),this}if(e.Zone)throw new Error("Zone already loaded.");var v=function(){function t(e,t){this._properties=null,this._parent=e,this._name=t?t.name||"unnamed":"",this._properties=t&&t.properties||{},this._zoneDelegate=new k(this,this._parent&&this._parent._zoneDelegate,t)}return t.assertZonePatched=function(){if(e.Promise!==F)throw new Error("Zone.js has detected that ZoneAwarePromise `(window|global).Promise` has been overwritten.\nMost likely cause is that a Promise polyfill has been loaded after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. If you must load one, do so before loading zone.js.)")},Object.defineProperty(t,"current",{get:function(){return w.zone},enumerable:!0,configurable:!0}),Object.defineProperty(t,"currentTask",{get:function(){return _},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"parent",{get:function(){return this._parent},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"name",{get:function(){return this._name},enumerable:!0,configurable:!0}),t.prototype.get=function(e){var t=this.getZoneWith(e);if(t)return t._properties[e]},t.prototype.getZoneWith=function(e){for(var t=this;t;){if(t._properties.hasOwnProperty(e))return t;t=t._parent}return null},t.prototype.fork=function(e){if(!e)throw new Error("ZoneSpec required!");return this._zoneDelegate.fork(this,e)},t.prototype.wrap=function(e,t){if("function"!=typeof e)throw new Error("Expecting function got: "+e);var n=this._zoneDelegate.intercept(this,e,t),r=this;return function(){return r.runGuarded(n,this,arguments,t)}},t.prototype.run=function(e,t,n,r){void 0===t&&(t=null),void 0===n&&(n=null),void 0===r&&(r=null),w=new y(w,this);try{return this._zoneDelegate.invoke(this,e,t,n,r)}finally{w=w.parent}},t.prototype.runGuarded=function(e,t,n,r){void 0===t&&(t=null),void 0===n&&(n=null),void 0===r&&(r=null),w=new y(w,this);try{try{return this._zoneDelegate.invoke(this,e,t,n,r)}catch(o){if(this._zoneDelegate.handleError(this,o))throw o}}finally{w=w.parent}},t.prototype.runTask=function(e,t,n){if(e.runCount++,e.zone!=this)throw new Error("A task can only be run in the zone which created it! (Creation: "+e.zone.name+"; Execution: "+this.name+")");var r=_;_=e,w=new y(w,this);try{"macroTask"==e.type&&e.data&&!e.data.isPeriodic&&(e.cancelFn=null);try{return this._zoneDelegate.invokeTask(this,e,t,n)}catch(o){if(this._zoneDelegate.handleError(this,o))throw o}}finally{w=w.parent,_=r}},t.prototype.scheduleMicroTask=function(e,t,n,r){return this._zoneDelegate.scheduleTask(this,new g("microTask",this,e,t,n,r,null))},t.prototype.scheduleMacroTask=function(e,t,n,r,o){return this._zoneDelegate.scheduleTask(this,new g("macroTask",this,e,t,n,r,o))},t.prototype.scheduleEventTask=function(e,t,n,r,o){return this._zoneDelegate.scheduleTask(this,new g("eventTask",this,e,t,n,r,o))},t.prototype.cancelTask=function(e){var t=this._zoneDelegate.cancelTask(this,e);return e.runCount=-1,e.cancelFn=null,t},t}();v.__symbol__=t;var k=function(){function e(e,t,n){this._taskCounts={microTask:0,macroTask:0,eventTask:0},this.zone=e,this._parentDelegate=t,this._forkZS=n&&(n&&n.onFork?n:t._forkZS),this._forkDlgt=n&&(n.onFork?t:t._forkDlgt),this._forkCurrZone=n&&(n.onFork?this.zone:t.zone),this._interceptZS=n&&(n.onIntercept?n:t._interceptZS),this._interceptDlgt=n&&(n.onIntercept?t:t._interceptDlgt),this._interceptCurrZone=n&&(n.onIntercept?this.zone:t.zone),this._invokeZS=n&&(n.onInvoke?n:t._invokeZS),this._invokeDlgt=n&&(n.onInvoke?t:t._invokeDlgt),this._invokeCurrZone=n&&(n.onInvoke?this.zone:t.zone),this._handleErrorZS=n&&(n.onHandleError?n:t._handleErrorZS),this._handleErrorDlgt=n&&(n.onHandleError?t:t._handleErrorDlgt),this._handleErrorCurrZone=n&&(n.onHandleError?this.zone:t.zone),this._scheduleTaskZS=n&&(n.onScheduleTask?n:t._scheduleTaskZS),this._scheduleTaskDlgt=n&&(n.onScheduleTask?t:t._scheduleTaskDlgt),this._scheduleTaskCurrZone=n&&(n.onScheduleTask?this.zone:t.zone),this._invokeTaskZS=n&&(n.onInvokeTask?n:t._invokeTaskZS),this._invokeTaskDlgt=n&&(n.onInvokeTask?t:t._invokeTaskDlgt),this._invokeTaskCurrZone=n&&(n.onInvokeTask?this.zone:t.zone),this._cancelTaskZS=n&&(n.onCancelTask?n:t._cancelTaskZS),this._cancelTaskDlgt=n&&(n.onCancelTask?t:t._cancelTaskDlgt),this._cancelTaskCurrZone=n&&(n.onCancelTask?this.zone:t.zone),this._hasTaskZS=n&&(n.onHasTask?n:t._hasTaskZS),this._hasTaskDlgt=n&&(n.onHasTask?t:t._hasTaskDlgt),this._hasTaskCurrZone=n&&(n.onHasTask?this.zone:t.zone)}return e.prototype.fork=function(e,t){return this._forkZS?this._forkZS.onFork(this._forkDlgt,this.zone,e,t):new v(e,t)},e.prototype.intercept=function(e,t,n){return this._interceptZS?this._interceptZS.onIntercept(this._interceptDlgt,this._interceptCurrZone,e,t,n):t},e.prototype.invoke=function(e,t,n,r,o){return this._invokeZS?this._invokeZS.onInvoke(this._invokeDlgt,this._invokeCurrZone,e,t,n,r,o):t.apply(n,r)},e.prototype.handleError=function(e,t){return!this._handleErrorZS||this._handleErrorZS.onHandleError(this._handleErrorDlgt,this._handleErrorCurrZone,e,t)},e.prototype.scheduleTask=function(e,t){try{if(this._scheduleTaskZS)return this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt,this._scheduleTaskCurrZone,e,t);if(t.scheduleFn)t.scheduleFn(t);else{if("microTask"!=t.type)throw new Error("Task is missing scheduleFn.");r(t)}return t}finally{e==this.zone&&this._updateTaskCount(t.type,1)}},e.prototype.invokeTask=function(e,t,n,r){try{return this._invokeTaskZS?this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt,this._invokeTaskCurrZone,e,t,n,r):t.callback.apply(n,r)}finally{e!=this.zone||"eventTask"==t.type||t.data&&t.data.isPeriodic||this._updateTaskCount(t.type,-1)}},e.prototype.cancelTask=function(e,t){var n;if(this._cancelTaskZS)n=this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt,this._cancelTaskCurrZone,e,t);else{if(!t.cancelFn)throw new Error("Task does not support cancellation, or is already canceled.");n=t.cancelFn(t)}return e==this.zone&&this._updateTaskCount(t.type,-1),n},e.prototype.hasTask=function(e,t){return this._hasTaskZS&&this._hasTaskZS.onHasTask(this._hasTaskDlgt,this._hasTaskCurrZone,e,t)},e.prototype._updateTaskCount=function(e,t){var n=this._taskCounts,r=n[e],o=n[e]=r+t;if(o<0)throw new Error("More tasks executed then were scheduled.");if(0==r||0==o){var a={microTask:n.microTask>0,macroTask:n.macroTask>0,eventTask:n.eventTask>0,change:e};try{this.hasTask(this.zone,a)}finally{this._parentDelegate&&this._parentDelegate._updateTaskCount(e,t)}}},e}(),g=function(){function e(e,t,n,r,o,i,s){this.runCount=0,this.type=e,this.zone=t,this.source=n,this.data=o,this.scheduleFn=i,this.cancelFn=s,this.callback=r;var c=this;this.invoke=function(){D++;try{return t.runTask(c,this,arguments)}finally{1==D&&a(),D--}}}return e.prototype.toString=function(){return this.data&&"undefined"!=typeof this.data.handleId?this.data.handleId:Object.prototype.toString.call(this)},e.prototype.toJSON=function(){return{type:this.type,source:this.source,data:this.data,zone:this.zone.name,invoke:this.invoke,scheduleFn:this.scheduleFn,cancelFn:this.cancelFn,runCount:this.runCount,callback:this.callback}},e}(),y=function(){function e(e,t){this.parent=e,this.zone=t}return e}(),b=t("setTimeout"),m=t("Promise"),T=t("then"),w=new y(null,new v(null,null)),_=null,S=[],O=!1,E=[],D=0,P=t("state"),j=t("value"),Z="Promise.then",z=null,C=!0,I=!1,L=0,F=function(){function e(t){var n=this;if(!(n instanceof e))throw new Error("Must be an instanceof Promise.");n[P]=z,n[j]=[];try{t&&t(u(n,C),u(n,I))}catch(r){l(n,!1,r)}}return e.toString=function(){return"function ZoneAwarePromise() { [native code] }"},e.resolve=function(e){return l(new this(null),C,e)},e.reject=function(e){return l(new this(null),I,e)},e.race=function(e){function t(e){a&&(a=r(e))}function n(e){a&&(a=o(e))}for(var r,o,a=new this(function(e,t){n=[e,t],r=n[0],o=n[1];var n}),s=0,c=e;s {
+ return function(s: any, args: any[]) {
+ return Zone.current.run(delegate, _global, args, name);
+ };
+ });
+}
+
+eventTargetPatch(_global);
+propertyDescriptorPatch(_global);
+patchClass('MutationObserver');
+patchClass('WebKitMutationObserver');
+patchClass('FileReader');
+propertyPatch();
+registerElementPatch(_global);
+
+// Treat XMLHTTPRequest as a macrotask.
+patchXHR(_global);
+
+const XHR_TASK = zoneSymbol('xhrTask');
+const XHR_SYNC = zoneSymbol('xhrSync');
+const XHR_LISTENER = zoneSymbol('xhrListener');
+const XHR_SCHEDULED = zoneSymbol('xhrScheduled');
+
+interface XHROptions extends TaskData {
+ target: any;
+ args: any[];
+ aborted: boolean;
+}
+
+function patchXHR(window: any) {
+ function findPendingTask(target: any) {
+ const pendingTask: Task = target[XHR_TASK];
+ return pendingTask;
+ }
+
+ function scheduleTask(task: Task) {
+ self[XHR_SCHEDULED] = false;
+ const data = task.data;
+ // remove existing event listener
+ const listener = data.target[XHR_LISTENER];
+ if (listener) {
+ data.target.removeEventListener('readystatechange', listener);
+ }
+ const newListener = data.target[XHR_LISTENER] = () => {
+ if (data.target.readyState === data.target.DONE) {
+ if (!data.aborted && self[XHR_SCHEDULED]) {
+ task.invoke();
+ }
+ }
+ };
+ data.target.addEventListener('readystatechange', newListener);
+
+ const storedTask: Task = data.target[XHR_TASK];
+ if (!storedTask) {
+ data.target[XHR_TASK] = task;
+ }
+ sendNative.apply(data.target, data.args);
+ self[XHR_SCHEDULED] = true;
+ return task;
+ }
+
+ function placeholderCallback() {}
+
+ function clearTask(task: Task) {
+ const data = task.data;
+ // Note - ideally, we would call data.target.removeEventListener here, but it's too late
+ // to prevent it from firing. So instead, we store info for the event listener.
+ data.aborted = true;
+ return abortNative.apply(data.target, data.args);
+ }
+
+ const openNative =
+ patchMethod(window.XMLHttpRequest.prototype, 'open', () => function(self: any, args: any[]) {
+ self[XHR_SYNC] = args[2] == false;
+ return openNative.apply(self, args);
+ });
+
+ const sendNative =
+ patchMethod(window.XMLHttpRequest.prototype, 'send', () => function(self: any, args: any[]) {
+ const zone = Zone.current;
+ if (self[XHR_SYNC]) {
+ // if the XHR is sync there is no task to schedule, just execute the code.
+ return sendNative.apply(self, args);
+ } else {
+ const options: XHROptions =
+ {target: self, isPeriodic: false, delay: null, args: args, aborted: false};
+ return zone.scheduleMacroTask(
+ 'XMLHttpRequest.send', placeholderCallback, options, scheduleTask, clearTask);
+ }
+ });
+
+ const abortNative = patchMethod(
+ window.XMLHttpRequest.prototype, 'abort',
+ (delegate: Function) => function(self: any, args: any[]) {
+ const task: Task = findPendingTask(self);
+ if (task && typeof task.type == 'string') {
+ // If the XHR has already completed, do nothing.
+ // If the XHR has already been aborted, do nothing.
+ // Fix #569, call abort multiple times before done will cause
+ // macroTask task count be negative number
+ if (task.cancelFn == null || (task.data && (task.data).aborted)) {
+ return;
+ }
+ task.zone.cancelTask(task);
+ }
+ // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no task
+ // to cancel. Do nothing.
+ });
+}
+
+/// GEO_LOCATION
+if (_global['navigator'] && _global['navigator'].geolocation) {
+ patchPrototype(_global['navigator'].geolocation, ['getCurrentPosition', 'watchPosition']);
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/define-property.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/define-property.ts
new file mode 100644
index 00000000..49761ded
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/define-property.ts
@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {zoneSymbol} from '../common/utils';
+/*
+ * This is necessary for Chrome and Chrome mobile, to enable
+ * things like redefining `createdCallback` on an element.
+ */
+
+const _defineProperty = Object[zoneSymbol('defineProperty')] = Object.defineProperty;
+const _getOwnPropertyDescriptor = Object[zoneSymbol('getOwnPropertyDescriptor')] =
+ Object.getOwnPropertyDescriptor;
+const _create = Object.create;
+const unconfigurablesKey = zoneSymbol('unconfigurables');
+
+export function propertyPatch() {
+ Object.defineProperty = function(obj, prop, desc) {
+ if (isUnconfigurable(obj, prop)) {
+ throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj);
+ }
+ const originalConfigurableFlag = desc.configurable;
+ if (prop !== 'prototype') {
+ desc = rewriteDescriptor(obj, prop, desc);
+ }
+ return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
+ };
+
+ Object.defineProperties = function(obj, props) {
+ Object.keys(props).forEach(function(prop) {
+ Object.defineProperty(obj, prop, props[prop]);
+ });
+ return obj;
+ };
+
+ Object.create = function(obj, proto) {
+ if (typeof proto === 'object' && !Object.isFrozen(proto)) {
+ Object.keys(proto).forEach(function(prop) {
+ proto[prop] = rewriteDescriptor(obj, prop, proto[prop]);
+ });
+ }
+ return _create(obj, proto);
+ };
+
+ Object.getOwnPropertyDescriptor = function(obj, prop) {
+ const desc = _getOwnPropertyDescriptor(obj, prop);
+ if (isUnconfigurable(obj, prop)) {
+ desc.configurable = false;
+ }
+ return desc;
+ };
+};
+
+export function _redefineProperty(obj, prop, desc) {
+ const originalConfigurableFlag = desc.configurable;
+ desc = rewriteDescriptor(obj, prop, desc);
+ return _tryDefineProperty(obj, prop, desc, originalConfigurableFlag);
+};
+
+function isUnconfigurable(obj, prop) {
+ return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];
+}
+
+function rewriteDescriptor(obj, prop, desc) {
+ desc.configurable = true;
+ if (!desc.configurable) {
+ if (!obj[unconfigurablesKey]) {
+ _defineProperty(obj, unconfigurablesKey, {writable: true, value: {}});
+ }
+ obj[unconfigurablesKey][prop] = true;
+ }
+ return desc;
+}
+
+function _tryDefineProperty(obj, prop, desc, originalConfigurableFlag) {
+ try {
+ return _defineProperty(obj, prop, desc);
+ } catch (e) {
+ if (desc.configurable) {
+ // In case of errors, when the configurable flag was likely set by rewriteDescriptor(), let's
+ // retry with the original flag value
+ if (typeof originalConfigurableFlag == 'undefined') {
+ delete desc.configurable;
+ } else {
+ desc.configurable = originalConfigurableFlag;
+ }
+ try {
+ return _defineProperty(obj, prop, desc);
+ } catch (e) {
+ let descJson: string = null;
+ try {
+ descJson = JSON.stringify(desc);
+ } catch (e) {
+ descJson = descJson.toString();
+ }
+ console.log(`Attempting to configure '${prop}' with descriptor '${descJson
+ }' on object '${obj}' and got error, giving up: ${e}`);
+ }
+ } else {
+ throw e;
+ }
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/event-target.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/event-target.ts
new file mode 100644
index 00000000..1927c0e4
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/event-target.ts
@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {patchEventTargetMethods} from '../common/utils';
+
+const WTF_ISSUE_555 =
+ 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';
+const NO_EVENT_TARGET =
+ 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Window,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex,WebSocket'
+ .split(',');
+const EVENT_TARGET = 'EventTarget';
+
+export function eventTargetPatch(_global) {
+ let apis = [];
+ const isWtf = _global['wtf'];
+ if (isWtf) {
+ // Workaround for: https://github.com/google/tracing-framework/issues/555
+ apis = WTF_ISSUE_555.split(',').map((v) => 'HTML' + v + 'Element').concat(NO_EVENT_TARGET);
+ } else if (_global[EVENT_TARGET]) {
+ apis.push(EVENT_TARGET);
+ } else {
+ // Note: EventTarget is not available in all browsers,
+ // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget
+ apis = NO_EVENT_TARGET;
+ }
+
+ for (let i = 0; i < apis.length; i++) {
+ const type = _global[apis[i]];
+ patchEventTargetMethods(type && type.prototype);
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/property-descriptor.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/property-descriptor.ts
new file mode 100644
index 00000000..dfd8ac95
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/property-descriptor.ts
@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isBrowser, isNode, patchClass, patchOnProperties, zoneSymbol} from '../common/utils';
+
+import * as webSocketPatch from './websocket';
+
+const eventNames =
+ 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'
+ .split(' ');
+
+export function propertyDescriptorPatch(_global) {
+ if (isNode) {
+ return;
+ }
+
+ const supportsWebSocket = typeof WebSocket !== 'undefined';
+ if (canPatchViaPropertyDescriptor()) {
+ // for browsers that we can patch the descriptor: Chrome & Firefox
+ if (isBrowser) {
+ patchOnProperties(HTMLElement.prototype, eventNames);
+ }
+ patchOnProperties(XMLHttpRequest.prototype, null);
+ if (typeof IDBIndex !== 'undefined') {
+ patchOnProperties(IDBIndex.prototype, null);
+ patchOnProperties(IDBRequest.prototype, null);
+ patchOnProperties(IDBOpenDBRequest.prototype, null);
+ patchOnProperties(IDBDatabase.prototype, null);
+ patchOnProperties(IDBTransaction.prototype, null);
+ patchOnProperties(IDBCursor.prototype, null);
+ }
+ if (supportsWebSocket) {
+ patchOnProperties(WebSocket.prototype, null);
+ }
+ } else {
+ // Safari, Android browsers (Jelly Bean)
+ patchViaCapturingAllTheEvents();
+ patchClass('XMLHttpRequest');
+ if (supportsWebSocket) {
+ webSocketPatch.apply(_global);
+ }
+ }
+}
+
+function canPatchViaPropertyDescriptor() {
+ if (isBrowser && !Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') &&
+ typeof Element !== 'undefined') {
+ // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364
+ // IDL interface attributes are not configurable
+ const desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick');
+ if (desc && !desc.configurable) return false;
+ }
+
+ const xhrDesc = Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype, 'onreadystatechange');
+
+ // add enumerable and configurable here because in opera
+ // by default XMLHttpRequest.prototype.onreadystatechange is undefined
+ // without adding enumerable and configurable will cause onreadystatechange
+ // non-configurable
+ Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {
+ enumerable: true,
+ configurable: true,
+ get: function() {
+ return true;
+ }
+ });
+ const req = new XMLHttpRequest();
+ const result = !!req.onreadystatechange;
+ // restore original desc
+ Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', xhrDesc || {});
+ return result;
+};
+
+const unboundKey = zoneSymbol('unbound');
+
+// Whenever any eventListener fires, we check the eventListener target and all parents
+// for `onwhatever` properties and replace them with zone-bound functions
+// - Chrome (for now)
+function patchViaCapturingAllTheEvents() {
+ for (let i = 0; i < eventNames.length; i++) {
+ const property = eventNames[i];
+ const onproperty = 'on' + property;
+ self.addEventListener(property, function(event) {
+ let elt = event.target, bound, source;
+ if (elt) {
+ source = elt.constructor['name'] + '.' + onproperty;
+ } else {
+ source = 'unknown.' + onproperty;
+ }
+ while (elt) {
+ if (elt[onproperty] && !elt[onproperty][unboundKey]) {
+ bound = Zone.current.wrap(elt[onproperty], source);
+ bound[unboundKey] = elt[onproperty];
+ elt[onproperty] = bound;
+ }
+ elt = elt.parentElement;
+ }
+ }, true);
+ };
+};
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/register-element.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/register-element.ts
new file mode 100644
index 00000000..abd85f50
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/register-element.ts
@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {isBrowser} from '../common/utils';
+
+import {_redefineProperty} from './define-property';
+
+export function registerElementPatch(_global: any) {
+ if (!isBrowser || !('registerElement' in (_global).document)) {
+ return;
+ }
+
+ const _registerElement = (document).registerElement;
+ const callbacks =
+ ['createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback'];
+
+ (document).registerElement = function(name, opts) {
+ if (opts && opts.prototype) {
+ callbacks.forEach(function(callback) {
+ const source = 'Document.registerElement::' + callback;
+ if (opts.prototype.hasOwnProperty(callback)) {
+ const descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback);
+ if (descriptor && descriptor.value) {
+ descriptor.value = Zone.current.wrap(descriptor.value, source);
+ _redefineProperty(opts.prototype, callback, descriptor);
+ } else {
+ opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
+ }
+ } else if (opts.prototype[callback]) {
+ opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
+ }
+ });
+ }
+
+ return _registerElement.apply(document, [name, opts]);
+ };
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/rollup-main.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/rollup-main.ts
new file mode 100644
index 00000000..2eb7d99a
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/rollup-main.ts
@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+
+import '../zone';
+import './browser';
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/webapis-media-query.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/webapis-media-query.ts
new file mode 100644
index 00000000..ef7ab100
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/webapis-media-query.ts
@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import {NestedEventListenerOrEventListenerObject, patchEventTargetMethods} from '../common/utils';
+
+((_global: any) => {
+ // patch MediaQuery
+ patchMediaQuery(_global);
+
+ function patchMediaQuery(_global: any) {
+ if (!_global['MediaQueryList']) {
+ return;
+ }
+ patchEventTargetMethods(
+ _global['MediaQueryList'].prototype, 'addListener', 'removeListener', (self, args) => {
+ return {
+ useCapturing: false,
+ eventName: 'mediaQuery',
+ handler: args[0],
+ target: self || _global,
+ name: 'mediaQuery',
+ invokeAddFunc: function(
+ addFnSymbol: any, delegate: Task|NestedEventListenerOrEventListenerObject) {
+ if (delegate && (delegate).invoke) {
+ return this.target[addFnSymbol]((delegate).invoke);
+ } else {
+ return this.target[addFnSymbol](delegate);
+ }
+ },
+ invokeRemoveFunc: function(
+ removeFnSymbol: any, delegate: Task|NestedEventListenerOrEventListenerObject) {
+ if (delegate && (delegate).invoke) {
+ return this.target[removeFnSymbol]((delegate).invoke);
+ } else {
+ return this.target[removeFnSymbol](delegate);
+ }
+ }
+ };
+ });
+ }
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/webapis-notification.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/webapis-notification.ts
new file mode 100644
index 00000000..f7120da9
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/webapis-notification.ts
@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import {patchOnProperties} from '../common/utils';
+
+((_global: any) => {
+ // patch Notification
+ patchNotification(_global);
+
+ function patchNotification(_global: any) {
+ const Notification = _global['Notification'];
+ if (!Notification || !Notification.prototype) {
+ return;
+ }
+
+ patchOnProperties(Notification.prototype, null);
+ }
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/websocket.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/websocket.ts
new file mode 100644
index 00000000..fe465ee0
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/browser/websocket.ts
@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {patchEventTargetMethods, patchOnProperties} from '../common/utils';
+
+// we have to patch the instance since the proto is non-configurable
+export function apply(_global: any) {
+ const WS = (_global).WebSocket;
+ // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener
+ // On older Chrome, no need since EventTarget was already patched
+ if (!(_global).EventTarget) {
+ patchEventTargetMethods(WS.prototype);
+ }
+ (_global).WebSocket = function(a, b) {
+ const socket = arguments.length > 1 ? new WS(a, b) : new WS(a);
+ let proxySocket;
+
+ // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance
+ const onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage');
+ if (onmessageDesc && onmessageDesc.configurable === false) {
+ proxySocket = Object.create(socket);
+ ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function(propName) {
+ proxySocket[propName] = function() {
+ return socket[propName].apply(socket, arguments);
+ };
+ });
+ } else {
+ // we can patch the real socket
+ proxySocket = socket;
+ }
+
+ patchOnProperties(proxySocket, ['close', 'error', 'message', 'open']);
+
+ return proxySocket;
+ };
+ for (const prop in WS) {
+ _global.WebSocket[prop] = WS[prop];
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/common/timers.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/common/timers.ts
new file mode 100644
index 00000000..3226854d
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/common/timers.ts
@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {patchMethod} from './utils';
+
+interface TimerOptions extends TaskData {
+ handleId: number;
+ args: any[];
+}
+
+export function patchTimer(window: any, setName: string, cancelName: string, nameSuffix: string) {
+ let setNative = null;
+ let clearNative = null;
+ setName += nameSuffix;
+ cancelName += nameSuffix;
+
+ const tasksByHandleId: {[id: number]: Task} = {};
+
+ function scheduleTask(task: Task) {
+ const data = task.data;
+ data.args[0] = function() {
+ task.invoke.apply(this, arguments);
+ delete tasksByHandleId[data.handleId];
+ };
+ data.handleId = setNative.apply(window, data.args);
+ tasksByHandleId[data.handleId] = task;
+ return task;
+ }
+
+ function clearTask(task: Task) {
+ delete tasksByHandleId[(task.data).handleId];
+ return clearNative((task.data).handleId);
+ }
+
+ setNative =
+ patchMethod(window, setName, (delegate: Function) => function(self: any, args: any[]) {
+ if (typeof args[0] === 'function') {
+ const zone = Zone.current;
+ const options: TimerOptions = {
+ handleId: null,
+ isPeriodic: nameSuffix === 'Interval',
+ delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : null,
+ args: args
+ };
+ const task = zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask);
+ if (!task) {
+ return task;
+ }
+ // Node.js must additionally support the ref and unref functions.
+ const handle = (task.data).handleId;
+ if ((handle).ref && (handle).unref) {
+ (task).ref = (handle).ref.bind(handle);
+ (task).unref = (handle).unref.bind(handle);
+ }
+ return task;
+ } else {
+ // cause an error by calling it directly.
+ return delegate.apply(window, args);
+ }
+ });
+
+ clearNative =
+ patchMethod(window, cancelName, (delegate: Function) => function(self: any, args: any[]) {
+ const task: Task = typeof args[0] === 'number' ? tasksByHandleId[args[0]] : args[0];
+ if (task && typeof task.type === 'string') {
+ if (task.cancelFn && task.data.isPeriodic || task.runCount === 0) {
+ // Do not cancel already canceled functions
+ task.zone.cancelTask(task);
+ }
+ } else {
+ // cause an error by calling it directly.
+ delegate.apply(window, args);
+ }
+ });
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/common/utils.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/common/utils.ts
new file mode 100644
index 00000000..ed084a1a
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/common/utils.ts
@@ -0,0 +1,518 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Suppress closure compiler errors about unknown 'Zone' variable
+ * @fileoverview
+ * @suppress {undefinedVars}
+ */
+
+// Hack since TypeScript isn't compiling this for a worker.
+declare const WorkerGlobalScope;
+export const zoneSymbol: (name: string) => string = (n) => `__zone_symbol__${n}`;
+const _global = typeof window === 'object' && window || typeof self === 'object' && self || global;
+
+export function bindArguments(args: any[], source: string): any[] {
+ for (let i = args.length - 1; i >= 0; i--) {
+ if (typeof args[i] === 'function') {
+ args[i] = Zone.current.wrap(args[i], source + '_' + i);
+ }
+ }
+ return args;
+}
+
+export function patchPrototype(prototype, fnNames) {
+ const source = prototype.constructor['name'];
+ for (let i = 0; i < fnNames.length; i++) {
+ const name = fnNames[i];
+ const delegate = prototype[name];
+ if (delegate) {
+ prototype[name] = ((delegate: Function) => {
+ return function() {
+ return delegate.apply(this, bindArguments(arguments, source + '.' + name));
+ };
+ })(delegate);
+ }
+ }
+}
+
+export const isWebWorker: boolean =
+ (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);
+
+export const isNode: boolean =
+ (!('nw' in _global) && typeof process !== 'undefined' &&
+ {}.toString.call(process) === '[object process]');
+
+export const isBrowser: boolean =
+ !isNode && !isWebWorker && !!(typeof window !== 'undefined' && window['HTMLElement']);
+
+
+export function patchProperty(obj, prop) {
+ const desc = Object.getOwnPropertyDescriptor(obj, prop) || {enumerable: true, configurable: true};
+
+ const originalDesc = Object.getOwnPropertyDescriptor(obj, 'original' + prop);
+ if (!originalDesc && desc.get) {
+ Object.defineProperty(
+ obj, 'original' + prop, {enumerable: false, configurable: true, get: desc.get});
+ }
+
+ // A property descriptor cannot have getter/setter and be writable
+ // deleting the writable and value properties avoids this error:
+ //
+ // TypeError: property descriptors must not specify a value or be writable when a
+ // getter or setter has been specified
+ delete desc.writable;
+ delete desc.value;
+
+ // substr(2) cuz 'onclick' -> 'click', etc
+ const eventName = prop.substr(2);
+ const _prop = '_' + prop;
+
+ desc.set = function(fn) {
+ if (this[_prop]) {
+ this.removeEventListener(eventName, this[_prop]);
+ }
+
+ if (typeof fn === 'function') {
+ const wrapFn = function(event) {
+ let result;
+ result = fn.apply(this, arguments);
+
+ if (result != undefined && !result) event.preventDefault();
+ };
+
+ this[_prop] = wrapFn;
+ this.addEventListener(eventName, wrapFn, false);
+ } else {
+ this[_prop] = null;
+ }
+ };
+
+ // The getter would return undefined for unassigned properties but the default value of an
+ // unassigned property is null
+ desc.get = function() {
+ let r = this[_prop] || null;
+ // result will be null when use inline event attribute,
+ // such as OK
+ // because the onclick function is internal raw uncompiled handler
+ // the onclick will be evaluated when first time event was triggered or
+ // the property is accessed, https://github.com/angular/zone.js/issues/525
+ // so we should use original native get to retrieve the handler
+ if (r === null) {
+ if (originalDesc && originalDesc.get) {
+ r = originalDesc.get.apply(this, arguments);
+ if (r) {
+ desc.set.apply(this, [r]);
+ if (typeof this['removeAttribute'] === 'function') {
+ this.removeAttribute(prop);
+ }
+ }
+ }
+ }
+ return this[_prop] || null;
+ };
+
+ Object.defineProperty(obj, prop, desc);
+};
+
+export function patchOnProperties(obj: any, properties: string[]) {
+ const onProperties = [];
+ for (const prop in obj) {
+ if (prop.substr(0, 2) == 'on') {
+ onProperties.push(prop);
+ }
+ }
+ for (let j = 0; j < onProperties.length; j++) {
+ patchProperty(obj, onProperties[j]);
+ }
+ if (properties) {
+ for (let i = 0; i < properties.length; i++) {
+ patchProperty(obj, 'on' + properties[i]);
+ }
+ }
+};
+
+const EVENT_TASKS = zoneSymbol('eventTasks');
+
+// For EventTarget
+const ADD_EVENT_LISTENER = 'addEventListener';
+const REMOVE_EVENT_LISTENER = 'removeEventListener';
+
+export interface NestedEventListener { listener?: EventListenerOrEventListenerObject; }
+
+export declare type NestedEventListenerOrEventListenerObject =
+ NestedEventListener | EventListener | EventListenerObject;
+
+export interface ListenerTaskMeta extends TaskData {
+ useCapturing: boolean;
+ eventName: string;
+ handler: NestedEventListenerOrEventListenerObject;
+ target: any;
+ name: string;
+ invokeAddFunc: (addFnSymbol: any, delegate: Task|NestedEventListenerOrEventListenerObject) => any;
+ invokeRemoveFunc:
+ (removeFnSymbol: any, delegate: Task|NestedEventListenerOrEventListenerObject) => any;
+}
+
+function findExistingRegisteredTask(
+ target: any, handler: any, name: string, capture: boolean, remove: boolean): Task {
+ const eventTasks: Task[] = target[EVENT_TASKS];
+ if (eventTasks) {
+ for (let i = 0; i < eventTasks.length; i++) {
+ const eventTask = eventTasks[i];
+ const data = eventTask.data;
+ const listener = data.handler;
+ if ((data.handler === handler || listener.listener === handler) &&
+ data.useCapturing === capture && data.eventName === name) {
+ if (remove) {
+ eventTasks.splice(i, 1);
+ }
+ return eventTask;
+ }
+ }
+ }
+ return null;
+}
+
+function findAllExistingRegisteredTasks(
+ target: any, name: string, capture: boolean, remove: boolean): Task[] {
+ const eventTasks: Task[] = target[EVENT_TASKS];
+ if (eventTasks) {
+ const result = [];
+ for (let i = eventTasks.length - 1; i >= 0; i--) {
+ const eventTask = eventTasks[i];
+ const data = eventTask.data;
+ if (data.eventName === name && data.useCapturing === capture) {
+ result.push(eventTask);
+ if (remove) {
+ eventTasks.splice(i, 1);
+ }
+ }
+ }
+ return result;
+ }
+ return null;
+}
+
+function attachRegisteredEvent(target: any, eventTask: Task, isPrepend: boolean): void {
+ let eventTasks: Task[] = target[EVENT_TASKS];
+ if (!eventTasks) {
+ eventTasks = target[EVENT_TASKS] = [];
+ }
+ if (isPrepend) {
+ eventTasks.unshift(eventTask);
+ } else {
+ eventTasks.push(eventTask);
+ }
+}
+
+const defaultListenerMetaCreator = (self: any, args: any[]) => {
+ return {
+ useCapturing: args[2],
+ eventName: args[0],
+ handler: args[1],
+ target: self || _global,
+ name: args[0],
+ invokeAddFunc: function(
+ addFnSymbol: any, delegate: Task|NestedEventListenerOrEventListenerObject) {
+ if (delegate && (delegate).invoke) {
+ return this.target[addFnSymbol](this.eventName, (delegate).invoke, this.useCapturing);
+ } else {
+ return this.target[addFnSymbol](this.eventName, delegate, this.useCapturing);
+ }
+ },
+ invokeRemoveFunc: function(
+ removeFnSymbol: any, delegate: Task|NestedEventListenerOrEventListenerObject) {
+ if (delegate && (delegate).invoke) {
+ return this.target[removeFnSymbol](
+ this.eventName, (delegate).invoke, this.useCapturing);
+ } else {
+ return this.target[removeFnSymbol](this.eventName, delegate, this.useCapturing);
+ }
+ }
+ };
+};
+
+export function makeZoneAwareAddListener(
+ addFnName: string, removeFnName: string, useCapturingParam: boolean = true,
+ allowDuplicates: boolean = false, isPrepend: boolean = false,
+ metaCreator: (self: any, args: any[]) => ListenerTaskMeta = defaultListenerMetaCreator) {
+ const addFnSymbol = zoneSymbol(addFnName);
+ const removeFnSymbol = zoneSymbol(removeFnName);
+ const defaultUseCapturing = useCapturingParam ? false : undefined;
+
+ function scheduleEventListener(eventTask: Task): any {
+ const meta = eventTask.data;
+ attachRegisteredEvent(meta.target, eventTask, isPrepend);
+ return meta.invokeAddFunc(addFnSymbol, eventTask);
+ }
+
+ function cancelEventListener(eventTask: Task): void {
+ const meta = eventTask.data;
+ findExistingRegisteredTask(
+ meta.target, eventTask.invoke, meta.eventName, meta.useCapturing, true);
+ return meta.invokeRemoveFunc(removeFnSymbol, eventTask);
+ }
+
+ return function zoneAwareAddListener(self: any, args: any[]) {
+ const data: ListenerTaskMeta = metaCreator(self, args);
+
+ data.useCapturing = data.useCapturing || defaultUseCapturing;
+ // - Inside a Web Worker, `this` is undefined, the context is `global`
+ // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+ // see https://github.com/angular/zone.js/issues/190
+ let delegate: EventListener = null;
+ if (typeof data.handler == 'function') {
+ delegate = data.handler;
+ } else if (data.handler && (data.handler).handleEvent) {
+ delegate = (event) => (data.handler).handleEvent(event);
+ }
+ let validZoneHandler = false;
+ try {
+ // In cross site contexts (such as WebDriver frameworks like Selenium),
+ // accessing the handler object here will cause an exception to be thrown which
+ // will fail tests prematurely.
+ validZoneHandler = data.handler && data.handler.toString() === '[object FunctionWrapper]';
+ } catch (e) {
+ // Returning nothing here is fine, because objects in a cross-site context are unusable
+ return;
+ }
+ // Ignore special listeners of IE11 & Edge dev tools, see
+ // https://github.com/angular/zone.js/issues/150
+ if (!delegate || validZoneHandler) {
+ return data.invokeAddFunc(addFnSymbol, data.handler);
+ }
+
+ if (!allowDuplicates) {
+ const eventTask: Task = findExistingRegisteredTask(
+ data.target, data.handler, data.eventName, data.useCapturing, false);
+ if (eventTask) {
+ // we already registered, so this will have noop.
+ return data.invokeAddFunc(addFnSymbol, eventTask);
+ }
+ }
+
+ const zone: Zone = Zone.current;
+ const source = data.target.constructor['name'] + '.' + addFnName + ':' + data.eventName;
+
+ zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener);
+ };
+}
+
+export function makeZoneAwareRemoveListener(
+ fnName: string, useCapturingParam: boolean = true,
+ metaCreator: (self: any, args: any[]) => ListenerTaskMeta = defaultListenerMetaCreator) {
+ const symbol = zoneSymbol(fnName);
+ const defaultUseCapturing = useCapturingParam ? false : undefined;
+
+ return function zoneAwareRemoveListener(self: any, args: any[]) {
+ const data = metaCreator(self, args);
+ data.useCapturing = data.useCapturing || defaultUseCapturing;
+ // - Inside a Web Worker, `this` is undefined, the context is `global`
+ // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+ // see https://github.com/angular/zone.js/issues/190
+ const eventTask = findExistingRegisteredTask(
+ data.target, data.handler, data.eventName, data.useCapturing, true);
+ if (eventTask) {
+ eventTask.zone.cancelTask(eventTask);
+ } else {
+ data.invokeRemoveFunc(symbol, data.handler);
+ }
+ };
+}
+
+export function makeZoneAwareRemoveAllListeners(fnName: string, useCapturingParam: boolean = true) {
+ const symbol = zoneSymbol(fnName);
+ const defaultUseCapturing = useCapturingParam ? false : undefined;
+
+ return function zoneAwareRemoveAllListener(self: any, args: any[]) {
+ const target = self || _global;
+ if (args.length === 0) {
+ // remove all listeners without eventName
+ target[EVENT_TASKS] = [];
+ // we don't cancel Task either, because call native eventEmitter.removeAllListeners will
+ // will do remove listener(cancelTask) for us
+ target[symbol]();
+ return;
+ }
+ const eventName = args[0];
+ const useCapturing = args[1] || defaultUseCapturing;
+ // call this function just remove the related eventTask from target[EVENT_TASKS]
+ findAllExistingRegisteredTasks(target, eventName, useCapturing, true);
+ // we don't need useCapturing here because useCapturing is just for DOM, and
+ // removeAllListeners should only be called by node eventEmitter
+ // and we don't cancel Task either, because call native eventEmitter.removeAllListeners will
+ // will do remove listener(cancelTask) for us
+ target[symbol](eventName);
+ };
+}
+
+export function makeZoneAwareListeners(fnName: string) {
+ const symbol = zoneSymbol(fnName);
+
+ return function zoneAwareEventListeners(self: any, args: any[]) {
+ const eventName: string = args[0];
+ const target = self || _global;
+ if (!target[EVENT_TASKS]) {
+ return [];
+ }
+ return target[EVENT_TASKS]
+ .filter(task => task.data.eventName === eventName)
+ .map(task => task.data.handler);
+ };
+}
+
+const zoneAwareAddEventListener =
+ makeZoneAwareAddListener(ADD_EVENT_LISTENER, REMOVE_EVENT_LISTENER);
+const zoneAwareRemoveEventListener = makeZoneAwareRemoveListener(REMOVE_EVENT_LISTENER);
+
+export function patchEventTargetMethods(
+ obj: any, addFnName: string = ADD_EVENT_LISTENER, removeFnName: string = REMOVE_EVENT_LISTENER,
+ metaCreator: (self: any, args: any[]) => ListenerTaskMeta =
+ defaultListenerMetaCreator): boolean {
+ if (obj && obj[addFnName]) {
+ patchMethod(
+ obj, addFnName,
+ () => makeZoneAwareAddListener(addFnName, removeFnName, true, false, false, metaCreator));
+ patchMethod(
+ obj, removeFnName, () => makeZoneAwareRemoveListener(removeFnName, true, metaCreator));
+ return true;
+ } else {
+ return false;
+ }
+}
+
+const originalInstanceKey = zoneSymbol('originalInstance');
+
+// wrap some native API on `window`
+export function patchClass(className) {
+ const OriginalClass = _global[className];
+ if (!OriginalClass) return;
+
+ _global[className] = function() {
+ const a = bindArguments(arguments, className);
+ switch (a.length) {
+ case 0:
+ this[originalInstanceKey] = new OriginalClass();
+ break;
+ case 1:
+ this[originalInstanceKey] = new OriginalClass(a[0]);
+ break;
+ case 2:
+ this[originalInstanceKey] = new OriginalClass(a[0], a[1]);
+ break;
+ case 3:
+ this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]);
+ break;
+ case 4:
+ this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]);
+ break;
+ default:
+ throw new Error('Arg list too long.');
+ }
+ };
+
+ const instance = new OriginalClass(function() {});
+
+ let prop;
+ for (prop in instance) {
+ // https://bugs.webkit.org/show_bug.cgi?id=44721
+ if (className === 'XMLHttpRequest' && prop === 'responseBlob') continue;
+ (function(prop) {
+ if (typeof instance[prop] === 'function') {
+ _global[className].prototype[prop] = function() {
+ return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
+ };
+ } else {
+ Object.defineProperty(_global[className].prototype, prop, {
+ set: function(fn) {
+ if (typeof fn === 'function') {
+ this[originalInstanceKey][prop] = Zone.current.wrap(fn, className + '.' + prop);
+ } else {
+ this[originalInstanceKey][prop] = fn;
+ }
+ },
+ get: function() {
+ return this[originalInstanceKey][prop];
+ }
+ });
+ }
+ }(prop));
+ }
+
+ for (prop in OriginalClass) {
+ if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
+ _global[className][prop] = OriginalClass[prop];
+ }
+ }
+};
+
+export function createNamedFn(name: string, delegate: (self: any, args: any[]) => any): Function {
+ try {
+ return (Function('f', `return function ${name}(){return f(this, arguments)}`))(delegate);
+ } catch (e) {
+ // if we fail, we must be CSP, just return delegate.
+ return function() {
+ return delegate(this, arguments);
+ };
+ }
+}
+
+export function patchMethod(
+ target: any, name: string,
+ patchFn: (delegate: Function, delegateName: string, name: string) => (self: any, args: any[]) =>
+ any): Function {
+ let proto = target;
+ while (proto && Object.getOwnPropertyNames(proto).indexOf(name) === -1) {
+ proto = Object.getPrototypeOf(proto);
+ }
+ if (!proto && target[name]) {
+ // somehow we did not find it, but we can see it. This happens on IE for Window properties.
+ proto = target;
+ }
+ const delegateName = zoneSymbol(name);
+ let delegate: Function;
+ if (proto && !(delegate = proto[delegateName])) {
+ delegate = proto[delegateName] = proto[name];
+ proto[name] = createNamedFn(name, patchFn(delegate, delegateName, name));
+ }
+ return delegate;
+}
+
+export interface MacroTaskMeta extends TaskData {
+ name: string;
+ target: any;
+ callbackIndex: number;
+ args: any[];
+}
+
+// TODO: support cancel task later if necessary
+export function patchMacroTask(
+ obj: any, funcName: string, metaCreator: (self: any, args: any[]) => MacroTaskMeta) {
+ let setNative = null;
+
+ function scheduleTask(task: Task) {
+ const data = task.data;
+ data.args[data.callbackIndex] = function() {
+ task.invoke.apply(this, arguments);
+ };
+ setNative.apply(data.target, data.args);
+ return task;
+ }
+
+ setNative = patchMethod(obj, funcName, (delegate: Function) => function(self: any, args: any[]) {
+ const meta = metaCreator(self, args);
+ if (meta.callbackIndex >= 0 && typeof args[meta.callbackIndex] === 'function') {
+ const task = Zone.current.scheduleMacroTask(
+ meta.name, args[meta.callbackIndex], meta, scheduleTask, null);
+ return task;
+ } else {
+ // cause an error by calling it directly.
+ return delegate.apply(self, args);
+ }
+ });
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/jasmine/jasmine.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/jasmine/jasmine.ts
new file mode 100644
index 00000000..7e5183b1
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/jasmine/jasmine.ts
@@ -0,0 +1,140 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+'use strict';
+(() => {
+ const __extends = function(d, b) {
+ for (const p in b)
+ if (b.hasOwnProperty(p)) d[p] = b[p];
+ function __() {
+ this.constructor = d;
+ }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ // Patch jasmine's describe/it/beforeEach/afterEach functions so test code always runs
+ // in a testZone (ProxyZone). (See: angular/zone.js#91 & angular/angular#10503)
+ if (!Zone) throw new Error('Missing: zone.js');
+ if (typeof jasmine == 'undefined') throw new Error('Missing: jasmine.js');
+ if (jasmine['__zone_patch__'])
+ throw new Error('\'jasmine\' has already been patched with \'Zone\'.');
+ jasmine['__zone_patch__'] = true;
+
+ const SyncTestZoneSpec: {new (name: string): ZoneSpec} = Zone['SyncTestZoneSpec'];
+ const ProxyZoneSpec: {new (): ZoneSpec} = Zone['ProxyZoneSpec'];
+ if (!SyncTestZoneSpec) throw new Error('Missing: SyncTestZoneSpec');
+ if (!ProxyZoneSpec) throw new Error('Missing: ProxyZoneSpec');
+
+ const ambientZone = Zone.current;
+ // Create a synchronous-only zone in which to run `describe` blocks in order to raise an
+ // error if any asynchronous operations are attempted inside of a `describe` but outside of
+ // a `beforeEach` or `it`.
+ const syncZone = ambientZone.fork(new SyncTestZoneSpec('jasmine.describe'));
+
+ // This is the zone which will be used for running individual tests.
+ // It will be a proxy zone, so that the tests function can retroactively install
+ // different zones.
+ // Example:
+ // - In beforeEach() do childZone = Zone.current.fork(...);
+ // - In it() try to do fakeAsync(). The issue is that because the beforeEach forked the
+ // zone outside of fakeAsync it will be able to escope the fakeAsync rules.
+ // - Because ProxyZone is parent fo `childZone` fakeAsync can retroactively add
+ // fakeAsync behavior to the childZone.
+ let testProxyZone: Zone = null;
+
+ // Monkey patch all of the jasmine DSL so that each function runs in appropriate zone.
+ const jasmineEnv = jasmine.getEnv();
+ ['describe', 'xdescribe', 'fdescribe'].forEach((methodName) => {
+ let originalJasmineFn: Function = jasmineEnv[methodName];
+ jasmineEnv[methodName] = function(description: string, specDefinitions: Function) {
+ return originalJasmineFn.call(this, description, wrapDescribeInZone(specDefinitions));
+ };
+ });
+ ['it', 'xit', 'fit'].forEach((methodName) => {
+ let originalJasmineFn: Function = jasmineEnv[methodName];
+ jasmineEnv[methodName] = function(
+ description: string, specDefinitions: Function, timeout: number) {
+ arguments[1] = wrapTestInZone(specDefinitions);
+ return originalJasmineFn.apply(this, arguments);
+ };
+ });
+ ['beforeEach', 'afterEach'].forEach((methodName) => {
+ let originalJasmineFn: Function = jasmineEnv[methodName];
+ jasmineEnv[methodName] = function(specDefinitions: Function, timeout: number) {
+ arguments[0] = wrapTestInZone(specDefinitions);
+ return originalJasmineFn.apply(this, arguments);
+ };
+ });
+
+ /**
+ * Gets a function wrapping the body of a Jasmine `describe` block to execute in a
+ * synchronous-only zone.
+ */
+ function wrapDescribeInZone(describeBody: Function): Function {
+ return function() {
+ return syncZone.run(describeBody, this, arguments as any as any[]);
+ };
+ }
+
+ /**
+ * Gets a function wrapping the body of a Jasmine `it/beforeEach/afterEach` block to
+ * execute in a ProxyZone zone.
+ * This will run in `testProxyZone`. The `testProxyZone` will be reset by the `ZoneQueueRunner`
+ */
+ function wrapTestInZone(testBody: Function): Function {
+ // The `done` callback is only passed through if the function expects at least one argument.
+ // Note we have to make a function with correct number of arguments, otherwise jasmine will
+ // think that all functions are sync or async.
+ return (testBody.length == 0) ? function() {
+ return testProxyZone.run(testBody, this);
+ } : function(done) {
+ return testProxyZone.run(testBody, this, [done]);
+ };
+ }
+ interface QueueRunner {
+ execute(): void;
+ }
+ interface QueueRunnerAttrs {
+ queueableFns: {fn: Function}[];
+ onComplete: () => void;
+ clearStack: (fn) => void;
+ onException: (error) => void;
+ catchException: () => boolean;
+ userContext: any;
+ timeout: {setTimeout: Function, clearTimeout: Function};
+ fail: () => void;
+ }
+
+ const QueueRunner = (jasmine as any).QueueRunner as {new (attrs: QueueRunnerAttrs): QueueRunner};
+ (jasmine as any).QueueRunner = (function(_super) {
+ __extends(ZoneQueueRunner, _super);
+ function ZoneQueueRunner(attrs) {
+ attrs.onComplete = ((fn) => () => {
+ // All functions are done, clear the test zone.
+ testProxyZone = null;
+ ambientZone.scheduleMicroTask('jasmine.onComplete', fn);
+ })(attrs.onComplete);
+ _super.call(this, attrs);
+ }
+ ZoneQueueRunner.prototype.execute = function() {
+ if (Zone.current !== ambientZone) throw new Error('Unexpected Zone: ' + Zone.current.name);
+ testProxyZone = ambientZone.fork(new ProxyZoneSpec());
+ if (!Zone.currentTask) {
+ // if we are not running in a task then if someone would register a
+ // element.addEventListener and then calling element.click() the
+ // addEventListener callback would think that it is the top most task and would
+ // drain the microtask queue on element.click() which would be incorrect.
+ // For this reason we always force a task when running jasmine tests.
+ Zone.current.scheduleMicroTask(
+ 'jasmine.execute().forceTask', () => QueueRunner.prototype.execute.call(this));
+ } else {
+ _super.prototype.execute.call(this);
+ }
+ };
+ return ZoneQueueRunner;
+ }(QueueRunner));
+})();
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/mocha/mocha.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/mocha/mocha.ts
new file mode 100644
index 00000000..768b5ecf
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/mocha/mocha.ts
@@ -0,0 +1,173 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+'use strict';
+
+((context: any) => {
+ const Mocha = context.Mocha;
+
+ if (typeof Mocha === 'undefined') {
+ throw new Error('Missing Mocha.js');
+ }
+
+ if (typeof Zone === 'undefined') {
+ throw new Error('Missing Zone.js');
+ }
+
+ const ProxyZoneSpec = Zone['ProxyZoneSpec'];
+ const SyncTestZoneSpec = Zone['SyncTestZoneSpec'];
+
+ if (!ProxyZoneSpec) {
+ throw new Error('Missing ProxyZoneSpec');
+ }
+
+ if (Mocha['__zone_patch__']) {
+ throw new Error('"Mocha" has already been patched with "Zone".');
+ }
+
+ Mocha['__zone_patch__'] = true;
+
+ const rootZone = Zone.current;
+ const syncZone = rootZone.fork(new SyncTestZoneSpec('Mocha.describe'));
+ let testZone = null;
+ const suiteZone = rootZone.fork(new ProxyZoneSpec());
+
+ const mochaOriginal = {
+ after: Mocha.after,
+ afterEach: Mocha.afterEach,
+ before: Mocha.before,
+ beforeEach: Mocha.beforeEach,
+ describe: Mocha.describe,
+ it: Mocha.it
+ };
+
+ function modifyArguments(args: IArguments, syncTest: Function, asyncTest?: Function): any[] {
+ for (let i = 0; i < args.length; i++) {
+ let arg = args[i];
+ if (typeof arg === 'function') {
+ // The `done` callback is only passed through if the function expects at
+ // least one argument.
+ // Note we have to make a function with correct number of arguments,
+ // otherwise mocha will
+ // think that all functions are sync or async.
+ args[i] = (arg.length === 0) ? syncTest(arg) : asyncTest(arg);
+ // Mocha uses toString to view the test body in the result list, make sure we return the
+ // correct function body
+ args[i].toString = function() {
+ return arg.toString();
+ };
+ }
+ }
+
+ return args as any;
+ }
+
+ function wrapDescribeInZone(args: IArguments): any[] {
+ const syncTest: any = function(fn) {
+ return function() {
+ return syncZone.run(fn, this, arguments as any as any[]);
+ };
+ };
+
+ return modifyArguments(args, syncTest);
+ }
+
+ function wrapTestInZone(args: IArguments): any[] {
+ const asyncTest = function(fn) {
+ return function(done) {
+ return testZone.run(fn, this, [done]);
+ };
+ };
+
+ const syncTest: any = function(fn) {
+ return function() {
+ return testZone.run(fn, this);
+ };
+ };
+
+ return modifyArguments(args, syncTest, asyncTest);
+ }
+
+ function wrapSuiteInZone(args: IArguments): any[] {
+ const asyncTest = function(fn) {
+ return function(done) {
+ return suiteZone.run(fn, this, [done]);
+ };
+ };
+
+ const syncTest: any = function(fn) {
+ return function() {
+ return suiteZone.run(fn, this);
+ };
+ };
+
+ return modifyArguments(args, syncTest, asyncTest);
+ };
+
+ context.describe = context.suite = Mocha.describe = function() {
+ return mochaOriginal.describe.apply(this, wrapDescribeInZone(arguments));
+ };
+
+ context.xdescribe = context.suite.skip = Mocha.describe.skip = function() {
+ return mochaOriginal.describe.skip.apply(this, wrapDescribeInZone(arguments));
+ };
+
+ context.describe.only = context.suite.only = Mocha.describe.only = function() {
+ return mochaOriginal.describe.only.apply(this, wrapDescribeInZone(arguments));
+ };
+
+ context.it = context.specify = context.test = Mocha.it = function() {
+ return mochaOriginal.it.apply(this, wrapTestInZone(arguments));
+ };
+
+ context.xit = context.xspecify = Mocha.it.skip = function() {
+ return mochaOriginal.it.skip.apply(this, wrapTestInZone(arguments));
+ };
+
+ context.it.only = context.test.only = Mocha.it.only = function() {
+ return mochaOriginal.it.only.apply(this, wrapTestInZone(arguments));
+ };
+
+ context.after = context.suiteTeardown = Mocha.after = function() {
+ return mochaOriginal.after.apply(this, wrapSuiteInZone(arguments));
+ };
+
+ context.afterEach = context.teardown = Mocha.afterEach = function() {
+ return mochaOriginal.afterEach.apply(this, wrapTestInZone(arguments));
+ };
+
+ context.before = context.suiteSetup = Mocha.before = function() {
+ return mochaOriginal.before.apply(this, wrapSuiteInZone(arguments));
+ };
+
+ context.beforeEach = context.setup = Mocha.beforeEach = function() {
+ return mochaOriginal.beforeEach.apply(this, wrapTestInZone(arguments));
+ };
+
+ ((originalRunTest, originalRun) => {
+ Mocha.Runner.prototype.runTest = function(fn) {
+ Zone.current.scheduleMicroTask('mocha.forceTask', () => {
+ originalRunTest.call(this, fn);
+ });
+ };
+
+ Mocha.Runner.prototype.run = function(fn) {
+ this.on('test', (e) => {
+ if (Zone.current !== rootZone) {
+ throw new Error('Unexpected zone: ' + Zone.current.name);
+ }
+ testZone = rootZone.fork(new ProxyZoneSpec());
+ });
+
+ return originalRun.call(this, fn);
+ };
+
+
+ })(Mocha.Runner.prototype.runTest, Mocha.Runner.prototype.run);
+
+})(window);
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/events.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/events.ts
new file mode 100644
index 00000000..fcb471ec
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/events.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {makeZoneAwareAddListener, makeZoneAwareListeners, makeZoneAwareRemoveAllListeners, makeZoneAwareRemoveListener, patchMethod} from '../common/utils';
+
+const callAndReturnFirstParam = (fn: (self: any, args: any[]) => any) => {
+ return (self: any, args: any[]) => {
+ fn(self, args);
+ return self;
+ };
+};
+
+// For EventEmitter
+const EE_ADD_LISTENER = 'addListener';
+const EE_PREPEND_LISTENER = 'prependListener';
+const EE_REMOVE_LISTENER = 'removeListener';
+const EE_REMOVE_ALL_LISTENER = 'removeAllListeners';
+const EE_LISTENERS = 'listeners';
+const EE_ON = 'on';
+
+const zoneAwareAddListener = callAndReturnFirstParam(
+ makeZoneAwareAddListener(EE_ADD_LISTENER, EE_REMOVE_LISTENER, false, true, false));
+const zoneAwarePrependListener = callAndReturnFirstParam(
+ makeZoneAwareAddListener(EE_PREPEND_LISTENER, EE_REMOVE_LISTENER, false, true, true));
+const zoneAwareRemoveListener =
+ callAndReturnFirstParam(makeZoneAwareRemoveListener(EE_REMOVE_LISTENER, false));
+const zoneAwareRemoveAllListeners =
+ callAndReturnFirstParam(makeZoneAwareRemoveAllListeners(EE_REMOVE_ALL_LISTENER, false));
+const zoneAwareListeners = makeZoneAwareListeners(EE_LISTENERS);
+
+export function patchEventEmitterMethods(obj: any): boolean {
+ if (obj && obj.addListener) {
+ patchMethod(obj, EE_ADD_LISTENER, () => zoneAwareAddListener);
+ patchMethod(obj, EE_PREPEND_LISTENER, () => zoneAwarePrependListener);
+ patchMethod(obj, EE_REMOVE_LISTENER, () => zoneAwareRemoveListener);
+ patchMethod(obj, EE_REMOVE_ALL_LISTENER, () => zoneAwareRemoveAllListeners);
+ patchMethod(obj, EE_LISTENERS, () => zoneAwareListeners);
+ obj[EE_ON] = obj[EE_ADD_LISTENER];
+ return true;
+ } else {
+ return false;
+ }
+}
+
+// EventEmitter
+let events;
+try {
+ events = require('events');
+} catch (err) {
+}
+
+if (events && events.EventEmitter) {
+ patchEventEmitterMethods(events.EventEmitter.prototype);
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/fs.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/fs.ts
new file mode 100644
index 00000000..51b9ae52
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/fs.ts
@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {patchMacroTask} from '../common/utils';
+
+let fs;
+try {
+ fs = require('fs');
+} catch (err) {
+}
+
+// watch, watchFile, unwatchFile has been patched
+// because EventEmitter has been patched
+const TO_PATCH_MACROTASK_METHODS = [
+ 'access', 'appendFile', 'chmod', 'chown', 'close', 'exists', 'fchmod',
+ 'fchown', 'fdatasync', 'fstat', 'fsync', 'ftruncate', 'futimes', 'lchmod',
+ 'lchown', 'link', 'lstat', 'mkdir', 'mkdtemp', 'open', 'read',
+ 'readdir', 'readFile', 'readlink', 'realpath', 'rename', 'rmdir', 'stat',
+ 'symlink', 'truncate', 'unlink', 'utimes', 'write', 'writeFile',
+];
+
+if (fs) {
+ TO_PATCH_MACROTASK_METHODS.filter(name => !!fs[name] && typeof fs[name] === 'function')
+ .forEach(name => {
+ patchMacroTask(fs, name, (self: any, args: any[]) => {
+ return {
+ name: 'fs.' + name,
+ args: args,
+ callbackIndex: args.length > 0 ? args.length - 1 : -1,
+ target: self
+ };
+ });
+ });
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/node.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/node.ts
new file mode 100644
index 00000000..4394ffec
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/node/node.ts
@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import '../zone';
+import './events';
+import './fs';
+
+import {patchTimer} from '../common/timers';
+import {patchMethod} from '../common/utils';
+
+const set = 'set';
+const clear = 'clear';
+const _global = typeof window === 'object' && window || typeof self === 'object' && self || global;
+
+// Timers
+const timers = require('timers');
+patchTimer(timers, set, clear, 'Timeout');
+patchTimer(timers, set, clear, 'Interval');
+patchTimer(timers, set, clear, 'Immediate');
+
+const shouldPatchGlobalTimers = global.setTimeout !== timers.setTimeout;
+
+if (shouldPatchGlobalTimers) {
+ patchTimer(_global, set, clear, 'Timeout');
+ patchTimer(_global, set, clear, 'Interval');
+ patchTimer(_global, set, clear, 'Immediate');
+}
+
+patchNextTick();
+
+// Crypto
+let crypto;
+try {
+ crypto = require('crypto');
+} catch (err) {
+}
+
+// TODO(gdi2290): implement a better way to patch these methods
+if (crypto) {
+ let nativeRandomBytes = crypto.randomBytes;
+ crypto.randomBytes = function randomBytesZone(size: number, callback?: Function) {
+ if (!callback) {
+ return nativeRandomBytes(size);
+ } else {
+ let zone = Zone.current;
+ const source = crypto.constructor.name + '.randomBytes';
+ return nativeRandomBytes(size, zone.wrap(callback, source));
+ }
+ }.bind(crypto);
+
+ let nativePbkdf2 = crypto.pbkdf2;
+ crypto.pbkdf2 = function pbkdf2Zone(...args: any[]) {
+ let fn = args[args.length - 1];
+ if (typeof fn === 'function') {
+ let zone = Zone.current;
+ const source = crypto.constructor.name + '.pbkdf2';
+ args[args.length - 1] = zone.wrap(fn, source);
+ return nativePbkdf2(...args);
+ } else {
+ return nativePbkdf2(...args);
+ }
+ }.bind(crypto);
+}
+
+// HTTP Client
+let httpClient;
+try {
+ httpClient = require('_http_client');
+} catch (err) {
+}
+
+if (httpClient && httpClient.ClientRequest) {
+ let ClientRequest = httpClient.ClientRequest.bind(httpClient);
+ httpClient.ClientRequest = function(options: any, callback?: Function) {
+ if (!callback) {
+ return new ClientRequest(options);
+ } else {
+ let zone = Zone.current;
+ return new ClientRequest(options, zone.wrap(callback, 'http.ClientRequest'));
+ }
+ };
+}
+
+function patchNextTick() {
+ let setNative = null;
+
+ function scheduleTask(task: Task) {
+ const args = task.data;
+ args[0] = function() {
+ task.invoke.apply(this, arguments);
+ };
+ setNative.apply(process, args);
+ return task;
+ }
+
+ setNative =
+ patchMethod(process, 'nextTick', (delegate: Function) => function(self: any, args: any[]) {
+ if (typeof args[0] === 'function') {
+ const zone = Zone.current;
+ const task = zone.scheduleMicroTask('nextTick', args[0], args, scheduleTask);
+ return task;
+ } else {
+ // cause an error by calling it directly.
+ return delegate.apply(process, args);
+ }
+ });
+}
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/async-test.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/async-test.ts
new file mode 100644
index 00000000..fdeb56a9
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/async-test.ts
@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+class AsyncTestZoneSpec implements ZoneSpec {
+ _finishCallback: Function;
+ _failCallback: Function;
+ _pendingMicroTasks: boolean = false;
+ _pendingMacroTasks: boolean = false;
+ _alreadyErrored: boolean = false;
+ runZone = Zone.current;
+
+ constructor(finishCallback: Function, failCallback: Function, namePrefix: string) {
+ this._finishCallback = finishCallback;
+ this._failCallback = failCallback;
+ this.name = 'asyncTestZone for ' + namePrefix;
+ }
+
+ _finishCallbackIfDone() {
+ if (!(this._pendingMicroTasks || this._pendingMacroTasks)) {
+ // We do this because we would like to catch unhandled rejected promises.
+ this.runZone.run(() => {
+ setTimeout(() => {
+ if (!this._alreadyErrored && !(this._pendingMicroTasks || this._pendingMacroTasks)) {
+ this._finishCallback();
+ }
+ }, 0);
+ });
+ }
+ }
+
+ // ZoneSpec implementation below.
+
+ name: string;
+
+ // Note - we need to use onInvoke at the moment to call finish when a test is
+ // fully synchronous. TODO(juliemr): remove this when the logic for
+ // onHasTask changes and it calls whenever the task queues are dirty.
+ onInvoke(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ applyThis: any, applyArgs: any[], source: string): any {
+ try {
+ return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+ } finally {
+ this._finishCallbackIfDone();
+ }
+ }
+
+ onHandleError(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any):
+ boolean {
+ // Let the parent try to handle the error.
+ const result = parentZoneDelegate.handleError(targetZone, error);
+ if (result) {
+ this._failCallback(error);
+ this._alreadyErrored = true;
+ }
+ return false;
+ }
+
+ onScheduleTask(delegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task): Task {
+ if (task.type == 'macroTask' && task.source == 'setInterval') {
+ this._failCallback('Cannot use setInterval from within an async zone test.');
+ return;
+ }
+
+ return delegate.scheduleTask(targetZone, task);
+ }
+
+ onHasTask(delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) {
+ delegate.hasTask(target, hasTaskState);
+ if (hasTaskState.change == 'microTask') {
+ this._pendingMicroTasks = hasTaskState.microTask;
+ this._finishCallbackIfDone();
+ } else if (hasTaskState.change == 'macroTask') {
+ this._pendingMacroTasks = hasTaskState.macroTask;
+ this._finishCallbackIfDone();
+ }
+ }
+}
+
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['AsyncTestZoneSpec'] = AsyncTestZoneSpec;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/fake-async-test.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/fake-async-test.ts
new file mode 100644
index 00000000..fb9912e7
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/fake-async-test.ts
@@ -0,0 +1,268 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+(function(global: any) {
+ interface ScheduledFunction {
+ endTime: number;
+ id: number;
+ func: Function;
+ args: any[];
+ delay: number;
+ }
+
+ class Scheduler {
+ // Next scheduler id.
+ public nextId: number = 0;
+
+ // Scheduler queue with the tuple of end time and callback function - sorted by end time.
+ private _schedulerQueue: ScheduledFunction[] = [];
+ // Current simulated time in millis.
+ private _currentTime: number = 0;
+
+ constructor() {}
+
+ scheduleFunction(cb: Function, delay: number, args: any[] = [], id: number = -1): number {
+ let currentId: number = id < 0 ? this.nextId++ : id;
+ let endTime = this._currentTime + delay;
+
+ // Insert so that scheduler queue remains sorted by end time.
+ let newEntry:
+ ScheduledFunction = {endTime: endTime, id: currentId, func: cb, args: args, delay: delay};
+ let i = 0;
+ for (; i < this._schedulerQueue.length; i++) {
+ let currentEntry = this._schedulerQueue[i];
+ if (newEntry.endTime < currentEntry.endTime) {
+ break;
+ }
+ }
+ this._schedulerQueue.splice(i, 0, newEntry);
+ return currentId;
+ }
+
+ removeScheduledFunctionWithId(id: number): void {
+ for (let i = 0; i < this._schedulerQueue.length; i++) {
+ if (this._schedulerQueue[i].id == id) {
+ this._schedulerQueue.splice(i, 1);
+ break;
+ }
+ }
+ }
+
+ tick(millis: number = 0): void {
+ let finalTime = this._currentTime + millis;
+ while (this._schedulerQueue.length > 0) {
+ let current = this._schedulerQueue[0];
+ if (finalTime < current.endTime) {
+ // Done processing the queue since it's sorted by endTime.
+ break;
+ } else {
+ // Time to run scheduled function. Remove it from the head of queue.
+ let current = this._schedulerQueue.shift();
+ this._currentTime = current.endTime;
+ let retval = current.func.apply(global, current.args);
+ if (!retval) {
+ // Uncaught exception in the current scheduled function. Stop processing the queue.
+ break;
+ }
+ }
+ }
+ this._currentTime = finalTime;
+ }
+ }
+
+ class FakeAsyncTestZoneSpec implements ZoneSpec {
+ static assertInZone(): void {
+ if (Zone.current.get('FakeAsyncTestZoneSpec') == null) {
+ throw new Error('The code should be running in the fakeAsync zone to call this function');
+ }
+ }
+
+ private _scheduler: Scheduler = new Scheduler();
+ private _microtasks: Function[] = [];
+ private _lastError: Error = null;
+ private _uncaughtPromiseErrors: {rejection: any}[] =
+ Promise[Zone['__symbol__']('uncaughtPromiseErrors')];
+
+ pendingPeriodicTimers: number[] = [];
+ pendingTimers: number[] = [];
+
+ constructor(namePrefix: string) {
+ this.name = 'fakeAsyncTestZone for ' + namePrefix;
+ }
+
+ private _fnAndFlush(fn: Function, completers: {onSuccess?: Function, onError?: Function}):
+ Function {
+ return (...args): boolean => {
+ fn.apply(global, args);
+
+ if (this._lastError === null) { // Success
+ if (completers.onSuccess != null) {
+ completers.onSuccess.apply(global);
+ }
+ // Flush microtasks only on success.
+ this.flushMicrotasks();
+ } else { // Failure
+ if (completers.onError != null) {
+ completers.onError.apply(global);
+ }
+ }
+ // Return true if there were no errors, false otherwise.
+ return this._lastError === null;
+ };
+ }
+
+ private static _removeTimer(timers: number[], id: number): void {
+ let index = timers.indexOf(id);
+ if (index > -1) {
+ timers.splice(index, 1);
+ }
+ }
+
+ private _dequeueTimer(id: number): Function {
+ return () => {
+ FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
+ };
+ }
+
+ private _requeuePeriodicTimer(fn: Function, interval: number, args: any[], id: number):
+ Function {
+ return () => {
+ // Requeue the timer callback if it's not been canceled.
+ if (this.pendingPeriodicTimers.indexOf(id) !== -1) {
+ this._scheduler.scheduleFunction(fn, interval, args, id);
+ }
+ };
+ }
+
+ private _dequeuePeriodicTimer(id: number): Function {
+ return () => {
+ FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id);
+ };
+ }
+
+ private _setTimeout(fn: Function, delay: number, args: any[]): number {
+ let removeTimerFn = this._dequeueTimer(this._scheduler.nextId);
+ // Queue the callback and dequeue the timer on success and error.
+ let cb = this._fnAndFlush(fn, {onSuccess: removeTimerFn, onError: removeTimerFn});
+ let id = this._scheduler.scheduleFunction(cb, delay, args);
+ this.pendingTimers.push(id);
+ return id;
+ }
+
+ private _clearTimeout(id: number): void {
+ FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
+ this._scheduler.removeScheduledFunctionWithId(id);
+ }
+
+ private _setInterval(fn: Function, interval: number, ...args): number {
+ let id = this._scheduler.nextId;
+ let completers = {onSuccess: null, onError: this._dequeuePeriodicTimer(id)};
+ let cb = this._fnAndFlush(fn, completers);
+
+ // Use the callback created above to requeue on success.
+ completers.onSuccess = this._requeuePeriodicTimer(cb, interval, args, id);
+
+ // Queue the callback and dequeue the periodic timer only on error.
+ this._scheduler.scheduleFunction(cb, interval, args);
+ this.pendingPeriodicTimers.push(id);
+ return id;
+ }
+
+ private _clearInterval(id: number): void {
+ FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id);
+ this._scheduler.removeScheduledFunctionWithId(id);
+ }
+
+ private _resetLastErrorAndThrow(): void {
+ let error = this._lastError || this._uncaughtPromiseErrors[0];
+ this._uncaughtPromiseErrors.length = 0;
+ this._lastError = null;
+ throw error;
+ }
+
+ tick(millis: number = 0): void {
+ FakeAsyncTestZoneSpec.assertInZone();
+ this.flushMicrotasks();
+ this._scheduler.tick(millis);
+ if (this._lastError !== null) {
+ this._resetLastErrorAndThrow();
+ }
+ }
+
+ flushMicrotasks(): void {
+ FakeAsyncTestZoneSpec.assertInZone();
+ const flushErrors = () => {
+ if (this._lastError !== null || this._uncaughtPromiseErrors.length) {
+ // If there is an error stop processing the microtask queue and rethrow the error.
+ this._resetLastErrorAndThrow();
+ }
+ };
+ while (this._microtasks.length > 0) {
+ let microtask = this._microtasks.shift();
+ microtask();
+ }
+ flushErrors();
+ }
+
+ // ZoneSpec implementation below.
+
+ name: string;
+
+ properties: {[key: string]: any} = {'FakeAsyncTestZoneSpec': this};
+
+ onScheduleTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task): Task {
+ switch (task.type) {
+ case 'microTask':
+ this._microtasks.push(task.invoke);
+ break;
+ case 'macroTask':
+ switch (task.source) {
+ case 'setTimeout':
+ task.data['handleId'] =
+ this._setTimeout(task.invoke, task.data['delay'], task.data['args']);
+ break;
+ case 'setInterval':
+ task.data['handleId'] =
+ this._setInterval(task.invoke, task.data['delay'], task.data['args']);
+ break;
+ case 'XMLHttpRequest.send':
+ throw new Error('Cannot make XHRs from within a fake async test.');
+ default:
+ task = delegate.scheduleTask(target, task);
+ }
+ break;
+ case 'eventTask':
+ task = delegate.scheduleTask(target, task);
+ break;
+ }
+ return task;
+ }
+
+ onCancelTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task): any {
+ switch (task.source) {
+ case 'setTimeout':
+ return this._clearTimeout(task.data['handleId']);
+ case 'setInterval':
+ return this._clearInterval(task.data['handleId']);
+ default:
+ return delegate.cancelTask(target, task);
+ }
+ }
+
+ onHandleError(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,
+ error: any): boolean {
+ this._lastError = error;
+ return false; // Don't propagate error to parent zone.
+ }
+ }
+
+ // Export the class so that new instances can be created with proper
+ // constructor params.
+ Zone['FakeAsyncTestZoneSpec'] = FakeAsyncTestZoneSpec;
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/long-stack-trace.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/long-stack-trace.ts
new file mode 100644
index 00000000..d17d547f
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/long-stack-trace.ts
@@ -0,0 +1,154 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+const NEWLINE = '\n';
+const SEP = ' ------------- ';
+const IGNORE_FRAMES = [];
+const creationTrace = '__creationTrace__';
+
+class LongStackTrace {
+ error: Error = getStacktrace();
+ timestamp: Date = new Date();
+}
+
+function getStacktraceWithUncaughtError(): Error {
+ return new Error('STACKTRACE TRACKING');
+}
+
+function getStacktraceWithCaughtError(): Error {
+ try {
+ throw getStacktraceWithUncaughtError();
+ } catch (e) {
+ return e;
+ }
+}
+
+// Some implementations of exception handling don't create a stack trace if the exception
+// isn't thrown, however it's faster not to actually throw the exception.
+const error = getStacktraceWithUncaughtError();
+const coughtError = getStacktraceWithCaughtError();
+const getStacktrace = error.stack ?
+ getStacktraceWithUncaughtError :
+ (coughtError.stack ? getStacktraceWithCaughtError : getStacktraceWithUncaughtError);
+
+function getFrames(error: Error): string[] {
+ return error.stack ? error.stack.split(NEWLINE) : [];
+}
+
+function addErrorStack(lines: string[], error: Error): void {
+ let trace: string[] = getFrames(error);
+ for (let i = 0; i < trace.length; i++) {
+ const frame = trace[i];
+ // Filter out the Frames which are part of stack capturing.
+ if (!(i < IGNORE_FRAMES.length && IGNORE_FRAMES[i] === frame)) {
+ lines.push(trace[i]);
+ }
+ }
+}
+
+function renderLongStackTrace(frames: LongStackTrace[], stack: string): string {
+ const longTrace: string[] = [stack];
+
+ if (frames) {
+ let timestamp = new Date().getTime();
+ for (let i = 0; i < frames.length; i++) {
+ const traceFrames: LongStackTrace = frames[i];
+ const lastTime = traceFrames.timestamp;
+ longTrace.push(
+ `${SEP} Elapsed: ${timestamp - lastTime.getTime()} ms; At: ${lastTime} ${SEP}`);
+ addErrorStack(longTrace, traceFrames.error);
+
+ timestamp = lastTime.getTime();
+ }
+ }
+
+ return longTrace.join(NEWLINE);
+}
+
+Zone['longStackTraceZoneSpec'] = {
+ name: 'long-stack-trace',
+ longStackTraceLimit: 10, // Max number of task to keep the stack trace for.
+
+ onScheduleTask: function(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task): any {
+ const currentTask = Zone.currentTask;
+ let trace = currentTask && currentTask.data && currentTask.data[creationTrace] || [];
+ trace = [new LongStackTrace()].concat(trace);
+ if (trace.length > this.longStackTraceLimit) {
+ trace.length = this.longStackTraceLimit;
+ }
+ if (!task.data) task.data = {};
+ task.data[creationTrace] = trace;
+ return parentZoneDelegate.scheduleTask(targetZone, task);
+ },
+
+ onHandleError: function(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any): any {
+ const parentTask = Zone.currentTask || error.task;
+ if (error instanceof Error && parentTask) {
+ let stackSetSucceeded: string|boolean = null;
+ try {
+ let descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+ if (descriptor && descriptor.configurable) {
+ const delegateGet = descriptor.get;
+ const value = descriptor.value;
+ descriptor = {
+ get: function() {
+ return renderLongStackTrace(
+ parentTask.data && parentTask.data[creationTrace],
+ delegateGet ? delegateGet.apply(this) : value);
+ }
+ };
+ Object.defineProperty(error, 'stack', descriptor);
+ stackSetSucceeded = true;
+ }
+ } catch (e) {
+ }
+ const longStack: string = stackSetSucceeded ?
+ null :
+ renderLongStackTrace(parentTask.data && parentTask.data[creationTrace], error.stack);
+ if (!stackSetSucceeded) {
+ try {
+ stackSetSucceeded = error.stack = longStack;
+ } catch (e) {
+ }
+ }
+ if (!stackSetSucceeded) {
+ try {
+ stackSetSucceeded = (error as any).longStack = longStack;
+ } catch (e) {
+ }
+ }
+ }
+ return parentZoneDelegate.handleError(targetZone, error);
+ }
+};
+
+function captureStackTraces(stackTraces: string[][], count: number): void {
+ if (count > 0) {
+ stackTraces.push(getFrames((new LongStackTrace()).error));
+ captureStackTraces(stackTraces, count - 1);
+ }
+}
+
+function computeIgnoreFrames() {
+ const frames: string[][] = [];
+ captureStackTraces(frames, 2);
+ const frames1 = frames[0];
+ const frames2 = frames[1];
+ for (let i = 0; i < frames1.length; i++) {
+ const frame1 = frames1[i];
+ const frame2 = frames2[i];
+ if (frame1 === frame2) {
+ IGNORE_FRAMES.push(frame1);
+ } else {
+ break;
+ }
+ }
+}
+computeIgnoreFrames();
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/proxy.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/proxy.ts
new file mode 100644
index 00000000..18200fec
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/proxy.ts
@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+class ProxyZoneSpec implements ZoneSpec {
+ name: string = 'ProxyZone';
+
+ private _delegateSpec: ZoneSpec;
+
+ properties: {[k: string]: any} = {'ProxyZoneSpec': this};
+ propertyKeys: string[] = null;
+
+ static get(): ProxyZoneSpec {
+ return Zone.current.get('ProxyZoneSpec');
+ }
+
+ static isLoaded(): boolean {
+ return ProxyZoneSpec.get() instanceof ProxyZoneSpec;
+ }
+
+ static assertPresent(): ProxyZoneSpec {
+ if (!this.isLoaded()) {
+ throw new Error(`Expected to be running in 'ProxyZone', but it was not found.`);
+ }
+ return ProxyZoneSpec.get();
+ }
+
+ constructor(private defaultSpecDelegate: ZoneSpec = null) {
+ this.setDelegate(defaultSpecDelegate);
+ }
+
+
+ setDelegate(delegateSpec: ZoneSpec) {
+ this._delegateSpec = delegateSpec;
+ this.propertyKeys && this.propertyKeys.forEach((key) => delete this.properties[key]);
+ this.propertyKeys = null;
+ if (delegateSpec && delegateSpec.properties) {
+ this.propertyKeys = Object.keys(delegateSpec.properties);
+ this.propertyKeys.forEach((k) => this.properties[k] = delegateSpec.properties[k]);
+ }
+ }
+
+ getDelegate() {
+ return this._delegateSpec;
+ }
+
+
+ resetDelegate() {
+ this.setDelegate(this.defaultSpecDelegate);
+ }
+
+
+ onFork(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, zoneSpec: ZoneSpec):
+ Zone {
+ if (this._delegateSpec && this._delegateSpec.onFork) {
+ return this._delegateSpec.onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec);
+ } else {
+ return parentZoneDelegate.fork(targetZone, zoneSpec);
+ }
+ }
+
+
+ onIntercept(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ source: string): Function {
+ if (this._delegateSpec && this._delegateSpec.onIntercept) {
+ return this._delegateSpec.onIntercept(
+ parentZoneDelegate, currentZone, targetZone, delegate, source);
+ } else {
+ return parentZoneDelegate.intercept(targetZone, delegate, source);
+ }
+ }
+
+
+ onInvoke(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ applyThis: any, applyArgs: any[], source: string): any {
+ if (this._delegateSpec && this._delegateSpec.onInvoke) {
+ return this._delegateSpec.onInvoke(
+ parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source);
+ } else {
+ return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+ }
+ }
+
+ onHandleError(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any):
+ boolean {
+ if (this._delegateSpec && this._delegateSpec.onHandleError) {
+ return this._delegateSpec.onHandleError(parentZoneDelegate, currentZone, targetZone, error);
+ } else {
+ return parentZoneDelegate.handleError(targetZone, error);
+ }
+ }
+
+ onScheduleTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
+ Task {
+ if (this._delegateSpec && this._delegateSpec.onScheduleTask) {
+ return this._delegateSpec.onScheduleTask(parentZoneDelegate, currentZone, targetZone, task);
+ } else {
+ return parentZoneDelegate.scheduleTask(targetZone, task);
+ }
+ }
+
+ onInvokeTask(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task,
+ applyThis: any, applyArgs: any): any {
+ if (this._delegateSpec && this._delegateSpec.onFork) {
+ return this._delegateSpec.onInvokeTask(
+ parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs);
+ } else {
+ return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+ }
+ }
+
+ onCancelTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
+ any {
+ if (this._delegateSpec && this._delegateSpec.onCancelTask) {
+ return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task);
+ } else {
+ return parentZoneDelegate.cancelTask(targetZone, task);
+ }
+ }
+
+ onHasTask(delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState): void {
+ if (this._delegateSpec && this._delegateSpec.onHasTask) {
+ this._delegateSpec.onHasTask(delegate, current, target, hasTaskState);
+ } else {
+ delegate.hasTask(target, hasTaskState);
+ }
+ }
+}
+
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['ProxyZoneSpec'] = ProxyZoneSpec;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/sync-test.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/sync-test.ts
new file mode 100644
index 00000000..f0f44b84
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/sync-test.ts
@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+class SyncTestZoneSpec implements ZoneSpec {
+ runZone = Zone.current;
+
+ constructor(namePrefix: string) {
+ this.name = 'syncTestZone for ' + namePrefix;
+ }
+
+ // ZoneSpec implementation below.
+
+ name: string;
+
+ onScheduleTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task): Task {
+ switch (task.type) {
+ case 'microTask':
+ case 'macroTask':
+ throw new Error(`Cannot call ${task.source} from within a sync test.`);
+ case 'eventTask':
+ task = delegate.scheduleTask(target, task);
+ break;
+ }
+ return task;
+ }
+}
+
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['SyncTestZoneSpec'] = SyncTestZoneSpec;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/task-tracking.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/task-tracking.ts
new file mode 100644
index 00000000..36ea191f
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/task-tracking.ts
@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * A `TaskTrackingZoneSpec` allows one to track all outstanding Tasks.
+ *
+ * This is useful in tests. For example to see which tasks are preventing a test from completing
+ * or an automated way of releasing all of the event listeners at the end of the test.
+ */
+class TaskTrackingZoneSpec implements ZoneSpec {
+ name = 'TaskTrackingZone';
+ microTasks: Task[] = [];
+ macroTasks: Task[] = [];
+ eventTasks: Task[] = [];
+ properties: {[key: string]: any} = {'TaskTrackingZone': this};
+
+ static get() {
+ return Zone.current.get('TaskTrackingZone');
+ }
+
+ private getTasksFor(type: string): Task[] {
+ switch (type) {
+ case 'microTask':
+ return this.microTasks;
+ case 'macroTask':
+ return this.macroTasks;
+ case 'eventTask':
+ return this.eventTasks;
+ }
+ throw new Error('Unknown task format: ' + type);
+ }
+
+ onScheduleTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
+ Task {
+ task['creationLocation'] = new Error(`Task '${task.type}' from '${task.source}'.`);
+ const tasks = this.getTasksFor(task.type);
+ tasks.push(task);
+ return parentZoneDelegate.scheduleTask(targetZone, task);
+ }
+
+ onCancelTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
+ any {
+ const tasks = this.getTasksFor(task.type);
+ for (let i = 0; i < tasks.length; i++) {
+ if (tasks[i] == task) {
+ tasks.splice(i, 1);
+ break;
+ }
+ }
+ return parentZoneDelegate.cancelTask(targetZone, task);
+ }
+
+ onInvokeTask(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task,
+ applyThis: any, applyArgs: any): any {
+ if (task.type === 'eventTask')
+ return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+ const tasks = this.getTasksFor(task.type);
+ for (let i = 0; i < tasks.length; i++) {
+ if (tasks[i] == task) {
+ tasks.splice(i, 1);
+ break;
+ }
+ }
+ return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
+ }
+
+ clearEvents() {
+ while (this.eventTasks.length) {
+ Zone.current.cancelTask(this.eventTasks[0]);
+ }
+ }
+}
+
+// Export the class so that new instances can be created with proper
+// constructor params.
+Zone['TaskTrackingZoneSpec'] = TaskTrackingZoneSpec;
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/wtf.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/wtf.ts
new file mode 100644
index 00000000..c38d1362
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone-spec/wtf.ts
@@ -0,0 +1,158 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+(function(global) {
+ interface Wtf {
+ trace: WtfTrace;
+ }
+ interface WtfScope {}
+ ;
+ interface WtfRange {}
+ ;
+ interface WtfTrace {
+ events: WtfEvents;
+ leaveScope(scope: WtfScope, returnValue?: any): void;
+ beginTimeRange(rangeType: string, action: string): WtfRange;
+ endTimeRange(range: WtfRange): void;
+ }
+ interface WtfEvents {
+ createScope(signature: string, flags?: any): WtfScopeFn;
+ createInstance(signature: string, flags?: any): WtfEventFn;
+ }
+
+ type WtfScopeFn = (...args: any[]) => WtfScope;
+ type WtfEventFn = (...args: any[]) => any;
+
+ // Detect and setup WTF.
+ let wtfTrace: WtfTrace = null;
+ let wtfEvents: WtfEvents = null;
+ const wtfEnabled: boolean = (function(): boolean {
+ const wtf: Wtf = global['wtf'];
+ if (wtf) {
+ wtfTrace = wtf.trace;
+ if (wtfTrace) {
+ wtfEvents = wtfTrace.events;
+ return true;
+ }
+ }
+ return false;
+ })();
+
+ class WtfZoneSpec implements ZoneSpec {
+ name: string = 'WTF';
+
+ static forkInstance =
+ wtfEnabled && wtfEvents.createInstance('Zone:fork(ascii zone, ascii newZone)');
+ static scheduleInstance: {[key: string]: WtfEventFn} = {};
+ static cancelInstance: {[key: string]: WtfEventFn} = {};
+ static invokeScope: {[key: string]: WtfEventFn} = {};
+ static invokeTaskScope: {[key: string]: WtfEventFn} = {};
+
+ onFork(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,
+ zoneSpec: ZoneSpec): Zone {
+ const retValue = parentZoneDelegate.fork(targetZone, zoneSpec);
+ WtfZoneSpec.forkInstance(zonePathName(targetZone), retValue.name);
+ return retValue;
+ }
+
+ onInvoke(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ applyThis: any, applyArgs: any[], source: string): any {
+ let scope = WtfZoneSpec.invokeScope[source];
+ if (!scope) {
+ scope = WtfZoneSpec.invokeScope[source] =
+ wtfEvents.createScope(`Zone:invoke:${source}(ascii zone)`);
+ }
+ return wtfTrace.leaveScope(
+ scope(zonePathName(targetZone)),
+ parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source));
+ }
+
+
+ onHandleError(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,
+ error: any): boolean {
+ return parentZoneDelegate.handleError(targetZone, error);
+ }
+
+ onScheduleTask(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task): any {
+ const key = task.type + ':' + task.source;
+ let instance = WtfZoneSpec.scheduleInstance[key];
+ if (!instance) {
+ instance = WtfZoneSpec.scheduleInstance[key] =
+ wtfEvents.createInstance(`Zone:schedule:${key}(ascii zone, any data)`);
+ }
+ const retValue = parentZoneDelegate.scheduleTask(targetZone, task);
+ instance(zonePathName(targetZone), shallowObj(task.data, 2));
+ return retValue;
+ }
+
+
+ onInvokeTask(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task,
+ applyThis: any, applyArgs: any[]): any {
+ const source = task.source;
+ let scope = WtfZoneSpec.invokeTaskScope[source];
+ if (!scope) {
+ scope = WtfZoneSpec.invokeTaskScope[source] =
+ wtfEvents.createScope(`Zone:invokeTask:${source}(ascii zone)`);
+ }
+ return wtfTrace.leaveScope(
+ scope(zonePathName(targetZone)),
+ parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs));
+ }
+
+ onCancelTask(parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
+ any {
+ const key = task.source;
+ let instance = WtfZoneSpec.cancelInstance[key];
+ if (!instance) {
+ instance = WtfZoneSpec.cancelInstance[key] =
+ wtfEvents.createInstance(`Zone:cancel:${key}(ascii zone, any options)`);
+ }
+ const retValue = parentZoneDelegate.cancelTask(targetZone, task);
+ instance(zonePathName(targetZone), shallowObj(task.data, 2));
+ return retValue;
+ };
+ }
+
+ function shallowObj(obj: any, depth: number): any {
+ if (!depth) return null;
+ const out = {};
+ for (const key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ let value = obj[key];
+ switch (typeof value) {
+ case 'object':
+ const name = value && value.constructor && (value.constructor).name;
+ value = name == (Object).name ? shallowObj(value, depth - 1) : name;
+ break;
+ case 'function':
+ value = value.name || undefined;
+ break;
+ }
+ out[key] = value;
+ }
+ }
+ return out;
+ }
+
+ function zonePathName(zone: Zone) {
+ let name: string = zone.name;
+ zone = zone.parent;
+ while (zone != null) {
+ name = zone.name + '::' + name;
+ zone = zone.parent;
+ }
+ return name;
+ }
+
+ Zone['wtfZoneSpec'] = !wtfEnabled ? null : new WtfZoneSpec();
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone.ts b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone.ts
new file mode 100644
index 00000000..9938cc0e
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/lib/zone.ts
@@ -0,0 +1,1627 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/*
+ * Suppress closure compiler errors about unknown 'global' variable
+ * @fileoverview
+ * @suppress {undefinedVars}
+ */
+
+/**
+ * Zone is a mechanism for intercepting and keeping track of asynchronous work.
+ *
+ * A Zone is a global object which is configured with rules about how to intercept and keep track
+ * of the asynchronous callbacks. Zone has these responsibilities:
+ *
+ * 1. Intercept asynchronous task scheduling
+ * 2. Wrap callbacks for error-handling and zone tracking across async operations.
+ * 3. Provide a way to attach data to zones
+ * 4. Provide a context specific last frame error handling
+ * 5. (Intercept blocking methods)
+ *
+ * A zone by itself does not do anything, instead it relies on some other code to route existing
+ * platform API through it. (The zone library ships with code which monkey patches all of the
+ * browsers's asynchronous API and redirects them through the zone for interception.)
+ *
+ * In its simplest form a zone allows one to intercept the scheduling and calling of asynchronous
+ * operations, and execute additional code before as well as after the asynchronous task. The rules
+ * of interception are configured using [ZoneConfig]. There can be many different zone instances in
+ * a system, but only one zone is active at any given time which can be retrieved using
+ * [Zone#current].
+ *
+ *
+ *
+ * ## Callback Wrapping
+ *
+ * An important aspect of the zones is that they should persist across asynchronous operations. To
+ * achieve this, when a future work is scheduled through async API, it is necessary to capture, and
+ * subsequently restore the current zone. For example if a code is running in zone `b` and it
+ * invokes `setTimeout` to scheduleTask work later, the `setTimeout` method needs to 1) capture the
+ * current zone and 2) wrap the `wrapCallback` in code which will restore the current zone `b` once
+ * the wrapCallback executes. In this way the rules which govern the current code are preserved in
+ * all future asynchronous tasks. There could be a different zone `c` which has different rules and
+ * is associated with different asynchronous tasks. As these tasks are processed, each asynchronous
+ * wrapCallback correctly restores the correct zone, as well as preserves the zone for future
+ * asynchronous callbacks.
+ *
+ * Example: Suppose a browser page consist of application code as well as third-party
+ * advertisement code. (These two code bases are independent, developed by different mutually
+ * unaware developers.) The application code may be interested in doing global error handling and
+ * so it configures the `app` zone to send all of the errors to the server for analysis, and then
+ * executes the application in the `app` zone. The advertising code is interested in the same
+ * error processing but it needs to send the errors to a different third-party. So it creates the
+ * `ads` zone with a different error handler. Now both advertising as well as application code
+ * create many asynchronous operations, but the [Zone] will ensure that all of the asynchronous
+ * operations created from the application code will execute in `app` zone with its error
+ * handler and all of the advertisement code will execute in the `ads` zone with its error handler.
+ * This will not only work for the async operations created directly, but also for all subsequent
+ * asynchronous operations.
+ *
+ * If you think of chain of asynchronous operations as a thread of execution (bit of a stretch)
+ * then [Zone#current] will act as a thread local variable.
+ *
+ *
+ *
+ * ## Asynchronous operation scheduling
+ *
+ * In addition to wrapping the callbacks to restore the zone, all operations which cause a
+ * scheduling of work for later are routed through the current zone which is allowed to intercept
+ * them by adding work before or after the wrapCallback as well as using different means of
+ * achieving the request. (Useful for unit testing, or tracking of requests). In some instances
+ * such as `setTimeout` the wrapping of the wrapCallback and scheduling is done in the same
+ * wrapCallback, but there are other examples such as `Promises` where the `then` wrapCallback is
+ * wrapped, but the execution of `then` in triggered by `Promise` scheduling `resolve` work.
+ *
+ * Fundamentally there are three kinds of tasks which can be scheduled:
+ *
+ * 1. [MicroTask] used for doing work right after the current task. This is non-cancelable which is
+ * guaranteed to run exactly once and immediately.
+ * 2. [MacroTask] used for doing work later. Such as `setTimeout`. This is typically cancelable
+ * which is guaranteed to execute at least once after some well understood delay.
+ * 3. [EventTask] used for listening on some future event. This may execute zero or more times, with
+ * an unknown delay.
+ *
+ * Each asynchronous API is modeled and routed through one of these APIs.
+ *
+ *
+ * ### [MicroTask]
+ *
+ * [MicroTask]s represent work which will be done in current VM turn as soon as possible, before VM
+ * yielding.
+ *
+ *
+ * ### [TimerTask]
+ *
+ * [TimerTask]s represent work which will be done after some delay. (Sometimes the delay is
+ * approximate such as on next available animation frame). Typically these methods include:
+ * `setTimeout`, `setImmediate`, `setInterval`, `requestAnimationFrame`, and all browser specif
+ * variants.
+ *
+ *
+ * ### [EventTask]
+ *
+ * [EventTask]s represent a request to create a listener on an event. Unlike the other task
+ * events may never be executed, but typically execute more than once. There is no queue of
+ * events, rather their callbacks are unpredictable both in order and time.
+ *
+ *
+ * ## Global Error Handling
+ *
+ *
+ * ## Composability
+ *
+ * Zones can be composed together through [Zone.fork()]. A child zone may create its own set of
+ * rules. A child zone is expected to either:
+ *
+ * 1. Delegate the interception to a parent zone, and optionally add before and after wrapCallback
+ * hook.s
+ * 2) Or process the request itself without delegation.
+ *
+ * Composability allows zones to keep their concerns clean. For example a top most zone may chose
+ * to handle error handling, while child zones may chose to do user action tracking.
+ *
+ *
+ * ## Root Zone
+ *
+ * At the start the browser will run in a special root zone, which is configure to behave exactly
+ * like the platform, making any existing code which is not-zone aware behave as expected. All
+ * zones are children of the root zone.
+ *
+ */
+interface Zone {
+ /**
+ *
+ * @returns {Zone} The parent Zone.
+ */
+ parent: Zone;
+ /**
+ * @returns {string} The Zone name (useful for debugging)
+ */
+ name: string;
+
+ /**
+ * Returns a value associated with the `key`.
+ *
+ * If the current zone does not have a key, the request is delegated to the parent zone. Use
+ * [ZoneSpec.properties] to configure the set of properties associated with the current zone.
+ *
+ * @param key The key to retrieve.
+ * @returns {any} The value for the key, or `undefined` if not found.
+ */
+ get(key: string): any;
+ /**
+ * Returns a Zone which defines a `key`.
+ *
+ * Recursively search the parent Zone until a Zone which has a property `key` is found.
+ *
+ * @param key The key to use for identification of the returned zone.
+ * @returns {Zone} The Zone which defines the `key`, `null` if not found.
+ */
+ getZoneWith(key: string): Zone;
+ /**
+ * Used to create a child zone.
+ *
+ * @param zoneSpec A set of rules which the child zone should follow.
+ * @returns {Zone} A new child zone.
+ */
+ fork(zoneSpec: ZoneSpec): Zone;
+ /**
+ * Wraps a callback function in a new function which will properly restore the current zone upon
+ * invocation.
+ *
+ * The wrapped function will properly forward `this` as well as `arguments` to the `callback`.
+ *
+ * Before the function is wrapped the zone can intercept the `callback` by declaring
+ * [ZoneSpec.onIntercept].
+ *
+ * @param callback the function which will be wrapped in the zone.
+ * @param source A unique debug location of the API being wrapped.
+ * @returns {function(): *} A function which will invoke the `callback` through [Zone.runGuarded].
+ */
+ wrap(callback: F, source: string): F;
+ /**
+ * Invokes a function in a given zone.
+ *
+ * The invocation of `callback` can be intercepted be declaring [ZoneSpec.onInvoke].
+ *
+ * @param callback The function to invoke.
+ * @param applyThis
+ * @param applyArgs
+ * @param source A unique debug location of the API being invoked.
+ * @returns {any} Value from the `callback` function.
+ */
+ run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
+ /**
+ * Invokes a function in a given zone and catches any exceptions.
+ *
+ * Any exceptions thrown will be forwarded to [Zone.HandleError].
+ *
+ * The invocation of `callback` can be intercepted be declaring [ZoneSpec.onInvoke]. The
+ * handling of exceptions can intercepted by declaring [ZoneSpec.handleError].
+ *
+ * @param callback The function to invoke.
+ * @param applyThis
+ * @param applyArgs
+ * @param source A unique debug location of the API being invoked.
+ * @returns {any} Value from the `callback` function.
+ */
+ runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
+ /**
+ * Execute the Task by restoring the [Zone.currentTask] in the Task's zone.
+ *
+ * @param callback
+ * @param applyThis
+ * @param applyArgs
+ * @returns {*}
+ */
+ runTask(task: Task, applyThis?: any, applyArgs?: any): any;
+ scheduleMicroTask(
+ source: string, callback: Function, data?: TaskData,
+ customSchedule?: (task: Task) => void): MicroTask;
+ scheduleMacroTask(
+ source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void,
+ customCancel: (task: Task) => void): MacroTask;
+ scheduleEventTask(
+ source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void,
+ customCancel: (task: Task) => void): EventTask;
+ /**
+ * Allows the zone to intercept canceling of scheduled Task.
+ *
+ * The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes
+ * the [Task.cancelFn].
+ *
+ * @param task
+ * @returns {any}
+ */
+ cancelTask(task: Task): any;
+}
+
+interface ZoneType {
+ /**
+ * @returns {Zone} Returns the current [Zone]. Returns the current zone. The only way to change
+ * the current zone is by invoking a run() method, which will update the current zone for the
+ * duration of the run method callback.
+ */
+ current: Zone;
+ /**
+ * @returns {Task} The task associated with the current execution.
+ */
+ currentTask: Task;
+
+ /**
+ * Verify that Zone has been correctly patched. Specifically that Promise is zone aware.
+ */
+ assertZonePatched();
+}
+
+/**
+ * Provides a way to configure the interception of zone events.
+ *
+ * Only the `name` property is required (all other are optional).
+ */
+interface ZoneSpec {
+ /**
+ * The name of the zone. Usefull when debugging Zones.
+ */
+ name: string;
+
+ /**
+ * A set of properties to be associated with Zone. Use [Zone.get] to retrive them.
+ */
+ properties?: {[key: string]: any};
+
+ /**
+ * Allows the interception of zone forking.
+ *
+ * When the zone is being forked, the request is forwarded to this method for interception.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param zoneSpec The argument passed into the `fork` method.
+ */
+ onFork?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,
+ zoneSpec: ZoneSpec) => Zone;
+
+ /**
+ * Allows interception of the wrapping of the callback.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param delegate The argument passed into the `warp` method.
+ * @param source The argument passed into the `warp` method.
+ */
+ onIntercept?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ source: string) => Function;
+
+ /**
+ * Allows interception of the callback invocation.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param delegate The argument passed into the `run` method.
+ * @param applyThis The argument passed into the `run` method.
+ * @param applyArgs The argument passed into the `run` method.
+ * @param source The argument passed into the `run` method.
+ */
+ onInvoke?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ applyThis: any, applyArgs: any[], source: string) => any;
+
+ /**
+ * Allows interception of the error handling.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param error The argument passed into the `handleError` method.
+ */
+ onHandleError?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone,
+ error: any) => boolean;
+
+ /**
+ * Allows interception of task scheduling.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param task The argument passed into the `scheduleTask` method.
+ */
+ onScheduleTask?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => Task;
+
+ onInvokeTask?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task,
+ applyThis: any, applyArgs: any) => any;
+
+ /**
+ * Allows interception of task cancelation.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param task The argument passed into the `cancelTask` method.
+ */
+ onCancelTask?:
+ (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => any;
+
+ /**
+ * Notifies of changes to the task queue empty status.
+ *
+ * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+ * @param currentZone The current [Zone] where the current interceptor has beed declared.
+ * @param targetZone The [Zone] which originally received the request.
+ * @param isEmpty
+ */
+ onHasTask?:
+ (delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) => void;
+}
+;
+
+/**
+ * A delegate when intercepting zone operations.
+ *
+ * A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. For
+ * example a child zone wrap can't just call parent zone wrap. Doing so would create a callback
+ * which is bound to the parent zone. What we are interested is intercepting the callback before it
+ * is bound to any zone. Furthermore, we also need to pass the targetZone (zone which received the
+ * original request) to the delegate.
+ *
+ * The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in
+ * the method signature. (The original Zone which received the request.) Some methods are renamed
+ * to prevent confusion, because they have slightly different semantics and arguments.
+ *
+ * - `wrap` => `intercept`: The `wrap` method delegates to `intercept`. The `wrap` method returns
+ * a callback which will run in a given zone, where as intercept allows wrapping the callback
+ * so that additional code can be run before and after, but does not associated the callback
+ * with the zone.
+ * - `run` => `invoke`: The `run` method delegates to `invoke` to perform the actual execution of
+ * the callback. The `run` method switches to new zone; saves and restores the `Zone.current`;
+ * and optionally performs error handling. The invoke is not responsible for error handling,
+ * or zone management.
+ *
+ * Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate
+ * stores the closest zone which overwrites this behavior along with the closest ZoneSpec.
+ *
+ * NOTE: We have tried to make this API analogous to Event bubbling with target and current
+ * properties.
+ *
+ * Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its `this` to
+ * store internal state.
+ */
+interface ZoneDelegate {
+ zone: Zone;
+ fork(targetZone: Zone, zoneSpec: ZoneSpec): Zone;
+ intercept(targetZone: Zone, callback: Function, source: string): Function;
+ invoke(targetZone: Zone, callback: Function, applyThis: any, applyArgs: any[], source: string):
+ any;
+ handleError(targetZone: Zone, error: any): boolean;
+ scheduleTask(targetZone: Zone, task: Task): Task;
+ invokeTask(targetZone: Zone, task: Task, applyThis: any, applyArgs: any): any;
+ cancelTask(targetZone: Zone, task: Task): any;
+ hasTask(targetZone: Zone, isEmpty: HasTaskState): void;
+}
+
+type HasTaskState = {
+ microTask: boolean; macroTask: boolean; eventTask: boolean; change: TaskType;
+};
+
+/**
+ * Task type: `microTask`, `macroTask`, `eventTask`.
+ */
+type TaskType = string; /* TS v1.8 => "microTask" | "macroTask" | "eventTask" */
+;
+
+/**
+ */
+interface TaskData {
+ /**
+ * A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
+ */
+ isPeriodic?: boolean;
+
+ /**
+ * Delay in milliseconds when the Task will run.
+ */
+ delay?: number;
+
+ /**
+ * identifier returned by the native setTimeout.
+ */
+ handleId?: number;
+}
+
+/**
+ * Represents work which is executed with a clean stack.
+ *
+ * Tasks are used in Zones to mark work which is performed on clean stack frame. There are three
+ * kinds of task. [MicroTask], [MacroTask], and [EventTask].
+ *
+ * A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set.
+ *
+ * - [MicroTask] queue represents a set of tasks which are executing right after the current stack
+ * frame becomes clean and before a VM yield. All [MicroTask]s execute in order of insertion
+ * before VM yield and the next [MacroTask] is executed.
+ * - [MacroTask] queue represents a set of tasks which are executed one at a time after each VM
+ * yield. The queue is order by time, and insertions can happen in any location.
+ * - [EventTask] is a set of tasks which can at any time be inserted to the end of the [MacroTask]
+ * queue. This happens when the event fires.
+ *
+ */
+interface Task {
+ /**
+ * Task type: `microTask`, `macroTask`, `eventTask`.
+ */
+ type: TaskType;
+
+ /**
+ * Debug string representing the API which requested the scheduling of the task.
+ */
+ source: string;
+
+ /**
+ * The Function to be used by the VM on entering the [Task]. This function will delegate to
+ * [Zone.runTask] and delegate to `callback`.
+ */
+ invoke: Function;
+
+ /**
+ * Function which needs to be executed by the Task after the [Zone.currentTask] has been set to
+ * the current task.
+ */
+ callback: Function;
+
+ /**
+ * Task specific options associated with the current task. This is passed to the `scheduleFn`.
+ */
+ data: TaskData;
+
+ /**
+ * Represents the default work which needs to be done to schedule the Task by the VM.
+ *
+ * A zone may chose to intercept this function and perform its own scheduling.
+ */
+ scheduleFn: (task: Task) => void;
+
+ /**
+ * Represents the default work which needs to be done to un-schedule the Task from the VM. Not all
+ * Tasks are cancelable, and therefore this method is optional.
+ *
+ * A zone may chose to intercept this function and perform its own scheduling.
+ */
+ cancelFn: (task: Task) => void;
+
+ /**
+ * @type {Zone} The zone which will be used to invoke the `callback`. The Zone is captured
+ * at the time of Task creation.
+ */
+ zone: Zone;
+
+ /**
+ * Number of times the task has been executed, or -1 if canceled.
+ */
+ runCount: number;
+}
+
+interface MicroTask extends Task {
+ /* TS v1.8 => type: 'microTask'; */
+}
+
+interface MacroTask extends Task {
+ /* TS v1.8 => type: 'macroTask'; */
+}
+
+interface EventTask extends Task {
+ /* TS v1.8 => type: 'eventTask'; */
+}
+
+/**
+ * Extend the Error with additional fields for rewritten stack frames
+ */
+interface Error {
+ /**
+ * Stack trace where extra frames have been removed and zone names added.
+ */
+ zoneAwareStack?: string;
+
+ /**
+ * Original stack trace with no modiffications
+ */
+ originalStack?: string;
+}
+
+/** @internal */
+type AmbientZone = Zone;
+/** @internal */
+type AmbientZoneDelegate = ZoneDelegate;
+
+const Zone: ZoneType = (function(global: any) {
+ if (global['Zone']) {
+ throw new Error('Zone already loaded.');
+ }
+
+ class Zone implements AmbientZone {
+ static __symbol__: (name: string) => string = __symbol__;
+
+ static assertZonePatched() {
+ if (global.Promise !== ZoneAwarePromise) {
+ throw new Error(
+ 'Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' +
+ 'has been overwritten.\n' +
+ 'Most likely cause is that a Promise polyfill has been loaded ' +
+ 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' +
+ 'If you must load one, do so before loading zone.js.)');
+ }
+ }
+
+
+ static get current(): AmbientZone {
+ return _currentZoneFrame.zone;
+ };
+ static get currentTask(): Task {
+ return _currentTask;
+ };
+
+ public get parent(): AmbientZone {
+ return this._parent;
+ };
+ public get name(): string {
+ return this._name;
+ };
+
+
+ private _parent: Zone;
+ private _name: string;
+ private _properties: {[key: string]: any} = null;
+ private _zoneDelegate: ZoneDelegate;
+
+ constructor(parent: Zone, zoneSpec: ZoneSpec) {
+ this._parent = parent;
+ this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '';
+ this._properties = zoneSpec && zoneSpec.properties || {};
+ this._zoneDelegate =
+ new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
+ }
+
+ public get(key: string): any {
+ const zone: Zone = this.getZoneWith(key) as Zone;
+ if (zone) return zone._properties[key];
+ }
+
+ public getZoneWith(key: string): AmbientZone {
+ let current: Zone = this;
+ while (current) {
+ if (current._properties.hasOwnProperty(key)) {
+ return current;
+ }
+ current = current._parent;
+ }
+ return null;
+ }
+
+ public fork(zoneSpec: ZoneSpec): AmbientZone {
+ if (!zoneSpec) throw new Error('ZoneSpec required!');
+ return this._zoneDelegate.fork(this, zoneSpec);
+ }
+
+ public wrap(callback: T, source: string): T {
+ if (typeof callback !== 'function') {
+ throw new Error('Expecting function got: ' + callback);
+ }
+ const _callback = this._zoneDelegate.intercept(this, callback, source);
+ const zone: Zone = this;
+ return function() {
+ return zone.runGuarded(_callback, this, arguments, source);
+ } as any as T;
+ }
+
+ public run(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any;
+ public run(
+ callback: (...args: any[]) => T, applyThis: any = null, applyArgs: any[] = null,
+ source: string = null): T {
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
+ } finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ }
+ }
+
+ public runGuarded(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any;
+ public runGuarded(
+ callback: (...args: any[]) => T, applyThis: any = null, applyArgs: any[] = null,
+ source: string = null) {
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ try {
+ return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
+ } catch (error) {
+ if (this._zoneDelegate.handleError(this, error)) {
+ throw error;
+ }
+ }
+ } finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ }
+ }
+
+
+ runTask(task: Task, applyThis?: any, applyArgs?: any): any {
+ task.runCount++;
+ if (task.zone != this)
+ throw new Error(
+ 'A task can only be run in the zone which created it! (Creation: ' + task.zone.name +
+ '; Execution: ' + this.name + ')');
+ const previousTask = _currentTask;
+ _currentTask = task;
+ _currentZoneFrame = new ZoneFrame(_currentZoneFrame, this);
+ try {
+ if (task.type == 'macroTask' && task.data && !task.data.isPeriodic) {
+ task.cancelFn = null;
+ }
+ try {
+ return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
+ } catch (error) {
+ if (this._zoneDelegate.handleError(this, error)) {
+ throw error;
+ }
+ }
+ } finally {
+ _currentZoneFrame = _currentZoneFrame.parent;
+ _currentTask = previousTask;
+ }
+ }
+
+
+ scheduleMicroTask(
+ source: string, callback: Function, data?: TaskData,
+ customSchedule?: (task: Task) => void): MicroTask {
+ return this._zoneDelegate.scheduleTask(
+ this, new ZoneTask('microTask', this, source, callback, data, customSchedule, null));
+ }
+
+ scheduleMacroTask(
+ source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void,
+ customCancel: (task: Task) => void): MacroTask {
+ return this._zoneDelegate.scheduleTask(
+ this,
+ new ZoneTask('macroTask', this, source, callback, data, customSchedule, customCancel));
+ }
+
+ scheduleEventTask(
+ source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void,
+ customCancel: (task: Task) => void): EventTask {
+ return this._zoneDelegate.scheduleTask(
+ this,
+ new ZoneTask('eventTask', this, source, callback, data, customSchedule, customCancel));
+ }
+
+ cancelTask(task: Task): any {
+ const value = this._zoneDelegate.cancelTask(this, task);
+ task.runCount = -1;
+ task.cancelFn = null;
+ return value;
+ }
+ };
+
+ class ZoneDelegate implements AmbientZoneDelegate {
+ public zone: Zone;
+
+ private _taskCounts: {microTask: number,
+ macroTask: number,
+ eventTask: number} = {microTask: 0, macroTask: 0, eventTask: 0};
+
+ private _parentDelegate: ZoneDelegate;
+
+ private _forkDlgt: ZoneDelegate;
+ private _forkZS: ZoneSpec;
+ private _forkCurrZone: Zone;
+
+ private _interceptDlgt: ZoneDelegate;
+ private _interceptZS: ZoneSpec;
+ private _interceptCurrZone: Zone;
+
+ private _invokeDlgt: ZoneDelegate;
+ private _invokeZS: ZoneSpec;
+ private _invokeCurrZone: Zone;
+
+ private _handleErrorDlgt: ZoneDelegate;
+ private _handleErrorZS: ZoneSpec;
+ private _handleErrorCurrZone: Zone;
+
+ private _scheduleTaskDlgt: ZoneDelegate;
+ private _scheduleTaskZS: ZoneSpec;
+ private _scheduleTaskCurrZone: Zone;
+
+ private _invokeTaskDlgt: ZoneDelegate;
+ private _invokeTaskZS: ZoneSpec;
+ private _invokeTaskCurrZone: Zone;
+
+ private _cancelTaskDlgt: ZoneDelegate;
+ private _cancelTaskZS: ZoneSpec;
+ private _cancelTaskCurrZone: Zone;
+
+ private _hasTaskDlgt: ZoneDelegate;
+ private _hasTaskZS: ZoneSpec;
+ private _hasTaskCurrZone: Zone;
+
+ constructor(zone: Zone, parentDelegate: ZoneDelegate, zoneSpec: ZoneSpec) {
+ this.zone = zone;
+ this._parentDelegate = parentDelegate;
+
+ this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
+ this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
+ this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate.zone);
+
+ this._interceptZS =
+ zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
+ this._interceptDlgt =
+ zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
+ this._interceptCurrZone =
+ zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate.zone);
+
+ this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
+ this._invokeDlgt =
+ zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
+ this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate.zone);
+
+ this._handleErrorZS =
+ zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
+ this._handleErrorDlgt =
+ zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
+ this._handleErrorCurrZone =
+ zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate.zone);
+
+ this._scheduleTaskZS =
+ zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
+ this._scheduleTaskDlgt =
+ zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
+ this._scheduleTaskCurrZone =
+ zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate.zone);
+
+ this._invokeTaskZS =
+ zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
+ this._invokeTaskDlgt =
+ zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
+ this._invokeTaskCurrZone =
+ zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate.zone);
+
+ this._cancelTaskZS =
+ zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
+ this._cancelTaskDlgt =
+ zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
+ this._cancelTaskCurrZone =
+ zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate.zone);
+
+ this._hasTaskZS = zoneSpec && (zoneSpec.onHasTask ? zoneSpec : parentDelegate._hasTaskZS);
+ this._hasTaskDlgt =
+ zoneSpec && (zoneSpec.onHasTask ? parentDelegate : parentDelegate._hasTaskDlgt);
+ this._hasTaskCurrZone = zoneSpec && (zoneSpec.onHasTask ? this.zone : parentDelegate.zone);
+ }
+
+ fork(targetZone: Zone, zoneSpec: ZoneSpec): AmbientZone {
+ return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
+ new Zone(targetZone, zoneSpec);
+ }
+
+ intercept(targetZone: Zone, callback: Function, source: string): Function {
+ return this._interceptZS ?
+ this._interceptZS.onIntercept(
+ this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) :
+ callback;
+ }
+
+ invoke(targetZone: Zone, callback: Function, applyThis: any, applyArgs: any[], source: string):
+ any {
+ return this._invokeZS ?
+ this._invokeZS.onInvoke(
+ this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs,
+ source) :
+ callback.apply(applyThis, applyArgs);
+ }
+
+ handleError(targetZone: Zone, error: any): boolean {
+ return this._handleErrorZS ?
+ this._handleErrorZS.onHandleError(
+ this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) :
+ true;
+ }
+
+ scheduleTask(targetZone: Zone, task: Task): Task {
+ try {
+ if (this._scheduleTaskZS) {
+ return this._scheduleTaskZS.onScheduleTask(
+ this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
+ } else if (task.scheduleFn) {
+ task.scheduleFn(task);
+ } else if (task.type == 'microTask') {
+ scheduleMicroTask(task);
+ } else {
+ throw new Error('Task is missing scheduleFn.');
+ }
+ return task;
+ } finally {
+ if (targetZone == this.zone) {
+ this._updateTaskCount(task.type, 1);
+ }
+ }
+ }
+
+ invokeTask(targetZone: Zone, task: Task, applyThis: any, applyArgs: any): any {
+ try {
+ return this._invokeTaskZS ?
+ this._invokeTaskZS.onInvokeTask(
+ this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis,
+ applyArgs) :
+ task.callback.apply(applyThis, applyArgs);
+ } finally {
+ if (targetZone == this.zone && (task.type != 'eventTask') &&
+ !(task.data && task.data.isPeriodic)) {
+ this._updateTaskCount(task.type, -1);
+ }
+ }
+ }
+
+ cancelTask(targetZone: Zone, task: Task): any {
+ let value;
+ if (this._cancelTaskZS) {
+ value = this._cancelTaskZS.onCancelTask(
+ this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
+ } else if (!task.cancelFn) {
+ throw new Error('Task does not support cancellation, or is already canceled.');
+ } else {
+ value = task.cancelFn(task);
+ }
+ if (targetZone == this.zone) {
+ // this should not be in the finally block, because exceptions assume not canceled.
+ this._updateTaskCount(task.type, -1);
+ }
+ return value;
+ }
+
+ hasTask(targetZone: Zone, isEmpty: HasTaskState) {
+ return this._hasTaskZS &&
+ this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
+ }
+
+ private _updateTaskCount(type: TaskType, count: number) {
+ const counts = this._taskCounts;
+ const prev = counts[type];
+ const next = counts[type] = prev + count;
+ if (next < 0) {
+ throw new Error('More tasks executed then were scheduled.');
+ }
+ if (prev == 0 || next == 0) {
+ const isEmpty: HasTaskState = {
+ microTask: counts.microTask > 0,
+ macroTask: counts.macroTask > 0,
+ eventTask: counts.eventTask > 0,
+ change: type
+ };
+ try {
+ this.hasTask(this.zone, isEmpty);
+ } finally {
+ if (this._parentDelegate) {
+ this._parentDelegate._updateTaskCount(type, count);
+ }
+ }
+ }
+ }
+ }
+
+
+ class ZoneTask implements Task {
+ public type: TaskType;
+ public source: string;
+ public invoke: Function;
+ public callback: Function;
+ public data: TaskData;
+ public scheduleFn: (task: Task) => void;
+ public cancelFn: (task: Task) => void;
+ public zone: Zone;
+ public runCount: number = 0;
+
+ constructor(
+ type: TaskType, zone: Zone, source: string, callback: Function, options: TaskData,
+ scheduleFn: (task: Task) => void, cancelFn: (task: Task) => void) {
+ this.type = type;
+ this.zone = zone;
+ this.source = source;
+ this.data = options;
+ this.scheduleFn = scheduleFn;
+ this.cancelFn = cancelFn;
+ this.callback = callback;
+ const self = this;
+ this.invoke = function() {
+ _numberOfNestedTaskFrames++;
+ try {
+ return zone.runTask(self, this, arguments);
+ } finally {
+ if (_numberOfNestedTaskFrames == 1) {
+ drainMicroTaskQueue();
+ }
+ _numberOfNestedTaskFrames--;
+ }
+ };
+ }
+
+ public toString() {
+ if (this.data && typeof this.data.handleId !== 'undefined') {
+ return this.data.handleId;
+ } else {
+ return Object.prototype.toString.call(this);
+ }
+ }
+
+ // add toJSON method to prevent cyclic error when
+ // call JSON.stringify(zoneTask)
+ public toJSON() {
+ return {
+ type: this.type,
+ source: this.source,
+ data: this.data,
+ zone: this.zone.name,
+ invoke: this.invoke,
+ scheduleFn: this.scheduleFn,
+ cancelFn: this.cancelFn,
+ runCount: this.runCount,
+ callback: this.callback
+ };
+ }
+ }
+
+ interface UncaughtPromiseError extends Error {
+ zone: AmbientZone;
+ task: Task;
+ promise: ZoneAwarePromise;
+ rejection: any;
+ }
+
+ class ZoneFrame {
+ public parent: ZoneFrame;
+ public zone: Zone;
+ constructor(parent: ZoneFrame, zone: Zone) {
+ this.parent = parent;
+ this.zone = zone;
+ }
+ }
+
+ function __symbol__(name: string) {
+ return '__zone_symbol__' + name;
+ };
+ const symbolSetTimeout = __symbol__('setTimeout');
+ const symbolPromise = __symbol__('Promise');
+ const symbolThen = __symbol__('then');
+
+ let _currentZoneFrame = new ZoneFrame(null, new Zone(null, null));
+ let _currentTask: Task = null;
+ let _microTaskQueue: Task[] = [];
+ let _isDrainingMicrotaskQueue: boolean = false;
+ const _uncaughtPromiseErrors: UncaughtPromiseError[] = [];
+ let _numberOfNestedTaskFrames = 0;
+
+ function scheduleQueueDrain() {
+ // if we are not running in any task, and there has not been anything scheduled
+ // we must bootstrap the initial task creation by manually scheduling the drain
+ if (_numberOfNestedTaskFrames === 0 && _microTaskQueue.length === 0) {
+ // We are not running in Task, so we need to kickstart the microtask queue.
+ if (global[symbolPromise]) {
+ global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue);
+ } else {
+ global[symbolSetTimeout](drainMicroTaskQueue, 0);
+ }
+ }
+ }
+
+ function scheduleMicroTask(task: MicroTask) {
+ scheduleQueueDrain();
+ _microTaskQueue.push(task);
+ }
+
+ function consoleError(e: any) {
+ const rejection = e && e.rejection;
+ if (rejection) {
+ console.error(
+ 'Unhandled Promise rejection:',
+ rejection instanceof Error ? rejection.message : rejection, '; Zone:',
+ (e.zone).name, '; Task:', e.task && (e.task).source, '; Value:', rejection,
+ rejection instanceof Error ? rejection.stack : undefined);
+ }
+ console.error(e);
+ }
+
+ function drainMicroTaskQueue() {
+ if (!_isDrainingMicrotaskQueue) {
+ _isDrainingMicrotaskQueue = true;
+ while (_microTaskQueue.length) {
+ const queue = _microTaskQueue;
+ _microTaskQueue = [];
+ for (let i = 0; i < queue.length; i++) {
+ const task = queue[i];
+ try {
+ task.zone.runTask(task, null, null);
+ } catch (e) {
+ consoleError(e);
+ }
+ }
+ }
+ while (_uncaughtPromiseErrors.length) {
+ while (_uncaughtPromiseErrors.length) {
+ const uncaughtPromiseError: UncaughtPromiseError = _uncaughtPromiseErrors.shift();
+ try {
+ uncaughtPromiseError.zone.runGuarded(() => {
+ throw uncaughtPromiseError;
+ });
+ } catch (e) {
+ consoleError(e);
+ }
+ }
+ }
+ _isDrainingMicrotaskQueue = false;
+ }
+ }
+
+
+ function isThenable(value: any): boolean {
+ return value && value.then;
+ }
+
+ function forwardResolution(value: any): any {
+ return value;
+ }
+
+ function forwardRejection(rejection: any): any {
+ return ZoneAwarePromise.reject(rejection);
+ }
+
+ const symbolState: string = __symbol__('state');
+ const symbolValue: string = __symbol__('value');
+ const source: string = 'Promise.then';
+ const UNRESOLVED = null;
+ const RESOLVED = true;
+ const REJECTED = false;
+ const REJECTED_NO_CATCH = 0;
+
+ function makeResolver(promise: ZoneAwarePromise, state: boolean): (value: any) => void {
+ return (v) => {
+ resolvePromise(promise, state, v);
+ // Do not return value or you will break the Promise spec.
+ };
+ }
+
+ function resolvePromise(
+ promise: ZoneAwarePromise, state: boolean, value: any): ZoneAwarePromise {
+ if (promise[symbolState] === UNRESOLVED) {
+ if (value instanceof ZoneAwarePromise && value.hasOwnProperty(symbolState) &&
+ value.hasOwnProperty(symbolValue) && value[symbolState] !== UNRESOLVED) {
+ clearRejectedNoCatch(>value);
+ resolvePromise(promise, value[symbolState], value[symbolValue]);
+ } else if (isThenable(value)) {
+ value.then(makeResolver(promise, state), makeResolver(promise, false));
+ } else {
+ promise[symbolState] = state;
+ const queue = promise[symbolValue];
+ promise[symbolValue] = value;
+
+ for (let i = 0; i < queue.length;) {
+ scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]);
+ }
+ if (queue.length == 0 && state == REJECTED) {
+ promise[symbolState] = REJECTED_NO_CATCH;
+ try {
+ throw new Error(
+ 'Uncaught (in promise): ' + value +
+ (value && value.stack ? '\n' + value.stack : ''));
+ } catch (e) {
+ const error: UncaughtPromiseError = e;
+ error.rejection = value;
+ error.promise = promise;
+ error.zone = Zone.current;
+ error.task = Zone.currentTask;
+ _uncaughtPromiseErrors.push(error);
+ scheduleQueueDrain();
+ }
+ }
+ }
+ }
+ // Resolving an already resolved promise is a noop.
+ return promise;
+ }
+
+ function clearRejectedNoCatch(promise: ZoneAwarePromise): void {
+ if (promise[symbolState] === REJECTED_NO_CATCH) {
+ promise[symbolState] = REJECTED;
+ for (let i = 0; i < _uncaughtPromiseErrors.length; i++) {
+ if (promise === _uncaughtPromiseErrors[i].promise) {
+ _uncaughtPromiseErrors.splice(i, 1);
+ break;
+ }
+ }
+ }
+ }
+
+
+ function scheduleResolveOrReject(
+ promise: ZoneAwarePromise, zone: AmbientZone, chainPromise: ZoneAwarePromise,
+ onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): void {
+ clearRejectedNoCatch(promise);
+ const delegate =
+ promise[symbolState] ? onFulfilled || forwardResolution : onRejected || forwardRejection;
+ zone.scheduleMicroTask(source, () => {
+ try {
+ resolvePromise(chainPromise, true, zone.run(delegate, null, [promise[symbolValue]]));
+ } catch (error) {
+ resolvePromise(chainPromise, false, error);
+ }
+ });
+ }
+
+ class ZoneAwarePromise implements Promise {
+ static toString() {
+ return 'function ZoneAwarePromise() { [native code] }';
+ }
+
+ static resolve(value: R): Promise {
+ return resolvePromise(>new this(null), RESOLVED, value);
+ }
+
+ static reject(error: U): Promise {
+ return resolvePromise(>new this(null), REJECTED, error);
+ }
+
+ static race(values: PromiseLike[]): Promise {
+ let resolve: (v: any) => void;
+ let reject: (v: any) => void;
+ let promise: any = new this((res, rej) => {
+ [resolve, reject] = [res, rej];
+ });
+ function onResolve(value) {
+ promise && (promise = null || resolve(value));
+ }
+ function onReject(error) {
+ promise && (promise = null || reject(error));
+ }
+
+ for (let value of values) {
+ if (!isThenable(value)) {
+ value = this.resolve(value);
+ }
+ value.then(onResolve, onReject);
+ }
+ return promise;
+ }
+
+ static all(values): Promise {
+ let resolve: (v: any) => void;
+ let reject: (v: any) => void;
+ let promise = new this((res, rej) => {
+ resolve = res;
+ reject = rej;
+ });
+ let count = 0;
+ const resolvedValues = [];
+ for (let value of values) {
+ if (!isThenable(value)) {
+ value = this.resolve(value);
+ }
+ value.then(
+ ((index) => (value) => {
+ resolvedValues[index] = value;
+ count--;
+ if (!count) {
+ resolve(resolvedValues);
+ }
+ })(count),
+ reject);
+ count++;
+ }
+ if (!count) resolve(resolvedValues);
+ return promise;
+ }
+
+ constructor(
+ executor:
+ (resolve: (value?: R|PromiseLike) => void, reject: (error?: any) => void) => void) {
+ const promise: ZoneAwarePromise = this;
+ if (!(promise instanceof ZoneAwarePromise)) {
+ throw new Error('Must be an instanceof Promise.');
+ }
+ promise[symbolState] = UNRESOLVED;
+ promise[symbolValue] = []; // queue;
+ try {
+ executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED));
+ } catch (e) {
+ resolvePromise(promise, false, e);
+ }
+ }
+
+ then(
+ onFulfilled?: (value: R) => U | PromiseLike,
+ onRejected?: (error: any) => U | PromiseLike): Promise {
+ const chainPromise: Promise = new (this.constructor as typeof ZoneAwarePromise)(null);
+ const zone = Zone.current;
+ if (this[symbolState] == UNRESOLVED) {
+ (this[symbolValue]).push(zone, chainPromise, onFulfilled, onRejected);
+ } else {
+ scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected);
+ }
+ return chainPromise;
+ }
+
+ catch(onRejected?: (error: any) => U | PromiseLike): Promise {
+ return this.then(null, onRejected);
+ }
+ }
+ // Protect against aggressive optimizers dropping seemingly unused properties.
+ // E.g. Closure Compiler in advanced mode.
+ ZoneAwarePromise['resolve'] = ZoneAwarePromise.resolve;
+ ZoneAwarePromise['reject'] = ZoneAwarePromise.reject;
+ ZoneAwarePromise['race'] = ZoneAwarePromise.race;
+ ZoneAwarePromise['all'] = ZoneAwarePromise.all;
+
+ const NativePromise = global[__symbol__('Promise')] = global['Promise'];
+ global['Promise'] = ZoneAwarePromise;
+ function patchThen(NativePromise) {
+ const NativePromiseProtototype = NativePromise.prototype;
+ const NativePromiseThen = NativePromiseProtototype[__symbol__('then')] =
+ NativePromiseProtototype.then;
+ NativePromiseProtototype.then = function(onResolve, onReject) {
+ const nativePromise = this;
+ return new ZoneAwarePromise((resolve, reject) => {
+ NativePromiseThen.call(nativePromise, resolve, reject);
+ })
+ .then(onResolve, onReject);
+ };
+ }
+
+ if (NativePromise) {
+ patchThen(NativePromise);
+ if (typeof global['fetch'] !== 'undefined') {
+ let fetchPromise: Promise;
+ try {
+ // In MS Edge this throws
+ fetchPromise = global['fetch']();
+ } catch (e) {
+ // In Chrome this throws instead.
+ fetchPromise = global['fetch']('about:blank');
+ }
+ // ignore output to prevent error;
+ fetchPromise.then(() => null, () => null);
+ if (fetchPromise.constructor != NativePromise &&
+ fetchPromise.constructor != ZoneAwarePromise) {
+ patchThen(fetchPromise.constructor);
+ }
+ }
+ }
+
+ // This is not part of public API, but it is usefull for tests, so we expose it.
+ Promise[Zone.__symbol__('uncaughtPromiseErrors')] = _uncaughtPromiseErrors;
+
+ /*
+ * This code patches Error so that:
+ * - It ignores un-needed stack frames.
+ * - It Shows the associated Zone for reach frame.
+ */
+
+ enum FrameType {
+ /// Skip this frame when printing out stack
+ blackList,
+ /// This frame marks zone transition
+ transition
+ }
+
+ const NativeError = global[__symbol__('Error')] = global.Error;
+ // Store the frames which should be removed from the stack frames
+ const blackListedStackFrames: {[frame: string]: FrameType} = {};
+ // We must find the frame where Error was created, otherwise we assume we don't understand stack
+ let zoneAwareFrame: string;
+ global.Error = ZoneAwareError;
+ // How should the stack frames be parsed.
+ let frameParserStrategy = null;
+ const stackRewrite = 'stackRewrite';
+
+ // fix #595, create property descriptor
+ // for error properties
+ const createProperty = function(props, key) {
+ // if property is already defined, skip it.
+ if (props[key]) {
+ return;
+ }
+ // define a local property
+ // in case error property is not settable
+ const name = __symbol__(key);
+ props[key] = {
+ configurable: true,
+ enumerable: true,
+ get: function() {
+ // if local property has no value
+ // use internal error's property value
+ if (!this[name]) {
+ const error = this[__symbol__('error')];
+ if (error) {
+ this[name] = error[key];
+ }
+ }
+ return this[name];
+ },
+ set: function(value) {
+ // setter will set value to local property value
+ this[name] = value;
+ }
+ };
+ };
+
+ // fix #595, create property descriptor
+ // for error method properties
+ const createMethodProperty = function(props, key) {
+ if (props[key]) {
+ return;
+ }
+ props[key] = {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: function() {
+ const error = this[__symbol__('error')];
+ let errorMethod = (error && error[key]) || this[key];
+ if (errorMethod) {
+ return errorMethod.apply(error, arguments);
+ }
+ }
+ };
+ };
+
+ const createErrorProperties = function() {
+ const props = Object.create(null);
+
+ const error = new NativeError();
+ let keys = Object.getOwnPropertyNames(error);
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ // Avoid bugs when hasOwnProperty is shadowed
+ if (Object.prototype.hasOwnProperty.call(error, key)) {
+ createProperty(props, key);
+ }
+ }
+
+ const proto = NativeError.prototype;
+ if (proto) {
+ let pKeys = Object.getOwnPropertyNames(proto);
+ for (let i = 0; i < pKeys.length; i++) {
+ const key = pKeys[i];
+ // skip constructor
+ if (key !== 'constructor' && key !== 'toString' && key !== 'toSource') {
+ createProperty(props, key);
+ }
+ }
+ }
+
+ // some other properties are not
+ // in NativeError
+ createProperty(props, 'originalStack');
+ createProperty(props, 'zoneAwareStack');
+
+ // define toString, toSource as method property
+ createMethodProperty(props, 'toString');
+ createMethodProperty(props, 'toSource');
+ return props;
+ };
+
+ const errorProperties = createErrorProperties();
+
+ // for derived Error class which extends ZoneAwareError
+ // we should not override the derived class's property
+ // so we create a new props object only copy the properties
+ // from errorProperties which not exist in derived Error's prototype
+ const getErrorPropertiesForPrototype = function(prototype) {
+ // if the prototype is ZoneAwareError.prototype
+ // we just return the prebuilt errorProperties.
+ if (prototype === ZoneAwareError.prototype) {
+ return errorProperties;
+ }
+ const newProps = Object.create(null);
+ const cKeys = Object.getOwnPropertyNames(errorProperties);
+ const keys = Object.getOwnPropertyNames(prototype);
+ cKeys.forEach(cKey => {
+ if (keys.filter(key => {
+ return key === cKey;
+ })
+ .length === 0) {
+ newProps[cKey] = errorProperties[cKey];
+ }
+ });
+
+ return newProps;
+ };
+
+ /**
+ * This is ZoneAwareError which processes the stack frame and cleans up extra frames as well as
+ * adds zone information to it.
+ */
+ function ZoneAwareError() {
+ // make sure we have a valid this
+ // if this is undefined(call Error without new) or this is global
+ // or this is some other objects, we should force to create a
+ // valid ZoneAwareError by call Object.create()
+ if (!(this instanceof ZoneAwareError)) {
+ return ZoneAwareError.apply(Object.create(ZoneAwareError.prototype), arguments);
+ }
+ // Create an Error.
+ let error: Error = NativeError.apply(this, arguments);
+ this[__symbol__('error')] = error;
+
+ // Save original stack trace
+ error.originalStack = error.stack;
+
+ // Process the stack trace and rewrite the frames.
+ if (ZoneAwareError[stackRewrite] && error.originalStack) {
+ let frames: string[] = error.originalStack.split('\n');
+ let zoneFrame = _currentZoneFrame;
+ let i = 0;
+ // Find the first frame
+ while (frames[i] !== zoneAwareFrame && i < frames.length) {
+ i++;
+ }
+ for (; i < frames.length && zoneFrame; i++) {
+ let frame = frames[i];
+ if (frame.trim()) {
+ let frameType =
+ blackListedStackFrames.hasOwnProperty(frame) && blackListedStackFrames[frame];
+ if (frameType === FrameType.blackList) {
+ frames.splice(i, 1);
+ i--;
+ } else if (frameType === FrameType.transition) {
+ if (zoneFrame.parent) {
+ // This is the special frame where zone changed. Print and process it accordingly
+ frames[i] += ` [${zoneFrame.parent.zone.name} => ${zoneFrame.zone.name}]`;
+ zoneFrame = zoneFrame.parent;
+ } else {
+ zoneFrame = null;
+ }
+ } else {
+ frames[i] += ` [${zoneFrame.zone.name}]`;
+ }
+ }
+ }
+ error.stack = error.zoneAwareStack = frames.join('\n');
+ }
+ // use defineProperties here instead of copy property value
+ // because of issue #595 which will break angular2.
+ Object.defineProperties(this, getErrorPropertiesForPrototype(Object.getPrototypeOf(this)));
+ return this;
+ }
+
+ // Copy the prototype so that instanceof operator works as expected
+ ZoneAwareError.prototype = NativeError.prototype;
+ ZoneAwareError[Zone.__symbol__('blacklistedStackFrames')] = blackListedStackFrames;
+ ZoneAwareError[stackRewrite] = false;
+
+ if (NativeError.hasOwnProperty('stackTraceLimit')) {
+ // Extend default stack limit as we will be removing few frames.
+ NativeError.stackTraceLimit = Math.max(NativeError.stackTraceLimit, 15);
+
+ // make sure that ZoneAwareError has the same property which forwards to NativeError.
+ Object.defineProperty(ZoneAwareError, 'stackTraceLimit', {
+ get: function() {
+ return NativeError.stackTraceLimit;
+ },
+ set: function(value) {
+ return NativeError.stackTraceLimit = value;
+ }
+ });
+ }
+
+ if (NativeError.hasOwnProperty('captureStackTrace')) {
+ Object.defineProperty(ZoneAwareError, 'captureStackTrace', {
+ // add named function here because we need to remove this
+ // stack frame when prepareStackTrace below
+ value: function zoneCaptureStackTrace(targetObject: Object, constructorOpt?: Function) {
+ NativeError.captureStackTrace(targetObject, constructorOpt);
+ }
+ });
+ }
+
+ Object.defineProperty(ZoneAwareError, 'prepareStackTrace', {
+ get: function() {
+ return NativeError.prepareStackTrace;
+ },
+ set: function(value) {
+ if (!value || typeof value !== 'function') {
+ return NativeError.prepareStackTrace = value;
+ }
+ return NativeError.prepareStackTrace = function(error, structuredStackTrace) {
+ // remove additional stack information from ZoneAwareError.captureStackTrace
+ if (structuredStackTrace) {
+ for (let i = 0; i < structuredStackTrace.length; i++) {
+ const st = structuredStackTrace[i];
+ // remove the first function which name is zoneCaptureStackTrace
+ if (st.getFunctionName() === 'zoneCaptureStackTrace') {
+ structuredStackTrace.splice(i, 1);
+ break;
+ }
+ }
+ }
+ return value.apply(this, [error, structuredStackTrace]);
+ };
+ }
+ });
+
+ // Now we need to populet the `blacklistedStackFrames` as well as find the
+ // run/runGuraded/runTask frames. This is done by creating a detect zone and then threading
+ // the execution through all of the above methods so that we can look at the stack trace and
+ // find the frames of interest.
+ let detectZone: Zone = Zone.current.fork({
+ name: 'detect',
+ onInvoke: function(
+ parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function,
+ applyThis: any, applyArgs: any[], source: string): any {
+ // Here only so that it will show up in the stack frame so that it can be black listed.
+ return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
+ },
+ onHandleError: function(parentZD: ZoneDelegate, current: Zone, target: Zone, error: any):
+ boolean {
+ if (error.originalStack && Error === ZoneAwareError) {
+ let frames = error.originalStack.split(/\n/);
+ let runFrame = false, runGuardedFrame = false, runTaskFrame = false;
+ while (frames.length) {
+ let frame = frames.shift();
+ // On safari it is possible to have stack frame with no line number.
+ // This check makes sure that we don't filter frames on name only (must have
+ // linenumber)
+ if (/:\d+:\d+/.test(frame)) {
+ // Get rid of the path so that we don't accidintely find function name in path.
+ // In chrome the seperator is `(` and `@` in FF and safari
+ // Chrome: at Zone.run (zone.js:100)
+ // Chrome: at Zone.run (http://localhost:9876/base/build/lib/zone.js:100:24)
+ // FireFox: Zone.prototype.run@http://localhost:9876/base/build/lib/zone.js:101:24
+ // Safari: run@http://localhost:9876/base/build/lib/zone.js:101:24
+ let fnName: string = frame.split('(')[0].split('@')[0];
+ let frameType = FrameType.transition;
+ if (fnName.indexOf('ZoneAwareError') !== -1) {
+ zoneAwareFrame = frame;
+ }
+ if (fnName.indexOf('runGuarded') !== -1) {
+ runGuardedFrame = true;
+ } else if (fnName.indexOf('runTask') !== -1) {
+ runTaskFrame = true;
+ } else if (fnName.indexOf('run') !== -1) {
+ runFrame = true;
+ } else {
+ frameType = FrameType.blackList;
+ }
+ blackListedStackFrames[frame] = frameType;
+ // Once we find all of the frames we can stop looking.
+ if (runFrame && runGuardedFrame && runTaskFrame) {
+ ZoneAwareError[stackRewrite] = true;
+ break;
+ }
+ }
+ }
+ }
+ return false;
+ }
+ }) as Zone;
+ // carefully constructor a stack frame which contains all of the frames of interest which
+ // need to be detected and blacklisted.
+ let detectRunFn = () => {
+ detectZone.run(() => {
+ detectZone.runGuarded(() => {
+ throw new Error('blacklistStackFrames');
+ });
+ });
+ };
+ // Cause the error to extract the stack frames.
+ detectZone.runTask(detectZone.scheduleMacroTask('detect', detectRunFn, null, () => null, null));
+
+ return global['Zone'] = Zone;
+})(typeof window === 'object' && window || typeof self === 'object' && self || global);
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/package.json b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/package.json
new file mode 100644
index 00000000..80f36938
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/zone.js/package.json
@@ -0,0 +1,84 @@
+{
+ "name": "zone.js",
+ "version": "0.7.6",
+ "description": "Zones for JavaScript",
+ "main": "dist/zone-node.js",
+ "browser": "dist/zone.js",
+ "typings": "dist/zone.js.d.ts",
+ "files": [
+ "lib",
+ "dist"
+ ],
+ "directories": {
+ "lib": "lib",
+ "test": "test"
+ },
+ "scripts": {
+ "changelog": "gulp changelog",
+ "ci": "npm run lint && npm run format && npm run test:single && npm run test-node",
+ "format": "gulp format:enforce",
+ "karma-jasmine": "karma start karma-build-jasmine.conf.js",
+ "karma-jasmine:single": "karma start karma-build-jasmine.conf.js --single-run",
+ "karma-jasmine:autoclose": "npm run karma-jasmine:single && npm run ws-client",
+ "lint": "gulp lint",
+ "prepublish": "tsc && gulp build",
+ "ws-client": "node ./test/ws-client.js",
+ "ws-server": "node ./test/ws-server.js",
+ "tsc": "tsc",
+ "tsc:w": "tsc -w",
+ "test": "npm run tsc && concurrently \"npm run tsc:w\" \"npm run ws-server\" \"npm run karma-jasmine\"",
+ "test:single": "npm run tsc && concurrently \"npm run ws-server\" \"npm run karma-jasmine:autoclose\"",
+ "test-dist": "concurrently \"npm run tsc:w\" \"npm run ws-server\" \"karma start karma-dist-jasmine.conf.js\"",
+ "test-node": "gulp test/node",
+ "test-mocha": "npm run tsc && concurrently \"npm run tsc:w\" \"npm run ws-server\" \"karma start karma-build-mocha.conf.js\"",
+ "serve": "python -m SimpleHTTPServer 8000"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/angular/zone.js.git"
+ },
+ "author": "Brian Ford",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/angular/zone.js/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {
+ "@types/jasmine": "^2.2.33",
+ "@types/node": "^6.0.38",
+ "@types/systemjs": "^0.19.30",
+ "clang-format": "^1.0.46",
+ "concurrently": "^2.2.0",
+ "conventional-changelog": "^1.1.0",
+ "es6-promise": "^3.0.2",
+ "gulp": "^3.8.11",
+ "gulp-clang-format": "^1.0.23",
+ "gulp-conventional-changelog": "^1.1.0",
+ "gulp-rename": "^1.2.2",
+ "gulp-rollup": "^2.3.0",
+ "gulp-tsc": "^1.1.4",
+ "gulp-tslint": "^7.0.1",
+ "gulp-uglify": "^1.2.0",
+ "gulp-util": "^3.0.7",
+ "jasmine": "^2.4.1",
+ "jasmine-core": "^2.2.0",
+ "karma": "^0.13.14",
+ "karma-chrome-launcher": "^0.2.1",
+ "karma-firefox-launcher": "^0.1.4",
+ "karma-jasmine": "^0.3.6",
+ "karma-mocha": "^1.2.0",
+ "karma-safari-launcher": "^0.1.1",
+ "karma-sauce-launcher": "^0.2.10",
+ "karma-sourcemap-loader": "^0.3.6",
+ "mocha": "^3.1.2",
+ "nodejs-websocket": "^1.2.0",
+ "pump": "^1.0.1",
+ "systemjs": "^0.19.37",
+ "ts-loader": "^0.6.0",
+ "tslint": "^4.1.1",
+ "tslint-eslint-rules": "^3.1.0",
+ "typescript": "^2.0.2",
+ "vrsource-tslint-rules": "^4.0.0",
+ "whatwg-fetch": "^2.0.1"
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/appInsightsClient.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/appInsightsClient.js
new file mode 100644
index 00000000..b94db1a1
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/appInsightsClient.js
@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const appInsights = require("applicationinsights");
+const vscode = require("vscode");
+class AppInsightsClient {
+ constructor() {
+ this._client = appInsights.getClient("a25ddf11-20fc-45c6-96ae-524f47754f28");
+ const config = vscode.workspace.getConfiguration("code-runner");
+ this._enableAppInsights = config.get("enableAppInsights");
+ }
+ sendEvent(eventName, properties) {
+ if (this._enableAppInsights) {
+ this._client.trackEvent(eventName === "" ? "bat" : eventName, properties);
+ }
+ }
+}
+exports.AppInsightsClient = AppInsightsClient;
+//# sourceMappingURL=appInsightsClient.js.map
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/codeManager.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/codeManager.js
new file mode 100644
index 00000000..1cc854cf
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/codeManager.js
@@ -0,0 +1,466 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const micromatch = require("micromatch");
+const os = require("os");
+const path_1 = require("path");
+const vscode = require("vscode");
+const appInsightsClient_1 = require("./appInsightsClient");
+const constants_1 = require("./constants");
+const utility_1 = require("./utility");
+const TmpDir = os.tmpdir();
+class CodeManager {
+ constructor() {
+ this._TERMINAL_DEFAULT_SHELL_WINDOWS = null;
+ this._outputChannel = vscode.window.createOutputChannel("Code");
+ this._terminal = null;
+ this._appInsightsClient = new appInsightsClient_1.AppInsightsClient();
+ }
+ onDidCloseTerminal() {
+ this._terminal = null;
+ }
+ run(languageId = null, fileUri = null) {
+ return __awaiter(this, void 0, void 0, function* () {
+ if (this._isRunning) {
+ vscode.window.showInformationMessage("Code is already running!");
+ return;
+ }
+ this._runFromExplorer = this.checkIsRunFromExplorer(fileUri);
+ if (this._runFromExplorer) {
+ this._document = yield vscode.workspace.openTextDocument(fileUri);
+ }
+ else {
+ const editor = vscode.window.activeTextEditor;
+ if (editor) {
+ this._document = editor.document;
+ }
+ else {
+ vscode.window.showInformationMessage("No code found or selected.");
+ return;
+ }
+ }
+ this.initialize();
+ const fileExtension = path_1.extname(this._document.fileName);
+ const executor = this.getExecutor(languageId, fileExtension);
+ // undefined or null
+ if (executor == null) {
+ vscode.window.showInformationMessage("Code language not supported or defined.");
+ return;
+ }
+ this.getCodeFileAndExecute(fileExtension, executor);
+ });
+ }
+ runCustomCommand() {
+ if (this._isRunning) {
+ vscode.window.showInformationMessage("Code is already running!");
+ return;
+ }
+ this._runFromExplorer = false;
+ const editor = vscode.window.activeTextEditor;
+ if (editor) {
+ this._document = editor.document;
+ }
+ this.initialize();
+ const executor = this._config.get("customCommand");
+ if (this._document) {
+ const fileExtension = path_1.extname(this._document.fileName);
+ this.getCodeFileAndExecute(fileExtension, executor, false);
+ }
+ else {
+ this.executeCommand(executor, false);
+ }
+ }
+ runByLanguage() {
+ this._appInsightsClient.sendEvent("runByLanguage");
+ const config = this.getConfiguration("code-runner");
+ const executorMap = config.get("executorMap");
+ vscode.window.showQuickPick(Object.keys(executorMap), { placeHolder: "Type or select language to run" }).then((languageId) => {
+ if (languageId !== undefined) {
+ this.run(languageId);
+ }
+ });
+ }
+ stop() {
+ this._appInsightsClient.sendEvent("stop");
+ this.stopRunning();
+ }
+ dispose() {
+ this.stopRunning();
+ }
+ checkIsRunFromExplorer(fileUri) {
+ const editor = vscode.window.activeTextEditor;
+ if (!fileUri || !fileUri.fsPath) {
+ return false;
+ }
+ if (!editor) {
+ return true;
+ }
+ if (fileUri.fsPath === editor.document.uri.fsPath) {
+ return false;
+ }
+ return true;
+ }
+ stopRunning() {
+ if (this._isRunning) {
+ this._isRunning = false;
+ vscode.commands.executeCommand("setContext", "code-runner.codeRunning", false);
+ const kill = require("tree-kill");
+ kill(this._process.pid);
+ }
+ }
+ initialize() {
+ this._config = this.getConfiguration("code-runner");
+ this._cwd = this._config.get("cwd");
+ if (this._cwd) {
+ return;
+ }
+ this._workspaceFolder = this.getWorkspaceFolder();
+ if ((this._config.get("fileDirectoryAsCwd") || !this._workspaceFolder)
+ && this._document && !this._document.isUntitled) {
+ this._cwd = path_1.dirname(this._document.fileName);
+ }
+ else {
+ this._cwd = this._workspaceFolder;
+ }
+ if (this._cwd) {
+ return;
+ }
+ this._cwd = TmpDir;
+ }
+ getConfiguration(section) {
+ return utility_1.Utility.getConfiguration(section, this._document);
+ }
+ getWorkspaceFolder() {
+ if (vscode.workspace.workspaceFolders) {
+ if (this._document) {
+ const workspaceFolder = vscode.workspace.getWorkspaceFolder(this._document.uri);
+ if (workspaceFolder) {
+ return workspaceFolder.uri.fsPath;
+ }
+ }
+ return vscode.workspace.workspaceFolders[0].uri.fsPath;
+ }
+ else {
+ return undefined;
+ }
+ }
+ getCodeFileAndExecute(fileExtension, executor, appendFile = true) {
+ let selection;
+ const activeTextEditor = vscode.window.activeTextEditor;
+ if (activeTextEditor) {
+ selection = activeTextEditor.selection;
+ }
+ const ignoreSelection = this._config.get("ignoreSelection");
+ if ((this._runFromExplorer || !selection || selection.isEmpty || ignoreSelection) && !this._document.isUntitled) {
+ this._isTmpFile = false;
+ this._codeFile = this._document.fileName;
+ if (this._config.get("saveAllFilesBeforeRun")) {
+ return vscode.workspace.saveAll().then(() => {
+ this.executeCommand(executor, appendFile);
+ });
+ }
+ if (this._config.get("saveFileBeforeRun")) {
+ return this._document.save().then(() => {
+ this.executeCommand(executor, appendFile);
+ });
+ }
+ }
+ else {
+ let text = (this._runFromExplorer || !selection || selection.isEmpty || ignoreSelection) ?
+ this._document.getText() : this._document.getText(selection);
+ if (this._languageId === "php") {
+ text = text.trim();
+ if (!text.startsWith(" {
+ cmd = cmd.replace(placeholder.regex, placeholder.replaceValue);
+ });
+ }
+ return (cmd !== executor ? cmd : executor + (appendFile ? " " + this.quoteFileName(this._codeFile) : ""));
+ });
+ }
+ changeExecutorFromCmdToPs(executor) {
+ if (executor.includes(" && ") && this.isPowershellOnWindows()) {
+ let replacement = "; if ($?) {";
+ executor = executor.replace("&&", replacement);
+ replacement = "} " + replacement;
+ executor = executor.replace(/&&/g, replacement);
+ executor = executor.replace(/\$dir\$fileNameWithoutExt/g, ".\\$fileNameWithoutExt");
+ return executor + " }";
+ }
+ return executor;
+ }
+ isPowershellOnWindows() {
+ if (os.platform() === "win32") {
+ const defaultProfile = vscode.workspace.getConfiguration("terminal").get("integrated.defaultProfile.windows");
+ if (defaultProfile) {
+ if (defaultProfile.toLowerCase().includes("powershell")) {
+ return true;
+ }
+ else if (defaultProfile === "Command Prompt") {
+ return false;
+ }
+ }
+ const windowsShell = vscode.env.shell;
+ return (windowsShell && windowsShell.toLowerCase().includes("powershell"));
+ }
+ return false;
+ }
+ changeFilePathForBashOnWindows(command) {
+ if (os.platform() === "win32") {
+ const windowsShell = vscode.env.shell;
+ const terminalRoot = this._config.get("terminalRoot");
+ if (windowsShell && terminalRoot) {
+ command = command
+ .replace(/([A-Za-z]):\\/g, (match, p1) => `${terminalRoot}${p1.toLowerCase()}/`)
+ .replace(/\\/g, "/");
+ }
+ else if (windowsShell && windowsShell.toLowerCase().indexOf("bash") > -1 && windowsShell.toLowerCase().indexOf("windows") > -1) {
+ command = command.replace(/([A-Za-z]):\\/g, this.replacer).replace(/\\/g, "/");
+ }
+ }
+ return command;
+ }
+ replacer(match, p1) {
+ return `/mnt/${p1.toLowerCase()}/`;
+ }
+ executeCommandInTerminal(executor, appendFile = true) {
+ return __awaiter(this, void 0, void 0, function* () {
+ let isNewTerminal = false;
+ if (this._terminal === null) {
+ this._terminal = vscode.window.createTerminal("Code");
+ isNewTerminal = true;
+ }
+ this._terminal.show(this._config.get("preserveFocus"));
+ this.sendRunEvent(executor, true);
+ executor = this.changeExecutorFromCmdToPs(executor);
+ let command = yield this.getFinalCommandToRunCodeFile(executor, appendFile);
+ command = this.changeFilePathForBashOnWindows(command);
+ if (this._config.get("clearPreviousOutput") && !isNewTerminal) {
+ yield vscode.commands.executeCommand("workbench.action.terminal.clear");
+ }
+ if (this._config.get("fileDirectoryAsCwd")) {
+ const cwd = this.changeFilePathForBashOnWindows(this._cwd);
+ this._terminal.sendText(`cd "${cwd}"`);
+ }
+ this._terminal.sendText(command);
+ });
+ }
+ executeCommandInOutputChannel(executor, appendFile = true) {
+ return __awaiter(this, void 0, void 0, function* () {
+ this._isRunning = true;
+ vscode.commands.executeCommand("setContext", "code-runner.codeRunning", true);
+ const clearPreviousOutput = this._config.get("clearPreviousOutput");
+ if (clearPreviousOutput) {
+ this._outputChannel.clear();
+ }
+ const showExecutionMessage = this._config.get("showExecutionMessage");
+ this._outputChannel.show(this._config.get("preserveFocus"));
+ const spawn = require("child_process").spawn;
+ const command = yield this.getFinalCommandToRunCodeFile(executor, appendFile);
+ if (showExecutionMessage) {
+ this._outputChannel.appendLine("[Running] " + command);
+ }
+ this.sendRunEvent(executor, false);
+ const startTime = new Date();
+ this._process = spawn(command, [], { cwd: this._cwd, shell: true });
+ this._process.stdout.on("data", (data) => {
+ this._outputChannel.append(data.toString());
+ });
+ this._process.stderr.on("data", (data) => {
+ this._outputChannel.append(data.toString());
+ });
+ this._process.on("close", (code) => {
+ this._isRunning = false;
+ vscode.commands.executeCommand("setContext", "code-runner.codeRunning", false);
+ const endTime = new Date();
+ const elapsedTime = (endTime.getTime() - startTime.getTime()) / 1000;
+ this._outputChannel.appendLine("");
+ if (showExecutionMessage) {
+ this._outputChannel.appendLine("[Done] exited with code=" + code + " in " + elapsedTime + " seconds");
+ this._outputChannel.appendLine("");
+ }
+ if (this._isTmpFile) {
+ fs.unlinkSync(this._codeFile);
+ }
+ });
+ });
+ }
+ sendRunEvent(executor, runFromTerminal) {
+ const properties = {
+ runFromTerminal: runFromTerminal.toString(),
+ runFromExplorer: this._runFromExplorer.toString(),
+ isTmpFile: this._isTmpFile.toString(),
+ };
+ this._appInsightsClient.sendEvent(executor, properties);
+ }
+}
+exports.CodeManager = CodeManager;
+//# sourceMappingURL=codeManager.js.map
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/constants.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/constants.js
new file mode 100644
index 00000000..fd9ba69d
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/constants.js
@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Constants {
+}
+exports.Constants = Constants;
+Constants.python = "python";
+//# sourceMappingURL=constants.js.map
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/extension.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/extension.js
new file mode 100644
index 00000000..5ad440bd
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/extension.js
@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode = require("vscode");
+const codeManager_1 = require("./codeManager");
+function activate(context) {
+ const codeManager = new codeManager_1.CodeManager();
+ vscode.window.onDidCloseTerminal(() => {
+ codeManager.onDidCloseTerminal();
+ });
+ const run = vscode.commands.registerCommand("code-runner.run", (fileUri) => {
+ codeManager.run(null, fileUri);
+ });
+ const runCustomCommand = vscode.commands.registerCommand("code-runner.runCustomCommand", () => {
+ codeManager.runCustomCommand();
+ });
+ const runByLanguage = vscode.commands.registerCommand("code-runner.runByLanguage", () => {
+ codeManager.runByLanguage();
+ });
+ const stop = vscode.commands.registerCommand("code-runner.stop", () => {
+ codeManager.stop();
+ });
+ context.subscriptions.push(run);
+ context.subscriptions.push(runCustomCommand);
+ context.subscriptions.push(runByLanguage);
+ context.subscriptions.push(stop);
+ context.subscriptions.push(codeManager);
+}
+exports.activate = activate;
+function deactivate() {
+}
+exports.deactivate = deactivate;
+//# sourceMappingURL=extension.js.map
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/utility.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/utility.js
new file mode 100644
index 00000000..d630123b
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/out/src/utility.js
@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode = require("vscode");
+const constants_1 = require("./constants");
+class Utility {
+ static getPythonPath(document) {
+ var _a, _b;
+ return __awaiter(this, void 0, void 0, function* () {
+ try {
+ const extension = vscode.extensions.getExtension("ms-python.python");
+ if (!extension) {
+ return constants_1.Constants.python;
+ }
+ const usingNewInterpreterStorage = (_b = (_a = extension.packageJSON) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b.usingNewInterpreterStorage;
+ if (usingNewInterpreterStorage) {
+ if (!extension.isActive) {
+ yield extension.activate();
+ }
+ const execCommand = extension.exports.settings.getExecutionDetails ?
+ extension.exports.settings.getExecutionDetails(document === null || document === void 0 ? void 0 : document.uri).execCommand :
+ extension.exports.settings.getExecutionCommand(document === null || document === void 0 ? void 0 : document.uri);
+ return execCommand ? execCommand.join(" ") : constants_1.Constants.python;
+ }
+ else {
+ return this.getConfiguration("python", document).get("pythonPath");
+ }
+ }
+ catch (error) {
+ return constants_1.Constants.python;
+ }
+ });
+ }
+ static getConfiguration(section, document) {
+ if (document) {
+ return vscode.workspace.getConfiguration(section, document.uri);
+ }
+ else {
+ return vscode.workspace.getConfiguration(section);
+ }
+ }
+}
+exports.Utility = Utility;
+//# sourceMappingURL=utility.js.map
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/package.json b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/package.json
new file mode 100644
index 00000000..02507bcb
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/package.json
@@ -0,0 +1,412 @@
+{
+ "name": "code-runner",
+ "displayName": "Code Runner",
+ "description": "Run C, C++, Java, JS, PHP, Python, Perl, Ruby, Go, Lua, Groovy, PowerShell, CMD, BASH, F#, C#, VBScript, TypeScript, CoffeeScript, Scala, Swift, Julia, Crystal, OCaml, R, AppleScript, Elixir, VB.NET, Clojure, Haxe, Obj-C, Rust, Racket, Scheme, AutoHotkey, AutoIt, Kotlin, Dart, Pascal, Haskell, Nim, D, Lisp, Kit, V, SCSS, Sass, CUDA, Less, Fortran, Ring, Standard ML, Zig, Mojo, Erlang, SPWN, Pkl, Gleam",
+ "version": "0.12.2",
+ "featureFlags": {
+ "usingNewPythonInterpreterPathApi": true,
+ "usingNewPythonInterpreterPathApiV2": true
+ },
+ "publisher": "formulahendry",
+ "icon": "images/logo.png",
+ "engines": {
+ "vscode": "^1.56.0"
+ },
+ "categories": [
+ "Programming Languages",
+ "Other"
+ ],
+ "keywords": [
+ "javascript",
+ "php",
+ "python",
+ "perl",
+ "ruby",
+ "multi-root ready"
+ ],
+ "bugs": {
+ "url": "https://github.com/formulahendry/vscode-code-runner/issues",
+ "email": "formulahendry@gmail.com"
+ },
+ "homepage": "https://github.com/formulahendry/vscode-code-runner/blob/master/README.md",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/formulahendry/vscode-code-runner.git"
+ },
+ "sponsor": {
+ "url": "https://www.patreon.com/junhan"
+ },
+ "activationEvents": [
+ "onCommand:code-runner.run",
+ "onCommand:code-runner.runCustomCommand",
+ "onCommand:code-runner.runByLanguage",
+ "onStartupFinished"
+ ],
+ "main": "./out/src/extension",
+ "contributes": {
+ "commands": [
+ {
+ "command": "code-runner.run",
+ "title": "Run Code",
+ "icon": "$(play)"
+ },
+ {
+ "command": "code-runner.runCustomCommand",
+ "title": "Run Custom Command"
+ },
+ {
+ "command": "code-runner.runByLanguage",
+ "title": "Run By Language"
+ },
+ {
+ "command": "code-runner.stop",
+ "title": "Stop Code Run",
+ "icon": "$(debug-stop)"
+ }
+ ],
+ "keybindings": [
+ {
+ "command": "code-runner.run",
+ "key": "ctrl+alt+n"
+ },
+ {
+ "command": "code-runner.runCustomCommand",
+ "key": "ctrl+alt+k"
+ },
+ {
+ "command": "code-runner.runByLanguage",
+ "key": "ctrl+alt+j"
+ },
+ {
+ "command": "code-runner.stop",
+ "key": "ctrl+alt+m"
+ }
+ ],
+ "menus": {
+ "editor/context": [
+ {
+ "when": "!inOutput && config.code-runner.showRunCommandInEditorContextMenu",
+ "command": "code-runner.run",
+ "group": "navigation"
+ },
+ {
+ "when": "inOutput && !config.code-runner.runInTerminal",
+ "command": "code-runner.stop",
+ "group": "stop-code-run"
+ }
+ ],
+ "editor/title/run": [
+ {
+ "when": "config.code-runner.showRunIconInEditorTitleMenu",
+ "command": "code-runner.run",
+ "group": "navigation"
+ }
+ ],
+ "editor/title": [
+ {
+ "when": "config.code-runner.showStopIconInEditorTitleMenu && code-runner.codeRunning",
+ "command": "code-runner.stop",
+ "group": "navigation"
+ }
+ ],
+ "explorer/context": [
+ {
+ "when": "!explorerResourceIsFolder && config.code-runner.showRunCommandInExplorerContextMenu",
+ "command": "code-runner.run",
+ "group": "navigation"
+ }
+ ]
+ },
+ "configuration": {
+ "type": "object",
+ "title": "Run Code configuration",
+ "properties": {
+ "code-runner.executorMapByGlob": {
+ "type": "object",
+ "default": {
+ "pom.xml": "cd $dir && mvn clean package"
+ },
+ "description": "Set the executor by glob.",
+ "scope": "resource"
+ },
+ "code-runner.executorMap": {
+ "type": "object",
+ "default": {
+ "javascript": "node",
+ "java": "cd $dir && javac $fileName && java $fileNameWithoutExt",
+ "c": "cd $dir && gcc $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "zig": "zig run",
+ "cpp": "cd $dir && g++ $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "objective-c": "cd $dir && gcc -framework Cocoa $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "php": "php",
+ "python": "python -u",
+ "perl": "perl",
+ "perl6": "perl6",
+ "ruby": "ruby",
+ "go": "go run",
+ "lua": "lua",
+ "groovy": "groovy",
+ "powershell": "powershell -ExecutionPolicy ByPass -File",
+ "bat": "cmd /c",
+ "shellscript": "bash",
+ "fsharp": "fsi",
+ "csharp": "scriptcs",
+ "vbscript": "cscript //Nologo",
+ "typescript": "ts-node",
+ "coffeescript": "coffee",
+ "scala": "scala",
+ "swift": "swift",
+ "julia": "julia",
+ "crystal": "crystal",
+ "ocaml": "ocaml",
+ "r": "Rscript",
+ "applescript": "osascript",
+ "clojure": "lein exec",
+ "haxe": "haxe --cwd $dirWithoutTrailingSlash --run $fileNameWithoutExt",
+ "rust": "cd $dir && rustc $fileName && $dir$fileNameWithoutExt",
+ "racket": "racket",
+ "scheme": "csi -script",
+ "ahk": "autohotkey",
+ "autoit": "autoit3",
+ "dart": "dart",
+ "pascal": "cd $dir && fpc $fileName && $dir$fileNameWithoutExt",
+ "d": "cd $dir && dmd $fileName && $dir$fileNameWithoutExt",
+ "haskell": "runghc",
+ "nim": "nim compile --verbosity:0 --hints:off --run",
+ "lisp": "sbcl --script",
+ "kit": "kitc --run",
+ "v": "v run",
+ "sass": "sass --style expanded",
+ "scss": "scss --style expanded",
+ "less": "cd $dir && lessc $fileName $fileNameWithoutExt.css",
+ "FortranFreeForm": "cd $dir && gfortran $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "fortran-modern": "cd $dir && gfortran $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "fortran_fixed-form": "cd $dir && gfortran $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "fortran": "cd $dir && gfortran $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ "sml": "cd $dir && sml $fileName",
+ "mojo": "mojo run",
+ "erlang": "escript",
+ "spwn": "spwn build",
+ "pkl": "cd $dir && pkl eval -f yaml $fileName -o $fileNameWithoutExt.yaml",
+ "gleam": "gleam run -m $fileNameWithoutExt"
+ },
+ "description": "Set the executor of each language.",
+ "scope": "resource"
+ },
+ "code-runner.executorMapByFileExtension": {
+ "type": "object",
+ "default": {
+ ".vb": "cd $dir && vbc /nologo $fileName && $dir$fileNameWithoutExt",
+ ".vbs": "cscript //Nologo",
+ ".scala": "scala",
+ ".jl": "julia",
+ ".cr": "crystal",
+ ".ml": "ocaml",
+ ".zig": "zig run",
+ ".exs": "elixir",
+ ".hx": "haxe --cwd $dirWithoutTrailingSlash --run $fileNameWithoutExt",
+ ".rkt": "racket",
+ ".scm": "csi -script",
+ ".ahk": "autohotkey",
+ ".au3": "autoit3",
+ ".kt": "cd $dir && kotlinc $fileName -include-runtime -d $fileNameWithoutExt.jar && java -jar $fileNameWithoutExt.jar",
+ ".kts": "kotlinc -script",
+ ".dart": "dart",
+ ".pas": "cd $dir && fpc $fileName && $dir$fileNameWithoutExt",
+ ".pp": "cd $dir && fpc $fileName && $dir$fileNameWithoutExt",
+ ".d": "cd $dir && dmd $fileName && $dir$fileNameWithoutExt",
+ ".hs": "runhaskell",
+ ".nim": "nim compile --verbosity:0 --hints:off --run",
+ ".csproj": "dotnet run --project",
+ ".fsproj": "dotnet run --project",
+ ".lisp": "sbcl --script",
+ ".kit": "kitc --run",
+ ".v": "v run",
+ ".vsh": "v run",
+ ".sass": "sass --style expanded",
+ ".cu": "cd $dir && nvcc $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
+ ".ring": "ring",
+ ".sml": "cd $dir && sml $fileName",
+ ".mojo": "mojo run",
+ ".erl": "escript",
+ ".spwn": "spwn build",
+ ".pkl": "cd $dir && pkl eval -f yaml $fileName -o $fileNameWithoutExt.yaml",
+ ".gleam": "gleam run -m $fileNameWithoutExt"
+ },
+ "description": "Set the executor of each file extension.",
+ "scope": "resource"
+ },
+ "code-runner.customCommand": {
+ "type": "string",
+ "default": "echo Hello",
+ "description": "Set the custom command to run.",
+ "scope": "resource"
+ },
+ "code-runner.languageIdToFileExtensionMap": {
+ "type": "object",
+ "default": {
+ "bat": ".bat",
+ "powershell": ".ps1",
+ "typescript": ".ts"
+ },
+ "description": "Set the mapping of languageId to file extension.",
+ "scope": "resource"
+ },
+ "code-runner.defaultLanguage": {
+ "type": "string",
+ "default": "",
+ "description": "Set the default language to run.",
+ "scope": "resource"
+ },
+ "code-runner.cwd": {
+ "type": "string",
+ "default": "",
+ "description": "Set the working directory.",
+ "scope": "resource"
+ },
+ "code-runner.fileDirectoryAsCwd": {
+ "type": "boolean",
+ "default": false,
+ "description": "Whether to use the directory of the file to be executed as the working directory.",
+ "scope": "resource"
+ },
+ "code-runner.clearPreviousOutput": {
+ "type": "boolean",
+ "default": false,
+ "description": "Whether to clear previous output before each run.",
+ "scope": "resource"
+ },
+ "code-runner.saveAllFilesBeforeRun": {
+ "type": "boolean",
+ "default": false,
+ "description": "Whether to save all files before running.",
+ "scope": "resource"
+ },
+ "code-runner.saveFileBeforeRun": {
+ "type": "boolean",
+ "default": false,
+ "description": "Whether to save the current file before running.",
+ "scope": "resource"
+ },
+ "code-runner.enableAppInsights": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to enable AppInsights to track user telemetry data.",
+ "scope": "resource"
+ },
+ "code-runner.showExecutionMessage": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to show extra execution message like [Running] ... and [Done] ...",
+ "scope": "resource"
+ },
+ "code-runner.runInTerminal": {
+ "type": "boolean",
+ "default": false,
+ "description": "Whether to run code in Integrated Terminal.",
+ "scope": "resource"
+ },
+ "code-runner.terminalRoot": {
+ "type": "string",
+ "default": "",
+ "description": "For Windows system, replaces the Windows style drive letter in the command with a Unix style root when using a custom shell as the terminal, like Bash or Cgywin. Example: Setting this to '/mnt/' will replace 'C:\\path' with '/mnt/c/path'",
+ "scope": "resource"
+ },
+ "code-runner.preserveFocus": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to preserve focus on code editor after code run is triggered.",
+ "scope": "resource"
+ },
+ "code-runner.ignoreSelection": {
+ "type": "boolean",
+ "default": false,
+ "description": "Whether to ignore selection to always run entire file.",
+ "scope": "resource"
+ },
+ "code-runner.showRunIconInEditorTitleMenu": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to show 'Run Code' icon in editor title menu.",
+ "scope": "resource"
+ },
+ "code-runner.showStopIconInEditorTitleMenu": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to show 'Stop code run' icon in the editor title menu when code is running.",
+ "scope": "resource"
+ },
+ "code-runner.showRunCommandInEditorContextMenu": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to show 'Run Code' command in editor context menu.",
+ "scope": "resource"
+ },
+ "code-runner.showRunCommandInExplorerContextMenu": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to show 'Run Code' command in explorer context menu.",
+ "scope": "resource"
+ },
+ "code-runner.temporaryFileName": {
+ "type": "string",
+ "default": "tempCodeRunnerFile",
+ "description": "Temporary file name used in running selected code snippet. When it is set as empty, the file name will be random.",
+ "scope": "resource"
+ },
+ "code-runner.respectShebang": {
+ "type": "boolean",
+ "default": true,
+ "description": "Whether to respect Shebang to run code.",
+ "scope": "resource"
+ }
+ }
+ },
+ "languages": [
+ {
+ "id": "code-runner-output",
+ "mimetypes": [
+ "text/x-code-output"
+ ]
+ }
+ ],
+ "grammars": [
+ {
+ "language": "code-runner-output",
+ "scopeName": "code-runner.output",
+ "path": "./syntaxes/code-runner-output.tmLanguage"
+ }
+ ]
+ },
+ "scripts": {
+ "vscode:prepublish": "tsc -p ./",
+ "compile": "tsc -watch -p ./",
+ "tslint": "tslint -t verbose src/**/*.ts"
+ },
+ "dependencies": {
+ "applicationinsights": "^0.19.0",
+ "micromatch": "^4.0.2",
+ "tree-kill": "^1.2.2"
+ },
+ "devDependencies": {
+ "@types/micromatch": "^3.1.0",
+ "@types/mocha": "^2.2.32",
+ "@types/node": "^6.0.40",
+ "@types/vscode": "^1.56.0",
+ "mocha": "^6.1.4",
+ "tslint": "^5.5.0",
+ "typescript": "^3.8.3"
+ },
+ "__metadata": {
+ "id": "a6a0c5b2-d078-4bf5-a9ee-4e37054414b3",
+ "publisherId": "38bbe3f0-5204-4170-845e-c2f966d979b8",
+ "publisherDisplayName": "formulahendry",
+ "targetPlatform": "universal",
+ "updated": false,
+ "isPreReleaseVersion": false,
+ "hasPreReleaseVersion": false,
+ "installedTimestamp": 1714049439694,
+ "pinned": false,
+ "source": "gallery"
+ }
+}
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/syntaxes/code-runner-output.tmLanguage b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/syntaxes/code-runner-output.tmLanguage
new file mode 100644
index 00000000..38b1ae7c
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/syntaxes/code-runner-output.tmLanguage
@@ -0,0 +1,76 @@
+
+
+
+
+ scopeName
+ code-runner.output
+ name
+ code-runner-output
+ patterns
+
+
+ captures
+
+ 1
+
+ name
+ token.info-token
+
+ 2
+
+ name
+ string
+
+
+ match
+ (\[Running\])(.*)
+ name
+ code-runner.running
+
+
+ captures
+
+ 1
+
+ name
+ token.info-token
+
+ 2
+
+ name
+ string
+
+ 3
+
+ name
+ token.debug-token
+
+ 4
+
+ name
+ token.error-token
+
+ 5
+
+ name
+ string
+
+ 6
+
+ name
+ constant.numeric
+
+ 7
+
+ name
+ string
+
+
+ match
+ (\[Done\])(.+)(?:(code=0)|(code=\d+))([^\d]+)(\d+(?:\.\d+)?)([^\d]+)
+ name
+ code-runner.done
+
+
+
+
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/tslint.json b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/tslint.json
new file mode 100644
index 00000000..c74d79a3
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/tslint.json
@@ -0,0 +1,18 @@
+{
+ "extends": "tslint:recommended",
+ "rules": {
+ "variable-name": [
+ true,
+ "ban-keywords",
+ "check-format",
+ "allow-pascal-case",
+ "allow-leading-underscore"
+ ],
+ "max-line-length": [
+ true,
+ 150
+ ],
+ "no-empty": false,
+ "object-literal-sort-keys": false
+ }
+}
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/.vsixmanifest b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/.vsixmanifest
new file mode 100644
index 00000000..da5c4ae5
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/.vsixmanifest
@@ -0,0 +1,45 @@
+
+
+
+ rust-analyzer
+ Rust language support for Visual Studio Code
+ rust,keybindings,json,ra_syntax_tree,__ext_rast,Rust,rs,__ext_rs
+ Formatters,Programming Languages
+ Public
+
+
+
+ extension/LICENSE.txt
+ extension/icon.png
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/LICENSE.txt b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/LICENSE.txt
new file mode 100644
index 00000000..d32e7fe8
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/LICENSE.txt
@@ -0,0 +1,230 @@
+This software is licensed under either of the Apache License, Version
+2.0, or the MIT License. See below for their text.
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+MIT License
+
+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.
diff --git a/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/README.md b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/README.md
new file mode 100644
index 00000000..36ab9818
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/README.md
@@ -0,0 +1,52 @@
+# rust-analyzer
+
+This extension provides support for the [Rust programming language](https://www.rust-lang.org/).
+It is recommended over and replaces `rust-lang.rust`.
+
+## Features
+
+- [code completion] with [imports insertion]
+- go to [definition], [implementation], [type definition]
+- [find all references], [workspace symbol search], [symbol renaming]
+- [types and documentation on hover]
+- [inlay hints] for types and parameter names
+- [semantic syntax highlighting]
+- a lot of [assists (code actions)]
+- apply suggestions from errors
+- ... and many more, check out the [manual] to see them all
+
+[code completion]: https://rust-analyzer.github.io/manual.html#magic-completions
+[imports insertion]: https://rust-analyzer.github.io/manual.html#completion-with-autoimport
+[definition]: https://rust-analyzer.github.io/manual.html#go-to-definition
+[implementation]: https://rust-analyzer.github.io/manual.html#go-to-implementation
+[type definition]: https://rust-analyzer.github.io/manual.html#go-to-type-definition
+[find all references]: https://rust-analyzer.github.io/manual.html#find-all-references
+[workspace symbol search]: https://rust-analyzer.github.io/manual.html#workspace-symbol
+[symbol renaming]: https://rust-analyzer.github.io/manual.html#rename
+[types and documentation on hover]: https://rust-analyzer.github.io/manual.html#hover
+[inlay hints]: https://rust-analyzer.github.io/manual.html#inlay-hints
+[semantic syntax highlighting]: https://rust-analyzer.github.io/manual.html#semantic-syntax-highlighting
+[assists (code actions)]: https://rust-analyzer.github.io/manual.html#assists-code-actions
+[manual]: https://rust-analyzer.github.io/manual.html
+
+## Quick start
+
+1. Install [rustup].
+2. Install the [rust-analyzer extension].
+
+[rustup]: https://rustup.rs
+[rust-analyzer extension]: https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer
+
+## Configuration
+
+This extension provides configurations through VSCode's configuration settings. All configurations are under `rust-analyzer.*`.
+
+See [the manual](https://rust-analyzer.github.io/manual.html#vs-code-2) for more information on VSCode specific configurations.
+
+## Communication
+
+For usage and troubleshooting requests, please use the ["IDEs and Editors" category of the Rust forum](https://users.rust-lang.org/c/ide/14).
+
+## Documentation
+
+See [rust-analyzer.github.io](https://rust-analyzer.github.io/) for more information.
diff --git a/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/icon.png b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/icon.png
new file mode 100644
index 00000000..072090c6
Binary files /dev/null and b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/icon.png differ
diff --git a/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/language-configuration.json b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/language-configuration.json
new file mode 100644
index 00000000..6619d0c8
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/language-configuration.json
@@ -0,0 +1,46 @@
+{
+ "comments": {
+ "lineComment": "//",
+ "blockComment": ["/*", "*/"]
+ },
+ "brackets": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"]
+ ],
+ "colorizedBracketPairs": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"]
+ ],
+ "autoClosingPairs": [
+ { "open": "{", "close": "}" },
+ { "open": "[", "close": "]" },
+ { "open": "(", "close": ")" },
+ { "open": "\"", "close": "\"", "notIn": ["string"] },
+ { "open": "/*", "close": " */", "notIn": ["string"] },
+ { "open": "`", "close": "`", "notIn": ["string"] },
+ { "open": "```", "close": "```", "notIn": ["string"] }
+ ],
+ "autoCloseBefore": ";:.,=}])> \n\t",
+ "surroundingPairs": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"],
+ ["<", ">"],
+ ["\"", "\""],
+ ["'", "'"],
+ ["`", "`"],
+ ["```", "```"]
+ ],
+ "indentationRules": {
+ "increaseIndentPattern": "^.*\\{[^}\"']*$|^.*\\([^\\)\"']*$",
+ "decreaseIndentPattern": "^\\s*(\\s*\\/[*].*[*]\\/\\s*)*[})]"
+ },
+ "folding": {
+ "markers": {
+ "start": "^\\s*// region:\\b",
+ "end": "^\\s*// endregion\\b"
+ }
+ }
+}
diff --git a/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/node_modules/d3-graphviz/build/d3-graphviz.min.js b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/node_modules/d3-graphviz/build/d3-graphviz.min.js
new file mode 100644
index 00000000..7dfd7aff
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.1932-linux-x64/node_modules/d3-graphviz/build/d3-graphviz.min.js
@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("d3-selection"),require("d3-dispatch"),require("d3-transition"),require("d3-timer"),require("d3-interpolate"),require("d3-zoom"),require("d3-format"),require("d3-path")):"function"==typeof define&&define.amd?define(["exports","d3-selection","d3-dispatch","d3-transition","d3-timer","d3-interpolate","d3-zoom","d3-format","d3-path"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self)["d3-graphviz"]={},t.d3,t.d3,t.d3,t.d3,t.d3,t.d3,t.d3,t.d3)}(this,(function(t,e,r,n,o,i,a,s,u){"use strict";function c(t){if(t&&t.__esModule)return t;var e=Object.create(null);return t&&Object.keys(t).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(t,r);Object.defineProperty(e,r,n.get?n:{enumerable:!0,get:function(){return t[r]}})}})),e.default=t,Object.freeze(e)}var l=c(e);function h(t,e,r){return(e=function(t){var e=function(t,e){if("object"!=typeof t||null===t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var n=r.call(t,e||"default");if("object"!=typeof n)return n;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===e?String:Number)(t)}(t,"string");return"symbol"==typeof e?e:String(e)}(e))in t?Object.defineProperty(t,e,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[e]=r,t}function f(t){return function(t){if(Array.isArray(t))return d(t)}(t)||function(t){if("undefined"!=typeof Symbol&&null!=t[Symbol.iterator]||null!=t["@@iterator"])return Array.from(t)}(t)||function(t,e){if(!t)return;if("string"==typeof t)return d(t,e);var r=Object.prototype.toString.call(t).slice(8,-1);"Object"===r&&t.constructor&&(r=t.constructor.name);if("Map"===r||"Set"===r)return Array.from(t);if("Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return d(t,e)}(t)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function d(t,e){(null==e||e>t.length)&&(e=t.length);for(var r=0,n=new Array(e);r1&&void 0!==arguments[1]?arguments[1]:0,r=l.select(this);t.tag;var n=t.attributes,o=r.node().attributes;if(o)for(var i=0;it.length)&&(r=t.length);var n=new X(r-e);return n.set(t.subarray(e,r)),n},F=function(t,e,r,n){if(X.prototype.fill)return X.prototype.fill.call(t,e,r,n);for((null==r||r<0)&&(r=0),(null==n||n>t.length)&&(n=t.length);rt.length)&&(n=t.length);r2046MB)","invalid block type","FSE accuracy too high","match distance too far back","unexpected EOF"],H=function(t,e,r){var n=new Error(e||z[t]);if(n.code=t,Error.captureStackTrace&&Error.captureStackTrace(n,H),!r)throw n;return n},k=function(t,e,r){for(var n=0,o=0;n>5&1,a=o>>2&1,s=3&o,u=o>>6;8&o&&H(0);var c=6-i,l=3==s?4:s,h=k(t,c,l),f=u?1<>3);p=v+(v>>3)*(7&t[5])}p>2145386496&&H(1);var m=new X((1==e?d||p:e?0:p)+12);return m[0]=1,m[4]=4,m[8]=8,{b:c+f,y:0,l:0,d:h,w:e&&1!=e?e:m.subarray(12),e:p,o:new O(m.buffer,0,3),u:d,c:a,m:Math.min(131072,p)}}if(25481893==(n>>4|t[3]<<20))return 8+(((r=t)[4]|r[5]<<8|r[6]<<16|r[7]<<24)>>>0);H(0)},Y=function(t){for(var e=0;1<r&&H(3);for(var i=1<0;){var y=Y(a+1),g=n>>3,E=(1<>(7&n)&E,_=(1<_&&(B-=D)),f[++s]=--B,-1==B?(a+=B,m[--l]=s):a-=B,!B)do{var M=n>>3;u=(t[M]|t[M+1]<<8)>>(7&n)&3,n+=2,s+=u}while(3==u)}(s>255||a)&&H(0);for(var L=0,x=(i>>1)+(i>>3)+3,G=i-1,O=0;O<=s;++O){var N=f[O];if(N<1)d[O]=-N;else for(c=0;c=l)}}for(L&&H(0),c=0;c>3,{b:o,s:m,n:w,t:p}]},R=Q(new X([81,16,99,140,49,198,24,99,12,33,196,24,99,102,102,134,70,146,4]),0,6)[1],U=Q(new X([33,20,196,24,99,140,33,132,16,66,8,33,132,16,66,8,33,68,68,68,68,68,68,68,68,36,9]),0,6)[1],V=Q(new X([32,132,16,66,102,70,68,68,68,68,36,73,2]),0,5)[1],j=function(t,e){for(var r=t.length,n=new O(r),o=0;os&&h>3;u=(u<>(7&l))&a,e[++h]=r.s[u],l-=c=r.n[u]}l==s&&h+1==o||H(0)},$=function(t,e,r){var n=6,o=e.length+3>>2,i=o<<1,a=o+i;J(t.subarray(n,n+=t[0]|t[1]<<8),e.subarray(0,o),r),J(t.subarray(n,n+=t[2]|t[3]<<8),e.subarray(o,i),r),J(t.subarray(n,n+=t[4]|t[5]<<8),e.subarray(i,a),r),J(t.subarray(n),e.subarray(a),r)},A=function(t,e,r){var n,o=e.b,i=t[o],a=i>>1&3;e.l=1&i;var s=i>>3|t[o+1]<<5|t[o+2]<<13,u=(o+=3)+s;if(1==a){if(o>=t.length)return;return e.b=o+1,r?(F(r,t[o],e.y,e.y+=s),r):F(new X(s),t[o])}if(!(u>t.length)){if(0==a)return e.b=u,r?(r.set(t.subarray(o,u),e.y),e.y+=s,r):N(t,o,u);if(2==a){var c=t[o],l=3&c,h=c>>2&3,f=c>>4,d=0,p=0;l<2?1&h?f|=t[++o]<<4|(2&h&&t[++o]<<12):f=c>>3:(p=h,h<2?(f|=(63&t[++o])<<4,d=t[o]>>6|t[++o]<<2):2==h?(f|=t[++o]<<4|(3&t[++o])<<12,d=t[o]>>2|t[++o]<<6):(f|=t[++o]<<4|(63&t[++o])<<12,d=t[o]>>6|t[++o]<<2|t[++o]<<10)),++o;var v=r?r.subarray(e.y,e.y+e.m):new X(e.m),m=v.length-f;if(0==l)v.set(t.subarray(o,o+=f),m);else if(1==l)F(v,t[o++],m);else{var w=e.h;if(2==l){var y=function(t,e){var r=0,n=-1,o=new X(292),i=t[e],a=o.subarray(0,256),s=o.subarray(256,268),u=new P(o.buffer,268);if(i<128){var c=Q(t,e+1,6),l=c[0],h=c[1],f=l<<3,d=t[e+=i];d||H(0);for(var p=0,v=0,m=h.b,w=m,y=(++e<<3)-8+Y(d);!((y-=m)>3;if(p+=(t[g]|t[g+1]<<8)>>(7&y)&(1<>3]|t[g+1]<<8)>>(7&y)&(1<255&&H(0)}else{for(n=i-127;r>4,a[r+1]=15&E}++e}var B=0;for(r=0;r11&&H(0),B+=M&&1<0;--r){var I=u[r];F(G,r,I,u[r-1]=I+s[r]*(1<<_-r))}for(u[0]!=D&&H(0),r=0;r127&&(g=g-128<<8|t[o++]);var E=t[o++];3&E&&H(0);for(var B=[U,V,R],_=2;_>-1;--_){var D=E>>2+(_<<1)&3;if(1==D){var b=new X([0,0,t[o++]]);B[_]={s:b.subarray(2,3),n:b.subarray(0,1),t:new P(b.buffer,0,1),b:0}}else 2==D?(o=(n=Q(t,o,9-(1&_)))[0],B[_]=n[1]):3==D&&(e.t||H(0),B[_]=e.t[_])}var M=e.t=B,L=M[0],x=M[1],G=M[2],I=t[u-1];I||H(0);var K=(u<<3)-8+Y(I)-G.b,O=K>>3,C=0,z=(t[O]|t[O+1]<<8)>>(7&K)&(1<>3]|t[O+1]<<8)>>(7&K)&(1<>3]|t[O+1]<<8)>>(7&K)&(1<>3]|t[O+1]<<8|t[O+2]<<16|t[O+3]<<24)>>>(7&K)&ot-1);O=(K-=S[tt])>>3;var at=Z[tt]+((t[O]|t[O+1]<<8|t[O+2]<<16)>>(7&K)&(1<>3;var st=T[j]+((t[O]|t[O+1]<<8|t[O+2]<<16)>>(7&K)&(1<>3,z=G.t[z]+((t[O]|t[O+1]<<8)>>(7&K)&(1<>3,W=L.t[W]+((t[O]|t[O+1]<<8)>>(7&K)&(1<>3,k=x.t[k]+((t[O]|t[O+1]<<8)>>(7&K)&(1<3)e.o[2]=e.o[1],e.o[1]=e.o[0],e.o[0]=it-=3;else{var ut=it-(0!=st);ut?(it=3==ut?e.o[0]-1:e.o[ut],ut>1&&(e.o[2]=e.o[1]),e.o[1]=e.o[0],e.o[0]=it):it=e.o[0]}for(_=0;_at&&(lt=at),_=0;_{throw e},u=n.print||console.log.bind(console),c=n.printErr||console.warn.bind(console);Object.assign(n,i),i=null,n.arguments&&n.arguments,n.thisProgram&&(a=n.thisProgram),n.quit&&(s=n.quit),n.wasmBinary&&(o=n.wasmBinary);var l,h=n.noExitRuntime||!0;"object"!=typeof WebAssembly&&H("no native wasm support detected");var f=!1;function d(t,e){t||H(e)}var p,v,m,w,y,g,E,B="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0;function _(t,e,r){for(var n=e+r,o=e;t[o]&&!(o>=n);)++o;if(o-e>16&&t.buffer&&B)return B.decode(t.subarray(e,o));for(var i="";e>10,56320|1023&c)}}else i+=String.fromCharCode((31&a)<<6|s)}else i+=String.fromCharCode(a)}return i}function D(t,e){return t?_(m,t,e):""}function b(t,e,r,n){if(!(n>0))return 0;for(var o=r,i=r+n-1,a=0;a=55296&&s<=57343&&(s=65536+((1023&s)<<10)|1023&t.charCodeAt(++a)),s<=127){if(r>=i)break;e[r++]=s}else if(s<=2047){if(r+1>=i)break;e[r++]=192|s>>6,e[r++]=128|63&s}else if(s<=65535){if(r+2>=i)break;e[r++]=224|s>>12,e[r++]=128|s>>6&63,e[r++]=128|63&s}else{if(r+3>=i)break;e[r++]=240|s>>18,e[r++]=128|s>>12&63,e[r++]=128|s>>6&63,e[r++]=128|63&s}}return e[r]=0,r-o}function M(t){for(var e=0,r=0;r=55296&&n<=57343?(e+=4,++r):e+=3}return e}function L(t){p=t,n.HEAP8=v=new Int8Array(t),n.HEAP16=w=new Int16Array(t),n.HEAP32=y=new Int32Array(t),n.HEAPU8=m=new Uint8Array(t),n.HEAPU16=new Uint16Array(t),n.HEAPU32=g=new Uint32Array(t),n.HEAPF32=new Float32Array(t),n.HEAPF64=E=new Float64Array(t)}n.INITIAL_MEMORY;var x,G,I,X,P=[],K=[],O=[],N=0,F=null;function C(t){N++,n.monitorRunDependencies&&n.monitorRunDependencies(N)}function z(t){if(N--,n.monitorRunDependencies&&n.monitorRunDependencies(N),0==N&&F){var e=F;F=null,e()}}function H(t){n.onAbort&&n.onAbort(t),c(t="Aborted("+t+")"),f=!0,t+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(t);throw r(e),e}function k(t){return t.startsWith("data:application/octet-stream;base64,")}k(x="graphvizlib.wasm")||(G=x,x=n.locateFile?n.locateFile(G,""):""+G);var W={175664:(t,e)=>{var r=D(t),n=D(e);Z.createPath("/",U.dirname(r)),Z.writeFile(U.join("/",r),n)}};function Y(t){this.name="ExitStatus",this.message="Program terminated with exit("+t+")",this.status=t}function Q(t){for(;t.length>0;)t.shift()(n)}function R(t){this.excPtr=t,this.ptr=t-24,this.set_type=function(t){g[this.ptr+4>>2]=t},this.get_type=function(){return g[this.ptr+4>>2]},this.set_destructor=function(t){g[this.ptr+8>>2]=t},this.get_destructor=function(){return g[this.ptr+8>>2]},this.set_refcount=function(t){y[this.ptr>>2]=t},this.set_caught=function(t){t=t?1:0,v[this.ptr+12>>0]=t},this.get_caught=function(){return 0!=v[this.ptr+12>>0]},this.set_rethrown=function(t){t=t?1:0,v[this.ptr+13>>0]=t},this.get_rethrown=function(){return 0!=v[this.ptr+13>>0]},this.init=function(t,e){this.set_adjusted_ptr(0),this.set_type(t),this.set_destructor(e),this.set_refcount(0),this.set_caught(!1),this.set_rethrown(!1)},this.add_ref=function(){var t=y[this.ptr>>2];y[this.ptr>>2]=t+1},this.release_ref=function(){var t=y[this.ptr>>2];return y[this.ptr>>2]=t-1,1===t},this.set_adjusted_ptr=function(t){g[this.ptr+16>>2]=t},this.get_adjusted_ptr=function(){return g[this.ptr+16>>2]},this.get_exception_ptr=function(){if(yt(this.get_type()))return g[this.excPtr>>2];var t=this.get_adjusted_ptr();return 0!==t?t:this.excPtr}}var U={isAbs:t=>"/"===t.charAt(0),splitPath:t=>/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(t).slice(1),normalizeArray:(t,e)=>{for(var r=0,n=t.length-1;n>=0;n--){var o=t[n];"."===o?t.splice(n,1):".."===o?(t.splice(n,1),r++):r&&(t.splice(n,1),r--)}if(e)for(;r;r--)t.unshift("..");return t},normalize:t=>{var e=U.isAbs(t),r="/"===t.substr(-1);return(t=U.normalizeArray(t.split("/").filter((t=>!!t)),!e).join("/"))||e||(t="."),t&&r&&(t+="/"),(e?"/":"")+t},dirname:t=>{var e=U.splitPath(t),r=e[0],n=e[1];return r||n?(n&&(n=n.substr(0,n.length-1)),r+n):"."},basename:t=>{if("/"===t)return"/";var e=(t=(t=U.normalize(t)).replace(/\/$/,"")).lastIndexOf("/");return-1===e?t:t.substr(e+1)},join:function(){var t=Array.prototype.slice.call(arguments);return U.normalize(t.join("/"))},join2:(t,e)=>U.normalize(t+"/"+e)},V={resolve:function(){for(var t="",e=!1,r=arguments.length-1;r>=-1&&!e;r--){var n=r>=0?arguments[r]:Z.cwd();if("string"!=typeof n)throw new TypeError("Arguments to path.resolve must be strings");if(!n)return"";t=n+"/"+t,e=U.isAbs(n)}return(e?"/":"")+(t=U.normalizeArray(t.split("/").filter((t=>!!t)),!e).join("/"))||"."},relative:(t,e)=>{function r(t){for(var e=0;e=0&&""===t[r];r--);return e>r?[]:t.slice(e,r-e+1)}t=V.resolve(t).substr(1),e=V.resolve(e).substr(1);for(var n=r(t.split("/")),o=r(e.split("/")),i=Math.min(n.length,o.length),a=i,s=0;s0?r:M(t)+1,o=new Array(n),i=b(t,o,0,o.length);return e&&(o.length=i),o}var q={ttys:[],init:function(){},shutdown:function(){},register:function(t,e){q.ttys[t]={input:[],output:[],ops:e},Z.registerDevice(t,q.stream_ops)},stream_ops:{open:function(t){var e=q.ttys[t.node.rdev];if(!e)throw new Z.ErrnoError(43);t.tty=e,t.seekable=!1},close:function(t){t.tty.ops.fsync(t.tty)},fsync:function(t){t.tty.ops.fsync(t.tty)},read:function(t,e,r,n,o){if(!t.tty||!t.tty.ops.get_char)throw new Z.ErrnoError(60);for(var i=0,a=0;a0&&(u(_(t.output,0)),t.output=[])}},default_tty1_ops:{put_char:function(t,e){null===e||10===e?(c(_(t.output,0)),t.output=[]):0!=e&&t.output.push(e)},fsync:function(t){t.output&&t.output.length>0&&(c(_(t.output,0)),t.output=[])}}};function T(t){t=function(t,e){return 65536*Math.ceil(t/65536)}(t);var e=wt(65536,t);return e?function(t,e){return m.fill(0,t,t+e),t}(e,t):0}var S={ops_table:null,mount:function(t){return S.createNode(null,"/",16895,0)},createNode:function(t,e,r,n){if(Z.isBlkdev(r)||Z.isFIFO(r))throw new Z.ErrnoError(63);S.ops_table||(S.ops_table={dir:{node:{getattr:S.node_ops.getattr,setattr:S.node_ops.setattr,lookup:S.node_ops.lookup,mknod:S.node_ops.mknod,rename:S.node_ops.rename,unlink:S.node_ops.unlink,rmdir:S.node_ops.rmdir,readdir:S.node_ops.readdir,symlink:S.node_ops.symlink},stream:{llseek:S.stream_ops.llseek}},file:{node:{getattr:S.node_ops.getattr,setattr:S.node_ops.setattr},stream:{llseek:S.stream_ops.llseek,read:S.stream_ops.read,write:S.stream_ops.write,allocate:S.stream_ops.allocate,mmap:S.stream_ops.mmap,msync:S.stream_ops.msync}},link:{node:{getattr:S.node_ops.getattr,setattr:S.node_ops.setattr,readlink:S.node_ops.readlink},stream:{}},chrdev:{node:{getattr:S.node_ops.getattr,setattr:S.node_ops.setattr},stream:Z.chrdev_stream_ops}});var o=Z.createNode(t,e,r,n);return Z.isDir(o.mode)?(o.node_ops=S.ops_table.dir.node,o.stream_ops=S.ops_table.dir.stream,o.contents={}):Z.isFile(o.mode)?(o.node_ops=S.ops_table.file.node,o.stream_ops=S.ops_table.file.stream,o.usedBytes=0,o.contents=null):Z.isLink(o.mode)?(o.node_ops=S.ops_table.link.node,o.stream_ops=S.ops_table.link.stream):Z.isChrdev(o.mode)&&(o.node_ops=S.ops_table.chrdev.node,o.stream_ops=S.ops_table.chrdev.stream),o.timestamp=Date.now(),t&&(t.contents[e]=o,t.timestamp=o.timestamp),o},getFileDataAsTypedArray:function(t){return t.contents?t.contents.subarray?t.contents.subarray(0,t.usedBytes):new Uint8Array(t.contents):new Uint8Array(0)},expandFileStorage:function(t,e){var r=t.contents?t.contents.length:0;if(!(r>=e)){e=Math.max(e,r*(r<1048576?2:1.125)>>>0),0!=r&&(e=Math.max(e,256));var n=t.contents;t.contents=new Uint8Array(e),t.usedBytes>0&&t.contents.set(n.subarray(0,t.usedBytes),0)}},resizeFileStorage:function(t,e){if(t.usedBytes!=e)if(0==e)t.contents=null,t.usedBytes=0;else{var r=t.contents;t.contents=new Uint8Array(e),r&&t.contents.set(r.subarray(0,Math.min(e,t.usedBytes))),t.usedBytes=e}},node_ops:{getattr:function(t){var e={};return e.dev=Z.isChrdev(t.mode)?t.id:1,e.ino=t.id,e.mode=t.mode,e.nlink=1,e.uid=0,e.gid=0,e.rdev=t.rdev,Z.isDir(t.mode)?e.size=4096:Z.isFile(t.mode)?e.size=t.usedBytes:Z.isLink(t.mode)?e.size=t.link.length:e.size=0,e.atime=new Date(t.timestamp),e.mtime=new Date(t.timestamp),e.ctime=new Date(t.timestamp),e.blksize=4096,e.blocks=Math.ceil(e.size/e.blksize),e},setattr:function(t,e){void 0!==e.mode&&(t.mode=e.mode),void 0!==e.timestamp&&(t.timestamp=e.timestamp),void 0!==e.size&&S.resizeFileStorage(t,e.size)},lookup:function(t,e){throw Z.genericErrors[44]},mknod:function(t,e,r,n){return S.createNode(t,e,r,n)},rename:function(t,e,r){if(Z.isDir(t.mode)){var n;try{n=Z.lookupNode(e,r)}catch(t){}if(n)for(var o in n.contents)throw new Z.ErrnoError(55)}delete t.parent.contents[t.name],t.parent.timestamp=Date.now(),t.name=r,e.contents[r]=t,e.timestamp=t.parent.timestamp,t.parent=e},unlink:function(t,e){delete t.contents[e],t.timestamp=Date.now()},rmdir:function(t,e){var r=Z.lookupNode(t,e);for(var n in r.contents)throw new Z.ErrnoError(55);delete t.contents[e],t.timestamp=Date.now()},readdir:function(t){var e=[".",".."];for(var r in t.contents)t.contents.hasOwnProperty(r)&&e.push(r);return e},symlink:function(t,e,r){var n=S.createNode(t,e,41471,0);return n.link=r,n},readlink:function(t){if(!Z.isLink(t.mode))throw new Z.ErrnoError(28);return t.link}},stream_ops:{read:function(t,e,r,n,o){var i=t.node.contents;if(o>=t.node.usedBytes)return 0;var a=Math.min(t.node.usedBytes-o,n);if(a>8&&i.subarray)e.set(i.subarray(o,o+a),r);else for(var s=0;s0||r+e{if(!(t=V.resolve(t)))return{path:"",node:null};if((e=Object.assign({follow_mount:!0,recurse_count:0},e)).recurse_count>8)throw new Z.ErrnoError(32);for(var r=t.split("/").filter((t=>!!t)),n=Z.root,o="/",i=0;i40)throw new Z.ErrnoError(32)}}return{path:o,node:n}},getPath:t=>{for(var e;;){if(Z.isRoot(t)){var r=t.mount.mountpoint;return e?"/"!==r[r.length-1]?r+"/"+e:r+e:r}e=e?t.name+"/"+e:t.name,t=t.parent}},hashName:(t,e)=>{for(var r=0,n=0;n>>0)%Z.nameTable.length},hashAddNode:t=>{var e=Z.hashName(t.parent.id,t.name);t.name_next=Z.nameTable[e],Z.nameTable[e]=t},hashRemoveNode:t=>{var e=Z.hashName(t.parent.id,t.name);if(Z.nameTable[e]===t)Z.nameTable[e]=t.name_next;else for(var r=Z.nameTable[e];r;){if(r.name_next===t){r.name_next=t.name_next;break}r=r.name_next}},lookupNode:(t,e)=>{var r=Z.mayLookup(t);if(r)throw new Z.ErrnoError(r,t);for(var n=Z.hashName(t.id,e),o=Z.nameTable[n];o;o=o.name_next){var i=o.name;if(o.parent.id===t.id&&i===e)return o}return Z.lookup(t,e)},createNode:(t,e,r,n)=>{var o=new Z.FSNode(t,e,r,n);return Z.hashAddNode(o),o},destroyNode:t=>{Z.hashRemoveNode(t)},isRoot:t=>t===t.parent,isMountpoint:t=>!!t.mounted,isFile:t=>32768==(61440&t),isDir:t=>16384==(61440&t),isLink:t=>40960==(61440&t),isChrdev:t=>8192==(61440&t),isBlkdev:t=>24576==(61440&t),isFIFO:t=>4096==(61440&t),isSocket:t=>49152==(49152&t),flagModes:{r:0,"r+":2,w:577,"w+":578,a:1089,"a+":1090},modeStringToFlags:t=>{var e=Z.flagModes[t];if(void 0===e)throw new Error("Unknown file open mode: "+t);return e},flagsToPermissionString:t=>{var e=["r","w","rw"][3&t];return 512&t&&(e+="w"),e},nodePermissions:(t,e)=>Z.ignorePermissions||(!e.includes("r")||292&t.mode)&&(!e.includes("w")||146&t.mode)&&(!e.includes("x")||73&t.mode)?0:2,mayLookup:t=>Z.nodePermissions(t,"x")||(t.node_ops.lookup?0:2),mayCreate:(t,e)=>{try{return Z.lookupNode(t,e),20}catch(t){}return Z.nodePermissions(t,"wx")},mayDelete:(t,e,r)=>{var n;try{n=Z.lookupNode(t,e)}catch(t){return t.errno}var o=Z.nodePermissions(t,"wx");if(o)return o;if(r){if(!Z.isDir(n.mode))return 54;if(Z.isRoot(n)||Z.getPath(n)===Z.cwd())return 10}else if(Z.isDir(n.mode))return 31;return 0},mayOpen:(t,e)=>t?Z.isLink(t.mode)?32:Z.isDir(t.mode)&&("r"!==Z.flagsToPermissionString(e)||512&e)?31:Z.nodePermissions(t,Z.flagsToPermissionString(e)):44,MAX_OPEN_FDS:4096,nextfd:(t=0,e=Z.MAX_OPEN_FDS)=>{for(var r=t;r<=e;r++)if(!Z.streams[r])return r;throw new Z.ErrnoError(33)},getStream:t=>Z.streams[t],createStream:(t,e,r)=>{Z.FSStream||(Z.FSStream=function(){this.shared={}},Z.FSStream.prototype={},Object.defineProperties(Z.FSStream.prototype,{object:{get:function(){return this.node},set:function(t){this.node=t}},isRead:{get:function(){return 1!=(2097155&this.flags)}},isWrite:{get:function(){return 0!=(2097155&this.flags)}},isAppend:{get:function(){return 1024&this.flags}},flags:{get:function(){return this.shared.flags},set:function(t){this.shared.flags=t}},position:{get:function(){return this.shared.position},set:function(t){this.shared.position=t}}})),t=Object.assign(new Z.FSStream,t);var n=Z.nextfd(e,r);return t.fd=n,Z.streams[n]=t,t},closeStream:t=>{Z.streams[t]=null},chrdev_stream_ops:{open:t=>{var e=Z.getDevice(t.node.rdev);t.stream_ops=e.stream_ops,t.stream_ops.open&&t.stream_ops.open(t)},llseek:()=>{throw new Z.ErrnoError(70)}},major:t=>t>>8,minor:t=>255&t,makedev:(t,e)=>t<<8|e,registerDevice:(t,e)=>{Z.devices[t]={stream_ops:e}},getDevice:t=>Z.devices[t],getMounts:t=>{for(var e=[],r=[t];r.length;){var n=r.pop();e.push(n),r.push.apply(r,n.mounts)}return e},syncfs:(t,e)=>{"function"==typeof t&&(e=t,t=!1),Z.syncFSRequests++,Z.syncFSRequests>1&&c("warning: "+Z.syncFSRequests+" FS.syncfs operations in flight at once, probably just doing extra work");var r=Z.getMounts(Z.root.mount),n=0;function o(t){return Z.syncFSRequests--,e(t)}function i(t){if(t)return i.errored?void 0:(i.errored=!0,o(t));++n>=r.length&&o(null)}r.forEach((e=>{if(!e.type.syncfs)return i(null);e.type.syncfs(e,t,i)}))},mount:(t,e,r)=>{var n,o="/"===r,i=!r;if(o&&Z.root)throw new Z.ErrnoError(10);if(!o&&!i){var a=Z.lookupPath(r,{follow_mount:!1});if(r=a.path,n=a.node,Z.isMountpoint(n))throw new Z.ErrnoError(10);if(!Z.isDir(n.mode))throw new Z.ErrnoError(54)}var s={type:t,opts:e,mountpoint:r,mounts:[]},u=t.mount(s);return u.mount=s,s.root=u,o?Z.root=u:n&&(n.mounted=s,n.mount&&n.mount.mounts.push(s)),u},unmount:t=>{var e=Z.lookupPath(t,{follow_mount:!1});if(!Z.isMountpoint(e.node))throw new Z.ErrnoError(28);var r=e.node,n=r.mounted,o=Z.getMounts(n);Object.keys(Z.nameTable).forEach((t=>{for(var e=Z.nameTable[t];e;){var r=e.name_next;o.includes(e.mount)&&Z.destroyNode(e),e=r}})),r.mounted=null;var i=r.mount.mounts.indexOf(n);r.mount.mounts.splice(i,1)},lookup:(t,e)=>t.node_ops.lookup(t,e),mknod:(t,e,r)=>{var n=Z.lookupPath(t,{parent:!0}).node,o=U.basename(t);if(!o||"."===o||".."===o)throw new Z.ErrnoError(28);var i=Z.mayCreate(n,o);if(i)throw new Z.ErrnoError(i);if(!n.node_ops.mknod)throw new Z.ErrnoError(63);return n.node_ops.mknod(n,o,e,r)},create:(t,e)=>(e=void 0!==e?e:438,e&=4095,e|=32768,Z.mknod(t,e,0)),mkdir:(t,e)=>(e=void 0!==e?e:511,e&=1023,e|=16384,Z.mknod(t,e,0)),mkdirTree:(t,e)=>{for(var r=t.split("/"),n="",o=0;o(void 0===r&&(r=e,e=438),e|=8192,Z.mknod(t,e,r)),symlink:(t,e)=>{if(!V.resolve(t))throw new Z.ErrnoError(44);var r=Z.lookupPath(e,{parent:!0}).node;if(!r)throw new Z.ErrnoError(44);var n=U.basename(e),o=Z.mayCreate(r,n);if(o)throw new Z.ErrnoError(o);if(!r.node_ops.symlink)throw new Z.ErrnoError(63);return r.node_ops.symlink(r,n,t)},rename:(t,e)=>{var r,n,o=U.dirname(t),i=U.dirname(e),a=U.basename(t),s=U.basename(e);if(r=Z.lookupPath(t,{parent:!0}).node,n=Z.lookupPath(e,{parent:!0}).node,!r||!n)throw new Z.ErrnoError(44);if(r.mount!==n.mount)throw new Z.ErrnoError(75);var u,c=Z.lookupNode(r,a),l=V.relative(t,i);if("."!==l.charAt(0))throw new Z.ErrnoError(28);if("."!==(l=V.relative(e,o)).charAt(0))throw new Z.ErrnoError(55);try{u=Z.lookupNode(n,s)}catch(t){}if(c!==u){var h=Z.isDir(c.mode),f=Z.mayDelete(r,a,h);if(f)throw new Z.ErrnoError(f);if(f=u?Z.mayDelete(n,s,h):Z.mayCreate(n,s))throw new Z.ErrnoError(f);if(!r.node_ops.rename)throw new Z.ErrnoError(63);if(Z.isMountpoint(c)||u&&Z.isMountpoint(u))throw new Z.ErrnoError(10);if(n!==r&&(f=Z.nodePermissions(r,"w")))throw new Z.ErrnoError(f);Z.hashRemoveNode(c);try{r.node_ops.rename(c,n,s)}catch(t){throw t}finally{Z.hashAddNode(c)}}},rmdir:t=>{var e=Z.lookupPath(t,{parent:!0}).node,r=U.basename(t),n=Z.lookupNode(e,r),o=Z.mayDelete(e,r,!0);if(o)throw new Z.ErrnoError(o);if(!e.node_ops.rmdir)throw new Z.ErrnoError(63);if(Z.isMountpoint(n))throw new Z.ErrnoError(10);e.node_ops.rmdir(e,r),Z.destroyNode(n)},readdir:t=>{var e=Z.lookupPath(t,{follow:!0}).node;if(!e.node_ops.readdir)throw new Z.ErrnoError(54);return e.node_ops.readdir(e)},unlink:t=>{var e=Z.lookupPath(t,{parent:!0}).node;if(!e)throw new Z.ErrnoError(44);var r=U.basename(t),n=Z.lookupNode(e,r),o=Z.mayDelete(e,r,!1);if(o)throw new Z.ErrnoError(o);if(!e.node_ops.unlink)throw new Z.ErrnoError(63);if(Z.isMountpoint(n))throw new Z.ErrnoError(10);e.node_ops.unlink(e,r),Z.destroyNode(n)},readlink:t=>{var e=Z.lookupPath(t).node;if(!e)throw new Z.ErrnoError(44);if(!e.node_ops.readlink)throw new Z.ErrnoError(28);return V.resolve(Z.getPath(e.parent),e.node_ops.readlink(e))},stat:(t,e)=>{var r=Z.lookupPath(t,{follow:!e}).node;if(!r)throw new Z.ErrnoError(44);if(!r.node_ops.getattr)throw new Z.ErrnoError(63);return r.node_ops.getattr(r)},lstat:t=>Z.stat(t,!0),chmod:(t,e,r)=>{var n;if(!(n="string"==typeof t?Z.lookupPath(t,{follow:!r}).node:t).node_ops.setattr)throw new Z.ErrnoError(63);n.node_ops.setattr(n,{mode:4095&e|-4096&n.mode,timestamp:Date.now()})},lchmod:(t,e)=>{Z.chmod(t,e,!0)},fchmod:(t,e)=>{var r=Z.getStream(t);if(!r)throw new Z.ErrnoError(8);Z.chmod(r.node,e)},chown:(t,e,r,n)=>{var o;if(!(o="string"==typeof t?Z.lookupPath(t,{follow:!n}).node:t).node_ops.setattr)throw new Z.ErrnoError(63);o.node_ops.setattr(o,{timestamp:Date.now()})},lchown:(t,e,r)=>{Z.chown(t,e,r,!0)},fchown:(t,e,r)=>{var n=Z.getStream(t);if(!n)throw new Z.ErrnoError(8);Z.chown(n.node,e,r)},truncate:(t,e)=>{if(e<0)throw new Z.ErrnoError(28);var r;if(!(r="string"==typeof t?Z.lookupPath(t,{follow:!0}).node:t).node_ops.setattr)throw new Z.ErrnoError(63);if(Z.isDir(r.mode))throw new Z.ErrnoError(31);if(!Z.isFile(r.mode))throw new Z.ErrnoError(28);var n=Z.nodePermissions(r,"w");if(n)throw new Z.ErrnoError(n);r.node_ops.setattr(r,{size:e,timestamp:Date.now()})},ftruncate:(t,e)=>{var r=Z.getStream(t);if(!r)throw new Z.ErrnoError(8);if(0==(2097155&r.flags))throw new Z.ErrnoError(28);Z.truncate(r.node,e)},utime:(t,e,r)=>{var n=Z.lookupPath(t,{follow:!0}).node;n.node_ops.setattr(n,{timestamp:Math.max(e,r)})},open:(t,e,r)=>{if(""===t)throw new Z.ErrnoError(44);var o;if(r=void 0===r?438:r,r=64&(e="string"==typeof e?Z.modeStringToFlags(e):e)?4095&r|32768:0,"object"==typeof t)o=t;else{t=U.normalize(t);try{o=Z.lookupPath(t,{follow:!(131072&e)}).node}catch(t){}}var i=!1;if(64&e)if(o){if(128&e)throw new Z.ErrnoError(20)}else o=Z.mknod(t,r,0),i=!0;if(!o)throw new Z.ErrnoError(44);if(Z.isChrdev(o.mode)&&(e&=-513),65536&e&&!Z.isDir(o.mode))throw new Z.ErrnoError(54);if(!i){var a=Z.mayOpen(o,e);if(a)throw new Z.ErrnoError(a)}512&e&&!i&&Z.truncate(o,0),e&=-131713;var s=Z.createStream({node:o,path:Z.getPath(o),flags:e,seekable:!0,position:0,stream_ops:o.stream_ops,ungotten:[],error:!1});return s.stream_ops.open&&s.stream_ops.open(s),!n.logReadFiles||1&e||(Z.readFiles||(Z.readFiles={}),t in Z.readFiles||(Z.readFiles[t]=1)),s},close:t=>{if(Z.isClosed(t))throw new Z.ErrnoError(8);t.getdents&&(t.getdents=null);try{t.stream_ops.close&&t.stream_ops.close(t)}catch(t){throw t}finally{Z.closeStream(t.fd)}t.fd=null},isClosed:t=>null===t.fd,llseek:(t,e,r)=>{if(Z.isClosed(t))throw new Z.ErrnoError(8);if(!t.seekable||!t.stream_ops.llseek)throw new Z.ErrnoError(70);if(0!=r&&1!=r&&2!=r)throw new Z.ErrnoError(28);return t.position=t.stream_ops.llseek(t,e,r),t.ungotten=[],t.position},read:(t,e,r,n,o)=>{if(n<0||o<0)throw new Z.ErrnoError(28);if(Z.isClosed(t))throw new Z.ErrnoError(8);if(1==(2097155&t.flags))throw new Z.ErrnoError(8);if(Z.isDir(t.node.mode))throw new Z.ErrnoError(31);if(!t.stream_ops.read)throw new Z.ErrnoError(28);var i=void 0!==o;if(i){if(!t.seekable)throw new Z.ErrnoError(70)}else o=t.position;var a=t.stream_ops.read(t,e,r,n,o);return i||(t.position+=a),a},write:(t,e,r,n,o,i)=>{if(n<0||o<0)throw new Z.ErrnoError(28);if(Z.isClosed(t))throw new Z.ErrnoError(8);if(0==(2097155&t.flags))throw new Z.ErrnoError(8);if(Z.isDir(t.node.mode))throw new Z.ErrnoError(31);if(!t.stream_ops.write)throw new Z.ErrnoError(28);t.seekable&&1024&t.flags&&Z.llseek(t,0,2);var a=void 0!==o;if(a){if(!t.seekable)throw new Z.ErrnoError(70)}else o=t.position;var s=t.stream_ops.write(t,e,r,n,o,i);return a||(t.position+=s),s},allocate:(t,e,r)=>{if(Z.isClosed(t))throw new Z.ErrnoError(8);if(e<0||r<=0)throw new Z.ErrnoError(28);if(0==(2097155&t.flags))throw new Z.ErrnoError(8);if(!Z.isFile(t.node.mode)&&!Z.isDir(t.node.mode))throw new Z.ErrnoError(43);if(!t.stream_ops.allocate)throw new Z.ErrnoError(138);t.stream_ops.allocate(t,e,r)},mmap:(t,e,r,n,o)=>{if(0!=(2&n)&&0==(2&o)&&2!=(2097155&t.flags))throw new Z.ErrnoError(2);if(1==(2097155&t.flags))throw new Z.ErrnoError(2);if(!t.stream_ops.mmap)throw new Z.ErrnoError(43);return t.stream_ops.mmap(t,e,r,n,o)},msync:(t,e,r,n,o)=>t.stream_ops.msync?t.stream_ops.msync(t,e,r,n,o):0,munmap:t=>0,ioctl:(t,e,r)=>{if(!t.stream_ops.ioctl)throw new Z.ErrnoError(59);return t.stream_ops.ioctl(t,e,r)},readFile:(t,e={})=>{if(e.flags=e.flags||0,e.encoding=e.encoding||"binary","utf8"!==e.encoding&&"binary"!==e.encoding)throw new Error('Invalid encoding type "'+e.encoding+'"');var r,n=Z.open(t,e.flags),o=Z.stat(t).size,i=new Uint8Array(o);return Z.read(n,i,0,o,0),"utf8"===e.encoding?r=_(i,0):"binary"===e.encoding&&(r=i),Z.close(n),r},writeFile:(t,e,r={})=>{r.flags=r.flags||577;var n=Z.open(t,r.flags,r.mode);if("string"==typeof e){var o=new Uint8Array(M(e)+1),i=b(e,o,0,o.length);Z.write(n,o,0,i,void 0,r.canOwn)}else{if(!ArrayBuffer.isView(e))throw new Error("Unsupported data type");Z.write(n,e,0,e.byteLength,void 0,r.canOwn)}Z.close(n)},cwd:()=>Z.currentPath,chdir:t=>{var e=Z.lookupPath(t,{follow:!0});if(null===e.node)throw new Z.ErrnoError(44);if(!Z.isDir(e.node.mode))throw new Z.ErrnoError(54);var r=Z.nodePermissions(e.node,"x");if(r)throw new Z.ErrnoError(r);Z.currentPath=e.path},createDefaultDirectories:()=>{Z.mkdir("/tmp"),Z.mkdir("/home"),Z.mkdir("/home/web_user")},createDefaultDevices:()=>{Z.mkdir("/dev"),Z.registerDevice(Z.makedev(1,3),{read:()=>0,write:(t,e,r,n,o)=>n}),Z.mkdev("/dev/null",Z.makedev(1,3)),q.register(Z.makedev(5,0),q.default_tty_ops),q.register(Z.makedev(6,0),q.default_tty1_ops),Z.mkdev("/dev/tty",Z.makedev(5,0)),Z.mkdev("/dev/tty1",Z.makedev(6,0));var t=function(){if("object"==typeof crypto&&"function"==typeof crypto.getRandomValues){var t=new Uint8Array(1);return()=>(crypto.getRandomValues(t),t[0])}return()=>H("randomDevice")}();Z.createDevice("/dev","random",t),Z.createDevice("/dev","urandom",t),Z.mkdir("/dev/shm"),Z.mkdir("/dev/shm/tmp")},createSpecialDirectories:()=>{Z.mkdir("/proc");var t=Z.mkdir("/proc/self");Z.mkdir("/proc/self/fd"),Z.mount({mount:()=>{var e=Z.createNode(t,"fd",16895,73);return e.node_ops={lookup:(t,e)=>{var r=+e,n=Z.getStream(r);if(!n)throw new Z.ErrnoError(8);var o={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>n.path}};return o.parent=o,o}},e}},{},"/proc/self/fd")},createStandardStreams:()=>{n.stdin?Z.createDevice("/dev","stdin",n.stdin):Z.symlink("/dev/tty","/dev/stdin"),n.stdout?Z.createDevice("/dev","stdout",null,n.stdout):Z.symlink("/dev/tty","/dev/stdout"),n.stderr?Z.createDevice("/dev","stderr",null,n.stderr):Z.symlink("/dev/tty1","/dev/stderr"),Z.open("/dev/stdin",0),Z.open("/dev/stdout",1),Z.open("/dev/stderr",1)},ensureErrnoError:()=>{Z.ErrnoError||(Z.ErrnoError=function(t,e){this.node=e,this.setErrno=function(t){this.errno=t},this.setErrno(t),this.message="FS error"},Z.ErrnoError.prototype=new Error,Z.ErrnoError.prototype.constructor=Z.ErrnoError,[44].forEach((t=>{Z.genericErrors[t]=new Z.ErrnoError(t),Z.genericErrors[t].stack=""})))},staticInit:()=>{Z.ensureErrnoError(),Z.nameTable=new Array(4096),Z.mount(S,{},"/"),Z.createDefaultDirectories(),Z.createDefaultDevices(),Z.createSpecialDirectories(),Z.filesystems={MEMFS:S}},init:(t,e,r)=>{Z.init.initialized=!0,Z.ensureErrnoError(),n.stdin=t||n.stdin,n.stdout=e||n.stdout,n.stderr=r||n.stderr,Z.createStandardStreams()},quit:()=>{Z.init.initialized=!1;for(var t=0;t{var r=0;return t&&(r|=365),e&&(r|=146),r},findObject:(t,e)=>{var r=Z.analyzePath(t,e);return r.exists?r.object:null},analyzePath:(t,e)=>{try{t=(n=Z.lookupPath(t,{follow:!e})).path}catch(t){}var r={isRoot:!1,exists:!1,error:0,name:null,path:null,object:null,parentExists:!1,parentPath:null,parentObject:null};try{var n=Z.lookupPath(t,{parent:!0});r.parentExists=!0,r.parentPath=n.path,r.parentObject=n.node,r.name=U.basename(t),n=Z.lookupPath(t,{follow:!e}),r.exists=!0,r.path=n.path,r.object=n.node,r.name=n.node.name,r.isRoot="/"===n.path}catch(t){r.error=t.errno}return r},createPath:(t,e,r,n)=>{t="string"==typeof t?t:Z.getPath(t);for(var o=e.split("/").reverse();o.length;){var i=o.pop();if(i){var a=U.join2(t,i);try{Z.mkdir(a)}catch(t){}t=a}}return a},createFile:(t,e,r,n,o)=>{var i=U.join2("string"==typeof t?t:Z.getPath(t),e),a=Z.getMode(n,o);return Z.create(i,a)},createDataFile:(t,e,r,n,o,i)=>{var a=e;t&&(t="string"==typeof t?t:Z.getPath(t),a=e?U.join2(t,e):t);var s=Z.getMode(n,o),u=Z.create(a,s);if(r){if("string"==typeof r){for(var c=new Array(r.length),l=0,h=r.length;l{var o=U.join2("string"==typeof t?t:Z.getPath(t),e),i=Z.getMode(!!r,!!n);Z.createDevice.major||(Z.createDevice.major=64);var a=Z.makedev(Z.createDevice.major++,0);return Z.registerDevice(a,{open:t=>{t.seekable=!1},close:t=>{n&&n.buffer&&n.buffer.length&&n(10)},read:(t,e,n,o,i)=>{for(var a=0,s=0;s{for(var a=0;a{if(t.isDevice||t.isFolder||t.link||t.contents)return!0;throw"undefined"!=typeof XMLHttpRequest?new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."):new Error("Cannot load without read() or XMLHttpRequest.")},createLazyFile:(t,e,r,n,o)=>{if("undefined"!=typeof XMLHttpRequest)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var i={isDevice:!1,url:r},a=Z.createFile(t,e,i,n,o);i.contents?a.contents=i.contents:i.url&&(a.contents=null,a.url=i.url),Object.defineProperties(a,{usedBytes:{get:function(){return this.contents.length}}});var s={};function u(t,e,r,n,o){var i=t.node.contents;if(o>=i.length)return 0;var a=Math.min(i.length-o,n);if(i.slice)for(var s=0;s{var e=a.stream_ops[t];s[t]=function(){return Z.forceLoadFile(a),e.apply(null,arguments)}})),s.read=(t,e,r,n,o)=>(Z.forceLoadFile(a),u(t,e,r,n,o)),s.mmap=(t,e,r,n,o)=>{Z.forceLoadFile(a);var i=T(e);if(!i)throw new Z.ErrnoError(48);return u(t,v,i,e,r),{ptr:i,allocated:!0}},a.stream_ops=s,a},createPreloadedFile:(t,e,r,n,o,i,a,s,u,c)=>{var l=e?V.resolve(U.join2(t,e)):t;function h(r){function h(r){c&&c(),s||Z.createDataFile(t,e,r,n,o,u),i&&i(),z()}Browser.handledByPreloadPlugin(r,l,h,(()=>{a&&a(),z()}))||h(r)}C(),"string"==typeof r?function(t,e,r,n){var o="al "+t;(void 0)(t,(e=>{d(e,'Loading data file "'+t+'" failed (no arrayBuffer).'),(t=>{h(t)})(new Uint8Array(e)),o&&z()}),(e=>{if(!r)throw'Loading data file "'+t+'" failed.';r()})),o&&C()}(r,0,a):h(r)},indexedDB:()=>window.indexedDB||window.mozIndexedDB||window.webkitIndexedDB||window.msIndexedDB,DB_NAME:()=>"EM_FS_"+window.location.pathname,DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:(t,e,r)=>{e=e||(()=>{}),r=r||(()=>{});var n=Z.indexedDB();try{var o=n.open(Z.DB_NAME(),Z.DB_VERSION)}catch(t){return r(t)}o.onupgradeneeded=()=>{u("creating db"),o.result.createObjectStore(Z.DB_STORE_NAME)},o.onsuccess=()=>{var n=o.result.transaction([Z.DB_STORE_NAME],"readwrite"),i=n.objectStore(Z.DB_STORE_NAME),a=0,s=0,u=t.length;function c(){0==s?e():r()}t.forEach((t=>{var e=i.put(Z.analyzePath(t).object.contents,t);e.onsuccess=()=>{++a+s==u&&c()},e.onerror=()=>{s++,a+s==u&&c()}})),n.onerror=r},o.onerror=r},loadFilesFromDB:(t,e,r)=>{e=e||(()=>{}),r=r||(()=>{});var n=Z.indexedDB();try{var o=n.open(Z.DB_NAME(),Z.DB_VERSION)}catch(t){return r(t)}o.onupgradeneeded=r,o.onsuccess=()=>{var n=o.result;try{var i=n.transaction([Z.DB_STORE_NAME],"readonly")}catch(t){return void r(t)}var a=i.objectStore(Z.DB_STORE_NAME),s=0,u=0,c=t.length;function l(){0==u?e():r()}t.forEach((t=>{var e=a.get(t);e.onsuccess=()=>{Z.analyzePath(t).exists&&Z.unlink(t),Z.createDataFile(U.dirname(t),U.basename(t),e.result,!0,!0,!0),++s+u==c&&l()},e.onerror=()=>{u++,s+u==c&&l()}})),i.onerror=r},o.onerror=r}},J={DEFAULT_POLLMASK:5,calculateAt:function(t,e,r){if(U.isAbs(e))return e;var n;if(n=-100===t?Z.cwd():J.getStreamFromFD(t).path,0==e.length){if(!r)throw new Z.ErrnoError(44);return n}return U.join2(n,e)},doStat:function(t,e,r){try{var n=t(e)}catch(t){if(t&&t.node&&U.normalize(e)!==U.normalize(Z.getPath(t.node)))return-54;throw t}y[r>>2]=n.dev,y[r+8>>2]=n.ino,y[r+12>>2]=n.mode,g[r+16>>2]=n.nlink,y[r+20>>2]=n.uid,y[r+24>>2]=n.gid,y[r+28>>2]=n.rdev,X=[n.size>>>0,(I=n.size,+Math.abs(I)>=1?I>0?(0|Math.min(+Math.floor(I/4294967296),4294967295))>>>0:~~+Math.ceil((I-+(~~I>>>0))/4294967296)>>>0:0)],y[r+40>>2]=X[0],y[r+44>>2]=X[1],y[r+48>>2]=4096,y[r+52>>2]=n.blocks;var o=n.atime.getTime(),i=n.mtime.getTime(),a=n.ctime.getTime();return X=[Math.floor(o/1e3)>>>0,(I=Math.floor(o/1e3),+Math.abs(I)>=1?I>0?(0|Math.min(+Math.floor(I/4294967296),4294967295))>>>0:~~+Math.ceil((I-+(~~I>>>0))/4294967296)>>>0:0)],y[r+56>>2]=X[0],y[r+60>>2]=X[1],g[r+64>>2]=o%1e3*1e3,X=[Math.floor(i/1e3)>>>0,(I=Math.floor(i/1e3),+Math.abs(I)>=1?I>0?(0|Math.min(+Math.floor(I/4294967296),4294967295))>>>0:~~+Math.ceil((I-+(~~I>>>0))/4294967296)>>>0:0)],y[r+72>>2]=X[0],y[r+76>>2]=X[1],g[r+80>>2]=i%1e3*1e3,X=[Math.floor(a/1e3)>>>0,(I=Math.floor(a/1e3),+Math.abs(I)>=1?I>0?(0|Math.min(+Math.floor(I/4294967296),4294967295))>>>0:~~+Math.ceil((I-+(~~I>>>0))/4294967296)>>>0:0)],y[r+88>>2]=X[0],y[r+92>>2]=X[1],g[r+96>>2]=a%1e3*1e3,X=[n.ino>>>0,(I=n.ino,+Math.abs(I)>=1?I>0?(0|Math.min(+Math.floor(I/4294967296),4294967295))>>>0:~~+Math.ceil((I-+(~~I>>>0))/4294967296)>>>0:0)],y[r+104>>2]=X[0],y[r+108>>2]=X[1],0},doMsync:function(t,e,r,n,o){if(!Z.isFile(e.node.mode))throw new Z.ErrnoError(43);if(2&n)return 0;var i=m.slice(t,t+r);Z.msync(e,i,o,r,n)},varargs:void 0,get:function(){return J.varargs+=4,y[J.varargs-4>>2]},getStr:function(t){return D(t)},getStreamFromFD:function(t){var e=Z.getStream(t);if(!e)throw new Z.ErrnoError(8);return e}},$=[];function A(t){try{return l.grow(t-p.byteLength+65535>>>16),L(l.buffer),1}catch(t){}}var tt={};function et(){if(!et.strings){var t={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"==typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:a||"./this.program"};for(var e in tt)void 0===tt[e]?delete t[e]:t[e]=tt[e];var r=[];for(var e in t)r.push(e+"="+t[e]);et.strings=r}return et.strings}function rt(t){return t%4==0&&(t%100!=0||t%400==0)}var nt=[31,29,31,30,31,30,31,31,30,31,30,31],ot=[31,28,31,30,31,30,31,31,30,31,30,31];var it=function(t,e,r,n){t||(t=this),this.parent=t,this.mount=t.mount,this.mounted=null,this.id=Z.nextInode++,this.name=e,this.mode=r,this.node_ops={},this.stream_ops={},this.rdev=n};Object.defineProperties(it.prototype,{read:{get:function(){return 365==(365&this.mode)},set:function(t){t?this.mode|=365:this.mode&=-366}},write:{get:function(){return 146==(146&this.mode)},set:function(t){t?this.mode|=146:this.mode&=-147}},isFolder:{get:function(){return Z.isDir(this.mode)}},isDevice:{get:function(){return Z.isChrdev(this.mode)}}}),Z.FSNode=it,Z.staticInit();var at={b:function(t,e,r){throw new R(t).init(e,r),t},l:function(t,e,r,n){try{if(e=J.getStr(e),e=J.calculateAt(t,e),-8&r)return-28;var o=Z.lookupPath(e,{follow:!0}).node;if(!o)return-44;var i="";return 4&r&&(i+="r"),2&r&&(i+="w"),1&r&&(i+="x"),i&&Z.nodePermissions(o,i)?-2:0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},i:function(t,e,r){J.varargs=r;try{var n=J.getStreamFromFD(t);switch(e){case 0:return(o=J.get())<0?-28:Z.createStream(n,o).fd;case 1:case 2:case 6:case 7:return 0;case 3:return n.flags;case 4:var o=J.get();return n.flags|=o,0;case 5:return o=J.get(),w[o+0>>1]=2,0;case 16:case 8:default:return-28;case 9:return 28,y[mt()>>2]=28,-1}}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},w:function(t,e){try{var r=J.getStreamFromFD(t);return J.doStat(Z.stat,r.path,e)}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},x:function(t,e,r){J.varargs=r;try{var n=J.getStreamFromFD(t);switch(e){case 21509:case 21505:case 21510:case 21511:case 21512:case 21506:case 21507:case 21508:case 21523:case 21524:return n.tty?0:-59;case 21519:if(!n.tty)return-59;var o=J.get();return y[o>>2]=0,0;case 21520:return n.tty?-28:-59;case 21531:return o=J.get(),Z.ioctl(n,e,o);default:return-28}}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},u:function(t,e,r,n){try{e=J.getStr(e);var o=256&n,i=4096&n;return n&=-6401,e=J.calculateAt(t,e,i),J.doStat(o?Z.lstat:Z.stat,e,r)}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},d:function(t,e,r,n){J.varargs=n;try{e=J.getStr(e),e=J.calculateAt(t,e);var o=n?J.get():0;return Z.open(e,r,o).fd}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},v:function(t,e){try{return t=J.getStr(t),J.doStat(Z.stat,t,e)}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},p:function(t,e,r){try{return e=J.getStr(e),e=J.calculateAt(t,e),0===r?Z.unlink(e):512===r?Z.rmdir(e):H("Invalid flags passed to unlinkat"),0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},j:function(){return!0},q:function(t,e,r,n,o,i,a){try{var s=J.getStreamFromFD(n),u=Z.mmap(s,t,o,e,r),c=u.ptr;return y[i>>2]=u.allocated,g[a>>2]=c,0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},r:function(t,e,r,n,o,i){try{var a=J.getStreamFromFD(o);2&r&&J.doMsync(t,a,e,n,i),Z.munmap(a)}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return-t.errno}},a:function(){H("")},y:function(t,e,r){return function(t,e,r){var n=function(t,e){var r;for($.length=0,e>>=2;r=m[t++];)e+=105!=r&e,$.push(105==r?y[e]:E[e++>>1]),++e;return $}(e,r);return W[t].apply(null,n)}(t,e,r)},e:function(){return Date.now()},k:function(t,e,r){m.copyWithin(t,e,e+r)},o:function(t){var e,r=m.length,n=2147483648;if((t>>>=0)>n)return!1;for(var o=1;o<=4;o*=2){var i=r*(1+.2/o);if(i=Math.min(i,t+100663296),A(Math.min(n,(e=Math.max(t,i))+(65536-e%65536)%65536)))return!0}return!1},s:function(t,e){var r=0;return et().forEach((function(n,o){var i=e+r;g[t+4*o>>2]=i,function(t,e,r){for(var n=0;n>0]=t.charCodeAt(n);v[e>>0]=0}(n,i),r+=n.length+1})),0},t:function(t,e){var r=et();g[t>>2]=r.length;var n=0;return r.forEach((function(t){n+=t.length+1})),g[e>>2]=n,0},f:function(t,e){!function(t){h||(n.onExit&&n.onExit(t),f=!0),s(t,new Y(t))}(t)},c:function(t){try{var e=J.getStreamFromFD(t);return Z.close(e),0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return t.errno}},g:function(t,e,r,n){try{var o=function(t,e,r,n){for(var o=0,i=0;i>2],s=g[e+4>>2];e+=8;var u=Z.read(t,v,a,s,undefined);if(u<0)return-1;if(o+=u,u>2]=o,0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return t.errno}},m:function(t,e,r,n,o){try{var i=(u=r)+2097152>>>0<4194305-!!(s=e)?(s>>>0)+4294967296*u:NaN;if(isNaN(i))return 61;var a=J.getStreamFromFD(t);return Z.llseek(a,i,n),X=[a.position>>>0,(I=a.position,+Math.abs(I)>=1?I>0?(0|Math.min(+Math.floor(I/4294967296),4294967295))>>>0:~~+Math.ceil((I-+(~~I>>>0))/4294967296)>>>0:0)],y[o>>2]=X[0],y[o+4>>2]=X[1],a.getdents&&0===i&&0===n&&(a.getdents=null),0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return t.errno}var s,u},h:function(t,e,r,n){try{var o=function(t,e,r,n){for(var o=0,i=0;i>2],s=g[e+4>>2];e+=8;var u=Z.write(t,v,a,s,undefined);if(u<0)return-1;o+=u}return o}(J.getStreamFromFD(t),e,r);return g[n>>2]=o,0}catch(t){if(void 0===Z||!(t instanceof Z.ErrnoError))throw t;return t.errno}},n:function(t,e,r,n,o){return function(t,e,r,n){var o=y[n+40>>2],i={tm_sec:y[n>>2],tm_min:y[n+4>>2],tm_hour:y[n+8>>2],tm_mday:y[n+12>>2],tm_mon:y[n+16>>2],tm_year:y[n+20>>2],tm_wday:y[n+24>>2],tm_yday:y[n+28>>2],tm_isdst:y[n+32>>2],tm_gmtoff:y[n+36>>2],tm_zone:o?D(o):""},a=D(r),s={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var u in s)a=a.replace(new RegExp(u,"g"),s[u]);var c=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],l=["January","February","March","April","May","June","July","August","September","October","November","December"];function h(t,e,r){for(var n="number"==typeof t?t.toString():t||"";n.length0?1:0}var n;return 0===(n=r(t.getFullYear()-e.getFullYear()))&&0===(n=r(t.getMonth()-e.getMonth()))&&(n=r(t.getDate()-e.getDate())),n}function p(t){switch(t.getDay()){case 0:return new Date(t.getFullYear()-1,11,29);case 1:return t;case 2:return new Date(t.getFullYear(),0,3);case 3:return new Date(t.getFullYear(),0,2);case 4:return new Date(t.getFullYear(),0,1);case 5:return new Date(t.getFullYear()-1,11,31);case 6:return new Date(t.getFullYear()-1,11,30)}}function m(t){var e=function(t,e){for(var r=new Date(t.getTime());e>0;){var n=rt(r.getFullYear()),o=r.getMonth(),i=(n?nt:ot)[o];if(!(e>i-r.getDate()))return r.setDate(r.getDate()+e),r;e-=i-r.getDate()+1,r.setDate(1),o<11?r.setMonth(o+1):(r.setMonth(0),r.setFullYear(r.getFullYear()+1))}return r}(new Date(t.tm_year+1900,0,1),t.tm_yday),r=new Date(e.getFullYear(),0,4),n=new Date(e.getFullYear()+1,0,4),o=p(r),i=p(n);return d(o,e)<=0?d(i,e)<=0?e.getFullYear()+1:e.getFullYear():e.getFullYear()-1}var w={"%a":function(t){return c[t.tm_wday].substring(0,3)},"%A":function(t){return c[t.tm_wday]},"%b":function(t){return l[t.tm_mon].substring(0,3)},"%B":function(t){return l[t.tm_mon]},"%C":function(t){return f((t.tm_year+1900)/100|0,2)},"%d":function(t){return f(t.tm_mday,2)},"%e":function(t){return h(t.tm_mday,2," ")},"%g":function(t){return m(t).toString().substring(2)},"%G":function(t){return m(t)},"%H":function(t){return f(t.tm_hour,2)},"%I":function(t){var e=t.tm_hour;return 0==e?e=12:e>12&&(e-=12),f(e,2)},"%j":function(t){return f(t.tm_mday+function(t,e){for(var r=0,n=0;n<=e;r+=t[n++]);return r}(rt(t.tm_year+1900)?nt:ot,t.tm_mon-1),3)},"%m":function(t){return f(t.tm_mon+1,2)},"%M":function(t){return f(t.tm_min,2)},"%n":function(){return"\n"},"%p":function(t){return t.tm_hour>=0&&t.tm_hour<12?"AM":"PM"},"%S":function(t){return f(t.tm_sec,2)},"%t":function(){return"\t"},"%u":function(t){return t.tm_wday||7},"%U":function(t){var e=t.tm_yday+7-t.tm_wday;return f(Math.floor(e/7),2)},"%V":function(t){var e=Math.floor((t.tm_yday+7-(t.tm_wday+6)%7)/7);if((t.tm_wday+371-t.tm_yday-2)%7<=2&&e++,e){if(53==e){var r=(t.tm_wday+371-t.tm_yday)%7;4==r||3==r&&rt(t.tm_year)||(e=1)}}else{e=52;var n=(t.tm_wday+7-t.tm_yday-1)%7;(4==n||5==n&&rt(t.tm_year%400-1))&&e++}return f(e,2)},"%w":function(t){return t.tm_wday},"%W":function(t){var e=t.tm_yday+7-(t.tm_wday+6)%7;return f(Math.floor(e/7),2)},"%y":function(t){return(t.tm_year+1900).toString().substring(2)},"%Y":function(t){return t.tm_year+1900},"%z":function(t){var e=t.tm_gmtoff,r=e>=0;return e=(e=Math.abs(e)/60)/60*100+e%60,(r?"+":"-")+String("0000"+e).slice(-4)},"%Z":function(t){return t.tm_zone},"%%":function(){return"%"}};for(var u in a=a.replace(/%%/g,"\0\0"),w)a.includes(u)&&(a=a.replace(new RegExp(u,"g"),w[u](i)));var g=j(a=a.replace(/\0\0/g,"%"),!1);return g.length>e?0:(function(t,e){v.set(t,e)}(g,t),g.length-1)}(t,e,r,n)}};!function(){var t={a:at};function e(t,e){var r,o=t.exports;n.asm=o,L((l=n.asm.z).buffer),n.asm.J,r=n.asm.A,K.unshift(r),z()}function i(t){e(t.instance)}function a(e){return Promise.resolve().then((function(){return function(t){try{if(t==x&&o)return new Uint8Array(o);throw"both async and sync fetching of the wasm failed"}catch(t){H(t)}}(x)})).then((function(e){return WebAssembly.instantiate(e,t)})).then((function(t){return t})).then(e,(function(t){c("failed to asynchronously prepare wasm: "+t),H(t)}))}if(C(),n.instantiateWasm)try{return n.instantiateWasm(t,e)}catch(t){c("Module.instantiateWasm callback failed with error: "+t),r(t)}(o||"function"!=typeof WebAssembly.instantiateStreaming||k(x)||function(t){return t.startsWith("file://")}(x)||"function"!=typeof fetch?a(i):fetch(x,{credentials:"same-origin"}).then((function(e){return WebAssembly.instantiateStreaming(e,t).then(i,(function(t){return c("wasm streaming compile failed: "+t),c("falling back to ArrayBuffer instantiation"),a(i)}))}))).catch(r)}(),n.___wasm_call_ctors=function(){return(n.___wasm_call_ctors=n.asm.A).apply(null,arguments)};var st=n._emscripten_bind_VoidPtr___destroy___0=function(){return(st=n._emscripten_bind_VoidPtr___destroy___0=n.asm.B).apply(null,arguments)},ut=n._emscripten_bind_Graphviz_Graphviz_2=function(){return(ut=n._emscripten_bind_Graphviz_Graphviz_2=n.asm.C).apply(null,arguments)},ct=n._emscripten_bind_Graphviz_version_0=function(){return(ct=n._emscripten_bind_Graphviz_version_0=n.asm.D).apply(null,arguments)},lt=n._emscripten_bind_Graphviz_lastError_0=function(){return(lt=n._emscripten_bind_Graphviz_lastError_0=n.asm.E).apply(null,arguments)},ht=n._emscripten_bind_Graphviz_createFile_2=function(){return(ht=n._emscripten_bind_Graphviz_createFile_2=n.asm.F).apply(null,arguments)},ft=n._emscripten_bind_Graphviz_lastResult_0=function(){return(ft=n._emscripten_bind_Graphviz_lastResult_0=n.asm.G).apply(null,arguments)},dt=n._emscripten_bind_Graphviz_layout_3=function(){return(dt=n._emscripten_bind_Graphviz_layout_3=n.asm.H).apply(null,arguments)},pt=n._emscripten_bind_Graphviz___destroy___0=function(){return(pt=n._emscripten_bind_Graphviz___destroy___0=n.asm.I).apply(null,arguments)};n._free=function(){return(n._free=n.asm.K).apply(null,arguments)},n._malloc=function(){return(n._malloc=n.asm.L).apply(null,arguments)};var vt,mt=n.___errno_location=function(){return(mt=n.___errno_location=n.asm.M).apply(null,arguments)},wt=n._emscripten_builtin_memalign=function(){return(wt=n._emscripten_builtin_memalign=n.asm.N).apply(null,arguments)},yt=n.___cxa_is_pointer_type=function(){return(yt=n.___cxa_is_pointer_type=n.asm.O).apply(null,arguments)};function gt(t){function r(){vt||(vt=!0,n.calledRun=!0,f||(n.noFSInit||Z.init.initialized||Z.init(),Z.ignorePermissions=!1,Q(K),e(n),n.onRuntimeInitialized&&n.onRuntimeInitialized(),function(){if(n.postRun)for("function"==typeof n.postRun&&(n.postRun=[n.postRun]);n.postRun.length;)t=n.postRun.shift(),O.unshift(t);var t;Q(O)}()))}N>0||(function(){if(n.preRun)for("function"==typeof n.preRun&&(n.preRun=[n.preRun]);n.preRun.length;)t=n.preRun.shift(),P.unshift(t);var t;Q(P)}(),N>0||(n.setStatus?(n.setStatus("Running..."),setTimeout((function(){setTimeout((function(){n.setStatus("")}),1),r()}),1)):r()))}if(n.___start_em_js=175828,n.___stop_em_js=175926,F=function t(){vt||gt(),vt||(F=t)},n.preInit)for("function"==typeof n.preInit&&(n.preInit=[n.preInit]);n.preInit.length>0;)n.preInit.pop()();function Et(){}function Bt(t){return(t||Et).__cache__}function _t(t,e){var r=Bt(e),n=r[t];return n||((n=Object.create((e||Et).prototype)).ptr=t,r[t]=n)}gt(),Et.prototype=Object.create(Et.prototype),Et.prototype.constructor=Et,Et.prototype.__class__=Et,Et.__cache__={},n.WrapperObject=Et,n.getCache=Bt,n.wrapPointer=_t,n.castObject=function(t,e){return _t(t.ptr,e)},n.NULL=_t(0),n.destroy=function(t){if(!t.__destroy__)throw"Error: Cannot destroy object. (Did you create it yourself?)";t.__destroy__(),delete Bt(t.__class__)[t.ptr]},n.compare=function(t,e){return t.ptr===e.ptr},n.getPointer=function(t){return t.ptr},n.getClass=function(t){return t.__class__};var Dt={buffer:0,size:0,pos:0,temps:[],needed:0,prepare:function(){if(Dt.needed){for(var t=0;t=Dt.size?(d(i>0),Dt.needed+=i,r=n._malloc(i),Dt.temps.push(r)):(r=Dt.buffer+Dt.pos,Dt.pos+=i),r},copy:function(t,e,r){switch(r>>>=0,e.BYTES_PER_ELEMENT){case 2:r>>>=1;break;case 4:r>>>=2;break;case 8:r>>>=3}for(var n=0;n\n\n88?13:14;do{r.push(255&n),n>>=8,o-=8}while(o>7);i=-1}}return i>-1&&r.push(255&(n|i<yKma:K`2htz8{/[.%Y+NAE>irU/?_Jh^Mi}V"~fyzS!(1y6%S]bqhFhw>~~ru@^Pac7~N4n9BkOjcZ=F8N$wB"s]in]%TG^=JD4LbgN,W+6`U7*)pj$2.G]B|XW)2S?0rH=FxUAWJwiE"zuZf0)RB~2Kbe?RKFBe3x;7LRO}f;59gq/YW)HPgVatkoCgRYB]qyBP44~o?mC@BZr%MLYT8>uCQ`Qy%m=N83JxW2TX@"]ah^ts!Mf5/<9bEMAkYr,#@?xH[aM9*mML}1!E~r+Z_g]5OPi/Ix@F;ecR~7~3V}L0|BH>#LiJcaQNj*Y8Ub^4oqp]&?s_;k*>N/3xmVhp8|C1sZOoZ8Uo8wp9lx?J$,!m>B$/)B94JH30/bf.pr<A2d_,&S_t9l?2CQ#YpcSeMAPA8HhZ1;^ag?RIN&KXJjIxHPdmwYKpu(/}bZ_,&x]Jj+9}&{DAuHr8EbEx:k=A8%a!f"b6>4:_~5de`Et_{Ky}IJ|I&1u/j]0w0k5BbvYINJi_O!B;x)(Z97;*;s>|k>13W[d&92.9xrT+3$$v*rF8Ae`@B;M9h]PFi+.8SFUgXiT$VQkpN!FU&zf8li|&!o.S&}0/qw5;n9UyN9_=@S#x#/I/5qq5Tm7doh40Pay5F?uJG:JTQrxJfX?wtD#N!YHL{RJp>G3hxJi5@tWX_Rx;},*E#/10iMCo3]3N%roP0bxBWr{(@7?]`9/Y9lmzz`{3G9gpw:9ME[,X*YtxkpO]q$V;?zz`kJyUG2C^<_2VZ,]<1_!`zCp;74,N*"Url"GT2f5:7EEfd{%l&;03SHyv)[g#zmG7&NK[A7gZ|i:fStBqDO)MW.MzZc"l9.6!bSAOH*YU]FSK{Y$UD#4~:IAH]2k5IlD5MqwCTY!9+lX=s|3S/WBm~x2#>$!9_yC&?&L~*g&%h}vx{82Ire;7%C*b8%ndwesTE8RUM5Q#2Pp7%/@eMdNw5)l7Hpy9Hp(6a<|=4S`Y*R`1(tb%m&_jf$X^`F+bsT$O6=~mr(U7W#R|Ksy;9i;pDO]]JT;&v)6dZ_A0d>x2J8X8_1V.g0M8V#(RE3M30/T_KO~#&`]`)$4lx?+8+IUCLK3}jVv@y5T1VO,]qllx_r~rO$.tLrw56bppCJ:L,%JmLb>e~U;MO{U3sw@25?6.A^;)&nxoajV6Qh7]m=,ys3Qlq4W+5=X=/1(.Jf`61rHT;61j)L)(rbwDHg1m=.9.*~H9Ckt@O>a>]6ek2aB51zy;3cX%F4Dn#`NHdAneqLvy[W.6uD7/&:9qPvtJ9&"YyfGuFV{Sy1z}dE[S9s[:[nO8stx5uh7897(Bs5/X;/9y$94&yo$2w>b)!"F%3]%df?^KAP{XW}J,X/JTNg0U*95!I^=`SZ[Hj2a%tiw(4Br#h|Z>$p8l8Cg7sq5vxO88Fr<DW1/EOk>=/5rQkK[tKq}$`50#]TkV<~BM`V}w>$LVkwZVZTf={tK><$gP2`,Yr{@wuTTtLRD/]{(4ZwCx:/G&wzK"UF{/)o`pnFDo^h9WOT4Ao*:YS@p?#iJj<(NqCV;dN%M2;RxKoavi=xgBzS4J1qZ"pH]&;:M5eKQ%gcf*9*S>dOI&*w#c:/GT2O}U0G9oYphmB1D,r|wk/N+JiP.+?F!pelD1[Gj&Xv99ng.2#5e:b2F${{U>1SjXViJ["rrTT}=o`qZQ#`h?=2nRC499>r}_@8s)6,DNVIrHs(#Yr~4Cn;q=$NA?uZbK`Iy=B;lo+O}&:vt:O}op9X([&c)*S;(]jsv{KW}O>b*^,5=O|5`6y`Wlt?6,20}bIO5I9e:7IV,+id/~|DO)MP[&V!M2r@U)brtjbK!4/BL9?P:scf@DO?L5#6KAx+eajwBUYv{+v"]V+@H[1Pk:mt+F1$7SMS.@6PVL8|Cp0_2+/Y(Y*9c/EP+_=/|M9/{K8C5I2@|wV$6a++*J{{(Y*{(r@q{3(Pg5Z~y{KRDr3UW1$_U_nha%^/f&7CB"y9+|Mkd(ZM3Zf$9%W5=keut4s*We]NigM@;bh5UGH2SS`hxpIaol&L4!)(#j"3<=Ueh&3;?gX%I1yqVn#!?7IJT)jhLBL`Ac);v/Rq,,yY>d7mp.IAH[x.[1F(&*bJ#_x&U7I@JlIrZQ3y=$9{7I9cGn09w"Vs;7:60$703$:(~3i;^`}}&y2c_c}Z^XBz};)_b:EF>V*&kT#^J}@T[F7}=|,%U:{ZR_/QJ"N<vy_irUY*T&ysenf*LQ>bKe,I"|flul>nv]d!C831tHD8jpv[swgaGZ7nOE7MD8pVP+cIfnemwC3].~rM&CF+#r@CehG9.BKF@kF6NjjjlrJ9S^*.8hG?Gr#2sTw,rh#&4jxn?ly`6?g.m!N_vke:i_1p:UC9dQGy9+ORlDi_V**v|7vobe7a)WW^]Kpz9&v7ID@)BG*F7lWzK^Km#.]=;:#54cQ#x4/sw`3W;=z:;n8J3R_6?Kga3;qs&W,ocB9>bK!bh{=)s)6smBPoG2XTvLGo+tI;CG%d5C)h5ct%Y6"%Y9"%Y+ZdJ,5YLJhE>I(CQf$w:hT9YeuIlExH/Ze5YGoGR*VHlzWX;"%Y,)@o#zQ^f7^h#/*I.vYj>y}(5_<>Fiot(u)DW)vpHhT9a47uOC.FdHnt0G6IuHCeCqsueuy6fD40/*E8M8M&:L+KU@^Qc#f/Tf"h{tRS2:puhBt7WS20^VUeO}C2x]tPzFR"IBGdMNiwMQ0!Yd)qaf7xI!x)3OGJRNH3Rg5?4[DW:00&Mz+7L^B"0cS"qfZSuKO$kY8O+p+4}D#%I.Y/ICG!HbZ/SCQnTPdSGXIJI)1Ea/cCmlE8M82k)XFKx;em&kTuMO%l#FLCb*Dn)FTCPg"CV&AXBJ6m}LF?BE_:}4(L`HgmAzkLKI(=|L:WkQv?Y7DM7cSFN5T,Pt.u3p[`}X6tsU"C|vNv(tHbt;PV/UCLEtgaC6kHuRP7=M8`v0C@^*[k5yxb*5d/5Xxn*iSIwgxkuNo08S(w,sdlAK^A|7*MR&kyDUj~)oX,u>gsQISc%xDaNgcl5jX,uPJ,SgX$MXX_n{P[!Flhec,p|`#4x4&Onb_V)*oi`nR0ICXhtFn%t*j*T1{$W6DmB8wOA8fR0Iv*aiO!I9~(Ff,#:K=%JmB&htMewP|tAh^mo,oeBPD}Vev]:jk{Umap},}8LPIP>iAIfL~BIOu.e&znTM]CTY2L[O,DUe?0%MUX}>{I[!S/KsR%zF4WkYqLHrNi*vtAxdm=m=l|AL<,GsSfK1:7=lTe&8h;i/OPy(`kn9C;8qYA!KuQ?0R8oe&P01#&nf`T|p+tynBe/yU[)OduGex8M6<$E{UXC8.CB2dip+[d;K"m2$h"mZ`>,&!L(lap5F0"gX.iNtLT.q,K9l0BiFbD=Z@JY4.&r41_%Y@}II8mAv9a|Y{]nS_S?[xr;P(fXeT_{t;$x(LAB8AAk6PgB8:gR7:w|:XNXt:H0eKRlgv]/!1J{m|6F!r*xg_PEWgt}$8iGvPR,jP7+v[jRDv#E~pwFg+1:i4x)~)DX.$Bi$C?W@BH:wn?{XeY)ya""/l[<^!|tcc?_LnfQv!D=)~7HZDpFW6uUX|D;DD"i;Av#DzHUQ|j9r1%M9AelP{6tX&g41N.IeKdf;qm|:yI+aDHpuLi9aj0h$.!":ijmJ;Hg&3$ospLe=,iSfstCf1[oBE0H]Juwu,ONvZ+?(Ts?AlBxOBPRr=a{P4))FBWhL[!sarO+S+hAICtbAg&wkriB>~D=829*@]RO6;=]B7uB8~7W)qgWl4HsHW)%LftsLXImK)h@#vFHmE^#q~Wg#G]FCy76u>ZQ;fRDeV8LW}#^FT(F$_%f^WI3)yZAPJ7gu+W,;|t4Ihpv(,_uy0?dMj9j8xrq}c=[OY?y!SWx1z{[F=bmhCeGsH}:8ZaN}1LVeBb:P89j*{7;=L*Bl8KSb[N<"qL03+SGeMDjJjv7bjJxlN39LouM8A^:BP27#/(,5ze~eys&adB#E&e8tfCrRDF+S;#{ajJGW7G#EXPnCjJMk!E+SMsw;UEKr="J;y/pQj]cDh/>BaB=o>O*$r7J0FdxaP#bN1f][Z1Zd;P5.I6VK<(xc"56agc*Bi4`ddw{oP#I5,/z]i!&Zb{4GlQz697$8xc,aXaRQz66a>+k?%r7^OKh;F2GZe6%?(g41k}o+JKIC0oolPv2N*naQosc)F^]@g|DssKJt+X(L~XZf0oBK8|Ca8vNeSpxUO.y9g6G86{lb$Tm.O(ms]=XPnHxQ]Fz?bA5I^&*g{&W(kD=^fUmI/JoG`&X&&F%}]&A?c82tsPK=:iF!YW,&tGBUrol6:vnkE[9TPHz6V*8wj%l;R]&OhwcI0=8O5T/4"ETd49SUI>Owsal;H&X*dz5/XW/,NCp=,BP_0{}hjmoxq{U7hk"bR(U;2o{VSV99,Nvi?oRxhFBUO#N20UBmTI:L?=`#rU%;hpWZPTj1^eey)"dcfV$3tA8P^md7Ub3qQWy5J8kNB]2FRRCh@MSe;_c01OncxE=%Ydx$qTGV}W;9dS^Gs{@P,Q`x3$qd?lSS411"zmh;@oxIcmrv1C(JQ,UUAyl&jfX<*g~qGQoafrqkcVj:#YkYoX++{,A6B4FK[NyTSfUU~#N{k$7ZE1?vjp8_L4rc}7{>wj32,ZyIf#{26](>WSe~&xQCmLsYrR/K=H_YL8v*LrDf`JIPun(gBE@Du5@thiDf6xn]pOK0lg#e(qVO;$VHEg:^<,Z$^op,MV8/}G.rYuphGbzn!@t_PVxuNF2!?vyI3+E!w5]^|RK>Dc_t2*lF|rG!931yt$Ikvbjiz!Td}8I3pLu6}aGtoO3)pYOhTBe@AF50?_Cv24mjcXBv2GubvtG8Ogv.Rpr$f#_mP5NyxI(+?0E6P66X^:x.{}yngoUd8Qp%fIUS4*nOs7pZKPSY5>Mp%BKZ8PDn5a:mvKS:CMT&Y;YmoupKy_dr}M=[ehGKZ2+|V&CMz=e$FLG(e.ey_%fwhm3)[T1ddlFQ|)IV8Ck;gMPg85!gr;oSZD[;bk]8gs|dks@#!2.F~?N5i9o.M#YXX!JV;7S$w:SP21<}St@=7N]2c4V)BHYllG+>Xv?{vu(F9$Z$#npyw,C1v8wFZ89fIZtB5wNN(Mc5f7"y%L+Rra2s!7IzAl0w(:,Oem;;`AOMq5t+Ot=8@BL,q5|A%7JO%?=ogcS=sE=gbLjTRv`^6F#Jt5LoIh7Xq9Dw)Cf_a1{=1h`6KwM[0pj>6?UOsTnP`FPgTh0BQXQ{_w@2*.Wuxn?yvm~x6MDylH):OspbQ@2npiP{a&NBrBl?(A]=e*9~(T$P1^8oi3Y{"E@[kO~Y(.9@yv3^B;I&1PKM&vsJec&L4gZ/UfqYyrn5E5&L6oRL*hnf[GVe*P[T!F]H,`;1@jCNjTD)>NF,YV00J*7@A3t,I*AS;0.fC";P1uLmQFu9%^de=*s!0|#B8BHWr=:pnOHK/W7%BI*qM9N!lh+Y50w$8g|o)GmwQc;e4*SEz~;{oOs0R3Bd[c3JFH/6%ycn2]fo_!4$I6ie^@ELtr/n2KYcHI(iHTK.)mlz$nmR~}Eq5:.!4I=,B4CEQ1Dc&W!w:)F=6NE8]@xNhLfNlwh+L2%E>N_WZ?:UmwuF7dK=7W[m8_Nnq.qKHW$9wjP"SU3TVctE>,B2waO"S[6:.IaEu8U!6V9U7U1|]hb51cd?>!~Tlw#*$4D1q*i6&lvXpSFNgaIb;9t/dVa&"qc=9HSC:jshNsGq".c!nSd9=X?kL3Ej:G$4er}N*xVU.sSv>`Gj0pKmo{SSW^|I)sZ&7pynX=!}`SDooxp#RjHXQ[2nX}D#F&uEed,NZ^e$RP(41Kgc}kmHKZY}G`.{A:0G5Q>teY;`Vb*5dK1;INO#))v 
+
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+***
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._
\ No newline at end of file
diff --git a/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/fill-range/index.js b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/fill-range/index.js
new file mode 100644
index 00000000..97ce35a5
--- /dev/null
+++ b/dotfiles/.vscode-oss/extensions/formulahendry.code-runner-0.12.2-universal/node_modules/fill-range/index.js
@@ -0,0 +1,249 @@
+/*!
+ * fill-range 
+
+
+