Added alasql database and pgp worker

1 files changed, 167 insertions, 0 deletions

diff --git a/public/additional/openpgp.worker.js b/public/additional/openpgp.worker.js
new file mode 100644
index 0000000..4cec5e5
--- /dev/null
+++ b/public/additional/openpgp.worker.js
@@ -0,0 +1,167 @@
+(function () {
+    function r(e, n, t) {
+        function o(i, f) {
+            if (!n[i]) {
+                if (!e[i]) {
+                    var c = "function" == typeof require && require;
+                    if (!f && c) return c(i, !0);
+                    if (u) return u(i, !0);
+                    var a = new Error("Cannot find module '" + i + "'");
+                    throw a.code = "MODULE_NOT_FOUND", a
+                }
+                var p = n[i] = {exports: {}};
+                e[i][0].call(p.exports, function (r) {
+                    var n = e[i][1][r];
+                    return o(n || r)
+                }, p, p.exports, r, e, n, t)
+            }
+            return n[i].exports
+        }
+
+        for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
+        return o
+    }
+
+    return r
+})()({
+    1: [function (require, module, exports) {
+// GPG4Browsers - An OpenPGP implementation in javascript
+// Copyright (C) 2011 Recurity Labs GmbH
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 3.0 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+        /* eslint-disable no-restricted-globals */
+        /* eslint-disable no-var */
+        /* eslint-disable vars-on-top */
+
+        /**
+         * @fileoverview Provides functions for communicating with workers
+         * @see module:openpgp.initWorker
+         * @see module:openpgp.getWorker
+         * @see module:openpgp.destroyWorker
+         * @see module:worker/async_proxy
+         * @module worker/worker
+         */
+
+        self.window = self; // to make UMD bundles work
+
+        importScripts('openpgp.js');
+        var openpgp = window.openpgp;
+
+        var randomQueue = [];
+        var MAX_SIZE_RANDOM_BUFFER = 60000;
+
+        /**
+         * Handle random buffer exhaustion by requesting more random bytes from the main window
+         * @returns {Promise<Object>}  Empty promise whose resolution indicates that the buffer has been refilled
+         */
+        function randomCallback() {
+
+            if (!randomQueue.length) {
+                self.postMessage({event: 'request-seed', amount: MAX_SIZE_RANDOM_BUFFER});
+            }
+
+            return new Promise(function (resolve) {
+                randomQueue.push(resolve);
+            });
+        }
+
+        openpgp.crypto.random.randomBuffer.init(MAX_SIZE_RANDOM_BUFFER, randomCallback);
+
+        /**
+         * Handle messages from the main window.
+         * @param  {Object} event   Contains event type and data
+         */
+        self.onmessage = function (event) {
+            var msg = event.data || {};
+
+            switch (msg.event) {
+                case 'configure':
+                    configure(msg.config);
+                    break;
+
+                case 'seed-random':
+                    seedRandom(msg.buf);
+
+                    var queueCopy = randomQueue;
+                    randomQueue = [];
+                    for (var i = 0; i < queueCopy.length; i++) {
+                        queueCopy[i]();
+                    }
+
+                    break;
+
+                default:
+                    delegate(msg.id, msg.event, msg.options || {});
+            }
+        };
+
+        /**
+         * Set config from main context to worker context.
+         * @param  {Object} config   The openpgp configuration
+         */
+        function configure(config) {
+            Object.keys(config).forEach(function (key) {
+                openpgp.config[key] = config[key];
+            });
+        }
+
+        /**
+         * Seed the library with entropy gathered window.crypto.getRandomValues
+         * as this api is only avalible in the main window.
+         * @param  {ArrayBuffer} buffer   Some random bytes
+         */
+        function seedRandom(buffer) {
+            if (!(buffer instanceof Uint8Array)) {
+                buffer = new Uint8Array(buffer);
+            }
+            openpgp.crypto.random.randomBuffer.set(buffer);
+        }
+
+        /**
+         * Generic proxy function that handles all commands from the public api.
+         * @param  {String} method    The public api function to be delegated to the worker thread
+         * @param  {Object} options   The api function's options
+         */
+        function delegate(id, method, options) {
+            if (typeof openpgp[method] !== 'function') {
+                response({id: id, event: 'method-return', err: 'Unknown Worker Event'});
+                return;
+            }
+            // parse cloned packets
+            options = openpgp.packet.clone.parseClonedPackets(options, method);
+            // construct ReadableStreams from MessagePorts
+            openpgp.util.restoreStreams(options);
+            openpgp[method](options).then(function (data) {
+                // clone packets (for web worker structured cloning algorithm)
+                response({id: id, event: 'method-return', data: openpgp.packet.clone.clonePackets(data)});
+            }).catch(function (e) {
+                openpgp.util.print_debug_error(e);
+                response({
+                    id: id, event: 'method-return', err: e.message, stack: e.stack
+                });
+            });
+        }
+
+        /**
+         * Respond to the main window.
+         * @param  {Object} event  Contains event type and data
+         */
+        function response(event) {
+            self.postMessage(event, openpgp.util.getTransferables(event.data, true));
+        }
+
+    }, {}]
+}, {}, [1]);