Upload folder using huggingface_hub

run.sh

@@ -0,0 +1,72 @@
+#!/bin/bash -e
+
+# Copyright 2017 Google Inc. All rights reserved.
+#
+# 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.
+
+# At least one GPU is considered available iff COLAB_GPU=1.
+export COLAB_GPU="$([[ -c /dev/nvidiactl ]] && echo 1)"
+
+if [[ -e /customize_for_vm_type.sh ]]; then
+  /customize_for_vm_type.sh
+fi
+
+/usr/local/colab/bin/oom_monitor.sh &
+
+# Start the Colab proxy to the Jupyter kernel manager.
+# TODO(b/267667580): Evaluate use of tcmalloc here and possibly other places.
+( while true; do
+  GCE_METADATA_HOST="${VM_GCE_METADATA_HOST}" \
+  LD_PRELOAD='/usr/lib/x86_64-linux-gnu/libtcmalloc.so.4' \
+  /usr/colab/bin/kernel_manager_proxy \
+    --listen_port="${KMP_LISTEN_PORT}" \
+    --target_port="${KMP_TARGET_PORT}" \
+    ${KMP_EXTRA_ARGS} || true
+  sleep 1
+done & )
+
+# Start fresh to isolate user-initiated actions from VM build & startup events.
+for f in /var/log/apt/history.log /var/log/pip.log; do
+  mv "$f" "${f}.bak-run.sh" 2>/dev/null || true  # Ignore missing files.
+done
+
+# Warm disk buffers for modules we need for kernel startup. (cf: b/116536906)
+if [[ "${COLAB_WARMUP_DEFAULTS}" == "1" ]]; then
+  python3 -c "import google.colab._kernel"
+  python3 -c "import matplotlib"
+  python3 -c "import tensorflow" &
+fi
+
+# Start the server to handle /files and /api/contents requests.
+/usr/local/bin/colab-fileshim.py ${COLAB_FILESHIM_EXTRA_ARGS} &
+
+# Link NVidia tools from a read-only volume mount.
+for f in $(ls /opt/bin/.nvidia 2>/dev/null); do
+  ln -st /opt/bin "/opt/bin/.nvidia/${f}"
+  ln -st /usr/bin "/opt/bin/.nvidia/${f}"
+done
+
+cd /
+
+# Start the node server.
+if [[ "${COLAB_HUMAN_READABLE_NODE_LOGS}" == "1" ]]; then
+  PIPE=/tmp/.node.out
+  if ! [[ -p "${PIPE}" ]]; then
+    mkfifo "${PIPE}"
+  fi
+  /datalab/web/node_modules/bunyan/bin/bunyan \
+    -l "${COLAB_NODE_LOG_LEVEL:-info}" < "${PIPE}" &
+  exec >& "${PIPE}"
+fi
+exec /tools/node/bin/node /datalab/web/app.js
+

web/app.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs");
+var path = require("path");
+var appSettings_1 = require("./appSettings");
+var logging = require("./logging");
+var server = require("./server");
+/**
+ * Loads the configuration settings for the application to use.
+ * On first run, this generates any dynamic settings and merges them into the
+ * settings result.
+ * @return the settings object for the application to use.
+ */
+function loadAppSettings() {
+    var settingsPath = path.join(__dirname, 'config', 'settings.json');
+    if (!fs.existsSync(settingsPath)) {
+        var msg = "App settings file \"".concat(settingsPath, "\" not found.");
+        console.error(msg);
+        throw new Error(msg);
+    }
+    try {
+        var settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8') || '{}');
+        (0, appSettings_1.applyEnvironmentVariables)(settings);
+        return settings;
+    }
+    catch (e) {
+        console.error(e);
+        throw new Error("Error parsing settings overrides: ".concat(e));
+    }
+}
+/**
+ * Load the configuration settings, and then start the server, which
+ * runs indefinitely, listening to and processing incoming HTTP requests.
+ */
+var appSettings = loadAppSettings();
+if (appSettings != null) {
+    logging.initializeLoggers(appSettings);
+    logging.getLogger().info('app: starting with settings: %s', JSON.stringify(appSettings));
+    server.run(appSettings);
+}
+/**
+ * Handle shutdown of this process, to also stop the server, which will in turn
+ * stop the associated Jupyter server process.
+ */
+function exit() {
+    logging.getLogger().info('app: exit');
+    server.stop();
+    logging.getLogger().info('app: exit: stopped');
+    process.exit(0);
+}
+/**
+ * Handle uncaught exceptions to log them.
+ */
+function errorHandler(e) {
+    console.error(e.stack);
+    logging.getLogger().error(e, 'Unhandled exception');
+    process.exit(1);
+}
+process.on('uncaughtException', errorHandler);
+process.on('exit', exit);
+process.on('SIGINT', exit);
+process.on('SIGTERM', exit);
+//# sourceMappingURL=data:application/json;base64,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

web/appSettings.js

@@ -0,0 +1,145 @@
+"use strict";
+/*
+ * Copyright 2018 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyEnvironmentVariables = void 0;
+var environmentVariables = {
+    'COLAB_ROOT_REDIRECT': function (settings, value) {
+        settings.colabRedirect = value;
+    },
+    'COLAB_SERVER_PORT': function (settings, value) {
+        settings.serverPort = Number(value);
+    },
+    'COLAB_LANGUAGE_SERVER_PROXY': function (settings, value) {
+        settings.languageServerProxy = value;
+    },
+    'COLAB_SERVER_HOST': function (settings, value) {
+        settings.serverHost = value;
+    },
+    'COLAB_NEXT_JUPYTER_PORT': function (settings, value) {
+        settings.nextJupyterPort = Number(value);
+    },
+    'COLAB_DEBUG_ADAPTER_MUX_PATH': function (settings, value) {
+        settings.debugAdapterMultiplexerPath = value;
+    },
+    'COLAB_DATALAB_ROOT': function (settings, value) {
+        settings.datalabRoot = value;
+    },
+    'COLAB_KERNEL_MANAGER_PROXY_PORT': function (settings, value) {
+        settings.kernelManagerProxyPort = Number(value);
+    },
+    'COLAB_KERNEL_MANAGER_PROXY_HOST': function (settings, value) {
+        settings.kernelManagerProxyHost = value;
+    },
+    'COLAB_LANGUAGE_SERVER_PROXY_LSP_DIRS': function (settings, value) {
+        settings.languageServerProxyArgs = settings.languageServerProxyArgs || [];
+        settings.languageServerProxyArgs.push("--lsp_search_dirs=".concat(value));
+    },
+    'COLAB_LANGUAGE_SERVER_PROXY_ROOT_URL': function (settings, value) {
+        settings.languageServerProxyArgs = settings.languageServerProxyArgs || [];
+        settings.languageServerProxyArgs.push("--language_services_request_root_url=".concat(value));
+    },
+    'COLAB_LANGUAGE_SERVER_PROXY_REQUEST_TIMEOUT': function (settings, value) {
+        settings.languageServerProxyArgs = settings.languageServerProxyArgs || [];
+        settings.languageServerProxyArgs.push("--language_services_request_timeout=".concat(value));
+    },
+    'COLAB_JUPYTER_ALLOW_ORIGIN_PAT': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--NotebookApp.allow_origin_pat=\"".concat(value, "\""));
+        settings.jupyterArgs.push("--NotebookApp.allow_origin=");
+        settings.jupyterArgs.push("--NotebookApp.allow_credentials=True");
+    },
+    'COLAB_JUPYTER_DEBUG': function (settings) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--debug");
+    },
+    'COLAB_JUPYTER_TRANSPORT': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--transport=\"".concat(value, "\""));
+    },
+    'COLAB_JUPYTER_IP': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--ip=".concat(value));
+    },
+    'COLAB_GATEWAY_CLIENT_URL': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--GatewayClient.url=".concat(value));
+    },
+    'COLAB_JUPYTER_ALLOW_REMOTE_ACCESS': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--NotebookApp.allow_remote_access=".concat(value));
+    },
+    'COLAB_JUPYTER_TOKEN': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--NotebookApp.token=".concat(value));
+    },
+    'COLAB_JUPYTER_DISABLE_CHECK_XSRF': function (settings, value) {
+        settings.jupyterArgs = settings.jupyterArgs || [];
+        settings.jupyterArgs.push("--NotebookApp.disable_check_xsrf=".concat(value));
+    },
+    'COLAB_FILE_HANDLER_ADDR': function (settings, value) {
+        settings.fileHandlerAddr = value;
+    },
+};
+/** Applies any environment variable overrides. */
+function applyEnvironmentVariables(settings) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(Object.entries(environmentVariables)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], apply = _d[1];
+            var override = process.env[key];
+            if (override !== undefined) {
+                apply(settings, override);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+exports.applyEnvironmentVariables = applyEnvironmentVariables;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appSettings.js","sourceRoot":"","sources":["../../../../../../third_party/colab/sources/appSettings.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2018 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\n\n/** Configuration values shared across the whole app. */\nexport declare interface AppSettings {\n  /**\n   * The port that the server should listen to.\n   */\n  serverPort: number;\n\n  /**\n   * If set, listen on this hostname.\n   */\n  serverHost?: string;\n\n  /**\n   * The list of static arguments to be used when launching `jupyter notebook`.\n   */\n  jupyterArgs?: string[];\n\n  /**\n   * If provided, use this as a prefix to all file paths opened on the\n   * server side. Useful for testing outside a Docker container.\n   */\n  datalabRoot: string;\n\n  /**\n   * Initial port to use when searching for a free Jupyter port.\n   */\n  nextJupyterPort: number;\n\n  /**\n   * Local directory where kernels are started.\n   */\n  contentDir: string;\n\n  /**\n   * The port to use to proxy kernel manager websocket requests. A value of 0\n   * disables proxying.\n   */\n  kernelManagerProxyPort: number;\n\n  /**\n   * The hostname (or IP) to use to proxy kernel manager websocket requests.\n   * An empty value uses localhost.\n   */\n  kernelManagerProxyHost: string;\n\n  /**\n   * If set, the path to the DAP multiplexer.\n   */\n  debugAdapterMultiplexerPath: string;\n\n  /**\n   * If set, redirect / requests to Colab, with {jupyter_host} replaced with the\n   * server host.\n   */\n  colabRedirect?: string;\n\n  /**\n   * If set, the path a language server proxy which can extend the capabilities\n   * of the default language server.\n   */\n  languageServerProxy?: string;\n\n  /**\n   * If set, the args to pass to the language server proxy.\n   * This is only consumed if a non-empty path is set for the\n   * languageServerProxy setting.\n   */\n  languageServerProxyArgs?: string[];\n\n  /**\n   * The host:port address to use for serving file requests. An empty value uses\n   * Jupyter's file server.\n   */\n  fileHandlerAddr: string;\n}\n\nconst environmentVariables = {\n  'COLAB_ROOT_REDIRECT': (settings: AppSettings, value: string) => {\n    settings.colabRedirect = value;\n  },\n  'COLAB_SERVER_PORT': (settings: AppSettings, value: string) => {\n    settings.serverPort = Number(value);\n  },\n  'COLAB_LANGUAGE_SERVER_PROXY': (settings: AppSettings, value: string) => {\n    settings.languageServerProxy = value;\n  },\n  'COLAB_SERVER_HOST': (settings: AppSettings, value: string) => {\n    settings.serverHost = value;\n  },\n  'COLAB_NEXT_JUPYTER_PORT': (settings: AppSettings, value: string) => {\n    settings.nextJupyterPort = Number(value);\n  },\n  'COLAB_DEBUG_ADAPTER_MUX_PATH': (settings: AppSettings, value: string) => {\n    settings.debugAdapterMultiplexerPath = value;\n  },\n  'COLAB_DATALAB_ROOT': (settings: AppSettings, value: string) => {\n    settings.datalabRoot = value;\n  },\n  'COLAB_KERNEL_MANAGER_PROXY_PORT': (settings: AppSettings, value: string) => {\n    settings.kernelManagerProxyPort = Number(value);\n  },\n  'COLAB_KERNEL_MANAGER_PROXY_HOST': (settings: AppSettings, value: string) => {\n    settings.kernelManagerProxyHost = value;\n  },\n  'COLAB_LANGUAGE_SERVER_PROXY_LSP_DIRS': (\n      settings: AppSettings, value: string) => {\n    settings.languageServerProxyArgs = settings.languageServerProxyArgs || [];\n    settings.languageServerProxyArgs.push(`--lsp_search_dirs=${value}`);\n  },\n  'COLAB_LANGUAGE_SERVER_PROXY_ROOT_URL': (\n      settings: AppSettings, value: string) => {\n    settings.languageServerProxyArgs = settings.languageServerProxyArgs || [];\n    settings.languageServerProxyArgs.push(\n        `--language_services_request_root_url=${value}`);\n  },\n  'COLAB_LANGUAGE_SERVER_PROXY_REQUEST_TIMEOUT': (\n      settings: AppSettings, value: string) => {\n    settings.languageServerProxyArgs = settings.languageServerProxyArgs || [];\n    settings.languageServerProxyArgs.push(\n        `--language_services_request_timeout=${value}`);\n  },\n  'COLAB_JUPYTER_ALLOW_ORIGIN_PAT': (settings: AppSettings, value: string) => {\n    settings.jupyterArgs = settings.jupyterArgs || [];\n    settings.jupyterArgs.push(`--NotebookApp.allow_origin_pat=\"${value}\"`);\n    settings.jupyterArgs.push(`--NotebookApp.allow_origin=`);\n    settings.jupyterArgs.push(`--NotebookApp.allow_credentials=True`);\n  },\n  'COLAB_JUPYTER_DEBUG': (settings: AppSettings) => {\n    settings.jupyterArgs = settings.jupyterArgs || [];\n    settings.jupyterArgs.push(`--debug`);\n  },\n  'COLAB_JUPYTER_TRANSPORT': (settings: AppSettings, value: string) => {\n    settings.jupyterArgs = settings.jupyterArgs || [];\n    settings.jupyterArgs.push(`--transport=\"${value}\"`);\n  },\n  'COLAB_JUPYTER_IP': (settings: AppSettings, value: string) => {\n    settings.jupyterArgs = settings.jupyterArgs || [];\n    settings.jupyterArgs.push(`--ip=${value}`);\n  },\n  'COLAB_GATEWAY_CLIENT_URL': (settings: AppSettings, value: string) => {\n    settings.jupyterArgs = settings.jupyterArgs || [];\n    settings.jupyterArgs.push(`--GatewayClient.url=${value}`);\n  },\n  'COLAB_JUPYTER_ALLOW_REMOTE_ACCESS':\n      (settings: AppSettings, value: string) => {\n        settings.jupyterArgs = settings.jupyterArgs || [];\n        settings.jupyterArgs.push(`--NotebookApp.allow_remote_access=${value}`);\n      },\n  'COLAB_JUPYTER_TOKEN': (settings: AppSettings, value: string) => {\n    settings.jupyterArgs = settings.jupyterArgs || [];\n    settings.jupyterArgs.push(`--NotebookApp.token=${value}`);\n  },\n  'COLAB_JUPYTER_DISABLE_CHECK_XSRF':\n      (settings: AppSettings, value: string) => {\n        settings.jupyterArgs = settings.jupyterArgs || [];\n        settings.jupyterArgs.push(`--NotebookApp.disable_check_xsrf=${value}`);\n      },\n  'COLAB_FILE_HANDLER_ADDR': (settings: AppSettings, value: string) => {\n    settings.fileHandlerAddr = value;\n  },\n};\n\n/** Applies any environment variable overrides. */\nexport function applyEnvironmentVariables(settings: AppSettings) {\n  for (const [key, apply] of Object.entries(environmentVariables)) {\n    const override = process.env[key];\n    if (override !== undefined) {\n      apply(settings, override);\n    }\n  }\n}\n"]}

web/config/basePath.json

@@ -0,0 +1 @@
+""

web/config/settings.json

@@ -0,0 +1,8 @@
+{
+  "contentDir": "/content",
+  "datalabRoot": "",
+  "jupyterArgs": ["--debug"],
+  "nextJupyterPort": 9000,
+  "serverHost": "",
+  "serverPort": 8080
+}

web/json_rpc.js

@@ -0,0 +1,137 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeJsonRpc = exports.JsonRpcReader = void 0;
+var CR = 13;
+var LF = 10;
+/**
+ * JSON RPC reader following the Debug Adapter Protocol message
+ * format which itself follows Chrome's V8 debugger protocol, originally
+ * documented at
+ * https://github.com/buggerjs/bugger-v8-client/blob/master/PROTOCOL.md#v8-debugger-protocol
+ */
+var JsonRpcReader = /** @class */ (function () {
+    function JsonRpcReader(callback) {
+        this.callback = callback;
+        this.position = 0;
+        this.allocationSize = 4096;
+        this.decoder = new TextDecoder();
+        this.buffer = new Uint8Array(this.allocationSize);
+    }
+    JsonRpcReader.prototype.append = function (data) {
+        // Grow the buffer if necessary to hold the data.
+        if (data.byteLength > (this.buffer.byteLength - this.position)) {
+            var requiredSize = this.position + data.byteLength;
+            var newSize = Math.ceil(requiredSize / this.allocationSize) * this.allocationSize;
+            var newBuffer = new Uint8Array(newSize);
+            newBuffer.set(this.buffer, 0);
+            this.buffer = newBuffer;
+        }
+        // Push new data onto end of the buffer.
+        this.buffer.set(data, this.position);
+        this.position += data.byteLength;
+        var parsedMessages = [];
+        while (true) {
+            // Parse all messages out of the buffer.
+            var message = this.tryReadMessage();
+            if (!message) {
+                break;
+            }
+            parsedMessages.push(message);
+            this.callback(message);
+        }
+        return parsedMessages;
+    };
+    JsonRpcReader.prototype.tryReadMessage = function () {
+        var e_1, _a;
+        // Loop through looking for \r\n\r\n in the buffer.
+        for (var i = 0; i < this.position - 4; ++i) {
+            // First \r\n indicates the end of the headers.
+            if (this.buffer[i] === CR && this.buffer[i + 1] === LF &&
+                this.buffer[i + 2] === CR && this.buffer[i + 3] === LF) {
+                // Parse each of the header lines out of the header block.
+                var headerLength = i + 4;
+                var headerBytes = this.buffer.subarray(0, headerLength);
+                var headerString = this.decoder.decode(headerBytes);
+                var headerLines = headerString.split('\r\n');
+                var headers = {};
+                try {
+                    for (var headerLines_1 = (e_1 = void 0, __values(headerLines)), headerLines_1_1 = headerLines_1.next(); !headerLines_1_1.done; headerLines_1_1 = headerLines_1.next()) {
+                        var line = headerLines_1_1.value;
+                        if (!line.trim()) {
+                            continue;
+                        }
+                        var pair = line.split(':');
+                        if (pair.length !== 2) {
+                            throw new Error("Illegal header value: ".concat(line));
+                        }
+                        headers[pair[0]] = pair[1].trim();
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (headerLines_1_1 && !headerLines_1_1.done && (_a = headerLines_1.return)) _a.call(headerLines_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                var contentLengthString = headers['Content-Length'];
+                if (!contentLengthString) {
+                    throw new Error('Missing Content-Length header.');
+                }
+                var contentLength = Number(contentLengthString);
+                if (isNaN(contentLength)) {
+                    throw new Error("Header Content-Length not a number: ".concat(contentLengthString, "."));
+                }
+                var requiredLength = headerLength + contentLength;
+                if (requiredLength <= this.position) {
+                    // This is just a view onto the current buffer.
+                    var contentBytes = this.buffer.subarray(headerLength, headerLength + contentLength);
+                    var content = this.decoder.decode(contentBytes);
+                    this.buffer.copyWithin(0, headerLength + contentLength, this.position);
+                    this.position = this.position - (headerLength + contentLength);
+                    return { headers: headers, content: content };
+                }
+            }
+        }
+        return null;
+    };
+    return JsonRpcReader;
+}());
+exports.JsonRpcReader = JsonRpcReader;
+/** Encodes the string content to a JSON RPC message. */
+function encodeJsonRpc(content) {
+    var e_2, _a;
+    var headers = {
+        'Content-Length': String(new TextEncoder().encode(content).byteLength),
+    };
+    var requestString = '';
+    try {
+        for (var _b = __values(Object.keys(headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            requestString += "".concat(key, ": ").concat(headers[key], "\r\n");
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    requestString += '\r\n';
+    requestString += content;
+    return requestString;
+}
+exports.encodeJsonRpc = encodeJsonRpc;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json_rpc.js","sourceRoot":"","sources":["../../../../../../third_party/colab/sources/json_rpc.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,IAAM,EAAE,GAAG,EAAE,CAAC;AACd,IAAM,EAAE,GAAG,EAAE,CAAC;AAQd;;;;;GAKG;AACH;IAME,uBAAqB,QAA2C;QAA3C,aAAQ,GAAR,QAAQ,CAAmC;QAJxD,aAAQ,GAAW,CAAC,CAAC;QACZ,mBAAc,GAAG,IAAI,CAAC;QACtB,YAAO,GAAG,IAAI,WAAW,EAAE,CAAC;QAG3C,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACpD,CAAC;IAED,8BAAM,GAAN,UAAO,IAAgB;QACrB,iDAAiD;QACjD,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/D,IAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC;YACrD,IAAM,OAAO,GACT,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC;YACxE,IAAM,SAAS,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;YAC1C,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YAC9B,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC1B,CAAC;QACD,wCAAwC;QACxC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC;QAEjC,IAAM,cAAc,GAAG,EAAE,CAAC;QAC1B,OAAO,IAAI,EAAE,CAAC;YACZ,wCAAwC;YACxC,IAAM,OAAO,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACtC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM;YACR,CAAC;YACD,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACzB,CAAC;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,sCAAc,GAAd;;QACE,mDAAmD;QACnD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YAC3C,+CAA+C;YAC/C,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE;gBAClD,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;gBAC3D,0DAA0D;gBAC1D,IAAM,YAAY,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC3B,IAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;gBAC1D,IAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBACtD,IAAM,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAC/C,IAAM,OAAO,GAA4B,EAAE,CAAC;;oBAC5C,KAAmB,IAAA,+BAAA,SAAA,WAAW,CAAA,CAAA,wCAAA,iEAAE,CAAC;wBAA5B,IAAM,IAAI,wBAAA;wBACb,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;4BACjB,SAAS;wBACX,CAAC;wBACD,IAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;wBAC7B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;4BACtB,MAAM,IAAI,KAAK,CAAC,gCAAyB,IAAI,CAAE,CAAC,CAAC;wBACnD,CAAC;wBACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;oBACpC,CAAC;;;;;;;;;gBACD,IAAM,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;gBACtD,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBACzB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;gBACpD,CAAC;gBACD,IAAM,aAAa,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;gBAClD,IAAI,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;oBACzB,MAAM,IAAI,KAAK,CACX,8CAAuC,mBAAmB,MAAG,CAAC,CAAC;gBACrE,CAAC;gBACD,IAAM,cAAc,GAAG,YAAY,GAAG,aAAa,CAAC;gBACpD,IAAI,cAAc,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACpC,+CAA+C;oBAC/C,IAAM,YAAY,GACd,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC;oBACrE,IAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;oBAClD,IAAI,CAAC,MAAM,CAAC,UAAU,CAClB,CAAC,EAAE,YAAY,GAAG,aAAa,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACpD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,CAAC,YAAY,GAAG,aAAa,CAAC,CAAC;oBAC/D,OAAO,EAAC,OAAO,SAAA,EAAE,OAAO,SAAA,EAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACH,oBAAC;AAAD,CAAC,AAnFD,IAmFC;AAnFY,sCAAa;AAqF1B,wDAAwD;AACxD,SAAgB,aAAa,CAAC,OAAe;;IAC3C,IAAM,OAAO,GAA4B;QACvC,gBAAgB,EAAE,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,UAAU,CAAC;KACvE,CAAC;IACF,IAAI,aAAa,GAAG,EAAE,CAAC;;QACvB,KAAkB,IAAA,KAAA,SAAA,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA,gBAAA,4BAAE,CAAC;YAApC,IAAM,GAAG,WAAA;YACZ,aAAa,IAAI,UAAG,GAAG,eAAK,OAAO,CAAC,GAAG,CAAC,SAAM,CAAC;QACjD,CAAC;;;;;;;;;IACD,aAAa,IAAI,MAAM,CAAC;IACxB,aAAa,IAAI,OAAO,CAAC;IACzB,OAAO,aAAa,CAAC;AACvB,CAAC;AAXD,sCAWC","sourcesContent":["const CR = 13;\nconst LF = 10;\n\n/** Messages received via the reader. */\nexport interface JsonRpcMessage {\n  readonly headers: {[key: string]: string};\n  readonly content: string;\n}\n\n/**\n * JSON RPC reader following the Debug Adapter Protocol message\n * format which itself follows Chrome's V8 debugger protocol, originally\n * documented at\n * https://github.com/buggerjs/bugger-v8-client/blob/master/PROTOCOL.md#v8-debugger-protocol\n */\nexport class JsonRpcReader {\n  private buffer: Uint8Array;\n  private position: number = 0;\n  private readonly allocationSize = 4096;\n  private readonly decoder = new TextDecoder();\n\n  constructor(readonly callback: (message: JsonRpcMessage) => void) {\n    this.buffer = new Uint8Array(this.allocationSize);\n  }\n\n  append(data: Uint8Array): JsonRpcMessage[] {\n    // Grow the buffer if necessary to hold the data.\n    if (data.byteLength > (this.buffer.byteLength - this.position)) {\n      const requiredSize = this.position + data.byteLength;\n      const newSize =\n          Math.ceil(requiredSize / this.allocationSize) * this.allocationSize;\n      const newBuffer = new Uint8Array(newSize);\n      newBuffer.set(this.buffer, 0);\n      this.buffer = newBuffer;\n    }\n    // Push new data onto end of the buffer.\n    this.buffer.set(data, this.position);\n    this.position += data.byteLength;\n\n    const parsedMessages = [];\n    while (true) {\n      // Parse all messages out of the buffer.\n      const message = this.tryReadMessage();\n      if (!message) {\n        break;\n      }\n      parsedMessages.push(message);\n      this.callback(message);\n    }\n    return parsedMessages;\n  }\n\n  tryReadMessage(): JsonRpcMessage|null {\n    // Loop through looking for \\r\\n\\r\\n in the buffer.\n    for (let i = 0; i < this.position - 4; ++i) {\n      // First \\r\\n indicates the end of the headers.\n      if (this.buffer[i] === CR && this.buffer[i + 1] === LF &&\n          this.buffer[i + 2] === CR && this.buffer[i + 3] === LF) {\n        // Parse each of the header lines out of the header block.\n        const headerLength = i + 4;\n        const headerBytes = this.buffer.subarray(0, headerLength);\n        const headerString = this.decoder.decode(headerBytes);\n        const headerLines = headerString.split('\\r\\n');\n        const headers: {[key: string]: string} = {};\n        for (const line of headerLines) {\n          if (!line.trim()) {\n            continue;\n          }\n          const pair = line.split(':');\n          if (pair.length !== 2) {\n            throw new Error(`Illegal header value: ${line}`);\n          }\n          headers[pair[0]] = pair[1].trim();\n        }\n        const contentLengthString = headers['Content-Length'];\n        if (!contentLengthString) {\n          throw new Error('Missing Content-Length header.');\n        }\n        const contentLength = Number(contentLengthString);\n        if (isNaN(contentLength)) {\n          throw new Error(\n              `Header Content-Length not a number: ${contentLengthString}.`);\n        }\n        const requiredLength = headerLength + contentLength;\n        if (requiredLength <= this.position) {\n          // This is just a view onto the current buffer.\n          const contentBytes =\n              this.buffer.subarray(headerLength, headerLength + contentLength);\n          const content = this.decoder.decode(contentBytes);\n          this.buffer.copyWithin(\n              0, headerLength + contentLength, this.position);\n          this.position = this.position - (headerLength + contentLength);\n          return {headers, content};\n        }\n      }\n    }\n    return null;\n  }\n}\n\n/** Encodes the string content to a JSON RPC message. */\nexport function encodeJsonRpc(content: string): string {\n  const headers: {[key: string]: string} = {\n    'Content-Length': String(new TextEncoder().encode(content).byteLength),\n  };\n  let requestString = '';\n  for (const key of Object.keys(headers)) {\n    requestString += `${key}: ${headers[key]}\\r\\n`;\n  }\n  requestString += '\\r\\n';\n  requestString += content;\n  return requestString;\n}\n"]}

web/jupyter.js

@@ -0,0 +1,214 @@
+"use strict";
+/*
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequest = exports.handleSocket = exports.close = exports.init = void 0;
+var childProcess = require("child_process");
+var httpProxy = require("http-proxy");
+var path = require("path");
+var logging = require("./logging");
+/**
+ * Singleton tracking the jupyter server instance we manage.
+ */
+var jupyterServer = null;
+/**
+ * The maximum number of times we'll restart jupyter; we set a limit to avoid
+ * users being stuck with a slow-crash-looping server.
+ */
+var remainingJupyterServerRestarts = 20;
+/**
+ * The application settings instance.
+ */
+var appSettings;
+/*
+ * This list of levels should match the ones used by Python:
+ *   https://docs.python.org/3/library/logging.html#logging-levels
+ */
+var LogLevels;
+(function (LogLevels) {
+    LogLevels["CRITICAL"] = "CRITICAL";
+    LogLevels["ERROR"] = "ERROR";
+    LogLevels["WARNING"] = "WARNING";
+    LogLevels["INFO"] = "INFO";
+    LogLevels["DEBUG"] = "DEBUG";
+    LogLevels["NOTSET"] = "NOTSET";
+})(LogLevels || (LogLevels = {}));
+function pipeOutput(stream) {
+    stream.setEncoding('utf8');
+    // The format we parse here corresponds to the log format we set in our
+    // jupyter configuration.
+    var logger = logging.getJupyterLogger();
+    stream.on('data', function (data) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(data.split('\n')), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var line = _c.value;
+                if (line.trim().length === 0) {
+                    continue;
+                }
+                var parts = line.split('|', 3);
+                if (parts.length !== 3) {
+                    // Non-logging messages (eg tracebacks) get logged as warnings.
+                    logger.warn(line);
+                    continue;
+                }
+                var level = parts[1];
+                var message = parts[2];
+                // We need to map Python's log levels to those used by bunyan.
+                if (level === LogLevels.CRITICAL || level === LogLevels.ERROR) {
+                    logger.error(message);
+                }
+                else if (level === LogLevels.WARNING) {
+                    logger.warn(message);
+                }
+                else if (level === LogLevels.INFO) {
+                    logger.info(message);
+                }
+                else {
+                    // We map DEBUG, NOTSET, and any unknown log levels to debug.
+                    logger.debug(message);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function createJupyterServer() {
+    var e_2, _a;
+    if (!remainingJupyterServerRestarts) {
+        logging.getLogger().error('No jupyter restart attempts remaining.');
+        return;
+    }
+    remainingJupyterServerRestarts -= 1;
+    var port = appSettings.nextJupyterPort;
+    logging.getLogger().info('Launching Jupyter server at %d', port);
+    var jupyterArgs = appSettings.jupyterArgs || [];
+    function exitHandler(code, signal) {
+        if (jupyterServer) {
+            logging.getLogger().error('Jupyter process %d exited due to signal: %s', jupyterServer.childProcess.pid, signal);
+        }
+        else {
+            logging.getLogger().error('Jupyter process exit before server creation finished due to signal: %s', signal);
+        }
+        // We want to restart jupyter whenever it terminates.
+        createJupyterServer();
+    }
+    var contentDir = path.join(appSettings.datalabRoot, appSettings.contentDir);
+    var processArgs = ['notebook'].concat(jupyterArgs || []).concat([
+        "--port=".concat(port),
+        "--FileContentsManager.root_dir=".concat(appSettings.datalabRoot, "/"),
+        // TODO(b/136659627): Delete this line.
+        "--MappingKernelManager.root_dir=".concat(contentDir),
+    ]);
+    var jupyterServerAddr = 'localhost';
+    try {
+        for (var jupyterArgs_1 = __values(jupyterArgs), jupyterArgs_1_1 = jupyterArgs_1.next(); !jupyterArgs_1_1.done; jupyterArgs_1_1 = jupyterArgs_1.next()) {
+            var flag = jupyterArgs_1_1.value;
+            // Extracts a string like '1.2.3.4' from the string '--ip=1.2.3.4'
+            var match = flag.match(/--ip=([^ ]+)/);
+            if (match) {
+                jupyterServerAddr = match[1];
+                break;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (jupyterArgs_1_1 && !jupyterArgs_1_1.done && (_a = jupyterArgs_1.return)) _a.call(jupyterArgs_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    logging.getLogger().info('Using jupyter server address %s', jupyterServerAddr);
+    var processOptions = {
+        detached: false,
+        env: process.env,
+    };
+    var serverProcess = childProcess.spawn('jupyter', processArgs, processOptions);
+    serverProcess.on('exit', exitHandler);
+    logging.getLogger().info('Jupyter process started with pid %d and args %j', serverProcess.pid, processArgs);
+    // Capture the output, so it can be piped for logging.
+    pipeOutput(serverProcess.stdout);
+    pipeOutput(serverProcess.stderr);
+    // Create the proxy.
+    var proxyTargetHost = appSettings.kernelManagerProxyHost || jupyterServerAddr;
+    var proxyTargetPort = appSettings.kernelManagerProxyPort || port;
+    var proxy = httpProxy.createProxyServer({ target: "http://".concat(proxyTargetHost, ":").concat(proxyTargetPort) });
+    proxy.on('error', errorHandler);
+    jupyterServer = { port: port, proxy: proxy, childProcess: serverProcess };
+}
+/**
+ * Initializes the Jupyter server manager.
+ */
+function init(settings) {
+    appSettings = settings;
+    createJupyterServer();
+}
+exports.init = init;
+/**
+ * Closes the Jupyter server manager.
+ */
+function close() {
+    if (!jupyterServer) {
+        return;
+    }
+    var pid = jupyterServer.childProcess.pid;
+    logging.getLogger().info("jupyter close: PID: ".concat(pid));
+    jupyterServer.childProcess.kill('SIGHUP');
+}
+exports.close = close;
+/** Proxy this socket request to jupyter. */
+function handleSocket(request, socket, head) {
+    if (!jupyterServer) {
+        logging.getLogger().error('Jupyter server is not running.');
+        return;
+    }
+    jupyterServer.proxy.ws(request, socket, head);
+}
+exports.handleSocket = handleSocket;
+/** Proxy this HTTP request to jupyter. */
+function handleRequest(request, response) {
+    if (!jupyterServer) {
+        response.statusCode = 500;
+        response.end();
+        return;
+    }
+    jupyterServer.proxy.web(request, response, null);
+}
+exports.handleRequest = handleRequest;
+function errorHandler(error, request, response) {
+    logging.getLogger().error(error, 'Jupyter server returned error.');
+    response.writeHead(500, 'Internal Server Error');
+    response.end();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jupyter.js","sourceRoot":"","sources":["../../../../../../third_party/colab/sources/jupyter.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\nimport * as childProcess from 'child_process';\nimport * as http from 'http';\nimport * as httpProxy from 'http-proxy';\nimport * as net from 'net';\nimport * as path from 'path';\n\nimport {AppSettings} from './appSettings';\nimport * as logging from './logging';\n\ninterface JupyterServer {\n  port: number;\n  childProcess: childProcess.ChildProcess;\n  proxy: httpProxy.ProxyServer;\n}\n\n/**\n * Singleton tracking the jupyter server instance we manage.\n */\nlet jupyterServer: JupyterServer|null = null;\n\n/**\n * The maximum number of times we'll restart jupyter; we set a limit to avoid\n * users being stuck with a slow-crash-looping server.\n */\nlet remainingJupyterServerRestarts: number = 20;\n\n/**\n * The application settings instance.\n */\nlet appSettings: AppSettings;\n\n/*\n * This list of levels should match the ones used by Python:\n *   https://docs.python.org/3/library/logging.html#logging-levels\n */\nenum LogLevels {\n  CRITICAL = 'CRITICAL',\n  ERROR = 'ERROR',\n  WARNING = 'WARNING',\n  INFO = 'INFO',\n  DEBUG = 'DEBUG',\n  NOTSET = 'NOTSET',\n}\n\nfunction pipeOutput(stream: NodeJS.ReadableStream) {\n  stream.setEncoding('utf8');\n\n  // The format we parse here corresponds to the log format we set in our\n  // jupyter configuration.\n  const logger = logging.getJupyterLogger();\n  stream.on('data', (data: string) => {\n    for (const line of data.split('\\n')) {\n      if (line.trim().length === 0) {\n        continue;\n      }\n      const parts = line.split('|', 3);\n      if (parts.length !== 3) {\n        // Non-logging messages (eg tracebacks) get logged as warnings.\n        logger.warn(line);\n        continue;\n      }\n      const level = parts[1];\n      const message = parts[2];\n      // We need to map Python's log levels to those used by bunyan.\n      if (level === LogLevels.CRITICAL || level === LogLevels.ERROR) {\n        logger.error(message);\n      } else if (level === LogLevels.WARNING) {\n        logger.warn(message);\n      } else if (level === LogLevels.INFO) {\n        logger.info(message);\n      } else {\n        // We map DEBUG, NOTSET, and any unknown log levels to debug.\n        logger.debug(message);\n      }\n    }\n  });\n}\n\nfunction createJupyterServer() {\n  if (!remainingJupyterServerRestarts) {\n    logging.getLogger().error('No jupyter restart attempts remaining.');\n    return;\n  }\n  remainingJupyterServerRestarts -= 1;\n  const port = appSettings.nextJupyterPort;\n  logging.getLogger().info('Launching Jupyter server at %d', port);\n  const jupyterArgs = appSettings.jupyterArgs || [];\n\n  function exitHandler(code: number, signal: string): void {\n    if (jupyterServer) {\n      logging.getLogger().error(\n          'Jupyter process %d exited due to signal: %s',\n          jupyterServer.childProcess.pid!, signal);\n    } else {\n      logging.getLogger().error(\n          'Jupyter process exit before server creation finished due to signal: %s',\n          signal);\n    }\n    // We want to restart jupyter whenever it terminates.\n    createJupyterServer();\n  }\n\n  const contentDir = path.join(appSettings.datalabRoot, appSettings.contentDir);\n  const processArgs = ['notebook'].concat(jupyterArgs || []).concat([\n    `--port=${port}`,\n    `--FileContentsManager.root_dir=${appSettings.datalabRoot}/`,\n    // TODO(b/136659627): Delete this line.\n    `--MappingKernelManager.root_dir=${contentDir}`,\n  ]);\n\n  let jupyterServerAddr = 'localhost';\n  for (const flag of jupyterArgs) {\n    // Extracts a string like '1.2.3.4' from the string '--ip=1.2.3.4'\n    const match = flag.match(/--ip=([^ ]+)/);\n    if (match) {\n      jupyterServerAddr = match[1];\n      break;\n    }\n  }\n  logging.getLogger().info(\n      'Using jupyter server address %s', jupyterServerAddr);\n\n  const processOptions = {\n    detached: false,\n    env: process.env,\n  };\n\n  const serverProcess =\n      childProcess.spawn('jupyter', processArgs, processOptions);\n  serverProcess.on('exit', exitHandler);\n  logging.getLogger().info(\n      'Jupyter process started with pid %d and args %j', serverProcess.pid!,\n      processArgs);\n\n  // Capture the output, so it can be piped for logging.\n  pipeOutput(serverProcess.stdout);\n  pipeOutput(serverProcess.stderr);\n\n  // Create the proxy.\n  const proxyTargetHost =\n      appSettings.kernelManagerProxyHost || jupyterServerAddr;\n  const proxyTargetPort = appSettings.kernelManagerProxyPort || port;\n\n  const proxy = httpProxy.createProxyServer(\n      {target: `http://${proxyTargetHost}:${proxyTargetPort}`});\n  proxy.on('error', errorHandler);\n\n  jupyterServer = {port, proxy, childProcess: serverProcess};\n}\n\n/**\n * Initializes the Jupyter server manager.\n */\nexport function init(settings: AppSettings): void {\n  appSettings = settings;\n  createJupyterServer();\n}\n\n/**\n * Closes the Jupyter server manager.\n */\nexport function close(): void {\n  if (!jupyterServer) {\n    return;\n  }\n\n  const pid = jupyterServer.childProcess.pid;\n  logging.getLogger().info(`jupyter close: PID: ${pid}`);\n  jupyterServer.childProcess.kill('SIGHUP');\n}\n\n/** Proxy this socket request to jupyter. */\nexport function handleSocket(\n    request: http.IncomingMessage, socket: net.Socket, head: Buffer) {\n  if (!jupyterServer) {\n    logging.getLogger().error('Jupyter server is not running.');\n    return;\n  }\n  jupyterServer.proxy.ws(request, socket, head);\n}\n\n/** Proxy this HTTP request to jupyter. */\nexport function handleRequest(\n    request: http.IncomingMessage, response: http.ServerResponse) {\n  if (!jupyterServer) {\n    response.statusCode = 500;\n    response.end();\n    return;\n  }\n\n  jupyterServer.proxy.web(request, response, null);\n}\n\nfunction errorHandler(\n    error: Error, request: http.IncomingMessage,\n    response: http.ServerResponse) {\n  logging.getLogger().error(error, 'Jupyter server returned error.');\n\n  response.writeHead(500, 'Internal Server Error');\n  response.end();\n}\n"]}

web/logging.js

@@ -0,0 +1,130 @@
+"use strict";
+/*
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeLoggers = exports.logRequest = exports.getJupyterLogger = exports.getLogger = void 0;
+var bunyan = require("bunyan");
+var path = require("path");
+// We import the bunyan-rotating-file-stream package, which exports a
+// constructor as a single object; we use lint disables here to make the usage
+// below look reasonable.
+//
+// tslint:disable-next-line:no-require-imports variable-name enforce-name-casing
+var RotatingFileStream = require('bunyan-rotating-file-stream');
+var logger = null;
+var requestLogger = null;
+var jupyterLogger = null;
+/**
+ * Gets the logger for generating debug logs.
+ * @returns the logger configured for debugging logging.
+ */
+function getLogger() {
+    return logger;
+}
+exports.getLogger = getLogger;
+/**
+ * Gets the logger for generating Jupyter logs.
+ * @returns the logger configured for Jupyter logging.
+ */
+function getJupyterLogger() {
+    return jupyterLogger;
+}
+exports.getJupyterLogger = getJupyterLogger;
+/**
+ * Logs a request and the corresponding response.
+ * @param request the request to be logged.
+ * @param response the response to be logged.
+ */
+function logRequest(request, response) {
+    requestLogger.debug({ url: request.url, method: request.method }, 'Received a new request');
+    response.on('finish', function () {
+        requestLogger.debug({
+            url: request.url,
+            method: request.method,
+            status: response.statusCode
+        });
+    });
+}
+exports.logRequest = logRequest;
+/**
+ * Initializes loggers used within the application.
+ */
+function initializeLoggers(settings) {
+    var e_1, _a;
+    // We configure our loggers as follows:
+    //  * our base logger tags all log records with `"name":"app"`, and sends logs
+    //    to stderr (including logs of all children)
+    //  * one child logger adds `"type":"request"`, and records method/URL for all
+    //    HTTP requests to the app, and method/URL/response code for all responses
+    //  * one child logger adds `"type":"jupyter"`, and records all messages from
+    //    the jupyter notebook server. These logs are also sent to a file on disk
+    //    (to assist user debugging).
+    //
+    // For more about bunyan, see:
+    //   https://github.com/trentm/node-bunyan/tree/f21007d46c0e64072617380b70d3f542368318a8
+    var jupyterLogPath = path.join(settings.datalabRoot, '/var/colab/app.log');
+    logger = bunyan.createLogger({
+        name: 'app',
+        streams: [
+            { level: 'debug', type: 'stream', stream: process.stderr },
+        ]
+    });
+    requestLogger = logger.child({ type: 'request' });
+    jupyterLogger = logger.child({
+        type: 'jupyter',
+        streams: [{
+                level: 'info',
+                type: 'stream',
+                stream: new RotatingFileStream({
+                    path: jupyterLogPath,
+                    rotateExisting: false,
+                    threshold: '2m',
+                    totalSize: '20m'
+                }),
+            }]
+    });
+    // Omit superfluous fields, unless using the bunyan CLI to make logs human
+    // readable, because the CLI requires them.
+    if (process.env['COLAB_HUMAN_READABLE_NODE_LOGS'] !== '1') {
+        try {
+            for (var _b = __values([logger, jupyterLogger, requestLogger]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var logs = _c.value;
+                delete logs.fields['hostname'];
+                delete logs.fields['name'];
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+}
+exports.initializeLoggers = initializeLoggers;
+//# sourceMappingURL=data:application/json;base64,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

web/lsp/capabilities_node.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

web/lsp/extensions_node.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5zaW9uc19ub2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vZ2VuZmlsZXMvdGhpcmRfcGFydHkvY29sYWIvc291cmNlcy9sc3AvZXh0ZW5zaW9uc19ub2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJcbmltcG9ydCAqIGFzIGNhcGFiaWxpdGllcyBmcm9tICcuL2NhcGFiaWxpdGllc19ub2RlJztcbmltcG9ydCAqIGFzIHRleHREb2N1bWVudCBmcm9tICcuL3RleHRfZG9jdW1lbnRfbm9kZSc7XG5cbi8vIHRzbGludDpkaXNhYmxlOmVuZm9yY2UtbmFtZS1jYXNpbmdcblxuLyoqXG4gKiBQYXJhbWV0ZXIgZm9yIGBpbml0aWFsaXplYCBtZXNzYWdlcy5cbiAqIEFkZHMgYSBmbGFnIGNvbnRyb2xsaW5nIHdoZXRoZXIgd2UgcnVuIEF1dG9GaXguXG4gKi9cbmV4cG9ydCBkZWNsYXJlIGludGVyZmFjZSBJbml0aWFsaXplUGFyYW1zIGV4dGVuZHNcbiAgICBjYXBhYmlsaXRpZXMuSW5pdGlhbGl6ZVBhcmFtcyB7XG4gIGF1dG9GaXg6IGJvb2xlYW47XG59XG5cbi8qKlxuICogUGFyYW1ldGVyIGZvciBgdGV4dERvY3VtZW50L2RpZE9wZW5gIG1lc3NhZ2VzLlxuICogQWRkcyBhIHByZWFtYmxlIHN0cmluZy5cbiAqL1xuZXhwb3J0IGRlY2xhcmUgaW50ZXJmYWNlIERpZE9wZW5UZXh0RG9jdW1lbnRQYXJhbXMgZXh0ZW5kc1xuICAgIHRleHREb2N1bWVudC5EaWRPcGVuVGV4dERvY3VtZW50UGFyYW1zIHtcbiAgcmVhZG9ubHkgcHJlYW1ibGU6IHN0cmluZztcbn1cbiJdfQ==

web/lsp/protocol_node.js

@@ -0,0 +1,186 @@
+"use strict";
+// tslint:disable:enforce-name-casing
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolTag = exports.SymbolKind = exports.DiagnosticSeverity = exports.DiagnosticTag = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.ErrorCode = exports.Method = void 0;
+/**
+ * JSON-RPC Methods.
+ */
+var Method;
+(function (Method) {
+    Method["CancelRequest"] = "$/cancelRequest";
+    Method["ClientRegisterCapability"] = "client/registerCapability";
+    Method["ColabPipLogChanged"] = "colab/pipLogChanged";
+    Method["CompletionItemResolve"] = "completionItem/resolve";
+    Method["Initialize"] = "initialize";
+    Method["Initialized"] = "initialized";
+    Method["TextDocumentAutoExecuteCheck"] = "textDocument/autoExecuteCheck";
+    Method["TextDocumentCodeAction"] = "textDocument/codeAction";
+    Method["TextDocumentCompletion"] = "textDocument/completion";
+    Method["TextDocumentDefinition"] = "textDocument/definition";
+    Method["TextDocumentDidChange"] = "textDocument/didChange";
+    Method["TextDocumentDidClose"] = "textDocument/didClose";
+    Method["TextDocumentDidOpen"] = "textDocument/didOpen";
+    Method["TextDocumentEchoDocument"] = "textDocument/echoDocument";
+    Method["TextDocumentHover"] = "textDocument/hover";
+    Method["TextDocumentPublishDiagnostics"] = "textDocument/publishDiagnostics";
+    Method["TextDocumentRename"] = "textDocument/rename";
+    Method["TextDocumentSignatureHelp"] = "textDocument/signatureHelp";
+    Method["WindowLogMessage"] = "window/logMessage";
+    Method["WorkspaceConfiguration"] = "workspace/configuration";
+    Method["WorkspaceDidChangeConfiguration"] = "workspace/didChangeConfiguration";
+    Method["WorkspaceDidChangeWatchedFiles"] = "workspace/didChangeWatchedFiles";
+})(Method || (exports.Method = Method = {}));
+/**
+ * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    // Defined by JSON RPC
+    ErrorCode[ErrorCode["ParseError"] = -32700] = "ParseError";
+    ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+    ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+    ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+    ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
+    ErrorCode[ErrorCode["ServerErrorStart"] = -32099] = "ServerErrorStart";
+    ErrorCode[ErrorCode["ServerErrorEnd"] = -32000] = "ServerErrorEnd";
+    ErrorCode[ErrorCode["ServerNotInitialized"] = -32002] = "ServerNotInitialized";
+    ErrorCode[ErrorCode["UnknownErrorCode"] = -32001] = "UnknownErrorCode";
+    // Defined by the protocol.
+    ErrorCode[ErrorCode["RequestCancelled"] = -32800] = "RequestCancelled";
+    ErrorCode[ErrorCode["ContentModified"] = -32801] = "ContentModified";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+/**
+ * The kind of resource operations supported by the client.
+ */
+var ResourceOperationKind;
+(function (ResourceOperationKind) {
+    /**
+     * Supports creating new files and folders.
+     */
+    ResourceOperationKind["CREATE"] = "create";
+    /**
+     * Supports renaming existing files and folders.
+     */
+    ResourceOperationKind["RENAME"] = "rename";
+    /**
+     * Supports deleting existing files and folders.
+     */
+    ResourceOperationKind["DELETE"] = "delete";
+})(ResourceOperationKind || (exports.ResourceOperationKind = ResourceOperationKind = {}));
+/**
+ * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspaceEditClientCapabilities
+ */
+var FailureHandlingKind;
+(function (FailureHandlingKind) {
+    /**
+     * Applying the workspace change is simply aborted if one of the changes
+     * provided fails.
+     * All operations executed before the failing operation stay executed.
+     */
+    FailureHandlingKind["Abort"] = "abort";
+    /**
+     * All operations are executed transactional. That means they either all
+     * succeed or no changes at all are applied to the workspace.
+     */
+    FailureHandlingKind["Transactional"] = "transactional";
+    /**
+     * If the workspace edit contains only textual file changes, they are
+     * executed transactionally.
+     * If resource changes (create, rename or delete file) are part of the
+     * change, the failure handling strategy is abort.
+     */
+    FailureHandlingKind["TextOnlyTransactional"] = "textOnlyTransactional";
+    /**
+     * The client tries to undo the operations already executed. But there is no
+     * guarantee that this is succeeding.
+     */
+    FailureHandlingKind["Undo"] = "undo";
+})(FailureHandlingKind || (exports.FailureHandlingKind = FailureHandlingKind = {}));
+/**
+ * The diagnostic tags.
+ *
+ * @since 3.15.0
+ */
+var DiagnosticTag;
+(function (DiagnosticTag) {
+    /**
+     * Unused or unnecessary code.
+     *
+     * Clients are allowed to render diagnostics with this tag faded out
+     * instead of having an error squiggle.
+     */
+    DiagnosticTag[DiagnosticTag["Unnecessary"] = 1] = "Unnecessary";
+    /**
+     * Deprecated or obsolete code.
+     *
+     * Clients are allowed to rendered diagnostics with this tag strike through.
+     */
+    DiagnosticTag[DiagnosticTag["Deprecated"] = 2] = "Deprecated";
+})(DiagnosticTag || (exports.DiagnosticTag = DiagnosticTag = {}));
+/**
+ * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#diagnostic
+ */
+var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    /**
+     * Reports an error.
+     */
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 1] = "Error";
+    /**
+     * Reports a warning.
+     */
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
+    /**
+     * Reports an information.
+     */
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 3] = "Information";
+    /**
+     * Reports a hint.
+     */
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 4] = "Hint";
+})(DiagnosticSeverity || (exports.DiagnosticSeverity = DiagnosticSeverity = {}));
+/**
+ * A symbol kind.
+ */
+var SymbolKind;
+(function (SymbolKind) {
+    SymbolKind[SymbolKind["File"] = 1] = "File";
+    SymbolKind[SymbolKind["Module"] = 2] = "Module";
+    SymbolKind[SymbolKind["Namespace"] = 3] = "Namespace";
+    SymbolKind[SymbolKind["Package"] = 4] = "Package";
+    SymbolKind[SymbolKind["Class"] = 5] = "Class";
+    SymbolKind[SymbolKind["Method"] = 6] = "Method";
+    SymbolKind[SymbolKind["Property"] = 7] = "Property";
+    SymbolKind[SymbolKind["Field"] = 8] = "Field";
+    SymbolKind[SymbolKind["Constructor"] = 9] = "Constructor";
+    SymbolKind[SymbolKind["Enum"] = 10] = "Enum";
+    SymbolKind[SymbolKind["Interface"] = 11] = "Interface";
+    SymbolKind[SymbolKind["Function"] = 12] = "Function";
+    SymbolKind[SymbolKind["Variable"] = 13] = "Variable";
+    SymbolKind[SymbolKind["Constant"] = 14] = "Constant";
+    SymbolKind[SymbolKind["String"] = 15] = "String";
+    SymbolKind[SymbolKind["Number"] = 16] = "Number";
+    SymbolKind[SymbolKind["Boolean"] = 17] = "Boolean";
+    SymbolKind[SymbolKind["Array"] = 18] = "Array";
+    SymbolKind[SymbolKind["Object"] = 19] = "Object";
+    SymbolKind[SymbolKind["Key"] = 20] = "Key";
+    SymbolKind[SymbolKind["Null"] = 21] = "Null";
+    SymbolKind[SymbolKind["EnumMember"] = 22] = "EnumMember";
+    SymbolKind[SymbolKind["Struct"] = 23] = "Struct";
+    SymbolKind[SymbolKind["Event"] = 24] = "Event";
+    SymbolKind[SymbolKind["Operator"] = 25] = "Operator";
+    SymbolKind[SymbolKind["TypeParameter"] = 26] = "TypeParameter";
+})(SymbolKind || (exports.SymbolKind = SymbolKind = {}));
+/**
+ * Symbol tags are extra annotations that tweak the rendering of a symbol.
+ *
+ * @since 3.16
+ */
+var SymbolTag;
+(function (SymbolTag) {
+    /**
+     * Render a symbol as obsolete, usually using a strike-out.
+     */
+    SymbolTag[SymbolTag["Deprecated"] = 1] = "Deprecated";
+})(SymbolTag || (exports.SymbolTag = SymbolTag = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol_node.js","sourceRoot":"","sources":["../../../../../../../../genfiles/third_party/colab/sources/lsp/protocol_node.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:enforce-name-casing\n\n/**\n * JSON-RPC Methods.\n */\nexport enum Method {\n  CancelRequest = '$/cancelRequest',\n  ClientRegisterCapability = 'client/registerCapability',\n  ColabPipLogChanged = 'colab/pipLogChanged',\n  CompletionItemResolve = 'completionItem/resolve',\n  Initialize = 'initialize',\n  Initialized = 'initialized',\n  TextDocumentAutoExecuteCheck = 'textDocument/autoExecuteCheck',\n  TextDocumentCodeAction = 'textDocument/codeAction',\n  TextDocumentCompletion = 'textDocument/completion',\n  TextDocumentDefinition = 'textDocument/definition',\n  TextDocumentDidChange = 'textDocument/didChange',\n  TextDocumentDidClose = 'textDocument/didClose',\n  TextDocumentDidOpen = 'textDocument/didOpen',\n  TextDocumentEchoDocument = 'textDocument/echoDocument',\n  TextDocumentHover = 'textDocument/hover',\n  TextDocumentPublishDiagnostics = 'textDocument/publishDiagnostics',\n  TextDocumentRename = 'textDocument/rename',\n  TextDocumentSignatureHelp = 'textDocument/signatureHelp',\n  WindowLogMessage = 'window/logMessage',\n  WorkspaceConfiguration = 'workspace/configuration',\n  WorkspaceDidChangeConfiguration = 'workspace/didChangeConfiguration',\n  WorkspaceDidChangeWatchedFiles = 'workspace/didChangeWatchedFiles',\n}\n\n/** Base JSON-RPC 2.0 type. */\nexport declare interface Message {\n  jsonrpc: '2.0';\n}\n\n/**\n * JSON-RPC 2.0 request.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#requestMessage\n */\nexport declare interface RequestMessage<T> extends Message {\n  /**\n   * The request id.\n   */\n  id: number|string;\n  /**\n   * The method to be invoked.\n   */\n  method: Method;\n  /**\n   * The method's params.\n   */\n  params: T;\n}\n\n/**\n * JSON-RPC 2.0 response.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage\n */\nexport declare interface ResponseMessage extends Message {\n  /**\n   * The request id.\n   */\n  id: number|string|null;\n\n  /**\n   * The result of a request. This member is REQUIRED on success.\n   * This member MUST NOT exist if there was an error invoking the method.\n   */\n  result?: string|number|boolean|object|null;\n\n  /**\n   * The error object in case a request fails.\n   */\n  error?: ResponseError;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage\n */\nexport declare interface ResponseError {\n  /**\n   * A number indicating the error type that occurred.\n   */\n  code: number;\n\n  /**\n   * A string providing a short description of the error.\n   */\n  message: string;\n\n  /**\n   * A primitive or structured value that contains additional\n   * information about the error. Can be omitted.\n   */\n  data?: string|number|boolean|unknown[]|object|null;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#responseMessage\n */\nexport enum ErrorCode {\n  // Defined by JSON RPC\n  ParseError = -32700,\n  InvalidRequest = -32600,\n  MethodNotFound = -32601,\n  InvalidParams = -32602,\n  InternalError = -32603,\n  ServerErrorStart = -32099,\n  ServerErrorEnd = -32000,\n  ServerNotInitialized = -32002,\n  UnknownErrorCode = -32001,\n\n  // Defined by the protocol.\n  RequestCancelled = -32800,\n  ContentModified = -32801,\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#notificationMessage\n */\nexport declare interface NotificationMessage<T> extends Message {\n  /**\n   * The method to be invoked.\n   */\n  method: string;\n\n  /**\n   * The notification's params.\n   */\n  params: T;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#cancelRequest\n */\nexport declare interface CancelParams {\n  /**\n   * The request id to cancel.\n   */\n  id: number|string;\n}\n\ntype ProgressToken = number|string;\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#progress\n */\nexport declare interface ProgressParams<T> {\n  /**\n   * The progress token provided by the client or server.\n   */\n  token: ProgressToken;\n\n  /**\n   * The progress data.\n   */\n  value: T;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#uri\n */\nexport type DocumentUri = string;\n\n/**\n * Position in a text document expressed as zero-based line and zero-based\n * character offset. A position is between two characters like an ‘insert’\n * cursor in a editor. Special values like for example -1 to denote the end of\n * a line are not supported.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#position\n */\nexport declare interface Position {\n  /**\n   * Line position in a document (zero-based).\n   */\n  line: number;\n\n  /**\n   * Character offset on a line in a document (zero-based). Assuming that the\n   * line is represented as a string, the `character` value represents the gap\n   * between the `character` and `character + 1`.\n   *\n   * If the character value is greater than the line length it defaults back\n   * to the line length.\n   */\n  character: number;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#range\n */\nexport declare interface Range {\n  /**\n   * The range's start position.\n   */\n  start: Position;\n\n  /**\n   * The range's end position.\n   */\n  end: Position;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#location\n */\nexport declare interface Location {\n  uri: DocumentUri;\n  range: Range;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#locationLink\n */\nexport declare interface LocationLink {\n  /**\n   * Span of the origin of this link.\n   *\n   * Used as the underlined span for mouse interaction.\n   * Defaults to the word range at the mouse position.\n   */\n  originSelectionRange?: Range;\n\n  /**\n   * The target resource identifier of this link.\n   */\n  targetUri: DocumentUri;\n\n  /**\n   * The full target range of this link.\n   * For example, if the target is a symbol, then target range is the range\n   * enclosing this symbol not including leading/trailing whitespace but\n   * everything else like comments.\n   * This information is typically used to highlight the range in the editor.\n   */\n  targetRange: Range;\n\n  /**\n   * The range that should be selected and revealed when this link is being\n   * followed, for example, the name of a function.\n   * Must be contained by the `targetRange`.\n   * See also `DocumentSymbol#range`\n   */\n  targetSelectionRange: Range;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#command\n */\nexport interface Command {\n  /**\n   * Title of the command, like `save`.\n   */\n  title: string;\n  /**\n   * The identifier of the actual command handler.\n   */\n  command: string;\n  /**\n   * Arguments that the command handler should be\n   * invoked with.\n   */\n  arguments?: unknown[];\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspaceEditClientCapabilities\n */\nexport declare interface WorkspaceEditClientCapabilities {\n  /**\n   * The client supports versioned document changes in `WorkspaceEdit`s\n   */\n  documentChanges?: boolean;\n\n  /**\n   * The resource operations the client supports. Clients should at least\n   * support 'create', 'rename' and 'delete' files and folders.\n   *\n   * @since 3.13.0\n   */\n  resourceOperations?: ResourceOperationKind[];\n\n  /**\n   * The failure handling strategy of a client if applying the workspace edit\n   * fails.\n   *\n   * @since 3.13.0\n   */\n  failureHandling?: FailureHandlingKind;\n}\n\n/**\n * The kind of resource operations supported by the client.\n */\nexport enum ResourceOperationKind {\n  /**\n   * Supports creating new files and folders.\n   */\n  CREATE = 'create',\n  /**\n   * Supports renaming existing files and folders.\n   */\n  RENAME = 'rename',\n  /**\n   * Supports deleting existing files and folders.\n   */\n  DELETE = 'delete',\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspaceEditClientCapabilities\n */\nexport enum FailureHandlingKind {\n  /**\n   * Applying the workspace change is simply aborted if one of the changes\n   * provided fails.\n   * All operations executed before the failing operation stay executed.\n   */\n  Abort = 'abort',\n\n  /**\n   * All operations are executed transactional. That means they either all\n   * succeed or no changes at all are applied to the workspace.\n   */\n  Transactional = 'transactional',\n\n  /**\n   * If the workspace edit contains only textual file changes, they are\n   * executed transactionally.\n   * If resource changes (create, rename or delete file) are part of the\n   * change, the failure handling strategy is abort.\n   */\n  TextOnlyTransactional = 'textOnlyTransactional',\n\n  /**\n   * The client tries to undo the operations already executed. But there is no\n   * guarantee that this is succeeding.\n   */\n  Undo = 'undo',\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#documentFilter\n */\nexport declare interface DocumentFilter {\n  /**\n   * A language id, like `typescript`.\n   */\n  language?: string;\n\n  /**\n   * A Uri [scheme](#Uri.scheme), like `file` or `untitled`.\n   */\n  scheme?: string;\n\n  /**\n   * A glob pattern, like `*.{ts,js}`.\n   *\n   * Glob patterns can have the following syntax:\n   * - `*` to match one or more characters in a path segment\n   * - `?` to match on one character in a path segment\n   * - `**` to match any number of path segments, including none\n   * - `{}` to group conditions\n   *   (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)\n   * - `[]` to declare a range of characters to match in a path segment\n   *   (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)\n   * - `[!...]` to negate a range of characters to match in a path segment\n   *   (e.g., `example.[!0-9]` to match on `example.a`, `example.b`,\n   *    but not `example.0`)\n   */\n  pattern?: string;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#documentFilter\n */\nexport type DocumentSelector = DocumentFilter[];\n\n/**\n * Static registration options to be returned in the initialize request.\n */\nexport declare interface StaticRegistrationOptions {\n  /**\n   * The id used to register the request. The id can be used to deregister\n   * the request again. See also Registration#id.\n   */\n  id?: string;\n}\n\n/**\n * General text document registration options.\n */\nexport declare interface TextDocumentRegistrationOptions {\n  /**\n   * A document selector to identify the scope of the registration.\n   * If set to null, the document selector provided on the client side\n   * will be used.\n   */\n  documentSelector: DocumentSelector|null;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initiatingWorkDoneProgress\n */\nexport declare interface WorkDoneProgressParams {\n  /**\n   * An optional token that a server can use to report work done progress.\n   */\n  workDoneToken?: ProgressToken;\n}\n\n/**\n * The diagnostic tags.\n *\n * @since 3.15.0\n */\nexport enum DiagnosticTag {\n  /**\n   * Unused or unnecessary code.\n   *\n   * Clients are allowed to render diagnostics with this tag faded out\n   * instead of having an error squiggle.\n   */\n  Unnecessary = 1,\n  /**\n   * Deprecated or obsolete code.\n   *\n   * Clients are allowed to rendered diagnostics with this tag strike through.\n   */\n  Deprecated = 2,\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#diagnostic\n */\nexport declare interface Diagnostic {\n  /**\n   * The range at which the message applies.\n   */\n  range: Range;\n\n  /**\n   * The diagnostic's severity. Can be omitted. If omitted it is up to the\n   * client to interpret diagnostics as error, warning, info or hint.\n   */\n  severity?: DiagnosticSeverity;\n\n  /**\n   * The diagnostic's code, which might appear in the user interface.\n   */\n  code?: number|string;\n\n  /**\n   * A human-readable string describing the source of this\n   * diagnostic, e.g. 'typescript' or 'super lint'.\n   */\n  source?: string;\n\n  /**\n   * The diagnostic's message.\n   */\n  message: string;\n\n  /**\n   * Additional metadata about the diagnostic.\n   *\n   * @since 3.15.0\n   */\n  tags?: DiagnosticTag[];\n\n  /**\n   * An array of related diagnostic information, e.g. when symbol-names within\n   * a scope collide all definitions can be marked via this property.\n   */\n  relatedInformation?: DiagnosticRelatedInformation[];\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#diagnostic\n */\nexport enum DiagnosticSeverity {\n  /**\n   * Reports an error.\n   */\n  Error = 1,\n  /**\n   * Reports a warning.\n   */\n  Warning = 2,\n  /**\n   * Reports an information.\n   */\n  Information = 3,\n  /**\n   * Reports a hint.\n   */\n  Hint = 4,\n}\n\n/**\n * Represents a related message and source code location for a diagnostic.\n * This should be used to point to code locations that cause or are related\n * to a diagnostics, for example, when duplicating a symbol in a scope.\n */\nexport declare interface DiagnosticRelatedInformation {\n  /**\n   * The location of this related diagnostic information.\n   */\n  location: Location;\n\n  /**\n   * The message of this related diagnostic information.\n   */\n  message: string;\n}\n\n/**\n * A symbol kind.\n */\nexport enum SymbolKind {\n  File = 1,\n  Module = 2,\n  Namespace = 3,\n  Package = 4,\n  Class = 5,\n  Method = 6,\n  Property = 7,\n  Field = 8,\n  Constructor = 9,\n  Enum = 10,\n  Interface = 11,\n  Function = 12,\n  Variable = 13,\n  Constant = 14,\n  String = 15,\n  Number = 16,\n  Boolean = 17,\n  Array = 18,\n  Object = 19,\n  Key = 20,\n  Null = 21,\n  EnumMember = 22,\n  Struct = 23,\n  Event = 24,\n  Operator = 25,\n  TypeParameter = 26,\n}\n\n/**\n * Symbol tags are extra annotations that tweak the rendering of a symbol.\n *\n * @since 3.16\n */\nexport enum SymbolTag {\n\n  /**\n   * Render a symbol as obsolete, usually using a strike-out.\n   */\n  Deprecated = 1,\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand\n */\nexport declare interface ExecuteCommandClientCapabilities {\n  /**\n   * Execute command supports dynamic registration.\n   */\n  dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#partialResultParams\n */\nexport declare interface PartialResultParams {\n  /**\n   * An optional token that a server can use to report partial results (e.g.\n   * streaming) to the client.\n   */\n  partialResultToken?: ProgressToken;\n}\n\n/**\n * Defines an integer number in the range of -2^31 to 2^31 - 1.\n */\nexport type integer = number;\n/**\n * Defines an unsigned integer number in the range of 0 to 2^31 - 1.\n */\nexport type uinteger = number;\n/**\n * Defines a decimal number. Since decimal numbers are very\n * rare in the language server specification we denote the\n * exact range with every decimal using the mathematics\n * interval notation (e.g. [0, 1] denotes all decimals d with\n * 0 <= d <= 1.\n */\nexport type decimal = number;\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialized\n */\nexport interface Initialized extends NotificationMessage<InitializedParams> {\n  method: Method.Initialized;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialized\n */\nexport interface InitializedParams {}\n\n/**\n * General parameters to register for a capability.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#client_registerCapability\n */\nexport interface Registration {\n  /**\n   * The id used to register the request. The id can be used to deregister\n   * the request again.\n   */\n  id: string;\n\n  /**\n   * The method / capability to register for.\n   */\n  method: string;\n\n  /**\n   * Options necessary for the registration.\n   */\n  registerOptions?: unknown;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#client_registerCapability\n */\nexport interface RegistrationParams {\n  registrations: Registration[];\n}\n"]}

web/lsp/settings_node.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.all = void 0;
+/**
+ * Settings which may be used by the Python language server.
+ * These are from the default preferences from a VSCode client, culled
+ * to the LSP-related values.
+ *
+ * The difficulty here is that LSP only defines a mechanism to provide
+ * generic settings and the server expects the client to send all necessary
+ * settings. VSCode sends all Python settings to every Python language server.
+ * Furthermore the language server may request specific settings later.
+ *
+ * See:
+ * https://github.com/microsoft/pyright/blob/9d4e58d06643dccbfe0f450070334675b6b64724/docs/settings.md
+ */
+exports.all = {
+    'python': {
+        'analysis': {
+            'diagnosticPublishDelay': 1000,
+            'errors': [],
+            'warnings': [],
+            'information': [],
+            'disabled': [],
+            'typeshedPaths': [],
+            'cacheFolderPath': '',
+            'memory': { 'keepLibraryAst': false },
+            'logLevel': 'Warning',
+            'symbolsHierarchyDepthLimit': 10,
+            'completeFunctionParens': false,
+            'autoImportCompletions': true,
+            'autoSearchPaths': true,
+            'stubPath': 'typings',
+            'diagnosticMode': 'openFilesOnly',
+            'extraPaths': [],
+            'useLibraryCodeForTypes': true,
+            'typeCheckingMode': 'basic',
+            // See diagnostics explanation at:
+            // https://github.com/microsoft/pyright/blob/main/docs/configuration.md
+            'diagnosticSeverityOverrides': {},
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

web/lsp/text_document_node.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureHelpTriggerKind = exports.InsertTextMode = exports.InsertTextFormat = exports.CodeActionKind = exports.TextDocumentSyncKind = exports.CompletionTriggerKind = exports.LanguageIdentifier = exports.CompletionItemKind = exports.CompletionItemTag = exports.MarkupKind = void 0;
+/**
+ * Describes the content type that a client supports in various
+ * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
+ *
+ * Please note that `MarkupKinds` must not start with a `$`. This kinds
+ * are reserved for internal usage.
+ */
+var MarkupKind;
+(function (MarkupKind) {
+    /**
+     * Plain text is supported as a content format
+     */
+    MarkupKind["PlainText"] = "plaintext";
+    /**
+     * Markdown is supported as a content format
+     */
+    MarkupKind["Markdown"] = "markdown";
+})(MarkupKind || (exports.MarkupKind = MarkupKind = {}));
+/**
+ * Completion item tags are extra annotations that tweak the rendering of
+ * a completion item.
+ *
+ * @since 3.15.0
+ */
+var CompletionItemTag;
+(function (CompletionItemTag) {
+    /**
+     * Render a completion as obsolete, usually using a strike-out.
+     */
+    CompletionItemTag[CompletionItemTag["Deprecated"] = 1] = "Deprecated";
+})(CompletionItemTag || (exports.CompletionItemTag = CompletionItemTag = {}));
+/**
+ * The kind of a completion entry.
+ */
+var CompletionItemKind;
+(function (CompletionItemKind) {
+    CompletionItemKind[CompletionItemKind["Text"] = 1] = "Text";
+    CompletionItemKind[CompletionItemKind["Method"] = 2] = "Method";
+    CompletionItemKind[CompletionItemKind["Function"] = 3] = "Function";
+    CompletionItemKind[CompletionItemKind["Constructor"] = 4] = "Constructor";
+    CompletionItemKind[CompletionItemKind["Field"] = 5] = "Field";
+    CompletionItemKind[CompletionItemKind["Variable"] = 6] = "Variable";
+    CompletionItemKind[CompletionItemKind["Class"] = 7] = "Class";
+    CompletionItemKind[CompletionItemKind["Interface"] = 8] = "Interface";
+    CompletionItemKind[CompletionItemKind["Module"] = 9] = "Module";
+    CompletionItemKind[CompletionItemKind["Property"] = 10] = "Property";
+    CompletionItemKind[CompletionItemKind["Unit"] = 11] = "Unit";
+    CompletionItemKind[CompletionItemKind["Value"] = 12] = "Value";
+    CompletionItemKind[CompletionItemKind["Enum"] = 13] = "Enum";
+    CompletionItemKind[CompletionItemKind["Keyword"] = 14] = "Keyword";
+    CompletionItemKind[CompletionItemKind["Snippet"] = 15] = "Snippet";
+    CompletionItemKind[CompletionItemKind["Color"] = 16] = "Color";
+    CompletionItemKind[CompletionItemKind["File"] = 17] = "File";
+    CompletionItemKind[CompletionItemKind["Reference"] = 18] = "Reference";
+    CompletionItemKind[CompletionItemKind["Folder"] = 19] = "Folder";
+    CompletionItemKind[CompletionItemKind["EnumMember"] = 20] = "EnumMember";
+    CompletionItemKind[CompletionItemKind["Constant"] = 21] = "Constant";
+    CompletionItemKind[CompletionItemKind["Struct"] = 22] = "Struct";
+    CompletionItemKind[CompletionItemKind["Event"] = 23] = "Event";
+    CompletionItemKind[CompletionItemKind["Operator"] = 24] = "Operator";
+    CompletionItemKind[CompletionItemKind["TypeParameter"] = 25] = "TypeParameter";
+})(CompletionItemKind || (exports.CompletionItemKind = CompletionItemKind = {}));
+/**
+ * Known language identifiers.
+ * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentItem
+ */
+var LanguageIdentifier;
+(function (LanguageIdentifier) {
+    LanguageIdentifier["ABAP"] = "abap";
+    LanguageIdentifier["WindowsBat"] = "bat";
+    LanguageIdentifier["BibTeX"] = "bibtex";
+    LanguageIdentifier["Clojure"] = "clojure";
+    LanguageIdentifier["Coffeescript"] = "coffeescript";
+    LanguageIdentifier["C"] = "c";
+    LanguageIdentifier["CPlusPlus"] = "cpp";
+    LanguageIdentifier["CSharp"] = "csharp";
+    LanguageIdentifier["CSS"] = "css";
+    LanguageIdentifier["Diff"] = "diff";
+    LanguageIdentifier["Dart"] = "dart";
+    LanguageIdentifier["Dockerfile"] = "dockerfile";
+    LanguageIdentifier["Elixir"] = "elixir";
+    LanguageIdentifier["Erlang"] = "erlang";
+    LanguageIdentifier["FSharp"] = "fsharp";
+    LanguageIdentifier["GitCommit"] = "git-commit";
+    LanguageIdentifier["GitRebase"] = "git-rebase";
+    LanguageIdentifier["Go"] = "go";
+    LanguageIdentifier["Groovy"] = "groovy";
+    LanguageIdentifier["Handlebars"] = "handlebars";
+    LanguageIdentifier["HTML"] = "html";
+    LanguageIdentifier["Ini"] = "ini";
+    LanguageIdentifier["Java"] = "java";
+    LanguageIdentifier["JavaScript"] = "javascript";
+    LanguageIdentifier["JavaScriptReact"] = "javascriptreact";
+    LanguageIdentifier["JSON"] = "json";
+    LanguageIdentifier["LaTeX"] = "latex";
+    LanguageIdentifier["Less"] = "less";
+    LanguageIdentifier["Lua"] = "lua";
+    LanguageIdentifier["Makefile"] = "makefile";
+    LanguageIdentifier["Markdown"] = "markdown";
+    LanguageIdentifier["ObjectiveC"] = "c";
+    LanguageIdentifier["ObjectiveCPlusPlus"] = "cpp";
+    LanguageIdentifier["Perl"] = "perl";
+    LanguageIdentifier["Perl6"] = "perl6";
+    LanguageIdentifier["PHP"] = "php";
+    LanguageIdentifier["Powershell"] = "powershell";
+    LanguageIdentifier["Pug"] = "jade";
+    LanguageIdentifier["Python"] = "python";
+    LanguageIdentifier["R"] = "r";
+    LanguageIdentifier["Razor"] = "razor";
+    LanguageIdentifier["Ruby"] = "ruby";
+    LanguageIdentifier["Rust"] = "rust";
+    LanguageIdentifier["SCSS"] = "scss";
+    LanguageIdentifier["Sass"] = "syntax";
+    LanguageIdentifier["Scala"] = "scala";
+    LanguageIdentifier["ShaderLab"] = "shaderlab";
+    LanguageIdentifier["Shell"] = "shellscript";
+    LanguageIdentifier["SQL"] = "sql";
+    LanguageIdentifier["Swift"] = "swift";
+    LanguageIdentifier["TypeScript"] = "typescript";
+    LanguageIdentifier["TypeScriptReact"] = "typescriptreact";
+    LanguageIdentifier["TeX"] = "tex";
+    LanguageIdentifier["VisualBasic"] = "vb";
+    LanguageIdentifier["XML"] = "xml";
+    LanguageIdentifier["XSL"] = "xsl";
+    LanguageIdentifier["YAML"] = "yaml";
+})(LanguageIdentifier || (exports.LanguageIdentifier = LanguageIdentifier = {}));
+/**
+ * How a completion was triggered
+ * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion
+ */
+var CompletionTriggerKind;
+(function (CompletionTriggerKind) {
+    /**
+     * Completion was triggered by typing an identifier (24x7 code
+     * complete), manual invocation (e.g Ctrl+Space) or via API.
+     */
+    CompletionTriggerKind[CompletionTriggerKind["Invoked"] = 1] = "Invoked";
+    /**
+     * Completion was triggered by a trigger character specified by
+     * the `triggerCharacters` properties of the
+     * `CompletionRegistrationOptions`.
+     */
+    CompletionTriggerKind[CompletionTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter";
+    /**
+     * Completion was re-triggered as the current completion list is incomplete.
+     */
+    CompletionTriggerKind[CompletionTriggerKind["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions";
+})(CompletionTriggerKind || (exports.CompletionTriggerKind = CompletionTriggerKind = {}));
+/**
+ * Defines how the host (editor) should sync document changes
+ * to the language server.
+ */
+var TextDocumentSyncKind;
+(function (TextDocumentSyncKind) {
+    /**
+     * Documents should not be synced at all.
+     */
+    TextDocumentSyncKind[TextDocumentSyncKind["None"] = 0] = "None";
+    /**
+     * Documents are synced by always sending the full content
+     * of the document.
+     */
+    TextDocumentSyncKind[TextDocumentSyncKind["Full"] = 1] = "Full";
+    /**
+     * Documents are synced by sending the full content on open.
+     * After that only incremental updates to the document are
+     * send.
+     */
+    TextDocumentSyncKind[TextDocumentSyncKind["Incremental"] = 2] = "Incremental";
+})(TextDocumentSyncKind || (exports.TextDocumentSyncKind = TextDocumentSyncKind = {}));
+/**
+ * The kind of a code action.
+ *
+ * Kinds are a hierarchical list of identifiers separated by `.`,
+ * e.g. `"refactor.extract.function"`.
+ *
+ * The set of kinds is open and the client needs to announce the kinds it
+ * supports to the server during initialization.
+ */
+var CodeActionKind;
+(function (CodeActionKind) {
+    /**
+     * Empty kind.
+     */
+    CodeActionKind["Empty"] = "";
+    /**
+     * Base kind for quickfix actions: 'quickfix'.
+     */
+    CodeActionKind["QuickFix"] = "quickfix";
+    /**
+     * Base kind for refactoring actions: 'refactor'.
+     */
+    CodeActionKind["Refactor"] = "refactor";
+    /**
+     * Base kind for refactoring extraction actions: 'refactor.extract'.
+     *
+     * Example extract actions:
+     *
+     * - Extract method
+     * - Extract function
+     * - Extract variable
+     * - Extract interface from class
+     * - ...
+     */
+    CodeActionKind["RefactorExtract"] = "refactor.extract";
+    /**
+     * Base kind for refactoring inline actions: 'refactor.inline'.
+     *
+     * Example inline actions:
+     *
+     * - Inline function
+     * - Inline variable
+     * - Inline constant
+     * - ...
+     */
+    CodeActionKind["RefactorInline"] = "refactor.inline";
+    /**
+     * Base kind for refactoring rewrite actions: 'refactor.rewrite'.
+     *
+     * Example rewrite actions:
+     *
+     * - Convert JavaScript function to class
+     * - Add or remove parameter
+     * - Encapsulate field
+     * - Make method static
+     * - Move method to base class
+     * - ...
+     */
+    CodeActionKind["RefactorRewrite"] = "refactor.rewrite";
+    /**
+     * Base kind for source actions: `source`.
+     *
+     * Source code actions apply to the entire file.
+     */
+    CodeActionKind["Source"] = "source";
+    /**
+     * Base kind for an organize imports source action `source.organizeImports`.
+     */
+    CodeActionKind["SourceOrganizeImports"] = "source.organizeImports";
+})(CodeActionKind || (exports.CodeActionKind = CodeActionKind = {}));
+/**
+ * Defines whether the insert text in a completion item should be interpreted as
+ * plain text or a snippet.
+ */
+var InsertTextFormat;
+(function (InsertTextFormat) {
+    /**
+     * The primary text to be inserted is treated as a plain string.
+     */
+    InsertTextFormat[InsertTextFormat["PlainText"] = 1] = "PlainText";
+    /**
+     * The primary text to be inserted is treated as a snippet.
+     *
+     * A snippet can define tab stops and placeholders with `$1`, `$2`
+     * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+     * the end of the snippet. Placeholders with equal identifiers are linked,
+     * that is typing in one will update others too.
+     */
+    InsertTextFormat[InsertTextFormat["Snippet"] = 2] = "Snippet";
+})(InsertTextFormat || (exports.InsertTextFormat = InsertTextFormat = {}));
+/**
+ * How whitespace and indentation is handled during completion
+ * item insertion.
+ *
+ * @since 3.16.0
+ */
+var InsertTextMode;
+(function (InsertTextMode) {
+    /**
+     * The insertion or replace strings is taken as it is. If the
+     * value is multi line the lines below the cursor will be
+     * inserted using the indentation defined in the string value.
+     * The client will not apply any kind of adjustments to the
+     * string.
+     */
+    InsertTextMode[InsertTextMode["asIs"] = 1] = "asIs";
+    /**
+     * The editor adjusts leading whitespace of new lines so that
+     * they match the indentation up to the cursor of the line for
+     * which the item is accepted.
+     *
+     * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a
+     * multi line completion item is indented using 2 tabs and all
+     * following lines inserted will be indented using 2 tabs as well.
+     */
+    InsertTextMode[InsertTextMode["adjustIndentation"] = 2] = "adjustIndentation";
+})(InsertTextMode || (exports.InsertTextMode = InsertTextMode = {}));
+/**
+ * How a signature help was triggered.
+ *
+ * @since 3.15.0
+ */
+var SignatureHelpTriggerKind;
+(function (SignatureHelpTriggerKind) {
+    /**
+     * Signature help was invoked manually by the user or by a command.
+     */
+    SignatureHelpTriggerKind[SignatureHelpTriggerKind["Invoked"] = 1] = "Invoked";
+    /**
+     * Signature help was triggered by a trigger character.
+     */
+    SignatureHelpTriggerKind[SignatureHelpTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter";
+    /**
+     * Signature help was triggered by the cursor moving or by the document
+     * content changing.
+     */
+    SignatureHelpTriggerKind[SignatureHelpTriggerKind["ContentChange"] = 3] = "ContentChange";
+})(SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = SignatureHelpTriggerKind = {}));
+// tslint:enable:enforce-name-casing
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text_document_node.js","sourceRoot":"","sources":["../../../../../../../../genfiles/third_party/colab/sources/lsp/text_document_node.ts"],"names":[],"mappings":"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","sourcesContent":["import * as protocol from './protocol_node';\nimport * as workspace from './workspace_node';\n\n// tslint:disable:enforce-name-casing\n\n/**\n * Text document specific client capabilities.\n */\nexport declare interface TextDocumentClientCapabilities {\n  synchronization?: TextDocumentSyncClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/completion` request.\n   */\n  completion?: CompletionClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/hover` request.\n   */\n  hover?: HoverClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/signatureHelp` request.\n   */\n  signatureHelp?: SignatureHelpClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/declaration` request.\n   *\n   * @since 3.14.0\n   */\n  declaration?: DeclarationClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/definition` request.\n   */\n  definition?: DefinitionClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/typeDefinition` request.\n   *\n   * @since 3.6.0\n   */\n  typeDefinition?: TypeDefinitionClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/implementation` request.\n   *\n   * @since 3.6.0\n   */\n  implementation?: ImplementationClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/references` request.\n   */\n  references?: ReferenceClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/documentHighlight` request.\n   */\n  documentHighlight?: DocumentHighlightClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/documentSymbol` request.\n   */\n  documentSymbol?: DocumentSymbolClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/codeAction` request.\n   */\n  codeAction?: CodeActionClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/codeLens` request.\n   */\n  codeLens?: CodeLensClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/documentLink` request.\n   */\n  documentLink?: DocumentLinkClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/documentColor` and the\n   * `textDocument/colorPresentation` request.\n   *\n   * @since 3.6.0\n   */\n  colorProvider?: DocumentColorClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/formatting` request.\n   */\n  formatting?: DocumentFormattingClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/rangeFormatting` request.\n   */\n  rangeFormatting?: DocumentRangeFormattingClientCapabilities;\n\n  /**\n   * request.\n   * Capabilities specific to the `textDocument/onTypeFormatting` request.\n   */\n  onTypeFormatting?: DocumentOnTypeFormattingClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/rename` request.\n   */\n  rename?: RenameClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/publishDiagnostics`\n   * notification.\n   */\n  publishDiagnostics?: PublishDiagnosticsClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/foldingRange` request.\n   *\n   * @since 3.10.0\n   */\n  foldingRange?: FoldingRangeClientCapabilities;\n\n  /**\n   * Capabilities specific to the `textDocument/selectionRange` request.\n   *\n   * @since 3.15.0\n   */\n  selectionRange?: SelectionRangeClientCapabilities;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion\n */\nexport declare interface CompletionClientCapabilities {\n  /**\n   * Whether completion supports dynamic registration.\n   */\n  dynamicRegistration?: boolean;\n\n  /**\n   * The client supports the following `CompletionItem` specific\n   * capabilities.\n   */\n  completionItem?: {\n    /**\n     * Client supports snippets as insert text.\n     *\n     * A snippet can define tab stops and placeholders with `$1`, `$2`\n     * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\n     * the end of the snippet.\n     * Placeholders with equal identifiers are linked, so that typing in\n     * one will update others as well.\n     */\n    snippetSupport?: boolean;\n\n    /**\n     * Client supports commit characters on a completion item.\n     */\n    commitCharactersSupport?: boolean\n\n  /**\n   * Client supports the follow content formats for the documentation\n   * property. The order describes the preferred format of the client.\n   */\n    documentationFormat?: MarkupKind[];\n\n    /**\n     * Client supports the deprecated property on a completion item.\n     */\n    deprecatedSupport?: boolean;\n\n    /**\n     * Client supports the preselect property on a completion item.\n     */\n    preselectSupport?: boolean;\n\n    /**\n     * Client supports the tag property on a completion item.\n     * Clients supporting tags have to handle unknown tags gracefully.\n     * Clients especially need to preserve unknown tags when sending\n     * a completion item back to the server in a resolve call.\n     *\n     * @since 3.15.0\n     */\n    tagSupport?: {\n      /**\n       * The tags supported by the client.\n       */\n      valueSet: CompletionItemTag[]\n    }\n  };\n\n    completionItemKind?: {\n      /**\n       * The completion item kind values the client supports. When this\n       * property exists the client also guarantees that it will\n       * handle values outside its set gracefully and falls back\n       * to a default value when unknown.\n       *\n       * If this property is not present the client only supports\n       * the completion items kinds from `Text` to `Reference` as defined in\n       * the initial version of the protocol.\n       */\n      valueSet?: CompletionItemKind[];\n    };\n\n    /**\n     * The client supports to send additional context information for a\n     * `textDocument/completion` request.\n     */\n    contextSupport?: boolean;\n}\n\n/**\n * Describes the content type that a client supports in various\n * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.\n *\n * Please note that `MarkupKinds` must not start with a `$`. This kinds\n * are reserved for internal usage.\n */\nexport enum MarkupKind {\n  /**\n   * Plain text is supported as a content format\n   */\n  PlainText = 'plaintext',\n\n  /**\n   * Markdown is supported as a content format\n   */\n  Markdown = 'markdown',\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover\n */\nexport declare interface HoverClientCapabilities {\n    /**\n     * Whether hover supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * Client supports the follow content formats for the content\n     * property. The order describes the preferred format of the client.\n     */\n    contentFormat?: MarkupKind[];\n}\n\n/**\n * Completion item tags are extra annotations that tweak the rendering of\n * a completion item.\n *\n * @since 3.15.0\n */\nexport enum CompletionItemTag {\n  /**\n   * Render a completion as obsolete, usually using a strike-out.\n   */\n  Deprecated = 1,\n}\n\n/**\n * The kind of a completion entry.\n */\nexport enum CompletionItemKind {\n  Text = 1,\n  Method = 2,\n  Function = 3,\n  Constructor = 4,\n  Field = 5,\n  Variable = 6,\n  Class = 7,\n  Interface = 8,\n  Module = 9,\n  Property = 10,\n  Unit = 11,\n  Value = 12,\n  Enum = 13,\n  Keyword = 14,\n  Snippet = 15,\n  Color = 16,\n  File = 17,\n  Reference = 18,\n  Folder = 19,\n  EnumMember = 20,\n  Constant = 21,\n  Struct = 22,\n  Event = 23,\n  Operator = 24,\n  TypeParameter = 25,\n}\n\n\n/**\n * An item to transfer a text document from the client to the server.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentItem\n */\nexport declare interface TextDocumentItem {\n    /**\n     * The text document's URI.\n     */\n    uri: protocol.DocumentUri;\n\n    /**\n     * The text document's language identifier.\n     */\n    languageId: LanguageIdentifier;\n\n    /**\n     * The version number of this document (it will increase after each\n     * change, including undo/redo).\n     */\n    version: number;\n\n    /**\n     * The content of the opened text document.\n     */\n    text: string;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didOpen\n */\nexport declare interface DidOpenTextDocumentParams {\n    /**\n     * The document that was opened.\n     */\n    textDocument: TextDocumentItem;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didOpen\n */\nexport declare interface DidOpenTextDocument extends\n    protocol.NotificationMessage<DidOpenTextDocumentParams> {\n    method: protocol.Method.TextDocumentDidOpen;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didClose\n */\nexport declare interface DidCloseTextDocumentParams {\n    /**\n     * The document that was closed.\n     */\n    textDocument: TextDocumentIdentifier;\n}\n\n/**\n * Known language identifiers.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentItem\n */\nexport enum LanguageIdentifier {\n  ABAP = 'abap',\n  WindowsBat = 'bat',\n  BibTeX = 'bibtex',\n  Clojure = 'clojure',\n  Coffeescript = 'coffeescript',\n  C = 'c',\n  CPlusPlus = 'cpp',\n  CSharp = 'csharp',\n  CSS = 'css',\n  Diff = 'diff',\n  Dart = 'dart',\n  Dockerfile = 'dockerfile',\n  Elixir = 'elixir',\n  Erlang = 'erlang',\n  FSharp = 'fsharp',\n  GitCommit = 'git-commit',\n  GitRebase = 'git-rebase',\n  Go = 'go',\n  Groovy = 'groovy',\n  Handlebars = 'handlebars',\n  HTML = 'html',\n  Ini = 'ini',\n  Java = 'java',\n  JavaScript = 'javascript',\n  JavaScriptReact = 'javascriptreact',\n  JSON = 'json',\n  LaTeX = 'latex',\n  Less = 'less',\n  Lua = 'lua',\n  Makefile = 'makefile',\n  Markdown = 'markdown',\n  ObjectiveC = 'c',\n  ObjectiveCPlusPlus = 'cpp',\n  Perl = 'perl',\n  Perl6 = 'perl6',\n  PHP = 'php',\n  Powershell = 'powershell',\n  Pug = 'jade',\n  Python = 'python',\n  R = 'r',\n  Razor = 'razor',\n  Ruby = 'ruby',\n  Rust = 'rust',\n  SCSS = 'scss',\n  Sass = 'syntax',\n  Scala = 'scala',\n  ShaderLab = 'shaderlab',\n  Shell = 'shellscript',\n  SQL = 'sql',\n  Swift = 'swift',\n  TypeScript = 'typescript',\n  TypeScriptReact = 'typescriptreact',\n  TeX = 'tex',\n  VisualBasic = 'vb',\n  XML = 'xml',\n  XSL = 'xsl',\n  YAML = 'yaml',\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_publishDiagnostics\n */\nexport declare interface PublishDiagnosticsClientCapabilities {\n    /**\n     * Whether the clients accepts diagnostics with related information.\n     */\n    relatedInformation?: boolean;\n\n    /**\n     * Client supports the tag property to provide meta data about a diagnostic.\n     * Clients supporting tags have to handle unknown tags gracefully.\n     *\n     * @since 3.15.0\n     */\n    tagSupport?: {\n      /**\n       * The tags supported by the client.\n       */\n      valueSet: protocol.DiagnosticTag[];\n    };\n\n    /**\n     * Whether the client interprets the version property of the\n     * `textDocument/publishDiagnostics` notification's parameter.\n     *\n     * @since 3.15.0\n     */\n    versionSupport?: boolean;\n}\n\n/**\n * Diagnostics notification are sent from the server to the client to signal\n * results of validation runs.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_publishDiagnostics\n */\nexport declare interface PublishDiagnostics extends\n    protocol.NotificationMessage<PublishDiagnosticsParams> {\n    method: protocol.Method.TextDocumentPublishDiagnostics;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_publishDiagnostics\n */\nexport declare interface PublishDiagnosticsParams {\n    /**\n     * The URI for which diagnostic information is reported.\n     */\n    uri: protocol.DocumentUri;\n\n    /**\n     * The version number of the document the diagnostics are published for.\n     * Optional.\n     * @since 3.15.0\n     */\n    version?: number;\n\n    /**\n     * An array of diagnostic information items.\n     */\n    diagnostics: protocol.Diagnostic[];\n}\n\n/**\n * Text documents are identified using a URI. On the protocol level, URIs are\n * passed as strings. The corresponding JSON structure looks like this:\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentIdentifier\n */\nexport declare interface TextDocumentIdentifier {\n    /**\n     * The text document's URI.\n     */\n    uri: protocol.DocumentUri;\n}\n\n/**\n * An identifier to denote a specific version of a text document. This\n * information usually flows from the client to the server.\n */\ninterface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {\n    /**\n     * The version number of this document.\n     *\n     * The version number of a document will increase after each change,\n     * including undo/redo. The number doesn't need to be consecutive.\n     */\n    version: protocol.integer;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentPositionParams\n */\nexport interface TextDocumentPositionParams {\n    /**\n     * The text document.\n     */\n    textDocument: TextDocumentIdentifier;\n\n    /**\n     * The position inside the text document.\n     */\n    position: protocol.Position;\n}\n\n/**\n * The Completion request is sent from the client to the server to compute\n * completion items at a given cursor position. Completion items are presented\n * in the IntelliSense user interface. If computing full completion items is\n * expensive, servers can additionally provide a handler for the completion\n * item resolve request (`completionItem/resolve`). This request is sent when a\n * completion item is selected in the user interface. A typical use case is for\n * example: the `textDocument/completion` request doesn’t fill in the\n * documentation property for returned completion items since it is expensive\n * to compute. When the item is selected in the user interface then a\n * `completionItem/resolve` request is sent with the selected completion item\n * as a parameter. The returned completion item should have the documentation\n * property filled in. By default the request can only delay the computation of\n * the detail and documentation properties. Since 3.16.0 the client can signal\n * that it can resolve more properties lazily. This is done using the\n * completionItem#resolveSupport client capability which lists all properties\n * that can be filled in during a `completionItem/resolve` request. All other\n * properties (usually sortText, filterText, insertText and textEdit) must be\n * provided in the textDocument/completion response and must not be changed\n * during resolve.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion\n */\nexport declare interface Completion extends\n    protocol.RequestMessage<CompletionParams> {\n    method: protocol.Method.TextDocumentCompletion;\n}\n\n/**\n * Params for the autoExecuteCheck call. This is a custom LSP command that\n * verifies that the provided code passes a number of LSP-related checks.\n */\nexport declare interface AutoExecuteCheckParams extends TextDocumentIdentifier {\n    /**\n     * The code to check whether it can be auto executed in the current\n     * document.\n     */\n    codeToCheck: string;\n\n    /**\n     * The position to insert the code at. If not set, append to the end of the\n     * notebook.\n     */\n    position?: protocol.Position;\n}\n\n/**\n * Response for the autoExecuteCheck call.\n */\nexport declare interface AutoExecuteCheckResponse {\n    /**\n     * Errors found when checking the code in the request. An empty list means\n     * that all checks passed and the code can be executed automatically.\n     */\n    errors: string[];\n\n    /**\n     * The actual code that should be executed. This will usually be the code\n     * that was passed in the request, but may include additional edits to make\n     * the code safer to run.\n     */\n    codeToExecute: string;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion\n */\nexport declare interface CompletionParams extends\n    TextDocumentPositionParams, protocol.WorkDoneProgressParams,\n    protocol.PartialResultParams {\n    /**\n     * The completion context. This is only available if the client specifies\n     * to send this using the client capability\n     * `completion.contextSupport === true`\n     */\n    context?: CompletionContext;\n}\n\n/**\n * How a completion was triggered\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion\n */\nexport enum CompletionTriggerKind {\n  /**\n   * Completion was triggered by typing an identifier (24x7 code\n   * complete), manual invocation (e.g Ctrl+Space) or via API.\n   */\n  Invoked = 1,\n\n  /**\n   * Completion was triggered by a trigger character specified by\n   * the `triggerCharacters` properties of the\n   * `CompletionRegistrationOptions`.\n   */\n  TriggerCharacter = 2,\n\n  /**\n   * Completion was re-triggered as the current completion list is incomplete.\n   */\n  TriggerForIncompleteCompletions = 3,\n}\n\n\n/**\n * Contains additional information about the context in which a completion\n * request is triggered.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion\n */\nexport declare interface CompletionContext {\n    /**\n     * How the completion was triggered.\n     */\n    triggerKind: CompletionTriggerKind;\n\n    /**\n     * The trigger character (a single character) that has trigger code\n     * complete. Is undefined if\n     * `triggerKind !== CompletionTriggerKind.TriggerCharacter`\n     */\n    triggerCharacter?: string;\n}\n\n/**\n * The document change notification is sent from the client to the server to\n * signal changes to a text document. Before a client can change a text\n * document it must claim ownership of its content using the\n * textDocument/didOpen notification. In 2.0 the shape of the params has\n * changed to include proper version numbers and language ids.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didChange\n */\nexport interface DidChangeTextDocumentParams {\n    /**\n     * The document that did change. The version number points\n     * to the version after all provided content changes have\n     * been applied.\n     */\n    textDocument: VersionedTextDocumentIdentifier;\n\n    /**\n     * The actual content changes. The content changes describe single state\n     * changes to the document. So if there are two content changes c1 (at\n     * array index 0) and c2 (at array index 1) for a document in state S then\n     * c1 moves the document from S to S' and c2 from S' to S''. So c1 is\n     * computed on the state S and c2 is computed on the state S'.\n     *\n     * To mirror the content of a document using change events use the following\n     * approach:\n     * - start with the same initial content\n     * - apply the 'textDocument/didChange' notifications in the order you\n     *   receive them.\n     * - apply the `TextDocumentContentChangeEvent`s in a single notification\n     *   in the order you receive them.\n     */\n    contentChanges: TextDocumentContentChangeEvent[];\n}\n\n/**\n * An event describing a change to a text document. If range and rangeLength are\n * omitted the new text is considered to be the full content of the document.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didChange\n */\nexport type TextDocumentContentChangeEvent = {\n  /**\n   * The range of the document that changed.\n   */\n  range: protocol.Range;\n\n  /**\n   * The optional length of the range that got replaced.\n   *\n   * @deprecated use range instead.\n   */\n  rangeLength?: protocol.uinteger;\n\n  /**\n   * The new text for the provided range.\n   */\n  text: string;\n}|{\n    /**\n     * The new text of the whole document.\n     */\n    text: string;\n};\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocumentEdit\n */\nexport declare interface TextDocumentEdit {\n    /**\n     * The text document to change.\n     */\n    textDocument: VersionedTextDocumentIdentifier;\n\n    /**\n     * The edits to be applied.\n     */\n    edits: TextEdit[];\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textEdit\n */\nexport interface TextEdit {\n    /**\n     * The range of the text document to be manipulated. To insert\n     * text into a document create a range where start === end.\n     */\n    range: protocol.Range;\n\n    /**\n     * The string to be inserted. For delete operations use an\n     * empty string.\n     */\n    newText: string;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_foldingRange\n */\nexport declare interface FoldingRangeClientCapabilities {\n    /**\n     * Whether the implementation supports dynamic registration for\n     * folding range providers.\n     * If this is set to `true`, the client supports the new\n     * `FoldingRangeRegistrationOptions` return value for the corresponding\n     * server capability as well.\n     */\n    dynamicRegistration?: boolean;\n    /**\n     * The maximum number of folding ranges that the client prefers to\n     * receive per document.\n     * The value serves as a hint, servers are free to follow the limit.\n     */\n    rangeLimit?: number;\n    /**\n     * If set, the client signals that it only supports folding complete lines.\n     * If set, the client will ignore specified `startCharacter` and\n     * `endCharacter` properties in a FoldingRange.\n     */\n    lineFoldingOnly?: boolean;\n}\n\n/**\n * The document range formatting request is sent from the client to the server\n * to format a given range in a document.\n */\nexport declare interface DocumentRangeFormattingClientCapabilities {\n    /**\n     * Whether formatting supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_selectionRange\n */\nexport declare interface SelectionRangeClientCapabilities {\n    /**\n     * Whether implementation supports dynamic registration for selection\n     * range providers.\n     * If set to `true`, the client supports the new\n     * `SelectionRangeRegistrationOptions` return value for the corresponding\n     * server capability as well.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_signatureHelp\n */\nexport declare interface SignatureHelpClientCapabilities {\n    /**\n     * Whether signature help supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports the following `SignatureInformation`\n     * specific properties.\n     */\n    signatureInformation?: {\n      /**\n       * Client supports the follow content formats for the documentation\n       * property. The order describes the preferred format of the client.\n       */\n      documentationFormat?: MarkupKind[];\n\n      /**\n       * Client capabilities specific to parameter information.\n       */\n      parameterInformation?: {\n        /**\n         * The client supports processing label offsets instead of a\n         * simple label string.\n         *\n         * @since 3.14.0\n         */\n        labelOffsetSupport?: boolean;\n      };\n\n      /**\n       * The client supports the `activeParameter` property on\n       * `SignatureInformation` literal.\n       *\n       * @since 3.16.0 - proposed state\n       */\n      activeParameterSupport?: boolean;\n    };\n\n    /**\n     * The client supports to send additional context information for a\n     * `textDocument/signatureHelp` request. A client that opts into\n     * contextSupport will also support the `retriggerCharacters` on\n     * `SignatureHelpOptions`.\n     *\n     * @since 3.15.0\n     */\n    contextSupport?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_implementation\n */\nexport declare interface ImplementationClientCapabilities {\n    /**\n     * Whether implementation supports dynamic registration.\n     * If this is set to `true`, the client supports the new\n     * `ImplementationRegistrationOptions` return value for the\n     * corresponding server capability as well.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports additional metadata in the form of definition links.\n     *\n     * @since 3.14.0\n     */\n    linkSupport?: boolean;\n}\n\n/**\n * The rename request is sent from the client to the server to ask the server to\n * compute a workspace change so that the client can perform a workspace-wide\n * rename of a symbol.\n */\nexport declare interface RenameClientCapabilities {\n    /**\n     * Whether rename supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * Client supports testing for validity of rename operations\n     * before execution.\n     *\n     * @since version 3.12.0\n     */\n    prepareSupport?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_typeDefinition\n */\nexport declare interface TypeDefinitionClientCapabilities {\n    /**\n     * Whether implementation supports dynamic registration.\n     * If this is set to `true`, the client supports the new `\n     * TypeDefinitionRegistrationOptions` return value for the\n     * corresponding server capability as well.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports additional metadata in the form of definition links.\n     *\n     * @since 3.14.0\n     */\n    linkSupport?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didClose\n */\nexport declare interface TextDocumentSyncClientCapabilities {\n    /**\n     * Whether text document synchronization supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports sending will save notifications.\n     */\n    willSave?: boolean;\n\n    /**\n     * The client supports sending a will save request and\n     * waits for a response providing text edits which will\n     * be applied to the document before it is saved.\n     */\n    willSaveWaitUntil?: boolean;\n\n    /**\n     * The client supports did save notifications.\n     */\n    didSave?: boolean;\n}\n\n/**\n * Defines how the host (editor) should sync document changes\n * to the language server.\n */\nexport enum TextDocumentSyncKind {\n  /**\n   * Documents should not be synced at all.\n   */\n  None = 0,\n\n  /**\n   * Documents are synced by always sending the full content\n   * of the document.\n   */\n  Full = 1,\n\n  /**\n   * Documents are synced by sending the full content on open.\n   * After that only incremental updates to the document are\n   * send.\n   */\n  Incremental = 2,\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didClose\n */\nexport declare interface TextDocumentSyncOptions {\n    /**\n     * Open and close notifications are sent to the server.\n     * If omitted, open close notification should not be sent.\n     */\n    openClose?: boolean;\n    /**\n     * Change notifications are sent to the server.\n     * See TextDocumentSyncKind.None, TextDocumentSyncKind.Full,\n     * and TextDocumentSyncKind.Incremental.\n     * If omitted, it defaults to TextDocumentSyncKind.None.\n     */\n    change?: number;\n    /**\n     * If present will save notifications are sent to the server.\n     * If omitted, the notification should not be sent.\n     */\n    willSave?: boolean;\n    /**\n     * If present will save wait until requests are sent to the server.\n     * If omitted, the request should not be sent.\n     */\n    willSaveWaitUntil?: boolean;\n    /**\n     * If present save notifications are sent to the server.\n     * If omitted, the notification should not be sent.\n     */\n    save?: boolean|SaveOptions;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_didSave\n */\nexport declare interface SaveOptions {\n    /**\n     * The client is supposed to include the content on save.\n     */\n    includeText?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_definition\n */\nexport declare interface DefinitionClientCapabilities {\n    /**\n     * Whether definition supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports additional metadata in the form of definition links.\n     *\n     * @since 3.14.0\n     */\n    linkSupport?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_declaration\n */\nexport declare interface DeclarationClientCapabilities {\n    /**\n     * Whether declaration supports dynamic registration.\n     * If this is set to `true`, the client supports the new\n     * `DeclarationRegistrationOptions` return value for the\n     * corresponding server capability as well.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports additional metadata in the form of declaration links.\n     */\n    linkSupport?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_documentHighlight\n */\nexport declare interface DocumentHighlightClientCapabilities {\n    /**\n     * Whether document highlight supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_references\n */\nexport declare interface ReferenceClientCapabilities {\n    /**\n     * Whether references supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_documentSymbol\n */\nexport declare interface DocumentSymbolClientCapabilities {\n    /**\n     * Whether document symbol supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * Specific capabilities for the `SymbolKind` in the\n     * `textDocument/documentSymbol` request.\n     */\n    symbolKind?: {\n      /**\n       * The symbol kind values the client supports. When this\n       * property exists the client also guarantees that it will\n       * handle values outside its set gracefully and falls back\n       * to a default value when unknown.\n       *\n       * If this property is not present the client only supports\n       * the symbol kinds from `File` to `Array` as defined in\n       * the initial version of the protocol.\n       */\n      valueSet?: protocol.SymbolKind[];\n    };\n\n    /**\n     * The client supports hierarchical document symbols.\n     */\n    hierarchicalDocumentSymbolSupport?: boolean;\n\n    /**\n     * The client supports tags on `SymbolInformation`. Tags are supported on\n     * `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true.\n     * Clients supporting tags have to handle unknown tags gracefully.\n     *\n     * @since 3.16.0\n     */\n    tagSupport?: {\n      /**\n       * The tags supported by the client.\n       */\n      valueSet: protocol.SymbolTag[]\n    };\n\n    /**\n     * The client supports an additional label presented in the UI when\n     * registering a document symbol provider.\n     *\n     * @since 3.16.0\n     */\n    labelSupport?: boolean;\n}\n\n/**\n * The document on type formatting request is sent from the client to the server\n * to format parts of the document during typing.\n */\nexport declare interface DocumentOnTypeFormattingClientCapabilities {\n    /**\n     * Whether on type formatting supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * The document formatting request is sent from the client to the server to\n * format a whole document.\n */\nexport declare interface DocumentFormattingClientCapabilities {\n    /**\n     * Whether formatting supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * The document color request is sent from the client to the server to list all\n * color references found in a given text document. Along with the range, a\n * color value in RGB is returned. Clients can use the result to decorate color\n * references in an editor. For example: Color boxes showing the actual color\n * next to the reference Show a color picker when a color reference is edited\n */\nexport declare interface DocumentColorClientCapabilities {\n    /**\n     * Whether document color supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * The document links request is sent from the client to the server to request\n * the location of links in a document.\n */\nexport declare interface DocumentLinkClientCapabilities {\n    /**\n     * Whether document link supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * Whether the client supports the `tooltip` property on `DocumentLink`.\n     *\n     * @since 3.15.0\n     */\n    tooltipSupport?: boolean;\n}\n\n/**\n * The CodeLens request is sent from the client to the server to compute\n * CodeLens for a given text document.\n */\nexport declare interface CodeLensClientCapabilities {\n    /**\n     * Whether CodeLens supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_codeAction\n */\nexport declare interface CodeActionClientCapabilities {\n    /**\n     * Whether code action supports dynamic registration.\n     */\n    dynamicRegistration?: boolean;\n\n    /**\n     * The client supports code action literals as a valid\n     * response of the `textDocument/codeAction` request.\n     *\n     * @since 3.8.0\n     */\n    codeActionLiteralSupport?: {\n      /**\n       * The code action kind is supported with the following value\n       * set.\n       */\n      codeActionKind: {\n\n        /**\n         * The code action kind values the client supports. When this\n         * property exists the client also guarantees that it will\n         * handle values outside its set gracefully and falls back\n         * to a default value when unknown.\n         */\n        valueSet: CodeActionKind[];\n      };\n    };\n\n    /**\n     * Whether code action supports the `isPreferred` property.\n     * @since 3.15.0\n     */\n    isPreferredSupport?: boolean;\n}\n\n/**\n * The kind of a code action.\n *\n * Kinds are a hierarchical list of identifiers separated by `.`,\n * e.g. `\"refactor.extract.function\"`.\n *\n * The set of kinds is open and the client needs to announce the kinds it\n * supports to the server during initialization.\n */\nexport enum CodeActionKind {\n\n  /**\n   * Empty kind.\n   */\n  Empty = '',\n\n  /**\n   * Base kind for quickfix actions: 'quickfix'.\n   */\n  QuickFix = 'quickfix',\n\n  /**\n   * Base kind for refactoring actions: 'refactor'.\n   */\n  Refactor = 'refactor',\n\n  /**\n   * Base kind for refactoring extraction actions: 'refactor.extract'.\n   *\n   * Example extract actions:\n   *\n   * - Extract method\n   * - Extract function\n   * - Extract variable\n   * - Extract interface from class\n   * - ...\n   */\n  RefactorExtract = 'refactor.extract',\n\n  /**\n   * Base kind for refactoring inline actions: 'refactor.inline'.\n   *\n   * Example inline actions:\n   *\n   * - Inline function\n   * - Inline variable\n   * - Inline constant\n   * - ...\n   */\n  RefactorInline = 'refactor.inline',\n\n  /**\n   * Base kind for refactoring rewrite actions: 'refactor.rewrite'.\n   *\n   * Example rewrite actions:\n   *\n   * - Convert JavaScript function to class\n   * - Add or remove parameter\n   * - Encapsulate field\n   * - Make method static\n   * - Move method to base class\n   * - ...\n   */\n  RefactorRewrite = 'refactor.rewrite',\n\n  /**\n   * Base kind for source actions: `source`.\n   *\n   * Source code actions apply to the entire file.\n   */\n  Source = 'source',\n\n  /**\n   * Base kind for an organize imports source action `source.organizeImports`.\n   */\n  SourceOrganizeImports = 'source.organizeImports',\n}\n\n/**\n * Contains additional diagnostic information about the context in which\n * a code action is run.\n */\nexport declare interface CodeActionContext {\n    /**\n     * An array of diagnostics known on the client side overlapping the range\n     * provided to the `textDocument/codeAction` request.\n     * They are provided so that the server knows which errors are currently\n     * presented to the user for the given range. There is no guarantee that\n     * these accurately reflect the error state of the resource.\n     * The primary parameter to compute code actions is the provided range.\n     */\n    diagnostics: protocol.Diagnostic[];\n\n    /**\n     * Requested kind of actions to return.\n     *\n     * Actions not of this kind are filtered out by the client before\n     * being shown, so servers can omit computing them.\n     */\n    only?: CodeActionKind[];\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_publishDiagnostics\n */\nexport declare interface PublishDiagnosticsClientCapabilities {\n    /**\n     * Whether the clients accepts diagnostics with related information.\n     */\n    relatedInformation?: boolean;\n\n    /**\n     * Client supports the tag property to provide meta data about a diagnostic.\n     * Clients supporting tags have to handle unknown tags gracefully.\n     *\n     * @since 3.15.0\n     */\n    tagSupport?: {\n      /**\n       * The tags supported by the client.\n       */\n      valueSet: protocol.DiagnosticTag[];\n    };\n\n    /**\n     * Whether the client interprets the version property of the\n     * `textDocument/publishDiagnostics` notification's parameter.\n     *\n     * @since 3.15.0\n     */\n    versionSupport?: boolean;\n}\n\n/**\n * Represents a collection of [completion items](#CompletionItem) to be\n * presented in the editor.\n */\nexport interface CompletionList {\n    /**\n     * This list it not complete. Further typing should result in recomputing\n     * this list.\n     */\n    isIncomplete: boolean;\n\n    /**\n     * The completion items.\n     */\n    items: CompletionItem[];\n}\n\n/**\n * Defines whether the insert text in a completion item should be interpreted as\n * plain text or a snippet.\n */\nexport enum InsertTextFormat {\n  /**\n   * The primary text to be inserted is treated as a plain string.\n   */\n  PlainText = 1,\n\n  /**\n   * The primary text to be inserted is treated as a snippet.\n   *\n   * A snippet can define tab stops and placeholders with `$1`, `$2`\n   * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\n   * the end of the snippet. Placeholders with equal identifiers are linked,\n   * that is typing in one will update others too.\n   */\n  Snippet = 2,\n}\n\n/**\n * A special text edit to provide an insert and a replace operation.\n *\n * @since 3.16.0\n */\nexport interface InsertReplaceEdit {\n    /**\n     * The string to be inserted.\n     */\n    newText: string;\n\n    /**\n     * The range if the insert is requested\n     */\n    insert: protocol.Range;\n\n    /**\n     * The range if the replace is requested.\n     */\n    replace: protocol.Range;\n}\n\n/**\n * How whitespace and indentation is handled during completion\n * item insertion.\n *\n * @since 3.16.0\n */\nexport enum InsertTextMode {\n  /**\n   * The insertion or replace strings is taken as it is. If the\n   * value is multi line the lines below the cursor will be\n   * inserted using the indentation defined in the string value.\n   * The client will not apply any kind of adjustments to the\n   * string.\n   */\n  asIs = 1,\n\n  /**\n   * The editor adjusts leading whitespace of new lines so that\n   * they match the indentation up to the cursor of the line for\n   * which the item is accepted.\n   *\n   * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a\n   * multi line completion item is indented using 2 tabs and all\n   * following lines inserted will be indented using 2 tabs as well.\n   */\n  adjustIndentation = 2,\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_completion\n */\nexport interface CompletionItem {\n    /**\n     * The label of this completion item. By default\n     * also the text that is inserted when selecting\n     * this completion.\n     */\n    label: string;\n\n    /**\n     * The kind of this completion item. Based of the kind\n     * an icon is chosen by the editor. The standardized set\n     * of available values is defined in `CompletionItemKind`.\n     */\n    kind?: CompletionItemKind;\n\n    /**\n     * Tags for this completion item.\n     *\n     * @since 3.15.0\n     */\n    tags?: CompletionItemTag[];\n\n    /**\n     * A human-readable string with additional information\n     * about this item, like type or symbol information.\n     */\n    detail?: string;\n\n    /**\n     * A human-readable string that represents a doc-comment.\n     */\n    documentation?: string|MarkupContent;\n\n    /**\n     * Indicates if this item is deprecated.\n     *\n     * @deprecated Use `tags` instead if supported.\n     */\n    deprecated?: boolean;\n\n    /**\n     * Select this item when showing.\n     *\n     * *Note* that only one completion item can be selected and that the\n     * tool / client decides which item that is. The rule is that the *first*\n     * item of those that match best is selected.\n     */\n    preselect?: boolean;\n\n    /**\n     * A string that should be used when comparing this item\n     * with other items. When `falsy` the label is used.\n     */\n    sortText?: string;\n\n    /**\n     * A string that should be used when filtering a set of\n     * completion items. When `falsy` the label is used.\n     */\n    filterText?: string;\n\n    /**\n     * A string that should be inserted into a document when selecting\n     * this completion. When `falsy` the label is used.\n     *\n     * The `insertText` is subject to interpretation by the client side.\n     * Some tools might not take the string literally. For example\n     * VS Code when code complete is requested in this example\n     * `con<cursor position>` and a completion item with an `insertText` of\n     * `console` is provided it will only insert `sole`. Therefore it is\n     * recommended to use `textEdit` instead since it avoids additional client\n     * side interpretation.\n     */\n    insertText?: string;\n\n    /**\n     * The format of the insert text. The format applies to both the\n     * `insertText` property and the `newText` property of a provided\n     * `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`.\n     */\n    insertTextFormat?: InsertTextFormat;\n\n    /**\n     * How whitespace and indentation is handled during completion\n     * item insertion. If not provided the client's default value depends on\n     * the `textDocument.completion.insertTextMode` client capability.\n     *\n     * @since 3.16.0\n     */\n    insertTextMode?: InsertTextMode;\n\n    /**\n     * An edit which is applied to a document when selecting this completion.\n     * When an edit is provided the value of `insertText` is ignored.\n     *\n     * *Note:* The range of the edit must be a single line range and it must\n     * contain the position at which completion has been requested.\n     *\n     * Most editors support two different operations when accepting a completion\n     * item. One is to insert a completion text and the other is to replace an\n     * existing text with a completion text. Since this can usually not be\n     * predetermined by a server it can report both ranges. Clients need to\n     * signal support for `InsertReplaceEdits` via the\n     * `textDocument.completion.insertReplaceSupport` client capability\n     * property.\n     *\n     * *Note 1:* The text edit's range as well as both ranges from an insert\n     * replace edit must be a [single line] and they must contain the position\n     * at which completion has been requested.\n     * *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range\n     * must be a prefix of the edit's replace range, that means it must be\n     * contained and starting at the same position.\n     *\n     * @since 3.16.0 additional type `InsertReplaceEdit`\n     */\n    textEdit?: TextEdit|InsertReplaceEdit;\n\n    /**\n     * An optional array of additional text edits that are applied when\n     * selecting this completion. Edits must not overlap (including the same\n     * insert position) with the main edit nor with themselves.\n     *\n     * Additional text edits should be used to change text unrelated to the\n     * current cursor position (for example adding an import statement at the\n     * top of the file if the completion item will insert an unqualified type).\n     */\n    additionalTextEdits?: TextEdit[];\n\n    /**\n     * An optional set of characters that when pressed while this completion is\n     * active will accept it first and then type that character. *Note* that all\n     * commit characters should have `length=1` and that superfluous characters\n     * will be ignored.\n     */\n    commitCharacters?: string[];\n\n    /**\n     * An optional command that is executed *after* inserting this completion.\n     * *Note* that additional modifications to the current document should be\n     * described with the additionalTextEdits-property.\n     */\n    command?: protocol.Command;\n\n    /**\n     * A data entry field that is preserved on a completion item between\n     * a completion and a completion resolve request.\n     */\n    data?: unknown;\n}\n\n\n// tslint:disable:jsdoc-format\n/**\n * A `MarkupContent` literal represents a string value which content is\n * interpreted base on its kind flag. Currently the protocol supports\n * `plaintext` and `markdown` as markup kinds.\n *\n * If the kind is `markdown` then the value can contain fenced code blocks like\n * in GitHub issues.\n *\n * Here is an example how such a string can be constructed using\n * JavaScript / TypeScript:\n * ```typescript\n * let markdown: MarkdownContent = {\n *  kind: MarkupKind.Markdown,\n *  value: [\n *    '# Header',\n *    'Some text',\n *    '```typescript',\n *    'someCode();',\n *    '```'\n *  ].join('\\n')\n * };\n * ```\n *\n * *Please Note* that clients might sanitize the return markdown. A client could\n * decide to remove HTML from the markdown to avoid script execution.\n */\n// tslint:enable:jsdoc-format\nexport interface MarkupContent {\n    /**\n     * The type of the Markup\n     */\n    kind: MarkupKind;\n\n    /**\n     * The content itself\n     */\n    value: string;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_signatureHelp\n */\nexport interface SignatureHelpParams extends TextDocumentPositionParams,\n                                             protocol.WorkDoneProgressParams {\n    /**\n     * The signature help context. This is only available if the client\n     * specifies to send this using the client capability\n     * `textDocument.signatureHelp.contextSupport === true`\n     *\n     * @since 3.15.0\n     */\n    context?: SignatureHelpContext;\n}\n\n/**\n * How a signature help was triggered.\n *\n * @since 3.15.0\n */\nexport enum SignatureHelpTriggerKind {\n  /**\n   * Signature help was invoked manually by the user or by a command.\n   */\n  Invoked = 1,\n  /**\n   * Signature help was triggered by a trigger character.\n   */\n  TriggerCharacter = 2,\n  /**\n   * Signature help was triggered by the cursor moving or by the document\n   * content changing.\n   */\n  ContentChange = 3,\n}\n\n/**\n * Additional information about the context in which a signature help request\n * was triggered.\n *\n * @since 3.15.0\n */\nexport interface SignatureHelpContext {\n    /**\n     * Action that caused signature help to be triggered.\n     */\n    triggerKind: SignatureHelpTriggerKind;\n\n    /**\n     * Character that caused signature help to be triggered.\n     *\n     * This is undefined when triggerKind !==\n     * SignatureHelpTriggerKind.TriggerCharacter\n     */\n    triggerCharacter?: string;\n\n    /**\n     * `true` if signature help was already showing when it was triggered.\n     *\n     * Retriggers occur when the signature help is already active and can be\n     * caused by actions such as typing a trigger character, a cursor move, or\n     * document content changes.\n     */\n    isRetrigger: boolean;\n\n    /**\n     * The currently active `SignatureHelp`.\n     *\n     * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field\n     * updated based on the user navigating through available signatures.\n     */\n    activeSignatureHelp?: SignatureHelp;\n}\n\n/**\n * Signature help represents the signature of something\n * callable. There can be multiple signature but only one\n * active and only one active parameter.\n */\nexport interface SignatureHelp {\n    /**\n     * One or more signatures. If no signatures are available the signature help\n     * request should return `null`.\n     */\n    signatures: SignatureInformation[];\n\n    /**\n     * The active signature. If omitted or the value lies outside the\n     * range of `signatures` the value defaults to zero or is ignored if\n     * the `SignatureHelp` has no signatures.\n     *\n     * Whenever possible implementors should make an active decision about\n     * the active signature and shouldn't rely on a default value.\n     *\n     * In future version of the protocol this property might become\n     * mandatory to better express this.\n     */\n    activeSignature?: protocol.uinteger;\n\n    /**\n     * The active parameter of the active signature. If omitted or the value\n     * lies outside the range of `signatures[activeSignature].parameters`\n     * defaults to 0 if the active signature has parameters. If\n     * the active signature has no parameters it is ignored.\n     * In future version of the protocol this property might become\n     * mandatory to better express the active parameter if the\n     * active signature does have any.\n     */\n    activeParameter?: protocol.uinteger;\n}\n\n/**\n * Represents the signature of something callable. A signature\n * can have a label, like a function-name, a doc-comment, and\n * a set of parameters.\n */\nexport interface SignatureInformation {\n    /**\n     * The label of this signature. Will be shown in\n     * the UI.\n     */\n    label: string;\n\n    /**\n     * The human-readable doc-comment of this signature. Will be shown\n     * in the UI but can be omitted.\n     */\n    documentation?: string|MarkupContent;\n\n    /**\n     * The parameters of this signature.\n     */\n    parameters?: ParameterInformation[];\n\n    /**\n     * The index of the active parameter.\n     *\n     * If provided, this is used in place of `SignatureHelp.activeParameter`.\n     *\n     * @since 3.16.0\n     */\n    activeParameter?: protocol.uinteger;\n}\n\n/**\n * Represents a parameter of a callable-signature. A parameter can\n * have a label and a doc-comment.\n */\nexport interface ParameterInformation {\n    /**\n     * The label of this parameter information.\n     *\n     * Either a string or an inclusive start and exclusive end offsets within\n     * its containing signature label. (see SignatureInformation.label). The\n     * offsets are based on a UTF-16 string representation as `Position` and\n     * `Range` does.\n     *\n     * *Note*: a label of type string should be a substring of its containing\n     * signature label. Its intended use case is to highlight the parameter\n     * label part in the `SignatureInformation.label`.\n     */\n    label: string|[protocol.uinteger, protocol.uinteger];\n\n    /**\n     * The human-readable doc-comment of this parameter. Will be shown\n     * in the UI but can be omitted.\n     */\n    documentation?: string|MarkupContent;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover\n */\nexport interface HoverParams extends TextDocumentPositionParams,\n                                     protocol.WorkDoneProgressParams {}\n\n/**\n * The result of a hover request.\n */\nexport interface Hover {\n    /**\n     * The hover's content\n     */\n    contents: MarkupContent;\n\n    /**\n     * An optional range is a range inside a text document\n     * that is used to visualize a hover, e.g. by changing the background color.\n     */\n    range?: protocol.Range;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#definitionParams\n */\nexport interface DefinitionParams extends TextDocumentPositionParams,\n                                          protocol.WorkDoneProgressParams,\n                                          protocol.PartialResultParams {}\n\n/**\n * Params for the custom 'echoDocument' comment which returns the current state\n * of the server's view of the LSP document.\n */\nexport interface EchoDocumentParams {}\n\n/**\n * Params for the CodeActionRequest\n */\nexport interface CodeActionParams extends protocol.WorkDoneProgressParams,\n                                          protocol.PartialResultParams {\n    /**\n     * The document in which the command was invoked.\n     */\n    textDocument: TextDocumentIdentifier;\n\n    /**\n     * The range for which the command was invoked.\n     */\n    range: protocol.Range;\n\n    /**\n     * Context carrying additional information.\n     */\n    context: CodeActionContext;\n}\n\n/**\n * Params for the RenameRequest\n */\nexport interface RenameParams extends TextDocumentPositionParams,\n                                      protocol.WorkDoneProgressParams {\n  /**\n   * The new name of the symbol. If the given name is not valid the\n   * request must return a [ResponseError](#ResponseError) with an\n   * appropriate message set.\n   */\n  newName: string;\n}\n\n/**\n * A code action represents a change that can be performed in code, e.g. to fix\n * a problem or to refactor code.\n *\n * A CodeAction must set either `edit` and/or a `command`. If both are supplied,\n * the `edit` is applied first, then the `command` is executed.\n */\nexport interface CodeAction {\n    /**\n     * A short, human-readable, title for this code action.\n     */\n    title: string;\n\n    /**\n     * The kind of the code action.\n     *\n     * Used to filter code actions.\n     */\n    kind?: CodeActionKind;\n\n    /**\n     * The diagnostics that this code action resolves.\n     */\n    diagnostics?: protocol.Diagnostic[];\n\n    /**\n     * Marks this as a preferred action. Preferred actions are used by the\n     * `auto fix` command and can be targeted by keybindings.\n     *\n     * A quick fix should be marked preferred if it properly addresses the\n     * underlying error. A refactoring should be marked preferred if it is the\n     * most reasonable choice of actions to take.\n     *\n     * @since 3.15.0\n     */\n    isPreferred?: boolean;\n\n    /**\n     * Marks that the code action cannot currently be applied.\n     *\n     * Clients should follow the following guidelines regarding disabled code\n     * actions:\n     *\n     * - Disabled code actions are not shown in automatic lightbulbs code\n     *   action menus.\n     *\n     * - Disabled actions are shown as faded out in the code action menu when\n     *   the user request a more specific type of code action, such as\n     *   refactorings.\n     *\n     * - If the user has a keybinding that auto applies a code action and only\n     *   a disabled code actions are returned, the client should show the user\n     *   an error message with `reason` in the editor.\n     *\n     * @since 3.16.0\n     */\n    disabled?: {\n\n      /**\n       * Human readable description of why the code action is currently\n       * disabled.\n       *\n       * This is displayed in the code actions UI.\n       */\n      reason: string;\n    };\n\n    /**\n     * The workspace edit this code action performs.\n     */\n    edit?: workspace.WorkspaceEdit;\n\n    /**\n     * A command this code action executes. If a code action\n     * provides an edit and a command, first the edit is\n     * executed and then the command.\n     */\n    command?: protocol.Command;\n\n    /**\n     * A data entry field that is preserved on a code action between\n     * a `textDocument/codeAction` and a `codeAction/resolve` request.\n     *\n     * @since 3.16.0\n     */\n    data?: unknown;\n}\n// tslint:enable:enforce-name-casing\n"]}

web/lsp/window_node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageType = void 0;
+/** Log message type. */
+var MessageType;
+(function (MessageType) {
+    /**
+     * An error message.
+     */
+    MessageType[MessageType["Error"] = 1] = "Error";
+    /**
+     * A warning message.
+     */
+    MessageType[MessageType["Warning"] = 2] = "Warning";
+    /**
+     * An information message.
+     */
+    MessageType[MessageType["Info"] = 3] = "Info";
+    /**
+     * A log message.
+     */
+    MessageType[MessageType["Log"] = 4] = "Log";
+})(MessageType || (exports.MessageType = MessageType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93X25vZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9nZW5maWxlcy90aGlyZF9wYXJ0eS9jb2xhYi9zb3VyY2VzL2xzcC93aW5kb3dfbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUErQkEsd0JBQXdCO0FBQ3hCLElBQVksV0FpQlg7QUFqQkQsV0FBWSxXQUFXO0lBQ3JCOztPQUVHO0lBQ0gsK0NBQVMsQ0FBQTtJQUNUOztPQUVHO0lBQ0gsbURBQVcsQ0FBQTtJQUNYOztPQUVHO0lBQ0gsNkNBQVEsQ0FBQTtJQUNSOztPQUVHO0lBQ0gsMkNBQU8sQ0FBQTtBQUNULENBQUMsRUFqQlcsV0FBVywyQkFBWCxXQUFXLFFBaUJ0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHByb3RvY29sIGZyb20gJy4vcHJvdG9jb2xfbm9kZSc7XG5cbi8vIHRzbGludDpkaXNhYmxlOmVuZm9yY2UtbmFtZS1jYXNpbmdcblxuLyoqXG4gKiBUaGUgbG9nIG1lc3NhZ2Ugbm90aWZpY2F0aW9uIGlzIHNlbnQgZnJvbSB0aGUgc2VydmVyIHRvIHRoZSBjbGllbnQgdG8gYXNrIHRoZVxuICogY2xpZW50IHRvIGxvZyBhIHBhcnRpY3VsYXIgbWVzc2FnZS5cbiAqIGh0dHBzOi8vbWljcm9zb2Z0LmdpdGh1Yi5pby9sYW5ndWFnZS1zZXJ2ZXItcHJvdG9jb2wvc3BlY2lmaWNhdGlvbnMvc3BlY2lmaWNhdGlvbi1jdXJyZW50LyN3aW5kb3dfbG9nTWVzc2FnZVxuICovXG5leHBvcnQgZGVjbGFyZSBpbnRlcmZhY2UgTG9nTWVzc2FnZSBleHRlbmRzXG4gICAgcHJvdG9jb2wuTm90aWZpY2F0aW9uTWVzc2FnZTxMb2dNZXNzYWdlUGFyYW1zPiB7XG4gIG1ldGhvZDogcHJvdG9jb2wuTWV0aG9kLldpbmRvd0xvZ01lc3NhZ2U7XG59XG5cbi8qKlxuICogVGhlIGxvZyBtZXNzYWdlIG5vdGlmaWNhdGlvbiBpcyBzZW50IGZyb20gdGhlIHNlcnZlciB0byB0aGUgY2xpZW50IHRvIGFzayB0aGVcbiAqIGNsaWVudCB0byBsb2cgYSBwYXJ0aWN1bGFyIG1lc3NhZ2UuXG4gKiBodHRwczovL21pY3Jvc29mdC5naXRodWIuaW8vbGFuZ3VhZ2Utc2VydmVyLXByb3RvY29sL3NwZWNpZmljYXRpb25zL3NwZWNpZmljYXRpb24tY3VycmVudC8jd2luZG93X2xvZ01lc3NhZ2VcbiAqL1xuZXhwb3J0IGRlY2xhcmUgaW50ZXJmYWNlIExvZ01lc3NhZ2VQYXJhbXMge1xuICAvKipcbiAgICogVGhlIG1lc3NhZ2UgdHlwZS4gU2VlIHtAbGluayBNZXNzYWdlVHlwZX1cbiAgICovXG4gIHR5cGU6IE1lc3NhZ2VUeXBlO1xuXG4gIC8qKlxuICAgKiBUaGUgYWN0dWFsIG1lc3NhZ2VcbiAgICovXG4gIG1lc3NhZ2U6IHN0cmluZztcbn1cblxuLyoqIExvZyBtZXNzYWdlIHR5cGUuICovXG5leHBvcnQgZW51bSBNZXNzYWdlVHlwZSB7XG4gIC8qKlxuICAgKiBBbiBlcnJvciBtZXNzYWdlLlxuICAgKi9cbiAgRXJyb3IgPSAxLFxuICAvKipcbiAgICogQSB3YXJuaW5nIG1lc3NhZ2UuXG4gICAqL1xuICBXYXJuaW5nID0gMixcbiAgLyoqXG4gICAqIEFuIGluZm9ybWF0aW9uIG1lc3NhZ2UuXG4gICAqL1xuICBJbmZvID0gMyxcbiAgLyoqXG4gICAqIEEgbG9nIG1lc3NhZ2UuXG4gICAqL1xuICBMb2cgPSA0LFxufVxuIl19

web/lsp/workspace_node.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileChangeType = exports.WatchKind = void 0;
+/**
+ * See:
+ * https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeWatchedFiles
+ */
+var WatchKind;
+(function (WatchKind) {
+    /**
+     * Interested in create events.
+     */
+    WatchKind[WatchKind["Create"] = 1] = "Create";
+    /**
+     * Interested in change events
+     */
+    WatchKind[WatchKind["Change"] = 2] = "Change";
+    /**
+     * Interested in delete events
+     */
+    WatchKind[WatchKind["Delete"] = 4] = "Delete";
+})(WatchKind || (exports.WatchKind = WatchKind = {}));
+/**
+ * The file event type.
+ */
+var FileChangeType;
+(function (FileChangeType) {
+    /**
+     * The file got created.
+     */
+    FileChangeType[FileChangeType["Created"] = 1] = "Created";
+    /**
+     * The file got changed.
+     */
+    FileChangeType[FileChangeType["Changed"] = 2] = "Changed";
+    /**
+     * The file got deleted.
+     */
+    FileChangeType[FileChangeType["Deleted"] = 3] = "Deleted";
+})(FileChangeType || (exports.FileChangeType = FileChangeType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace_node.js","sourceRoot":"","sources":["../../../../../../../../genfiles/third_party/colab/sources/lsp/workspace_node.ts"],"names":[],"mappings":";;;AAiTA;;;GAGG;AACH,IAAY,SAeX;AAfD,WAAY,SAAS;IACnB;;OAEG;IACH,6CAAU,CAAA;IAEV;;OAEG;IACH,6CAAU,CAAA;IAEV;;OAEG;IACH,6CAAU,CAAA;AACZ,CAAC,EAfW,SAAS,yBAAT,SAAS,QAepB;AA2BD;;GAEG;AACH,IAAY,cAaX;AAbD,WAAY,cAAc;IACxB;;OAEG;IACH,yDAAW,CAAA;IACX;;OAEG;IACH,yDAAW,CAAA;IACX;;OAEG;IACH,yDAAW,CAAA;AACb,CAAC,EAbW,cAAc,8BAAd,cAAc,QAazB","sourcesContent":["import * as protocol from './protocol_node';\nimport * as textDocument from './text_document_node';\n\n// tslint:disable:enforce-name-casing\n\n/**\n * The workspace/configuration request is sent from the server to the client to\n * fetch configuration settings from the client. The request can fetch several\n * configuration settings in one roundtrip. The order of the returned\n * configuration settings correspond to the order of the passed\n * ConfigurationItems (e.g. the first item in the response is the result for\n * the first configuration item in the params).\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_configuration\n */\nexport declare interface ConfigurationParams {\n  items: ConfigurationItem[];\n}\n\n/**\n * Specific part of the Configuration which is being requested.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_configuration\n */\nexport declare interface ConfigurationItem {\n  /**\n   * The scope to get the configuration section for.\n   */\n  scopeUri?: protocol.DocumentUri;\n\n  /**\n   * The configuration section asked for.\n   */\n  section?: string;\n}\n\n/**\n * A notification sent from the client to the server to signal the change of\n * configuration settings.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_didChangeConfiguration\n */\nexport declare interface DidChangeConfiguration extends\n    protocol.NotificationMessage<DidChangeConfigurationParams> {\n  method: protocol.Method.WorkspaceDidChangeConfiguration;\n}\n\n/**\n * Parameters for DidChangeConfiguration.\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_didChangeConfiguration\n */\nexport declare interface DidChangeConfigurationParams {\n  /**\n   * The actual changed settings\n   */\n  settings: unknown;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspaceEdit\n */\nexport declare interface WorkspaceEdit {\n  /**\n   * Holds changes to existing resources.\n   */\n  changes?: {[uri: string]: textDocument.TextEdit[];};\n\n  /**\n   * The client capability `workspace.workspaceEdit.resourceOperations`\n   * determines whether document changes are either an array of\n   * `TextDocumentEdit`s to express changes to different text documents,\n   * where each text document edit addresses a specific version\n   * of a text document, or it can contains the above `TextDocumentEdit`s\n   * mixed with create, rename, and delete file / folder operations.\n   *\n   * Whether a client supports versioned document edits is expressed via\n   * `workspace.workspaceEdit.documentChanges` client capability.\n   *\n   * If a client doesn't support `documentChanges` or\n   * `workspace.workspaceEdit.resourceOperations`, then only plain\n   * `TextEdit`s using the `changes` property are supported.\n   */\n  documentChanges?:\n      (textDocument.TextDocumentEdit[]|\n       Array<textDocument.TextDocumentEdit|CreateFile|RenameFile|DeleteFile>);\n}\n\n/**\n * Options to create a file.\n */\nexport declare interface CreateFileOptions {\n  /**\n   * Overwrite existing file. Overwrite wins over `ignoreIfExists`\n   */\n  overwrite?: boolean;\n  /**\n   * Ignore if exists.\n   */\n  ignoreIfExists?: boolean;\n}\n\n/**\n * Create file operation\n */\nexport declare interface CreateFile {\n  /**\n   * A create\n   */\n  kind: 'create';\n  /**\n   * The resource to create.\n   */\n  uri: protocol.DocumentUri;\n  /**\n   * Additional options\n   */\n  options?: CreateFileOptions;\n}\n\n\n/**\n * Rename file options\n */\nexport declare interface RenameFileOptions {\n  /**\n   * Overwrite target if existing. Overwrite wins over `ignoreIfExists`\n   */\n  overwrite?: boolean;\n  /**\n   * Ignores if target exists.\n   */\n  ignoreIfExists?: boolean;\n}\n\n/**\n * Rename file operation\n */\nexport declare interface RenameFile {\n  /**\n   * A rename\n   */\n  kind: 'rename';\n  /**\n   * The old (existing) location.\n   */\n  oldUri: protocol.DocumentUri;\n  /**\n   * The new location.\n   */\n  newUri: protocol.DocumentUri;\n  /**\n   * Rename options.\n   */\n  options?: RenameFileOptions;\n}\n\n/**\n * Delete file options\n */\nexport declare interface DeleteFileOptions {\n  /**\n   * Delete the content recursively if a folder is denoted.\n   */\n  recursive?: boolean;\n  /**\n   * Ignore the operation if the file doesn't exist.\n   */\n  ignoreIfNotExists?: boolean;\n}\n\n/**\n * Delete file operation\n */\nexport declare interface DeleteFile {\n  /**\n   * A delete\n   */\n  kind: 'delete';\n  /**\n   * The file to delete.\n   */\n  uri: protocol.DocumentUri;\n  /**\n   * Delete options.\n   */\n  options?: DeleteFileOptions;\n}\n\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_symbol\n */\nexport interface WorkspaceSymbolClientCapabilities {\n  /**\n   * Symbol request supports dynamic registration.\n   */\n  dynamicRegistration?: boolean;\n\n  /**\n   * Specific capabilities for the `SymbolKind` in the\n   * `workspace/symbol` request.\n   */\n  symbolKind?: {\n    /**\n     * The symbol kind values the client supports. When this\n     * property exists the client also guarantees that it will\n     * handle values outside its set gracefully and falls back\n     * to a default value when unknown.\n     *\n     * If this property is not present the client only supports\n     * the symbol kinds from `File` to `Array` as defined in\n     * the initial version of the protocol.\n     */\n    valueSet?: protocol.SymbolKind[];\n  };\n\n  /**\n   * The client supports tags on `SymbolInformation`.\n   * Clients supporting tags have to handle unknown tags gracefully.\n   *\n   * @since 3.16.0\n   */\n  tagSupport?: {\n    /**\n     * The tags supported by the client.\n     */\n    valueSet: protocol.SymbolTag[],\n  };\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_didChangeWatchedFiles\n */\nexport declare interface DidChangeWatchedFilesClientCapabilities {\n  /**\n   * Did change watched files notification supports dynamic registration.\n   * Please note that the current protocol doesn't support static\n   * configuration for file changes from the server side.\n   */\n  dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_didChangeConfiguration\n */\nexport declare interface DidChangeConfigurationClientCapabilities {\n  /**\n   * Did change configuration notification supports dynamic registration.\n   */\n  dynamicRegistration?: boolean;\n}\n\n/**\n * https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_workspaceFolders\n */\nexport declare interface WorkspaceFolder {\n  /**\n   * The associated URI for this workspace folder.\n   */\n  uri: protocol.DocumentUri;\n\n  /**\n   * The name of the workspace folder. Used to refer to this\n   * workspace folder in the user interface.\n   */\n  name: string;\n}\n\n/**\n * Describe options to be used when registering for file system change events.\n */\nexport declare interface DidChangeWatchedFilesRegistrationOptions {\n  /**\n   * The watchers to register.\n   */\n  watchers: FileSystemWatcher[];\n}\n\n/**\n * See:\n * https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeWatchedFiles\n */\nexport declare interface FileSystemWatcher {\n  /**\n   * The glob pattern to watch.\n   *\n   * Glob patterns can have the following syntax:\n   * - `*` to match one or more characters in a path segment\n   * - `?` to match on one character in a path segment\n   * - `**` to match any number of path segments, including none\n   * - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}`\n   *   matches all TypeScript and JavaScript files)\n   * - `[]` to declare a range of characters to match in a path segment\n   *   (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)\n   * - `[!...]` to negate a range of characters to match in a path segment\n   *   (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not\n   *   `example.0`)\n   */\n  globPattern: string;\n\n  /**\n   * The kind of events of interest. If omitted it defaults\n   * to WatchKind.Create | WatchKind.Change | WatchKind.Delete\n   * which is 7.\n   */\n  kind?: WatchKind;\n}\n\n/**\n * See:\n * https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeWatchedFiles\n */\nexport enum WatchKind {\n  /**\n   * Interested in create events.\n   */\n  Create = 1,\n\n  /**\n   * Interested in change events\n   */\n  Change = 2,\n\n  /**\n   * Interested in delete events\n   */\n  Delete = 4,\n}\n\n/**\n * See:\n * https://microsoft.github.io/language-server-protocol/specification#workspace_didChangeWatchedFiles\n */\nexport declare interface DidChangeWatchedFilesParams {\n  /**\n   * The actual file events.\n   */\n  changes: FileEvent[];\n}\n\n/**\n * An event describing a file change.\n */\ninterface FileEvent {\n  /**\n   * The file's URI.\n   */\n  uri: protocol.DocumentUri;\n  /**\n   * The change type.\n   */\n  type: FileChangeType;\n}\n\n/**\n * The file event type.\n */\nexport enum FileChangeType {\n  /**\n   * The file got created.\n   */\n  Created = 1,\n  /**\n   * The file got changed.\n   */\n  Changed = 2,\n  /**\n   * The file got deleted.\n   */\n  Deleted = 3,\n}\n"]}

web/node_modules/.bin/bunyan

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb97ac3eee1e35dfbaa2025aa5bb391bbe5adcbe7305a32d6f6e6cdbe1879ac9
+size 56829

web/node_modules/.bin/mkdirp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24b028bccb1773f02cf0d0fb3dca5468f1b5d22a06cbc5cbf351e1eb3accefb1
+size 731

web/node_modules/.bin/ncp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7ca0417a675931d7d4f549009af66f25b47ea5a07e6ddcd85efb712afba3178
+size 1084

web/node_modules/.bin/rimraf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a1557fb195dd6ba967235a93927f74e0452b913425c713bcabdeaee9f62d189
+size 838

web/node_modules/.bin/semver

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5c53c713df57d8bdfd03f00e758b5b6a3f51e91a44eb888065394c0deb0da51
+size 4784

web/node_modules/accepts/HISTORY.md

@@ -0,0 +1,224 @@
+1.3.5 / 2018-02-28
+==================
+
+  * deps: mime-types@~2.1.18
+    - deps: mime-db@~1.33.0
+
+1.3.4 / 2017-08-22
+==================
+
+  * deps: mime-types@~2.1.16
+    - deps: mime-db@~1.29.0
+
+1.3.3 / 2016-05-02
+==================
+
+  * deps: mime-types@~2.1.11
+    - deps: mime-db@~1.23.0
+  * deps: [email protected]
+    - perf: improve `Accept` parsing speed
+    - perf: improve `Accept-Charset` parsing speed
+    - perf: improve `Accept-Encoding` parsing speed
+    - perf: improve `Accept-Language` parsing speed
+
+1.3.2 / 2016-03-08
+==================
+
+  * deps: mime-types@~2.1.10
+    - Fix extension of `application/dash+xml`
+    - Update primary extension for `audio/mp4`
+    - deps: mime-db@~1.22.0
+
+1.3.1 / 2016-01-19
+==================
+
+  * deps: mime-types@~2.1.9
+    - deps: mime-db@~1.21.0
+
+1.3.0 / 2015-09-29
+==================
+
+  * deps: mime-types@~2.1.7
+    - deps: mime-db@~1.19.0
+  * deps: [email protected]
+    - Fix including type extensions in parameters in `Accept` parsing
+    - Fix parsing `Accept` parameters with quoted equals
+    - Fix parsing `Accept` parameters with quoted semicolons
+    - Lazy-load modules from main entry point
+    - perf: delay type concatenation until needed
+    - perf: enable strict mode
+    - perf: hoist regular expressions
+    - perf: remove closures getting spec properties
+    - perf: remove a closure from media type parsing
+    - perf: remove property delete from media type parsing
+
+1.2.13 / 2015-09-06
+===================
+
+  * deps: mime-types@~2.1.6
+    - deps: mime-db@~1.18.0
+
+1.2.12 / 2015-07-30
+===================
+
+  * deps: mime-types@~2.1.4
+    - deps: mime-db@~1.16.0
+
+1.2.11 / 2015-07-16
+===================
+
+  * deps: mime-types@~2.1.3
+    - deps: mime-db@~1.15.0
+
+1.2.10 / 2015-07-01
+===================
+
+  * deps: mime-types@~2.1.2
+    - deps: mime-db@~1.14.0
+
+1.2.9 / 2015-06-08
+==================
+
+  * deps: mime-types@~2.1.1
+    - perf: fix deopt during mapping
+
+1.2.8 / 2015-06-07
+==================
+
+  * deps: mime-types@~2.1.0
+    - deps: mime-db@~1.13.0
+  * perf: avoid argument reassignment & argument slice
+  * perf: avoid negotiator recursive construction
+  * perf: enable strict mode
+  * perf: remove unnecessary bitwise operator
+
+1.2.7 / 2015-05-10
+==================
+
+  * deps: [email protected]
+    - Fix media type parameter matching to be case-insensitive
+
+1.2.6 / 2015-05-07
+==================
+
+  * deps: mime-types@~2.0.11
+    - deps: mime-db@~1.9.1
+  * deps: [email protected]
+    - Fix comparing media types with quoted values
+    - Fix splitting media types with quoted commas
+
+1.2.5 / 2015-03-13
+==================
+
+  * deps: mime-types@~2.0.10
+    - deps: mime-db@~1.8.0
+
+1.2.4 / 2015-02-14
+==================
+
+  * Support Node.js 0.6
+  * deps: mime-types@~2.0.9
+    - deps: mime-db@~1.7.0
+  * deps: [email protected]
+    - Fix preference sorting to be stable for long acceptable lists
+
+1.2.3 / 2015-01-31
+==================
+
+  * deps: mime-types@~2.0.8
+    - deps: mime-db@~1.6.0
+
+1.2.2 / 2014-12-30
+==================
+
+  * deps: mime-types@~2.0.7
+    - deps: mime-db@~1.5.0
+
+1.2.1 / 2014-12-30
+==================
+
+  * deps: mime-types@~2.0.5
+    - deps: mime-db@~1.3.1
+
+1.2.0 / 2014-12-19
+==================
+
+  * deps: [email protected]
+    - Fix list return order when large accepted list
+    - Fix missing identity encoding when q=0 exists
+    - Remove dynamic building of Negotiator class
+
+1.1.4 / 2014-12-10
+==================
+
+  * deps: mime-types@~2.0.4
+    - deps: mime-db@~1.3.0
+
+1.1.3 / 2014-11-09
+==================
+
+  * deps: mime-types@~2.0.3
+    - deps: mime-db@~1.2.0
+
+1.1.2 / 2014-10-14
+==================
+
+  * deps: [email protected]
+    - Fix error when media type has invalid parameter
+
+1.1.1 / 2014-09-28
+==================
+
+  * deps: mime-types@~2.0.2
+    - deps: mime-db@~1.1.0
+  * deps: [email protected]
+    - Fix all negotiations to be case-insensitive
+    - Stable sort preferences of same quality according to client order
+
+1.1.0 / 2014-09-02
+==================
+
+  * update `mime-types`
+
+1.0.7 / 2014-07-04
+==================
+
+  * Fix wrong type returned from `type` when match after unknown extension
+
+1.0.6 / 2014-06-24
+==================
+
+  * deps: [email protected]
+
+1.0.5 / 2014-06-20
+==================
+
+ * fix crash when unknown extension given
+
+1.0.4 / 2014-06-19
+==================
+
+  * use `mime-types`
+
+1.0.3 / 2014-06-11
+==================
+
+  * deps: [email protected]
+    - Order by specificity when quality is the same
+
+1.0.2 / 2014-05-29
+==================
+
+  * Fix interpretation when header not in request
+  * deps: pin [email protected]
+
+1.0.1 / 2014-01-18
+==================
+
+  * Identity encoding isn't always acceptable
+  * deps: negotiator@~0.4.0
+
+1.0.0 / 2013-12-27
+==================
+
+  * Genesis

web/node_modules/accepts/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <[email protected]>
+Copyright (c) 2015 Douglas Christopher Wilson <[email protected]>
+
+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.

web/node_modules/accepts/README.md

@@ -0,0 +1,143 @@
+# accepts
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator).
+Extracted from [koa](https://www.npmjs.com/package/koa) for general use.
+
+In addition to negotiator, it allows:
+
+- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])`
+  as well as `('text/html', 'application/json')`.
+- Allows type shorthands such as `json`.
+- Returns `false` when no types match
+- Treats non-existent headers as `*`
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install accepts
+```
+
+## API
+
+<!-- eslint-disable no-unused-vars -->
+
+```js
+var accepts = require('accepts')
+```
+
+### accepts(req)
+
+Create a new `Accepts` object for the given `req`.
+
+#### .charset(charsets)
+
+Return the first accepted charset. If nothing in `charsets` is accepted,
+then `false` is returned.
+
+#### .charsets()
+
+Return the charsets that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .encoding(encodings)
+
+Return the first accepted encoding. If nothing in `encodings` is accepted,
+then `false` is returned.
+
+#### .encodings()
+
+Return the encodings that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .language(languages)
+
+Return the first accepted language. If nothing in `languages` is accepted,
+then `false` is returned.
+
+#### .languages()
+
+Return the languages that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .type(types)
+
+Return the first accepted type (and it is returned as the same text as what
+appears in the `types` array). If nothing in `types` is accepted, then `false`
+is returned.
+
+The `types` array can contain full MIME types or file extensions. Any value
+that is not a full MIME types is passed to `require('mime-types').lookup`.
+
+#### .types()
+
+Return the types that the request accepts, in the order of the client's
+preference (most preferred first).
+
+## Examples
+
+### Simple type negotiation
+
+This simple example shows how to use `accepts` to return a different typed
+respond body based on what the client wants to accept. The server lists it's
+preferences in order and will get back the best match between the client and
+server.
+
+```js
+var accepts = require('accepts')
+var http = require('http')
+
+function app (req, res) {
+  var accept = accepts(req)
+
+  // the order of this list is significant; should be server preferred order
+  switch (accept.type(['json', 'html'])) {
+    case 'json':
+      res.setHeader('Content-Type', 'application/json')
+      res.write('{"hello":"world!"}')
+      break
+    case 'html':
+      res.setHeader('Content-Type', 'text/html')
+      res.write('<b>hello, world!</b>')
+      break
+    default:
+      // the fallback is text/plain, so no need to specify it above
+      res.setHeader('Content-Type', 'text/plain')
+      res.write('hello, world!')
+      break
+  }
+
+  res.end()
+}
+
+http.createServer(app).listen(3000)
+```
+
+You can test this out with the cURL program:
+```sh
+curl -I -H'Accept: text/html' http://localhost:3000/
+```
+
+## License
+
+[MIT](LICENSE)
+
+[npm-image]: https://img.shields.io/npm/v/accepts.svg
+[npm-url]: https://npmjs.org/package/accepts
+[node-version-image]: https://img.shields.io/node/v/accepts.svg
+[node-version-url]: https://nodejs.org/en/download/
+[travis-image]: https://img.shields.io/travis/jshttp/accepts/master.svg
+[travis-url]: https://travis-ci.org/jshttp/accepts
+[coveralls-image]: https://img.shields.io/coveralls/jshttp/accepts/master.svg
+[coveralls-url]: https://coveralls.io/r/jshttp/accepts
+[downloads-image]: https://img.shields.io/npm/dm/accepts.svg
+[downloads-url]: https://npmjs.org/package/accepts

web/node_modules/accepts/index.js

@@ -0,0 +1,238 @@
+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var Negotiator = require('negotiator')
+var mime = require('mime-types')
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = Accepts
+
+/**
+ * Create a new Accepts object for the given req.
+ *
+ * @param {object} req
+ * @public
+ */
+
+function Accepts (req) {
+  if (!(this instanceof Accepts)) {
+    return new Accepts(req)
+  }
+
+  this.headers = req.headers
+  this.negotiator = new Negotiator(req)
+}
+
+/**
+ * Check if the given `type(s)` is acceptable, returning
+ * the best match when true, otherwise `undefined`, in which
+ * case you should respond with 406 "Not Acceptable".
+ *
+ * The `type` value may be a single mime type string
+ * such as "application/json", the extension name
+ * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+ * or array is given the _best_ match, if any is returned.
+ *
+ * Examples:
+ *
+ *     // Accept: text/html
+ *     this.types('html');
+ *     // => "html"
+ *
+ *     // Accept: text/*, application/json
+ *     this.types('html');
+ *     // => "html"
+ *     this.types('text/html');
+ *     // => "text/html"
+ *     this.types('json', 'text');
+ *     // => "json"
+ *     this.types('application/json');
+ *     // => "application/json"
+ *
+ *     // Accept: text/*, application/json
+ *     this.types('image/png');
+ *     this.types('png');
+ *     // => undefined
+ *
+ *     // Accept: text/*;q=.5, application/json
+ *     this.types(['html', 'json']);
+ *     this.types('html', 'json');
+ *     // => "json"
+ *
+ * @param {String|Array} types...
+ * @return {String|Array|Boolean}
+ * @public
+ */
+
+Accepts.prototype.type =
+Accepts.prototype.types = function (types_) {
+  var types = types_
+
+  // support flattened arguments
+  if (types && !Array.isArray(types)) {
+    types = new Array(arguments.length)
+    for (var i = 0; i < types.length; i++) {
+      types[i] = arguments[i]
+    }
+  }
+
+  // no types, return all requested types
+  if (!types || types.length === 0) {
+    return this.negotiator.mediaTypes()
+  }
+
+  // no accept header, return first given type
+  if (!this.headers.accept) {
+    return types[0]
+  }
+
+  var mimes = types.map(extToMime)
+  var accepts = this.negotiator.mediaTypes(mimes.filter(validMime))
+  var first = accepts[0]
+
+  return first
+    ? types[mimes.indexOf(first)]
+    : false
+}
+
+/**
+ * Return accepted encodings or best fit based on `encodings`.
+ *
+ * Given `Accept-Encoding: gzip, deflate`
+ * an array sorted by quality is returned:
+ *
+ *     ['gzip', 'deflate']
+ *
+ * @param {String|Array} encodings...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.encoding =
+Accepts.prototype.encodings = function (encodings_) {
+  var encodings = encodings_
+
+  // support flattened arguments
+  if (encodings && !Array.isArray(encodings)) {
+    encodings = new Array(arguments.length)
+    for (var i = 0; i < encodings.length; i++) {
+      encodings[i] = arguments[i]
+    }
+  }
+
+  // no encodings, return all requested encodings
+  if (!encodings || encodings.length === 0) {
+    return this.negotiator.encodings()
+  }
+
+  return this.negotiator.encodings(encodings)[0] || false
+}
+
+/**
+ * Return accepted charsets or best fit based on `charsets`.
+ *
+ * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+ * an array sorted by quality is returned:
+ *
+ *     ['utf-8', 'utf-7', 'iso-8859-1']
+ *
+ * @param {String|Array} charsets...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.charset =
+Accepts.prototype.charsets = function (charsets_) {
+  var charsets = charsets_
+
+  // support flattened arguments
+  if (charsets && !Array.isArray(charsets)) {
+    charsets = new Array(arguments.length)
+    for (var i = 0; i < charsets.length; i++) {
+      charsets[i] = arguments[i]
+    }
+  }
+
+  // no charsets, return all requested charsets
+  if (!charsets || charsets.length === 0) {
+    return this.negotiator.charsets()
+  }
+
+  return this.negotiator.charsets(charsets)[0] || false
+}
+
+/**
+ * Return accepted languages or best fit based on `langs`.
+ *
+ * Given `Accept-Language: en;q=0.8, es, pt`
+ * an array sorted by quality is returned:
+ *
+ *     ['es', 'pt', 'en']
+ *
+ * @param {String|Array} langs...
+ * @return {Array|String}
+ * @public
+ */
+
+Accepts.prototype.lang =
+Accepts.prototype.langs =
+Accepts.prototype.language =
+Accepts.prototype.languages = function (languages_) {
+  var languages = languages_
+
+  // support flattened arguments
+  if (languages && !Array.isArray(languages)) {
+    languages = new Array(arguments.length)
+    for (var i = 0; i < languages.length; i++) {
+      languages[i] = arguments[i]
+    }
+  }
+
+  // no languages, return all requested languages
+  if (!languages || languages.length === 0) {
+    return this.negotiator.languages()
+  }
+
+  return this.negotiator.languages(languages)[0] || false
+}
+
+/**
+ * Convert extnames to mime.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function extToMime (type) {
+  return type.indexOf('/') === -1
+    ? mime.lookup(type)
+    : type
+}
+
+/**
+ * Check if mime is valid.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function validMime (type) {
+  return typeof type === 'string'
+}

web/node_modules/accepts/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "accepts",
+  "description": "Higher-level content negotiation",
+  "version": "1.3.5",
+  "contributors": [
+    "Douglas Christopher Wilson <[email protected]>",
+    "Jonathan Ong <[email protected]> (http://jongleberry.com)"
+  ],
+  "license": "MIT",
+  "repository": "jshttp/accepts",
+  "dependencies": {
+    "mime-types": "~2.1.18",
+    "negotiator": "0.6.1"
+  },
+  "devDependencies": {
+    "eslint": "4.18.1",
+    "eslint-config-standard": "11.0.0",
+    "eslint-plugin-import": "2.9.0",
+    "eslint-plugin-markdown": "1.0.0-beta.6",
+    "eslint-plugin-node": "6.0.1",
+    "eslint-plugin-promise": "3.6.0",
+    "eslint-plugin-standard": "3.0.1",
+    "istanbul": "0.4.5",
+    "mocha": "~1.21.5"
+  },
+  "files": [
+    "LICENSE",
+    "HISTORY.md",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "scripts": {
+    "lint": "eslint --plugin markdown --ext js,md .",
+    "test": "mocha --reporter spec --check-leaks --bail test/",
+    "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --reporter dot --check-leaks test/",
+    "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --reporter spec --check-leaks test/"
+  },
+  "keywords": [
+    "content",
+    "negotiation",
+    "accept",
+    "accepts"
+  ]
+
+,"_resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz"
+,"_integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I="
+,"_from": "[email protected]"
+}

web/node_modules/after/.npmignore

@@ -0,0 +1,2 @@
+node_modules
+.monitor

web/node_modules/after/.travis.yml

@@ -0,0 +1,12 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8
+  - 0.9
+  - 0.10
+  - 0.12
+  - 4.2.4
+  - 5.4.1
+  - iojs-1
+  - iojs-2
+  - iojs-3

web/node_modules/after/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Raynos.
+
+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.

web/node_modules/after/README.md

@@ -0,0 +1,115 @@
+# After [![Build Status][1]][2]
+
+Invoke callback after n calls
+
+## Status: production ready
+
+## Example
+
+```js
+var after = require("after")
+var db = require("./db") // some db.
+
+var updateUser = function (req, res) {
+  // use after to run two tasks in parallel,
+  // namely get request body and get session
+  // then run updateUser with the results
+  var next = after(2, updateUser)
+  var results = {}
+  
+  getJSONBody(req, res, function (err, body) {
+    if (err) return next(err)
+    
+    results.body = body
+    next(null, results)
+  })
+  
+  getSessionUser(req, res, function (err, user) {
+    if (err) return next(err)
+    
+    results.user = user
+    next(null, results)
+  })
+  
+  // now do the thing!
+  function updateUser(err, result) {
+    if (err) {
+      res.statusCode = 500
+      return res.end("Unexpected Error")
+    }
+    
+    if (!result.user || result.user.role !== "admin") {
+      res.statusCode = 403
+      return res.end("Permission Denied")
+    }
+    
+    db.put("users:" + req.params.userId, result.body, function (err) {
+      if (err) {
+        res.statusCode = 500
+        return res.end("Unexpected Error")
+      }
+      
+      res.statusCode = 200
+      res.end("Ok")  
+    })   
+  }
+}
+```
+
+## Naive Example
+
+```js
+var after = require("after")
+    , next = after(3, logItWorks)
+
+next()
+next()
+next() // it works
+
+function logItWorks() {
+    console.log("it works!")
+}
+```
+
+## Example with error handling
+
+```js
+var after = require("after")
+    , next = after(3, logError)
+
+next()
+next(new Error("oops")) // logs oops
+next() // does nothing
+
+// This callback is only called once.
+// If there is an error the callback gets called immediately
+// this avoids the situation where errors get lost.
+function logError(err) {
+    console.log(err)
+}
+```
+
+## Installation
+
+`npm install after`
+
+## Tests
+
+`npm test`
+
+## Contributors
+
+ - Raynos
+ - defunctzombie
+
+## MIT Licenced
+
+  [1]: https://secure.travis-ci.org/Raynos/after.png
+  [2]: http://travis-ci.org/Raynos/after
+  [3]: http://raynos.org/blog/2/Flow-control-in-node.js
+  [4]: http://stackoverflow.com/questions/6852059/determining-the-end-of-asynchronous-operations-javascript/6852307#6852307
+  [5]: http://stackoverflow.com/questions/6869872/in-javascript-what-are-best-practices-for-executing-multiple-asynchronous-functi/6870031#6870031
+  [6]: http://stackoverflow.com/questions/6864397/javascript-performance-long-running-tasks/6889419#6889419
+  [7]: http://stackoverflow.com/questions/6597493/synchronous-database-queries-with-node-js/6620091#6620091
+  [8]: http://github.com/Raynos/iterators
+  [9]: http://github.com/Raynos/composite

web/node_modules/after/index.js

@@ -0,0 +1,28 @@
+module.exports = after
+
+function after(count, callback, err_cb) {
+    var bail = false
+    err_cb = err_cb || noop
+    proxy.count = count
+
+    return (count === 0) ? callback() : proxy
+
+    function proxy(err, result) {
+        if (proxy.count <= 0) {
+            throw new Error('after called too many times')
+        }
+        --proxy.count
+
+        // after first error, rest are passed to err_cb
+        if (err) {
+            bail = true
+            callback(err)
+            // future error callbacks will go to error handler
+            callback = err_cb
+        } else if (proxy.count === 0 && !bail) {
+            callback(null, result)
+        }
+    }
+}
+
+function noop() {}

web/node_modules/after/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "after",
+  "description": "after - tiny flow control",
+  "version": "0.8.2",
+  "author": "Raynos <[email protected]>",
+  "contributors": [
+    {
+      "name": "Raynos",
+      "email": "[email protected]",
+      "url": "http://raynos.org"
+    }
+  ],
+  "scripts": {
+    "test": "mocha --ui tdd --reporter spec test/*.js"
+  },
+  "devDependencies": {
+    "mocha": "~1.8.1"
+  },
+  "keywords": [
+    "flowcontrol",
+    "after",
+    "flow",
+    "control",
+    "arch"
+  ],
+  "license": "MIT",
+  "repository": "git://github.com/Raynos/after.git"
+
+,"_resolved": "https://registry.npmjs.org/after/-/after-0.8.2.tgz"
+,"_integrity": "sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8="
+,"_from": "[email protected]"
+}

web/node_modules/after/test/after-test.js

@@ -0,0 +1,120 @@
+/*global suite, test*/
+
+var assert = require("assert")
+    , after = require("../")
+
+test("exists", function () {
+    assert(typeof after === "function", "after is not a function")
+})
+
+test("after when called with 0 invokes", function (done) {
+    after(0, done)
+});
+
+test("after 1", function (done) {
+    var next = after(1, done)
+    next()
+})
+
+test("after 5", function (done) {
+    var next = after(5, done)
+    , i = 5
+
+    while (i--) {
+        next()
+    }
+})
+
+test("manipulate count", function (done) {
+    var next = after(1, done)
+    , i = 5
+
+    next.count = i
+    while (i--) {
+        next()
+    }
+})
+
+test("after terminates on error", function (done) {
+    var next = after(2, function(err) {
+        assert.equal(err.message, 'test');
+        done();
+    })
+    next(new Error('test'))
+    next(new Error('test2'))
+})
+
+test('gee', function(done) {
+    done = after(2, done)
+
+    function cb(err) {
+        assert.equal(err.message, 1);
+        done()
+    }
+
+    var next = after(3, cb, function(err) {
+        assert.equal(err.message, 2)
+        done()
+    });
+
+    next()
+    next(new Error(1))
+    next(new Error(2))
+})
+
+test('eee', function(done) {
+    done = after(3, done)
+
+    function cb(err) {
+        assert.equal(err.message, 1);
+        done()
+    }
+
+    var next = after(3, cb, function(err) {
+        assert.equal(err.message, 2)
+        done()
+    });
+
+    next(new Error(1))
+    next(new Error(2))
+    next(new Error(2))
+})
+
+test('gge', function(done) {
+    function cb(err) {
+        assert.equal(err.message, 1);
+        done()
+    }
+
+    var next = after(3, cb, function(err) {
+        // should not happen
+        assert.ok(false);
+    });
+
+    next()
+    next()
+    next(new Error(1))
+})
+
+test('egg', function(done) {
+    function cb(err) {
+        assert.equal(err.message, 1);
+        done()
+    }
+
+    var next = after(3, cb, function(err) {
+        // should not happen
+        assert.ok(false);
+    });
+
+    next(new Error(1))
+    next()
+    next()
+})
+
+test('throws on too many calls', function(done) {
+    var next = after(1, done);
+    next()
+    assert.throws(next, /after called too many times/);
+});
+

web/node_modules/arraybuffer.slice/.npmignore

@@ -0,0 +1,17 @@
+lib-cov
+lcov.info
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+pids
+logs
+results
+build
+.grunt
+
+node_modules

web/node_modules/arraybuffer.slice/LICENCE

@@ -0,0 +1,18 @@
+Copyright (C) 2013 Rase-
+
+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.

web/node_modules/arraybuffer.slice/Makefile

@@ -0,0 +1,8 @@
+
+REPORTER = dot
+
+test:
+	@./node_modules/.bin/mocha \
+		--reporter $(REPORTER)
+
+.PHONY: test

web/node_modules/arraybuffer.slice/README.md

@@ -0,0 +1,17 @@
+# How to
+```javascript
+var sliceBuffer = require('arraybuffer.slice');
+var ab = (new Int8Array(5)).buffer;
+var sliced = sliceBuffer(ab, 1, 3);
+sliced = sliceBuffer(ab, 1);
+```
+
+# Licence (MIT)
+Copyright (C) 2013 Rase-
+
+
+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.

web/node_modules/arraybuffer.slice/index.js

@@ -0,0 +1,29 @@
+/**
+ * An abstraction for slicing an arraybuffer even when
+ * ArrayBuffer.prototype.slice is not supported
+ *
+ * @api public
+ */
+
+module.exports = function(arraybuffer, start, end) {
+  var bytes = arraybuffer.byteLength;
+  start = start || 0;
+  end = end || bytes;
+
+  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }
+
+  if (start < 0) { start += bytes; }
+  if (end < 0) { end += bytes; }
+  if (end > bytes) { end = bytes; }
+
+  if (start >= bytes || start >= end || bytes === 0) {
+    return new ArrayBuffer(0);
+  }
+
+  var abv = new Uint8Array(arraybuffer);
+  var result = new Uint8Array(end - start);
+  for (var i = start, ii = 0; i < end; i++, ii++) {
+    result[ii] = abv[i];
+  }
+  return result.buffer;
+};

web/node_modules/arraybuffer.slice/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "arraybuffer.slice",
+  "description": "Exports a function for slicing ArrayBuffers (no polyfilling)",
+  "version": "0.0.7",
+  "license": "MIT",
+  "homepage": "https://github.com/rase-/arraybuffer.slice",
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "1.17.1",
+    "expect.js": "0.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "[email protected]:rase-/arraybuffer.slice.git"
+  }
+
+,"_resolved": "https://registry.npmjs.org/arraybuffer.slice/-/arraybuffer.slice-0.0.7.tgz"
+,"_integrity": "sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog=="
+,"_from": "[email protected]"
+}

web/node_modules/arraybuffer.slice/test/slice-buffer.js

@@ -0,0 +1,227 @@
+/*
+ * Test dependencies
+ */
+
+var sliceBuffer = require('../index.js');
+var expect = require('expect.js');
+
+/**
+ * Tests
+ */
+
+describe('sliceBuffer', function() {
+  describe('using standard slice', function() {
+    it('should slice correctly with only start provided', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, 3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 3, ii = 0; i < abv.length; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with start and end provided', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, 3, 8);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 3, ii = 0; i < 8; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with negative start', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, -3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = abv.length - 3, ii = 0; i < abv.length; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with negative end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, 0, -3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 0, ii = 0; i < abv.length - 3; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with negative start and end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, -6, -3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = abv.length - 6, ii = 0; i < abv.length - 3; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with equal start and end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, 1, 1);
+      expect(sliced.byteLength).to.equal(0);
+    });
+    
+    it('should slice correctly when end larger than buffer', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, 0, 100);
+      expect(new Uint8Array(sliced)).to.eql(abv);
+    });
+
+    it('shoud slice correctly when start larger than end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+
+      var sliced = sliceBuffer(abv.buffer, 6, 5);
+      expect(sliced.byteLength).to.equal(0);
+    });
+  });
+
+  describe('using fallback', function() {
+    it('should slice correctly with only start provided', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+      var sliced = sliceBuffer(ab, 3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 3, ii = 0; i < abv.length; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with start and end provided', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+
+      var sliced = sliceBuffer(ab, 3, 8);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 3, ii = 0; i < 8; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with negative start', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+
+      var sliced = sliceBuffer(ab, -3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = abv.length - 3, ii = 0; i < abv.length; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with negative end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+      var sliced = sliceBuffer(ab, 0, -3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 0, ii = 0; i < abv.length - 3; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with negative start and end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+      var sliced = sliceBuffer(ab, -6, -3);
+      var sabv = new Uint8Array(sliced);
+      for (var i = abv.length - 6, ii = 0; i < abv.length - 3; i++, ii++) {
+        expect(abv[i]).to.equal(sabv[ii]);
+      }
+    });
+
+    it('should slice correctly with equal start and end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+      var sliced = sliceBuffer(ab, 1, 1);
+      expect(sliced.byteLength).to.equal(0);
+    });
+
+    it('should slice correctly when end larger than buffer', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+      var sliced = sliceBuffer(ab, 0, 100);
+      var sabv = new Uint8Array(sliced);
+      for (var i = 0; i < abv.length; i++) {
+        expect(abv[i]).to.equal(sabv[i]);
+      }
+    });
+
+    it('shoud slice correctly when start larger than end', function() {
+      var abv = new Uint8Array(10);
+      for (var i = 0; i < abv.length; i++) {
+        abv[i] = i;
+      }
+      var ab = abv.buffer;
+      ab.slice = undefined;
+
+      var sliced = sliceBuffer(ab, 6, 5);
+      expect(sliced.byteLength).to.equal(0);
+    });
+  });
+});

web/node_modules/async-limiter/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - "6"
+  - "node"
+script: npm run travis
+cache:
+  yarn: true

web/node_modules/async-limiter/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2017 Samuel Reed <[email protected]>
+
+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.

web/node_modules/async-limiter/coverage/coverage.json

@@ -0,0 +1 @@
+{"/Users/samuelreed/git/forks/async-throttle/index.js":{"path":"/Users/samuelreed/git/forks/async-throttle/index.js","s":{"1":1,"2":7,"3":1,"4":6,"5":6,"6":6,"7":6,"8":6,"9":6,"10":1,"11":1,"12":3,"13":13,"14":13,"15":13,"16":1,"17":19,"18":1,"19":45,"20":6,"21":39,"22":13,"23":13,"24":13,"25":13,"26":39,"27":18,"28":6,"29":6,"30":1,"31":6,"32":6,"33":6,"34":1,"35":13,"36":13,"37":1},"b":{"1":[1,6],"2":[6,5],"3":[6,5],"4":[6,39],"5":[13,26],"6":[18,21],"7":[6,0]},"f":{"1":7,"2":3,"3":13,"4":19,"5":45,"6":6,"7":13},"fnMap":{"1":{"name":"Queue","line":3,"loc":{"start":{"line":3,"column":0},"end":{"line":3,"column":24}}},"2":{"name":"(anonymous_2)","line":22,"loc":{"start":{"line":22,"column":24},"end":{"line":22,"column":41}}},"3":{"name":"(anonymous_3)","line":23,"loc":{"start":{"line":23,"column":28},"end":{"line":23,"column":39}}},"4":{"name":"(anonymous_4)","line":31,"loc":{"start":{"line":31,"column":7},"end":{"line":31,"column":18}}},"5":{"name":"(anonymous_5)","line":36,"loc":{"start":{"line":36,"column":23},"end":{"line":36,"column":34}}},"6":{"name":"(anonymous_6)","line":55,"loc":{"start":{"line":55,"column":25},"end":{"line":55,"column":38}}},"7":{"name":"done","line":62,"loc":{"start":{"line":62,"column":0},"end":{"line":62,"column":16}}}},"statementMap":{"1":{"start":{"line":3,"column":0},"end":{"line":14,"column":1}},"2":{"start":{"line":4,"column":2},"end":{"line":6,"column":3}},"3":{"start":{"line":5,"column":4},"end":{"line":5,"column":30}},"4":{"start":{"line":8,"column":2},"end":{"line":8,"column":26}},"5":{"start":{"line":9,"column":2},"end":{"line":9,"column":53}},"6":{"start":{"line":10,"column":2},"end":{"line":10,"column":19}},"7":{"start":{"line":11,"column":2},"end":{"line":11,"column":17}},"8":{"start":{"line":12,"column":2},"end":{"line":12,"column":16}},"9":{"start":{"line":13,"column":2},"end":{"line":13,"column":31}},"10":{"start":{"line":16,"column":0},"end":{"line":20,"column":2}},"11":{"start":{"line":22,"column":0},"end":{"line":28,"column":3}},"12":{"start":{"line":23,"column":2},"end":{"line":27,"column":4}},"13":{"start":{"line":24,"column":4},"end":{"line":24,"column":75}},"14":{"start":{"line":25,"column":4},"end":{"line":25,"column":16}},"15":{"start":{"line":26,"column":4},"end":{"line":26,"column":24}},"16":{"start":{"line":30,"column":0},"end":{"line":34,"column":3}},"17":{"start":{"line":32,"column":4},"end":{"line":32,"column":43}},"18":{"start":{"line":36,"column":0},"end":{"line":53,"column":2}},"19":{"start":{"line":37,"column":2},"end":{"line":39,"column":3}},"20":{"start":{"line":38,"column":4},"end":{"line":38,"column":11}},"21":{"start":{"line":40,"column":2},"end":{"line":45,"column":3}},"22":{"start":{"line":41,"column":4},"end":{"line":41,"column":32}},"23":{"start":{"line":42,"column":4},"end":{"line":42,"column":19}},"24":{"start":{"line":43,"column":4},"end":{"line":43,"column":20}},"25":{"start":{"line":44,"column":4},"end":{"line":44,"column":16}},"26":{"start":{"line":47,"column":2},"end":{"line":52,"column":3}},"27":{"start":{"line":48,"column":4},"end":{"line":51,"column":5}},"28":{"start":{"line":49,"column":6},"end":{"line":49,"column":30}},"29":{"start":{"line":50,"column":6},"end":{"line":50,"column":27}},"30":{"start":{"line":55,"column":0},"end":{"line":60,"column":2}},"31":{"start":{"line":56,"column":2},"end":{"line":59,"column":3}},"32":{"start":{"line":57,"column":4},"end":{"line":57,"column":22}},"33":{"start":{"line":58,"column":4},"end":{"line":58,"column":16}},"34":{"start":{"line":62,"column":0},"end":{"line":65,"column":1}},"35":{"start":{"line":63,"column":2},"end":{"line":63,"column":17}},"36":{"start":{"line":64,"column":2},"end":{"line":64,"column":14}},"37":{"start":{"line":67,"column":0},"end":{"line":67,"column":23}}},"branchMap":{"1":{"line":4,"type":"if","locations":[{"start":{"line":4,"column":2},"end":{"line":4,"column":2}},{"start":{"line":4,"column":2},"end":{"line":4,"column":2}}]},"2":{"line":8,"type":"binary-expr","locations":[{"start":{"line":8,"column":12},"end":{"line":8,"column":19}},{"start":{"line":8,"column":23},"end":{"line":8,"column":25}}]},"3":{"line":9,"type":"binary-expr","locations":[{"start":{"line":9,"column":21},"end":{"line":9,"column":40}},{"start":{"line":9,"column":44},"end":{"line":9,"column":52}}]},"4":{"line":37,"type":"if","locations":[{"start":{"line":37,"column":2},"end":{"line":37,"column":2}},{"start":{"line":37,"column":2},"end":{"line":37,"column":2}}]},"5":{"line":40,"type":"if","locations":[{"start":{"line":40,"column":2},"end":{"line":40,"column":2}},{"start":{"line":40,"column":2},"end":{"line":40,"column":2}}]},"6":{"line":47,"type":"if","locations":[{"start":{"line":47,"column":2},"end":{"line":47,"column":2}},{"start":{"line":47,"column":2},"end":{"line":47,"column":2}}]},"7":{"line":56,"type":"if","locations":[{"start":{"line":56,"column":2},"end":{"line":56,"column":2}},{"start":{"line":56,"column":2},"end":{"line":56,"column":2}}]}}}}

web/node_modules/async-limiter/coverage/lcov-report/async-throttle/index.html

@@ -0,0 +1,73 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <title>Code coverage report for async-throttle/</title>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="../prettify.css">
+    <link rel="stylesheet" href="../base.css">
+    <style type='text/css'>
+        div.coverage-summary .sorter {
+            background-image: url(../sort-arrow-sprite.png);
+        }
+    </style>
+</head>
+<body>
+<div class="header high">
+    <h1>Code coverage report for <span class="entity">async-throttle/</span></h1>
+    <h2>
+        Statements: <span class="metric">100% <small>(37 / 37)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Branches: <span class="metric">92.86% <small>(13 / 14)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Functions: <span class="metric">100% <small>(7 / 7)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Lines: <span class="metric">100% <small>(37 / 37)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Ignored: <span class="metric"><span class="ignore-none">none</span></span> &nbsp;&nbsp;&nbsp;&nbsp;
+    </h2>
+    <div class="path"><a href="../index.html">All files</a> &#187; async-throttle/</div>
+</div>
+<div class="body">
+<div class="coverage-summary">
+<table>
+<thead>
+<tr>
+   <th data-col="file" data-fmt="html" data-html="true" class="file">File</th>
+   <th data-col="pic" data-type="number" data-fmt="html" data-html="true" class="pic"></th>
+   <th data-col="statements" data-type="number" data-fmt="pct" class="pct">Statements</th>
+   <th data-col="statements_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="branches" data-type="number" data-fmt="pct" class="pct">Branches</th>
+   <th data-col="branches_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="functions" data-type="number" data-fmt="pct" class="pct">Functions</th>
+   <th data-col="functions_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="lines" data-type="number" data-fmt="pct" class="pct">Lines</th>
+   <th data-col="lines_raw" data-type="number" data-fmt="html" class="abs"></th>
+</tr>
+</thead>
+<tbody><tr>
+	<td class="file high" data-value="index.js"><a href="index.js.html">index.js</a></td>
+	<td data-value="100" class="pic high"><span class="cover-fill cover-full" style="width: 100px;"></span><span class="cover-empty" style="width:0px;"></span></td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="37" class="abs high">(37&nbsp;/&nbsp;37)</td>
+	<td data-value="92.86" class="pct high">92.86%</td>
+	<td data-value="14" class="abs high">(13&nbsp;/&nbsp;14)</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="7" class="abs high">(7&nbsp;/&nbsp;7)</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="37" class="abs high">(37&nbsp;/&nbsp;37)</td>
+	</tr>
+
+</tbody>
+</table>
+</div>
+</div>
+<div class="footer">
+    <div class="meta">Generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Mon Sep 11 2017 11:14:14 GMT-0500 (CDT)</div>
+</div>
+<script src="../prettify.js"></script>
+<script>
+window.onload = function () {
+        if (typeof prettyPrint === 'function') {
+            prettyPrint();
+        }
+};
+</script>
+<script src="../sorter.js"></script>
+</body>
+</html>

web/node_modules/async-limiter/coverage/lcov-report/async-throttle/index.js.html

@@ -0,0 +1,246 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <title>Code coverage report for async-throttle/index.js</title>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="../prettify.css">
+    <link rel="stylesheet" href="../base.css">
+    <style type='text/css'>
+        div.coverage-summary .sorter {
+            background-image: url(../sort-arrow-sprite.png);
+        }
+    </style>
+</head>
+<body>
+<div class="header high">
+    <h1>Code coverage report for <span class="entity">async-throttle/index.js</span></h1>
+    <h2>
+        Statements: <span class="metric">100% <small>(37 / 37)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Branches: <span class="metric">92.86% <small>(13 / 14)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Functions: <span class="metric">100% <small>(7 / 7)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Lines: <span class="metric">100% <small>(37 / 37)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Ignored: <span class="metric"><span class="ignore-none">none</span></span> &nbsp;&nbsp;&nbsp;&nbsp;
+    </h2>
+    <div class="path"><a href="../index.html">All files</a> &#187; <a href="index.html">async-throttle/</a> &#187; index.js</div>
+</div>
+<div class="body">
+<pre><table class="coverage">
+<tr><td class="line-count">1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68</td><td class="line-coverage"><span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-yes">7</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-yes">3</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">19</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-yes">45</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">39</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">39</span>
+<span class="cline-any cline-yes">18</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-yes">6</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-yes">13</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-yes">1</span>
+<span class="cline-any cline-neutral">&nbsp;</span></td><td class="text"><pre class="prettyprint lang-js">'use strict';
+&nbsp;
+function Queue(options) {
+  if (!(this instanceof Queue)) {
+    return new Queue(options);
+  }
+&nbsp;
+  options = options || {};
+  this.concurrency = options.concurrency || Infinity;
+  this.pending = 0;
+  this.jobs = [];
+  this.cbs = [];
+  this._done = done.bind(this);
+}
+&nbsp;
+var arrayAddMethods = [
+  'push',
+  'unshift',
+  'splice'
+];
+&nbsp;
+arrayAddMethods.forEach(function(method) {
+  Queue.prototype[method] = function() {
+    var methodResult = Array.prototype[method].apply(this.jobs, arguments);
+    this._run();
+    return methodResult;
+  };
+});
+&nbsp;
+Object.defineProperty(Queue.prototype, 'length', {
+  get: function() {
+    return this.pending + this.jobs.length;
+  }
+});
+&nbsp;
+Queue.prototype._run = function() {
+  if (this.pending === this.concurrency) {
+    return;
+  }
+  if (this.jobs.length) {
+    var job = this.jobs.shift();
+    this.pending++;
+    job(this._done);
+    this._run();
+  }
+&nbsp;
+  if (this.pending === 0) {
+    while (this.cbs.length !== 0) {
+      var cb = this.cbs.pop();
+      process.nextTick(cb);
+    }
+  }
+};
+&nbsp;
+Queue.prototype.onDone = function(cb) {
+  <span class="missing-if-branch" title="else path not taken" >E</span>if (typeof cb === 'function') {
+    this.cbs.push(cb);
+    this._run();
+  }
+};
+&nbsp;
+function done() {
+  this.pending--;
+  this._run();
+}
+&nbsp;
+module.exports = Queue;
+&nbsp;</pre></td></tr>
+</table></pre>
+
+</div>
+<div class="footer">
+    <div class="meta">Generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Mon Sep 11 2017 11:14:14 GMT-0500 (CDT)</div>
+</div>
+<script src="../prettify.js"></script>
+<script>
+window.onload = function () {
+        if (typeof prettyPrint === 'function') {
+            prettyPrint();
+        }
+};
+</script>
+<script src="../sorter.js"></script>
+</body>
+</html>

web/node_modules/async-limiter/coverage/lcov-report/base.css

@@ -0,0 +1,182 @@
+body, html {
+    margin:0; padding: 0;
+}
+body {
+    font-family: Helvetica Neue, Helvetica,Arial;
+    font-size: 10pt;
+}
+div.header, div.footer {
+    background: #eee;
+    padding: 1em;
+}
+div.header {
+    z-index: 100;
+    position: fixed;
+    top: 0;
+    border-bottom: 1px solid #666;
+    width: 100%;
+}
+div.footer {
+    border-top: 1px solid #666;
+}
+div.body {
+    margin-top: 10em;
+}
+div.meta {
+    font-size: 90%;
+    text-align: center;
+}
+h1, h2, h3 {
+    font-weight: normal;
+}
+h1 {
+    font-size: 12pt;
+}
+h2 {
+    font-size: 10pt;
+}
+pre {
+    font-family: Consolas, Menlo, Monaco, monospace;
+    margin: 0;
+    padding: 0;
+    line-height: 1.3;
+    font-size: 14px;
+    -moz-tab-size: 2;
+    -o-tab-size:  2;
+    tab-size: 2;
+}
+
+div.path { font-size: 110%; }
+div.path a:link, div.path a:visited { color: #000; }
+table.coverage { border-collapse: collapse; margin:0; padding: 0 }
+
+table.coverage td {
+    margin: 0;
+    padding: 0;
+    color: #111;
+    vertical-align: top;
+}
+table.coverage td.line-count {
+    width: 50px;
+    text-align: right;
+    padding-right: 5px;
+}
+table.coverage td.line-coverage {
+    color: #777 !important;
+    text-align: right;
+    border-left: 1px solid #666;
+    border-right: 1px solid #666;
+}
+
+table.coverage td.text {
+}
+
+table.coverage td span.cline-any {
+    display: inline-block;
+    padding: 0 5px;
+    width: 40px;
+}
+table.coverage td span.cline-neutral {
+    background: #eee;
+}
+table.coverage td span.cline-yes {
+    background: #b5d592;
+    color: #999;
+}
+table.coverage td span.cline-no {
+    background: #fc8c84;
+}
+
+.cstat-yes { color: #111; }
+.cstat-no { background: #fc8c84; color: #111; }
+.fstat-no { background: #ffc520; color: #111 !important; }
+.cbranch-no { background:  yellow !important; color: #111; }
+
+.cstat-skip { background: #ddd; color: #111; }
+.fstat-skip { background: #ddd; color: #111 !important; }
+.cbranch-skip { background: #ddd !important; color: #111; }
+
+.missing-if-branch {
+    display: inline-block;
+    margin-right: 10px;
+    position: relative;
+    padding: 0 4px;
+    background: black;
+    color: yellow;
+}
+
+.skip-if-branch {
+    display: none;
+    margin-right: 10px;
+    position: relative;
+    padding: 0 4px;
+    background: #ccc;
+    color: white;
+}
+
+.missing-if-branch .typ, .skip-if-branch .typ {
+    color: inherit !important;
+}
+
+.entity, .metric { font-weight: bold; }
+.metric { display: inline-block; border: 1px solid #333; padding: 0.3em; background: white; }
+.metric small { font-size: 80%; font-weight: normal; color: #666; }
+
+div.coverage-summary table { border-collapse: collapse; margin: 3em; font-size: 110%; }
+div.coverage-summary td, div.coverage-summary table  th { margin: 0; padding: 0.25em 1em; border-top: 1px solid #666; border-bottom: 1px solid #666; }
+div.coverage-summary th { text-align: left; border: 1px solid #666; background: #eee; font-weight: normal; }
+div.coverage-summary th.file { border-right: none !important; }
+div.coverage-summary th.pic { border-left: none !important; text-align: right; }
+div.coverage-summary th.pct { border-right: none !important; }
+div.coverage-summary th.abs { border-left: none !important; text-align: right; }
+div.coverage-summary td.pct { text-align: right; border-left: 1px solid #666; }
+div.coverage-summary td.abs { text-align: right; font-size: 90%; color: #444; border-right: 1px solid #666; }
+div.coverage-summary td.file { border-left: 1px solid #666; white-space: nowrap;  }
+div.coverage-summary td.pic { min-width: 120px !important;  }
+div.coverage-summary a:link { text-decoration: none; color: #000; }
+div.coverage-summary a:visited { text-decoration: none; color: #777; }
+div.coverage-summary a:hover { text-decoration: underline; }
+div.coverage-summary tfoot td { border-top: 1px solid #666; }
+
+div.coverage-summary .sorter {
+    height: 10px;
+    width: 7px;
+    display: inline-block;
+    margin-left: 0.5em;
+    background: url(sort-arrow-sprite.png) no-repeat scroll 0 0 transparent;
+}
+div.coverage-summary .sorted .sorter {
+    background-position: 0 -20px;
+}
+div.coverage-summary .sorted-desc .sorter {
+    background-position: 0 -10px;
+}
+
+.high { background: #b5d592 !important; }
+.medium { background: #ffe87c !important; }
+.low { background: #fc8c84 !important; }
+
+span.cover-fill, span.cover-empty {
+    display:inline-block;
+    border:1px solid #444;
+    background: white;
+    height: 12px;
+}
+span.cover-fill {
+    background: #ccc;
+    border-right: 1px solid #444;
+}
+span.cover-empty {
+    background: white;
+    border-left: none;
+}
+span.cover-full {
+    border-right: none !important;
+}
+pre.prettyprint {
+    border: none !important;
+    padding: 0 !important;
+    margin: 0 !important;
+}
+.com { color: #999 !important; }
+.ignore-none { color: #999; font-weight: normal; }

web/node_modules/async-limiter/coverage/lcov-report/index.html

@@ -0,0 +1,73 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <title>Code coverage report for All files</title>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="prettify.css">
+    <link rel="stylesheet" href="base.css">
+    <style type='text/css'>
+        div.coverage-summary .sorter {
+            background-image: url(sort-arrow-sprite.png);
+        }
+    </style>
+</head>
+<body>
+<div class="header high">
+    <h1>Code coverage report for <span class="entity">All files</span></h1>
+    <h2>
+        Statements: <span class="metric">100% <small>(37 / 37)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Branches: <span class="metric">92.86% <small>(13 / 14)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Functions: <span class="metric">100% <small>(7 / 7)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Lines: <span class="metric">100% <small>(37 / 37)</small></span> &nbsp;&nbsp;&nbsp;&nbsp;
+        Ignored: <span class="metric"><span class="ignore-none">none</span></span> &nbsp;&nbsp;&nbsp;&nbsp;
+    </h2>
+    <div class="path"></div>
+</div>
+<div class="body">
+<div class="coverage-summary">
+<table>
+<thead>
+<tr>
+   <th data-col="file" data-fmt="html" data-html="true" class="file">File</th>
+   <th data-col="pic" data-type="number" data-fmt="html" data-html="true" class="pic"></th>
+   <th data-col="statements" data-type="number" data-fmt="pct" class="pct">Statements</th>
+   <th data-col="statements_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="branches" data-type="number" data-fmt="pct" class="pct">Branches</th>
+   <th data-col="branches_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="functions" data-type="number" data-fmt="pct" class="pct">Functions</th>
+   <th data-col="functions_raw" data-type="number" data-fmt="html" class="abs"></th>
+   <th data-col="lines" data-type="number" data-fmt="pct" class="pct">Lines</th>
+   <th data-col="lines_raw" data-type="number" data-fmt="html" class="abs"></th>
+</tr>
+</thead>
+<tbody><tr>
+	<td class="file high" data-value="async-throttle/"><a href="async-throttle/index.html">async-throttle/</a></td>
+	<td data-value="100" class="pic high"><span class="cover-fill cover-full" style="width: 100px;"></span><span class="cover-empty" style="width:0px;"></span></td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="37" class="abs high">(37&nbsp;/&nbsp;37)</td>
+	<td data-value="92.86" class="pct high">92.86%</td>
+	<td data-value="14" class="abs high">(13&nbsp;/&nbsp;14)</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="7" class="abs high">(7&nbsp;/&nbsp;7)</td>
+	<td data-value="100" class="pct high">100%</td>
+	<td data-value="37" class="abs high">(37&nbsp;/&nbsp;37)</td>
+	</tr>
+
+</tbody>
+</table>
+</div>
+</div>
+<div class="footer">
+    <div class="meta">Generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Mon Sep 11 2017 11:14:14 GMT-0500 (CDT)</div>
+</div>
+<script src="prettify.js"></script>
+<script>
+window.onload = function () {
+        if (typeof prettyPrint === 'function') {
+            prettyPrint();
+        }
+};
+</script>
+<script src="sorter.js"></script>
+</body>
+</html>

web/node_modules/async-limiter/coverage/lcov-report/prettify.css

@@ -0,0 +1 @@
+.pln{color:#000}@media screen{.str{color:#080}.kwd{color:#008}.com{color:#800}.typ{color:#606}.lit{color:#066}.pun,.opn,.clo{color:#660}.tag{color:#008}.atn{color:#606}.atv{color:#080}.dec,.var{color:#606}.fun{color:red}}@media print,projection{.str{color:#060}.kwd{color:#006;font-weight:bold}.com{color:#600;font-style:italic}.typ{color:#404;font-weight:bold}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:bold}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8{list-style-type:none}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee}

web/node_modules/async-limiter/coverage/lcov-report/prettify.js

@@ -0,0 +1 @@
+window.PR_SHOULD_USE_CONTINUATION=true;(function(){var h=["break,continue,do,else,for,if,return,while"];var u=[h,"auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"];var p=[u,"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"];var l=[p,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"];var x=[p,"abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient"];var R=[x,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var"];var r="all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,true,try,unless,until,when,while,yes";var w=[p,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"];var s="caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END";var I=[h,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"];var f=[h,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"];var H=[h,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"];var A=[l,R,w,s+I,f,H];var e=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)/;var C="str";var z="kwd";var j="com";var O="typ";var G="lit";var L="pun";var F="pln";var m="tag";var E="dec";var J="src";var P="atn";var n="atv";var N="nocode";var M="(?:^^\\.?|[+-]|\\!|\\!=|\\!==|\\#|\\%|\\%=|&|&&|&&=|&=|\\(|\\*|\\*=|\\+=|\\,|\\-=|\\->|\\/|\\/=|:|::|\\;|<|<<|<<=|<=|=|==|===|>|>=|>>|>>=|>>>|>>>=|\\?|\\@|\\[|\\^|\\^=|\\^\\^|\\^\\^=|\\{|\\||\\|=|\\|\\||\\|\\|=|\\~|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*";function k(Z){var ad=0;var S=false;var ac=false;for(var V=0,U=Z.length;V<U;++V){var ae=Z[V];if(ae.ignoreCase){ac=true}else{if(/[a-z]/i.test(ae.source.replace(/\\u[0-9a-f]{4}|\\x[0-9a-f]{2}|\\[^ux]/gi,""))){S=true;ac=false;break}}}var Y={b:8,t:9,n:10,v:11,f:12,r:13};function ab(ah){var ag=ah.charCodeAt(0);if(ag!==92){return ag}var af=ah.charAt(1);ag=Y[af];if(ag){return ag}else{if("0"<=af&&af<="7"){return parseInt(ah.substring(1),8)}else{if(af==="u"||af==="x"){return parseInt(ah.substring(2),16)}else{return ah.charCodeAt(1)}}}}function T(af){if(af<32){return(af<16?"\\x0":"\\x")+af.toString(16)}var ag=String.fromCharCode(af);if(ag==="\\"||ag==="-"||ag==="["||ag==="]"){ag="\\"+ag}return ag}function X(am){var aq=am.substring(1,am.length-1).match(new RegExp("\\\\u[0-9A-Fa-f]{4}|\\\\x[0-9A-Fa-f]{2}|\\\\[0-3][0-7]{0,2}|\\\\[0-7]{1,2}|\\\\[\\s\\S]|-|[^-\\\\]","g"));var ak=[];var af=[];var ao=aq[0]==="^";for(var ar=ao?1:0,aj=aq.length;ar<aj;++ar){var ah=aq[ar];if(/\\[bdsw]/i.test(ah)){ak.push(ah)}else{var ag=ab(ah);var al;if(ar+2<aj&&"-"===aq[ar+1]){al=ab(aq[ar+2]);ar+=2}else{al=ag}af.push([ag,al]);if(!(al<65||ag>122)){if(!(al<65||ag>90)){af.push([Math.max(65,ag)|32,Math.min(al,90)|32])}if(!(al<97||ag>122)){af.push([Math.max(97,ag)&~32,Math.min(al,122)&~32])}}}}af.sort(function(av,au){return(av[0]-au[0])||(au[1]-av[1])});var ai=[];var ap=[NaN,NaN];for(var ar=0;ar<af.length;++ar){var at=af[ar];if(at[0]<=ap[1]+1){ap[1]=Math.max(ap[1],at[1])}else{ai.push(ap=at)}}var an=["["];if(ao){an.push("^")}an.push.apply(an,ak);for(var ar=0;ar<ai.length;++ar){var at=ai[ar];an.push(T(at[0]));if(at[1]>at[0]){if(at[1]+1>at[0]){an.push("-")}an.push(T(at[1]))}}an.push("]");return an.join("")}function W(al){var aj=al.source.match(new RegExp("(?:\\[(?:[^\\x5C\\x5D]|\\\\[\\s\\S])*\\]|\\\\u[A-Fa-f0-9]{4}|\\\\x[A-Fa-f0-9]{2}|\\\\[0-9]+|\\\\[^ux0-9]|\\(\\?[:!=]|[\\(\\)\\^]|[^\\x5B\\x5C\\(\\)\\^]+)","g"));var ah=aj.length;var an=[];for(var ak=0,am=0;ak<ah;++ak){var ag=aj[ak];if(ag==="("){++am}else{if("\\"===ag.charAt(0)){var af=+ag.substring(1);if(af&&af<=am){an[af]=-1}}}}for(var ak=1;ak<an.length;++ak){if(-1===an[ak]){an[ak]=++ad}}for(var ak=0,am=0;ak<ah;++ak){var ag=aj[ak];if(ag==="("){++am;if(an[am]===undefined){aj[ak]="(?:"}}else{if("\\"===ag.charAt(0)){var af=+ag.substring(1);if(af&&af<=am){aj[ak]="\\"+an[am]}}}}for(var ak=0,am=0;ak<ah;++ak){if("^"===aj[ak]&&"^"!==aj[ak+1]){aj[ak]=""}}if(al.ignoreCase&&S){for(var ak=0;ak<ah;++ak){var ag=aj[ak];var ai=ag.charAt(0);if(ag.length>=2&&ai==="["){aj[ak]=X(ag)}else{if(ai!=="\\"){aj[ak]=ag.replace(/[a-zA-Z]/g,function(ao){var ap=ao.charCodeAt(0);return"["+String.fromCharCode(ap&~32,ap|32)+"]"})}}}}return aj.join("")}var aa=[];for(var V=0,U=Z.length;V<U;++V){var ae=Z[V];if(ae.global||ae.multiline){throw new Error(""+ae)}aa.push("(?:"+W(ae)+")")}return new RegExp(aa.join("|"),ac?"gi":"g")}function a(V){var U=/(?:^|\s)nocode(?:\s|$)/;var X=[];var T=0;var Z=[];var W=0;var S;if(V.currentStyle){S=V.currentStyle.whiteSpace}else{if(window.getComputedStyle){S=document.defaultView.getComputedStyle(V,null).getPropertyValue("white-space")}}var Y=S&&"pre"===S.substring(0,3);function aa(ab){switch(ab.nodeType){case 1:if(U.test(ab.className)){return}for(var ae=ab.firstChild;ae;ae=ae.nextSibling){aa(ae)}var ad=ab.nodeName;if("BR"===ad||"LI"===ad){X[W]="\n";Z[W<<1]=T++;Z[(W++<<1)|1]=ab}break;case 3:case 4:var ac=ab.nodeValue;if(ac.length){if(!Y){ac=ac.replace(/[ \t\r\n]+/g," ")}else{ac=ac.replace(/\r\n?/g,"\n")}X[W]=ac;Z[W<<1]=T;T+=ac.length;Z[(W++<<1)|1]=ab}break}}aa(V);return{sourceCode:X.join("").replace(/\n$/,""),spans:Z}}function B(S,U,W,T){if(!U){return}var V={sourceCode:U,basePos:S};W(V);T.push.apply(T,V.decorations)}var v=/\S/;function o(S){var V=undefined;for(var U=S.firstChild;U;U=U.nextSibling){var T=U.nodeType;V=(T===1)?(V?S:U):(T===3)?(v.test(U.nodeValue)?S:V):V}return V===S?undefined:V}function g(U,T){var S={};var V;(function(){var ad=U.concat(T);var ah=[];var ag={};for(var ab=0,Z=ad.length;ab<Z;++ab){var Y=ad[ab];var ac=Y[3];if(ac){for(var ae=ac.length;--ae>=0;){S[ac.charAt(ae)]=Y}}var af=Y[1];var aa=""+af;if(!ag.hasOwnProperty(aa)){ah.push(af);ag[aa]=null}}ah.push(/[\0-\uffff]/);V=k(ah)})();var X=T.length;var W=function(ah){var Z=ah.sourceCode,Y=ah.basePos;var ad=[Y,F];var af=0;var an=Z.match(V)||[];var aj={};for(var ae=0,aq=an.length;ae<aq;++ae){var ag=an[ae];var ap=aj[ag];var ai=void 0;var am;if(typeof ap==="string"){am=false}else{var aa=S[ag.charAt(0)];if(aa){ai=ag.match(aa[1]);ap=aa[0]}else{for(var ao=0;ao<X;++ao){aa=T[ao];ai=ag.match(aa[1]);if(ai){ap=aa[0];break}}if(!ai){ap=F}}am=ap.length>=5&&"lang-"===ap.substring(0,5);if(am&&!(ai&&typeof ai[1]==="string")){am=false;ap=J}if(!am){aj[ag]=ap}}var ab=af;af+=ag.length;if(!am){ad.push(Y+ab,ap)}else{var al=ai[1];var ak=ag.indexOf(al);var ac=ak+al.length;if(ai[2]){ac=ag.length-ai[2].length;ak=ac-al.length}var ar=ap.substring(5);B(Y+ab,ag.substring(0,ak),W,ad);B(Y+ab+ak,al,q(ar,al),ad);B(Y+ab+ac,ag.substring(ac),W,ad)}}ah.decorations=ad};return W}function i(T){var W=[],S=[];if(T.tripleQuotedStrings){W.push([C,/^(?:\'\'\'(?:[^\'\\]|\\[\s\S]|\'{1,2}(?=[^\']))*(?:\'\'\'|$)|\"\"\"(?:[^\"\\]|\\[\s\S]|\"{1,2}(?=[^\"]))*(?:\"\"\"|$)|\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$))/,null,"'\""])}else{if(T.multiLineStrings){W.push([C,/^(?:\'(?:[^\\\']|\\[\s\S])*(?:\'|$)|\"(?:[^\\\"]|\\[\s\S])*(?:\"|$)|\`(?:[^\\\`]|\\[\s\S])*(?:\`|$))/,null,"'\"`"])}else{W.push([C,/^(?:\'(?:[^\\\'\r\n]|\\.)*(?:\'|$)|\"(?:[^\\\"\r\n]|\\.)*(?:\"|$))/,null,"\"'"])}}if(T.verbatimStrings){S.push([C,/^@\"(?:[^\"]|\"\")*(?:\"|$)/,null])}var Y=T.hashComments;if(Y){if(T.cStyleComments){if(Y>1){W.push([j,/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,null,"#"])}else{W.push([j,/^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\r\n]*)/,null,"#"])}S.push([C,/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,null])}else{W.push([j,/^#[^\r\n]*/,null,"#"])}}if(T.cStyleComments){S.push([j,/^\/\/[^\r\n]*/,null]);S.push([j,/^\/\*[\s\S]*?(?:\*\/|$)/,null])}if(T.regexLiterals){var X=("/(?=[^/*])(?:[^/\\x5B\\x5C]|\\x5C[\\s\\S]|\\x5B(?:[^\\x5C\\x5D]|\\x5C[\\s\\S])*(?:\\x5D|$))+/");S.push(["lang-regex",new RegExp("^"+M+"("+X+")")])}var V=T.types;if(V){S.push([O,V])}var U=(""+T.keywords).replace(/^ | $/g,"");if(U.length){S.push([z,new RegExp("^(?:"+U.replace(/[\s,]+/g,"|")+")\\b"),null])}W.push([F,/^\s+/,null," \r\n\t\xA0"]);S.push([G,/^@[a-z_$][a-z_$@0-9]*/i,null],[O,/^(?:[@_]?[A-Z]+[a-z][A-Za-z_$@0-9]*|\w+_t\b)/,null],[F,/^[a-z_$][a-z_$@0-9]*/i,null],[G,new RegExp("^(?:0x[a-f0-9]+|(?:\\d(?:_\\d+)*\\d*(?:\\.\\d*)?|\\.\\d\\+)(?:e[+\\-]?\\d+)?)[a-z]*","i"),null,"0123456789"],[F,/^\\[\s\S]?/,null],[L,/^.[^\s\w\.$@\'\"\`\/\#\\]*/,null]);return g(W,S)}var K=i({keywords:A,hashComments:true,cStyleComments:true,multiLineStrings:true,regexLiterals:true});function Q(V,ag){var U=/(?:^|\s)nocode(?:\s|$)/;var ab=/\r\n?|\n/;var ac=V.ownerDocument;var S;if(V.currentStyle){S=V.currentStyle.whiteSpace}else{if(window.getComputedStyle){S=ac.defaultView.getComputedStyle(V,null).getPropertyValue("white-space")}}var Z=S&&"pre"===S.substring(0,3);var af=ac.createElement("LI");while(V.firstChild){af.appendChild(V.firstChild)}var W=[af];function ae(al){switch(al.nodeType){case 1:if(U.test(al.className)){break}if("BR"===al.nodeName){ad(al);if(al.parentNode){al.parentNode.removeChild(al)}}else{for(var an=al.firstChild;an;an=an.nextSibling){ae(an)}}break;case 3:case 4:if(Z){var am=al.nodeValue;var aj=am.match(ab);if(aj){var ai=am.substring(0,aj.index);al.nodeValue=ai;var ah=am.substring(aj.index+aj[0].length);if(ah){var ak=al.parentNode;ak.insertBefore(ac.createTextNode(ah),al.nextSibling)}ad(al);if(!ai){al.parentNode.removeChild(al)}}}break}}function ad(ak){while(!ak.nextSibling){ak=ak.parentNode;if(!ak){return}}function ai(al,ar){var aq=ar?al.cloneNode(false):al;var ao=al.parentNode;if(ao){var ap=ai(ao,1);var an=al.nextSibling;ap.appendChild(aq);for(var am=an;am;am=an){an=am.nextSibling;ap.appendChild(am)}}return aq}var ah=ai(ak.nextSibling,0);for(var aj;(aj=ah.parentNode)&&aj.nodeType===1;){ah=aj}W.push(ah)}for(var Y=0;Y<W.length;++Y){ae(W[Y])}if(ag===(ag|0)){W[0].setAttribute("value",ag)}var aa=ac.createElement("OL");aa.className="linenums";var X=Math.max(0,((ag-1))|0)||0;for(var Y=0,T=W.length;Y<T;++Y){af=W[Y];af.className="L"+((Y+X)%10);if(!af.firstChild){af.appendChild(ac.createTextNode("\xA0"))}aa.appendChild(af)}V.appendChild(aa)}function D(ac){var aj=/\bMSIE\b/.test(navigator.userAgent);var am=/\n/g;var al=ac.sourceCode;var an=al.length;var V=0;var aa=ac.spans;var T=aa.length;var ah=0;var X=ac.decorations;var Y=X.length;var Z=0;X[Y]=an;var ar,aq;for(aq=ar=0;aq<Y;){if(X[aq]!==X[aq+2]){X[ar++]=X[aq++];X[ar++]=X[aq++]}else{aq+=2}}Y=ar;for(aq=ar=0;aq<Y;){var at=X[aq];var ab=X[aq+1];var W=aq+2;while(W+2<=Y&&X[W+1]===ab){W+=2}X[ar++]=at;X[ar++]=ab;aq=W}Y=X.length=ar;var ae=null;while(ah<T){var af=aa[ah];var S=aa[ah+2]||an;var ag=X[Z];var ap=X[Z+2]||an;var W=Math.min(S,ap);var ak=aa[ah+1];var U;if(ak.nodeType!==1&&(U=al.substring(V,W))){if(aj){U=U.replace(am,"\r")}ak.nodeValue=U;var ai=ak.ownerDocument;var ao=ai.createElement("SPAN");ao.className=X[Z+1];var ad=ak.parentNode;ad.replaceChild(ao,ak);ao.appendChild(ak);if(V<S){aa[ah+1]=ak=ai.createTextNode(al.substring(W,S));ad.insertBefore(ak,ao.nextSibling)}}V=W;if(V>=S){ah+=2}if(V>=ap){Z+=2}}}var t={};function c(U,V){for(var S=V.length;--S>=0;){var T=V[S];if(!t.hasOwnProperty(T)){t[T]=U}else{if(window.console){console.warn("cannot override language handler %s",T)}}}}function q(T,S){if(!(T&&t.hasOwnProperty(T))){T=/^\s*</.test(S)?"default-markup":"default-code"}return t[T]}c(K,["default-code"]);c(g([],[[F,/^[^<?]+/],[E,/^<!\w[^>]*(?:>|$)/],[j,/^<\!--[\s\S]*?(?:-\->|$)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],[L,/^(?:<[%?]|[%?]>)/],["lang-",/^<xmp\b[^>]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-js",/^<script\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^<style\b[^>]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),["default-markup","htm","html","mxml","xhtml","xml","xsl"]);c(g([[F,/^[\s]+/,null," \t\r\n"],[n,/^(?:\"[^\"]*\"?|\'[^\']*\'?)/,null,"\"'"]],[[m,/^^<\/?[a-z](?:[\w.:-]*\w)?|\/?>$/i],[P,/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^>\'\"\s]*(?:[^>\'\"\s\/]|\/(?=\s)))/],[L,/^[=<>\/]+/],["lang-js",/^on\w+\s*=\s*\"([^\"]+)\"/i],["lang-js",/^on\w+\s*=\s*\'([^\']+)\'/i],["lang-js",/^on\w+\s*=\s*([^\"\'>\s]+)/i],["lang-css",/^style\s*=\s*\"([^\"]+)\"/i],["lang-css",/^style\s*=\s*\'([^\']+)\'/i],["lang-css",/^style\s*=\s*([^\"\'>\s]+)/i]]),["in.tag"]);c(g([],[[n,/^[\s\S]+/]]),["uq.val"]);c(i({keywords:l,hashComments:true,cStyleComments:true,types:e}),["c","cc","cpp","cxx","cyc","m"]);c(i({keywords:"null,true,false"}),["json"]);c(i({keywords:R,hashComments:true,cStyleComments:true,verbatimStrings:true,types:e}),["cs"]);c(i({keywords:x,cStyleComments:true}),["java"]);c(i({keywords:H,hashComments:true,multiLineStrings:true}),["bsh","csh","sh"]);c(i({keywords:I,hashComments:true,multiLineStrings:true,tripleQuotedStrings:true}),["cv","py"]);c(i({keywords:s,hashComments:true,multiLineStrings:true,regexLiterals:true}),["perl","pl","pm"]);c(i({keywords:f,hashComments:true,multiLineStrings:true,regexLiterals:true}),["rb"]);c(i({keywords:w,cStyleComments:true,regexLiterals:true}),["js"]);c(i({keywords:r,hashComments:3,cStyleComments:true,multilineStrings:true,tripleQuotedStrings:true,regexLiterals:true}),["coffee"]);c(g([],[[C,/^[\s\S]+/]]),["regex"]);function d(V){var U=V.langExtension;try{var S=a(V.sourceNode);var T=S.sourceCode;V.sourceCode=T;V.spans=S.spans;V.basePos=0;q(U,T)(V);D(V)}catch(W){if("console" in window){console.log(W&&W.stack?W.stack:W)}}}function y(W,V,U){var S=document.createElement("PRE");S.innerHTML=W;if(U){Q(S,U)}var T={langExtension:V,numberLines:U,sourceNode:S};d(T);return S.innerHTML}function b(ad){function Y(af){return document.getElementsByTagName(af)}var ac=[Y("pre"),Y("code"),Y("xmp")];var T=[];for(var aa=0;aa<ac.length;++aa){for(var Z=0,V=ac[aa].length;Z<V;++Z){T.push(ac[aa][Z])}}ac=null;var W=Date;if(!W.now){W={now:function(){return +(new Date)}}}var X=0;var S;var ab=/\blang(?:uage)?-([\w.]+)(?!\S)/;var ae=/\bprettyprint\b/;function U(){var ag=(window.PR_SHOULD_USE_CONTINUATION?W.now()+250:Infinity);for(;X<T.length&&W.now()<ag;X++){var aj=T[X];var ai=aj.className;if(ai.indexOf("prettyprint")>=0){var ah=ai.match(ab);var am;if(!ah&&(am=o(aj))&&"CODE"===am.tagName){ah=am.className.match(ab)}if(ah){ah=ah[1]}var al=false;for(var ak=aj.parentNode;ak;ak=ak.parentNode){if((ak.tagName==="pre"||ak.tagName==="code"||ak.tagName==="xmp")&&ak.className&&ak.className.indexOf("prettyprint")>=0){al=true;break}}if(!al){var af=aj.className.match(/\blinenums\b(?::(\d+))?/);af=af?af[1]&&af[1].length?+af[1]:true:false;if(af){Q(aj,af)}S={langExtension:ah,sourceNode:aj,numberLines:af};d(S)}}}if(X<T.length){setTimeout(U,250)}else{if(ad){ad()}}}U()}window.prettyPrintOne=y;window.prettyPrint=b;window.PR={createSimpleLexer:g,registerLangHandler:c,sourceDecorator:i,PR_ATTRIB_NAME:P,PR_ATTRIB_VALUE:n,PR_COMMENT:j,PR_DECLARATION:E,PR_KEYWORD:z,PR_LITERAL:G,PR_NOCODE:N,PR_PLAIN:F,PR_PUNCTUATION:L,PR_SOURCE:J,PR_STRING:C,PR_TAG:m,PR_TYPE:O}})();PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_DECLARATION,/^<!\w[^>]*(?:>|$)/],[PR.PR_COMMENT,/^<\!--[\s\S]*?(?:-\->|$)/],[PR.PR_PUNCTUATION,/^(?:<[%?]|[%?]>)/],["lang-",/^<\?([\s\S]+?)(?:\?>|$)/],["lang-",/^<%([\s\S]+?)(?:%>|$)/],["lang-",/^<xmp\b[^>]*>([\s\S]+?)<\/xmp\b[^>]*>/i],["lang-handlebars",/^<script\b[^>]*type\s*=\s*['"]?text\/x-handlebars-template['"]?\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-js",/^<script\b[^>]*>([\s\S]*?)(<\/script\b[^>]*>)/i],["lang-css",/^<style\b[^>]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i],[PR.PR_DECLARATION,/^{{[#^>/]?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{&?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{{>?\s*[\w.][^}]*}}}/],[PR.PR_COMMENT,/^{{![^}]*}}/]]),["handlebars","hbs"]);PR.registerLangHandler(PR.createSimpleLexer([[PR.PR_PLAIN,/^[ \t\r\n\f]+/,null," \t\r\n\f"]],[[PR.PR_STRING,/^\"(?:[^\n\r\f\\\"]|\\(?:\r\n?|\n|\f)|\\[\s\S])*\"/,null],[PR.PR_STRING,/^\'(?:[^\n\r\f\\\']|\\(?:\r\n?|\n|\f)|\\[\s\S])*\'/,null],["lang-css-str",/^url\(([^\)\"\']*)\)/i],[PR.PR_KEYWORD,/^(?:url|rgb|\!important|@import|@page|@media|@charset|inherit)(?=[^\-\w]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|(?:\\[0-9a-f]+ ?))(?:[_a-z0-9\-]|\\(?:\\[0-9a-f]+ ?))*)\s*:/i],[PR.PR_COMMENT,/^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//],[PR.PR_COMMENT,/^(?:<!--|-->)/],[PR.PR_LITERAL,/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],[PR.PR_LITERAL,/^#(?:[0-9a-f]{3}){1,2}/i],[PR.PR_PLAIN,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i],[PR.PR_PUNCTUATION,/^[^\s\w\'\"]+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_KEYWORD,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_STRING,/^[^\)\"\']+/]]),["css-str"]);

web/node_modules/async-limiter/coverage/lcov-report/sorter.js

@@ -0,0 +1,156 @@
+var addSorting = (function () {
+    "use strict";
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() { return document.querySelector('.coverage-summary table'); }
+    // returns the thead element of the summary table
+    function getTableHeader() { return getTable().querySelector('thead tr'); }
+    // returns the tbody element of the summary table
+    function getTableBody() { return getTable().querySelector('tbody'); }
+    // returns the th element for nth column
+    function getNthColumn(n) { return getTableHeader().querySelectorAll('th')[n]; }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML = colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function (a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function (a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc ? ' sorted-desc' : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function () {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i =0 ; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                el = getNthColumn(i).querySelector('.sorter');
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function () {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData(cols);
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);