normal Model Upload (teja)

.gitattributes

@@ -37,3 +37,5 @@ sample_data/mnist_test.csv filter=lfs diff=lfs merge=lfs -text
 sample_data/mnist_train_small.csv filter=lfs diff=lfs merge=lfs -text
 updated_data.csv filter=lfs diff=lfs merge=lfs -text
 updated_data_train.csv filter=lfs diff=lfs merge=lfs -text
+datalab/web/node_modules/dtrace-provider/build/node_gyp_bins/python3 filter=lfs diff=lfs merge=lfs -text
+datalab/web/node_modules/node-pty/build/node_gyp_bins/python3 filter=lfs diff=lfs merge=lfs -text

datalab/run.sh

@@ -0,0 +1,75 @@
+#!/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)"
+
+/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"
+  # importing tensorflow on a TPU VM causes the process to acquire the TPU for
+  # the duration of the import. This makes the TPU effectively unacquirable for
+  # the duration of the warmup, which can break things like probers.
+  if [[ "${COLAB_TPU_1VM}" == "1" ]]; then
+    python3 -c "import tensorflow"
+  else
+    python3 -c "import tensorflow" &
+  fi
+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
+

datalab/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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

datalab/web/appSettings.js

@@ -0,0 +1,144 @@
+"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 = applyEnvironmentVariables;
+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; }
+    }
+}
+//# 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"]}

datalab/web/config/basePath.json

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

datalab/web/config/settings.json

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

datalab/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.JsonRpcReader = void 0;
+exports.encodeJsonRpc = encodeJsonRpc;
+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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json_rpc.js","sourceRoot":"","sources":["../../../../../../third_party/colab/sources/json_rpc.ts"],"names":[],"mappings":"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","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"]}

datalab/web/jupyter.js

@@ -0,0 +1,213 @@
+"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.init = init;
+exports.close = close;
+exports.handleSocket = handleSocket;
+exports.handleRequest = handleRequest;
+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();
+}
+/**
+ * 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');
+}
+/** 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);
+}
+/** Proxy this HTTP request to jupyter. */
+function handleRequest(request, response) {
+    if (!jupyterServer) {
+        response.statusCode = 500;
+        response.end();
+        return;
+    }
+    jupyterServer.proxy.web(request, response, null);
+}
+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"]}

datalab/web/logging.js

@@ -0,0 +1,129 @@
+"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.getLogger = getLogger;
+exports.getJupyterLogger = getJupyterLogger;
+exports.logRequest = logRequest;
+exports.initializeLoggers = initializeLoggers;
+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;
+}
+/**
+ * Gets the logger for generating Jupyter logs.
+ * @returns the logger configured for Jupyter logging.
+ */
+function getJupyterLogger() {
+    return jupyterLogger;
+}
+/**
+ * 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
+        });
+    });
+}
+/**
+ * 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; }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

datalab/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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

datalab/web/lsp/extensions_node.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionStatus = void 0;
+/** The status of a cell's execution. */
+var ExecutionStatus;
+(function (ExecutionStatus) {
+    /** The default value for an execution status. */
+    ExecutionStatus[ExecutionStatus["UNKNOWN"] = 0] = "UNKNOWN";
+    /** Execution is up to date. */
+    ExecutionStatus[ExecutionStatus["FRESH"] = 1] = "FRESH";
+    /** Execution is out of date. */
+    ExecutionStatus[ExecutionStatus["STALE"] = 2] = "STALE";
+})(ExecutionStatus || (exports.ExecutionStatus = ExecutionStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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

datalab/web/lsp/protocol_node.js

@@ -0,0 +1,191 @@
+"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["TextDocumentCellDependents"] = "textDocument/cellDependents";
+    Method["TextDocumentCellPrerequisites"] = "textDocument/cellPrerequisites";
+    Method["TextDocumentInlayHint"] = "textDocument/inlayHint";
+    Method["TextDocumentPublishDiagnostics"] = "textDocument/publishDiagnostics";
+    Method["TextDocumentPrepareRename"] = "textDocument/prepareRename";
+    Method["TextDocumentRename"] = "textDocument/rename";
+    Method["TextDocumentRepair"] = "textDocument/repair";
+    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  TextDocumentCellDependents = 'textDocument/cellDependents',\n  TextDocumentCellPrerequisites = 'textDocument/cellPrerequisites',\n  TextDocumentInlayHint = 'textDocument/inlayHint',\n  TextDocumentPublishDiagnostics = 'textDocument/publishDiagnostics',\n  TextDocumentPrepareRename = 'textDocument/prepareRename',\n  TextDocumentRename = 'textDocument/rename',\n  TextDocumentRepair = 'textDocument/repair',\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"]}

datalab/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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

datalab/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,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

datalab/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 */\ndeclare interface 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"]}

datalab/web/node_modules/.bin/bunyan

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

datalab/web/node_modules/.bin/mkdirp

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

datalab/web/node_modules/.bin/ncp

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

datalab/web/node_modules/.bin/rimraf

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

datalab/web/node_modules/.bin/semver

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

datalab/web/node_modules/.package-lock.json

@@ -0,0 +1,634 @@
+{
+  "name": "ipy-rev-proxy",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "node_modules/accepts": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz",
+      "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=",
+      "dependencies": {
+        "mime-types": "~2.1.18",
+        "negotiator": "0.6.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/after": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/after/-/after-0.8.2.tgz",
+      "integrity": "sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8="
+    },
+    "node_modules/arraybuffer.slice": {
+      "version": "0.0.7",
+      "resolved": "https://registry.npmjs.org/arraybuffer.slice/-/arraybuffer.slice-0.0.7.tgz",
+      "integrity": "sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog=="
+    },
+    "node_modules/async": {
+      "version": "1.5.2",
+      "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz",
+      "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo="
+    },
+    "node_modules/async-limiter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz",
+      "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg=="
+    },
+    "node_modules/backo2": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/backo2/-/backo2-1.0.2.tgz",
+      "integrity": "sha1-MasayLEpNjRj41s+u2n038+6eUc="
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=",
+      "optional": true
+    },
+    "node_modules/base64-arraybuffer": {
+      "version": "0.1.5",
+      "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz",
+      "integrity": "sha1-c5JncZI7Whl0etZmqlzUv5xunOg=",
+      "engines": {
+        "node": ">= 0.6.0"
+      }
+    },
+    "node_modules/base64id": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/base64id/-/base64id-1.0.0.tgz",
+      "integrity": "sha1-R2iMuZu2gE8OBtPnY7HDLlfY5rY=",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/better-assert": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/better-assert/-/better-assert-1.0.2.tgz",
+      "integrity": "sha1-QIZrnhueC1W0gYlDEeaPr/rrxSI=",
+      "dependencies": {
+        "callsite": "1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/blob": {
+      "version": "0.0.4",
+      "resolved": "https://registry.npmjs.org/blob/-/blob-0.0.4.tgz",
+      "integrity": "sha1-vPEwUspURj8w+fx+lbmkdjCpSSE="
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "optional": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/bunyan": {
+      "version": "1.8.12",
+      "resolved": "https://registry.npmjs.org/bunyan/-/bunyan-1.8.12.tgz",
+      "integrity": "sha1-8VDw9nSKvdcq6uhPBEA74u8RN5c=",
+      "engines": [
+        "node >=0.10.0"
+      ],
+      "bin": {
+        "bunyan": "bin/bunyan"
+      },
+      "optionalDependencies": {
+        "dtrace-provider": "~0.8",
+        "moment": "^2.10.6",
+        "mv": "~2",
+        "safe-json-stringify": "~1"
+      }
+    },
+    "node_modules/bunyan-rotating-file-stream": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/bunyan-rotating-file-stream/-/bunyan-rotating-file-stream-1.6.3.tgz",
+      "integrity": "sha512-pJFBvosqXjYXsOtDr72SDhZr3d+1ADDBO8TiU0ju0DbNBS4+vjI3GatczzB7LCcBWqWevQ91j1HYsl8cgnI+HQ==",
+      "engines": [
+        "node >=0.10.0"
+      ],
+      "dependencies": {
+        "async": "^1.5.2",
+        "lodash": "^4.2.1",
+        "semver": "^5.1.0",
+        "strftime": "^0.9.2"
+      }
+    },
+    "node_modules/callsite": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/callsite/-/callsite-1.0.0.tgz",
+      "integrity": "sha1-KAOY5dZkvXQDi28JBRU+borxvCA=",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/component-bind": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/component-bind/-/component-bind-1.0.0.tgz",
+      "integrity": "sha1-AMYIq33Nk4l8AAllGx06jh5zu9E="
+    },
+    "node_modules/component-emitter": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz",
+      "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY="
+    },
+    "node_modules/component-inherit": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/component-inherit/-/component-inherit-0.0.3.tgz",
+      "integrity": "sha1-ZF/ErfWLcrZJ1crmUTVhnbJv8UM="
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+      "optional": true
+    },
+    "node_modules/cookie": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz",
+      "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/debug": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
+      "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/dtrace-provider": {
+      "version": "0.8.7",
+      "resolved": "https://registry.npmjs.org/dtrace-provider/-/dtrace-provider-0.8.7.tgz",
+      "integrity": "sha1-3JObTT4GIM/gwc2APQ0tftBP/QQ=",
+      "hasInstallScript": true,
+      "optional": true,
+      "dependencies": {
+        "nan": "^2.10.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/engine.io": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-3.2.0.tgz",
+      "integrity": "sha512-mRbgmAtQ4GAlKwuPnnAvXXwdPhEx+jkc0OBCLrXuD/CRvwNK3AxRSnqK4FSqmAMRRHryVJP8TopOvmEaA64fKw==",
+      "dependencies": {
+        "accepts": "~1.3.4",
+        "base64id": "1.0.0",
+        "cookie": "0.3.1",
+        "debug": "~3.1.0",
+        "engine.io-parser": "~2.1.0",
+        "ws": "~3.3.1"
+      }
+    },
+    "node_modules/engine.io-client": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-3.2.1.tgz",
+      "integrity": "sha512-y5AbkytWeM4jQr7m/koQLc5AxpRKC1hEVUb/s1FUAWEJq5AzJJ4NLvzuKPuxtDi5Mq755WuDvZ6Iv2rXj4PTzw==",
+      "dependencies": {
+        "component-emitter": "1.2.1",
+        "component-inherit": "0.0.3",
+        "debug": "~3.1.0",
+        "engine.io-parser": "~2.1.1",
+        "has-cors": "1.1.0",
+        "indexof": "0.0.1",
+        "parseqs": "0.0.5",
+        "parseuri": "0.0.5",
+        "ws": "~3.3.1",
+        "xmlhttprequest-ssl": "~1.5.4",
+        "yeast": "0.1.2"
+      }
+    },
+    "node_modules/engine.io-client/node_modules/ws": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz",
+      "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==",
+      "dependencies": {
+        "async-limiter": "~1.0.0",
+        "safe-buffer": "~5.1.0",
+        "ultron": "~1.1.0"
+      }
+    },
+    "node_modules/engine.io-parser": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-2.1.2.tgz",
+      "integrity": "sha512-dInLFzr80RijZ1rGpx1+56/uFoH7/7InhH3kZt+Ms6hT8tNx3NGW/WNSA/f8As1WkOfkuyb3tnRyuXGxusclMw==",
+      "dependencies": {
+        "after": "0.8.2",
+        "arraybuffer.slice": "~0.0.7",
+        "base64-arraybuffer": "0.1.5",
+        "blob": "0.0.4",
+        "has-binary2": "~1.0.2"
+      }
+    },
+    "node_modules/engine.io/node_modules/ws": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz",
+      "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==",
+      "dependencies": {
+        "async-limiter": "~1.0.0",
+        "safe-buffer": "~5.1.0",
+        "ultron": "~1.1.0"
+      }
+    },
+    "node_modules/eventemitter3": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-3.1.0.tgz",
+      "integrity": "sha512-ivIvhpq/Y0uSjcHDcOIccjmYjGLcP09MFGE7ysAwkAvkXfpZlC985pH2/ui64DKazbTW/4kN3yqozUxlXzI6cA=="
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.5.1.tgz",
+      "integrity": "sha512-v9GI1hpaqq1ZZR6pBD1+kI7O24PhDvNGNodjS3MdcEqyrahCp8zbtpv+2B/krUnSmUH80lbAS7MrdeK5IylgKg==",
+      "dependencies": {
+        "debug": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/glob": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-6.0.4.tgz",
+      "integrity": "sha1-DwiGD2oVUSey+t1PnOJLGqtuTSI=",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "optional": true,
+      "dependencies": {
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "2 || 3",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/has-binary2": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has-binary2/-/has-binary2-1.0.3.tgz",
+      "integrity": "sha512-G1LWKhDSvhGeAQ8mPVQlqNcOB2sJdwATtZKl2pDKKHfpf/rYj24lkinxf69blJbnsvtqqNU+L3SL50vzZhXOnw==",
+      "dependencies": {
+        "isarray": "2.0.1"
+      }
+    },
+    "node_modules/has-cors": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-cors/-/has-cors-1.1.0.tgz",
+      "integrity": "sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk="
+    },
+    "node_modules/http-proxy": {
+      "version": "1.17.0",
+      "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.17.0.tgz",
+      "integrity": "sha512-Taqn+3nNvYRfJ3bGvKfBSRwy1v6eePlm3oc/aWVxZp57DQr5Eq3xhKJi7Z4hZpS8PC3H4qI+Yly5EmFacGuA/g==",
+      "dependencies": {
+        "eventemitter3": "^3.0.0",
+        "follow-redirects": "^1.0.0",
+        "requires-port": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/indexof": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz",
+      "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10="
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "optional": true,
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=",
+      "optional": true
+    },
+    "node_modules/isarray": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz",
+      "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4="
+    },
+    "node_modules/lodash": {
+      "version": "4.17.11",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz",
+      "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg=="
+    },
+    "node_modules/mime-db": {
+      "version": "1.35.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.35.0.tgz",
+      "integrity": "sha512-JWT/IcCTsB0Io3AhWUMjRqucrHSPsSf2xKLaRldJVULioggvkJvggZ3VXNNSRkCddE6D+BUI4HEIZIA2OjwIvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.19",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.19.tgz",
+      "integrity": "sha512-P1tKYHVSZ6uFo26mtnve4HQFE3koh1UWVkp8YUC+ESBHe945xWSoXuHHiGarDqcEZ+whpCDnlNw5LON0kLo+sw==",
+      "dependencies": {
+        "mime-db": "~1.35.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "optional": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
+      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=",
+      "optional": true
+    },
+    "node_modules/mkdirp": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
+      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
+      "deprecated": "Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)",
+      "optional": true,
+      "dependencies": {
+        "minimist": "0.0.8"
+      },
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      }
+    },
+    "node_modules/moment": {
+      "version": "2.22.2",
+      "resolved": "https://registry.npmjs.org/moment/-/moment-2.22.2.tgz",
+      "integrity": "sha1-PCV/mDn8DpP/UxSWMiOeuQeD/2Y=",
+      "optional": true,
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+    },
+    "node_modules/mv": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/mv/-/mv-2.1.1.tgz",
+      "integrity": "sha1-rmzg1vbV4KT32JN5jQPB6pVZtqI=",
+      "optional": true,
+      "dependencies": {
+        "mkdirp": "~0.5.1",
+        "ncp": "~2.0.0",
+        "rimraf": "~2.4.0"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/nan": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz",
+      "integrity": "sha512-bAdJv7fBLhWC+/Bls0Oza+mvTaNQtP+1RyhhhvD95pgUJz6XM5IzgmxOkItJ9tkoCiplvAnXI1tNmmUD/eScyA==",
+      "optional": true
+    },
+    "node_modules/ncp": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ncp/-/ncp-2.0.0.tgz",
+      "integrity": "sha1-GVoh1sRuNh0vsSgbo4uR6d9727M=",
+      "optional": true,
+      "bin": {
+        "ncp": "bin/ncp"
+      }
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz",
+      "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-pty": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/node-pty/-/node-pty-0.9.0.tgz",
+      "integrity": "sha512-MBnCQl83FTYOu7B4xWw10AW77AAh7ThCE1VXEv+JeWj8mSpGo+0bwgsV+b23ljBFwEM9OmsOv3kM27iUPPm84g==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "nan": "^2.14.0"
+      }
+    },
+    "node_modules/node-pty/node_modules/nan": {
+      "version": "2.14.2",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz",
+      "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ=="
+    },
+    "node_modules/object-component": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/object-component/-/object-component-0.0.3.tgz",
+      "integrity": "sha1-8MaapQ78lbhmwYb0AKM3acsvEpE="
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "optional": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/options": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz",
+      "integrity": "sha1-7CLTEoBrtT5zF3Pnza788cZDEo8=",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/parseqs": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/parseqs/-/parseqs-0.0.5.tgz",
+      "integrity": "sha1-1SCKNzjkZ2bikbouoXNoSSGouJ0=",
+      "dependencies": {
+        "better-assert": "~1.0.0"
+      }
+    },
+    "node_modules/parseuri": {
+      "version": "0.0.5",
+      "resolved": "https://registry.npmjs.org/parseuri/-/parseuri-0.0.5.tgz",
+      "integrity": "sha1-gCBKUNTbt3m/3G6+J3jZDkvOMgo=",
+      "dependencies": {
+        "better-assert": "~1.0.0"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8="
+    },
+    "node_modules/rimraf": {
+      "version": "2.4.5",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.4.5.tgz",
+      "integrity": "sha1-7nEM5dk6j9uFb7Xqj/Di11k0sto=",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "optional": true,
+      "dependencies": {
+        "glob": "^6.0.1"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+    },
+    "node_modules/safe-json-stringify": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/safe-json-stringify/-/safe-json-stringify-1.2.0.tgz",
+      "integrity": "sha512-gH8eh2nZudPQO6TytOvbxnuhYBOvDBBLW52tz5q6X58lJcd/tkmqFR+5Z9adS8aJtURSXWThWy/xJtJwixErvg==",
+      "optional": true
+    },
+    "node_modules/semver": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
+      "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==",
+      "bin": {
+        "semver": "bin/semver"
+      }
+    },
+    "node_modules/socket.io": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-2.1.1.tgz",
+      "integrity": "sha512-rORqq9c+7W0DAK3cleWNSyfv/qKXV99hV4tZe+gGLfBECw3XEhBy7x85F3wypA9688LKjtwO9pX9L33/xQI8yA==",
+      "dependencies": {
+        "debug": "~3.1.0",
+        "engine.io": "~3.2.0",
+        "has-binary2": "~1.0.2",
+        "socket.io-adapter": "~1.1.0",
+        "socket.io-client": "2.1.1",
+        "socket.io-parser": "~3.2.0"
+      }
+    },
+    "node_modules/socket.io-adapter": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-1.1.1.tgz",
+      "integrity": "sha1-KoBeihTWNyEk3ZFZrUUC+MsH8Gs="
+    },
+    "node_modules/socket.io-client": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/socket.io-client/-/socket.io-client-2.1.1.tgz",
+      "integrity": "sha512-jxnFyhAuFxYfjqIgduQlhzqTcOEQSn+OHKVfAxWaNWa7ecP7xSNk2Dx/3UEsDcY7NcFafxvNvKPmmO7HTwTxGQ==",
+      "dependencies": {
+        "backo2": "1.0.2",
+        "base64-arraybuffer": "0.1.5",
+        "component-bind": "1.0.0",
+        "component-emitter": "1.2.1",
+        "debug": "~3.1.0",
+        "engine.io-client": "~3.2.0",
+        "has-binary2": "~1.0.2",
+        "has-cors": "1.1.0",
+        "indexof": "0.0.1",
+        "object-component": "0.0.3",
+        "parseqs": "0.0.5",
+        "parseuri": "0.0.5",
+        "socket.io-parser": "~3.2.0",
+        "to-array": "0.1.4"
+      }
+    },
+    "node_modules/socket.io-parser": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.2.0.tgz",
+      "integrity": "sha512-FYiBx7rc/KORMJlgsXysflWx/RIvtqZbyGLlHZvjfmPTPeuD/I8MaW7cfFrj5tRltICJdgwflhfZ3NVVbVLFQA==",
+      "dependencies": {
+        "component-emitter": "1.2.1",
+        "debug": "~3.1.0",
+        "isarray": "2.0.1"
+      }
+    },
+    "node_modules/strftime": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/strftime/-/strftime-0.9.2.tgz",
+      "integrity": "sha1-vMooYfKUVtNyqvaheBHIvG859YM=",
+      "engines": {
+        "node": ">=0.2.0"
+      }
+    },
+    "node_modules/to-array": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/to-array/-/to-array-0.1.4.tgz",
+      "integrity": "sha1-F+bBH3PdTz10zaek/zI46a2b+JA="
+    },
+    "node_modules/ultron": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz",
+      "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og=="
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+      "optional": true
+    },
+    "node_modules/ws": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-1.1.4.tgz",
+      "integrity": "sha1-V/QNA2gy5fUFVmKjl8Tedu1mv2E=",
+      "dependencies": {
+        "options": ">=0.0.5",
+        "ultron": "1.0.x"
+      }
+    },
+    "node_modules/ws/node_modules/ultron": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.2.tgz",
+      "integrity": "sha1-rOEWq1V80Zc4ak6I9GhTeMiy5Po="
+    },
+    "node_modules/xmlhttprequest-ssl": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.5.tgz",
+      "integrity": "sha1-wodrBhaKrcQOV9l+gRkayPQ5iz4=",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/yeast": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/yeast/-/yeast-0.1.2.tgz",
+      "integrity": "sha1-AI4G2AlDIMNy28L47XagymyKxBk="
+    }
+  }
+}

datalab/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

datalab/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.

datalab/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

datalab/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'
+}

datalab/web/node_modules/accepts/package.json

@@ -0,0 +1,46 @@
+{
+  "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"
+  ]
+}

datalab/web/node_modules/after/.npmignore

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

datalab/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

datalab/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.

datalab/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

datalab/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() {}

datalab/web/node_modules/after/package.json

@@ -0,0 +1,28 @@
+{
+  "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"
+}

datalab/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/);
+});
+

datalab/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

datalab/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.

datalab/web/node_modules/arraybuffer.slice/Makefile

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

datalab/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.

datalab/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;
+};

datalab/web/node_modules/arraybuffer.slice/package.json

@@ -0,0 +1,16 @@
+{
+  "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"
+  }
+}

datalab/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);
+    });
+  });
+});

datalab/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

datalab/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.

datalab/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}}]}}}}

datalab/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>

datalab/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>

datalab/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; }

datalab/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>

datalab/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}

datalab/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"]);