@dodona/papyros 0.1.8-rc → 0.1.12-rc

package/dist/114.index.js

@@ -0,0 +1,556 @@
+"use strict";
+exports.id = 114;
+exports.ids = [114];
+exports.modules = {
+
+/***/ 872:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "z": () => (/* binding */ Backend)
+});
+
+;// CONCATENATED MODULE: ./src/ProgrammingLanguage.ts
+var ProgrammingLanguage;
+(function (ProgrammingLanguage) {
+    ProgrammingLanguage["Python"] = "Python";
+    ProgrammingLanguage["JavaScript"] = "JavaScript";
+})(ProgrammingLanguage || (ProgrammingLanguage = {}));
+var PROGRAMMING_LANGUAGES = [
+    ProgrammingLanguage.Python,
+    ProgrammingLanguage.JavaScript
+];
+var LANGUAGE_MAP = new Map([
+    ["python", ProgrammingLanguage.Python],
+    ["javascript", ProgrammingLanguage.JavaScript]
+]);
+function plFromString(language) {
+    var langLC = language.toLowerCase();
+    if (LANGUAGE_MAP.has(langLC)) {
+        return LANGUAGE_MAP.get(langLC);
+    }
+    else {
+        throw new Error("Unsupported language: " + language);
+    }
+}
+
+;// CONCATENATED MODULE: ./src/Constants.ts
+
+var MAIN_APP_ID = "papyros";
+var OUTPUT_TA_ID = "code-output-area";
+var INPUT_TA_ID = "code-input-area";
+var EDITOR_WRAPPER_ID = "code-area";
+var STATE_SPINNER_ID = "state-spinner";
+var APPLICATION_STATE_TEXT_ID = "application-state-text";
+var RUN_BTN_ID = "run-code-btn";
+var TERMINATE_BTN_ID = "terminate-btn";
+var PROGRAMMING_LANGUAGE_SELECT_ID = "programming-language-select";
+var DEFAULT_PROGRAMMING_LANGUAGE = ProgrammingLanguage.Python;
+var LOCALE_SELECT_ID = "locale-select";
+var DEFAULT_LOCALE = "nl";
+var INPUT_RELATIVE_URL = "/__papyros_input";
+var SERVICE_WORKER_PATH = "./inputServiceWorker.js";
+
+;// CONCATENATED MODULE: ./src/util/Logging.ts
+var __read = (undefined && undefined.__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;
+};
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var LogType;
+(function (LogType) {
+    LogType[LogType["Debug"] = 0] = "Debug";
+    LogType[LogType["Error"] = 1] = "Error";
+    LogType[LogType["Important"] = 2] = "Important";
+})(LogType || (LogType = {}));
+var ENVIRONMENT = "production" || 0;
+function papyrosLog(logType) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    var doLog = ENVIRONMENT !== "production" || logType !== LogType.Debug;
+    if (doLog) {
+        if (logType === LogType.Error) {
+            console.error.apply(console, __spreadArray([], __read(args), false));
+        }
+        else {
+            console.log.apply(console, __spreadArray([], __read(args), false));
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/Backend.ts
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+
+
+function getInputCallback(inputTextArray, inputMetaData) {
+    if (inputTextArray && inputMetaData) {
+        var textDecoder_1 = new TextDecoder();
+        return function () {
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                if (Atomics.wait(inputMetaData, 0, 0, 100) === "timed-out") {
+                    // papyrosLog.log("waiting on input");
+                    // if (interruptBuffer[0] === 2) {
+                    //  return null;
+                    // }
+                }
+                else {
+                    break;
+                }
+            }
+            Atomics.store(inputMetaData, 0, 0);
+            var size = Atomics.exchange(inputMetaData, 1, 0);
+            var bytes = inputTextArray.slice(0, size);
+            return textDecoder_1.decode(bytes);
+        };
+    }
+    else {
+        return function () {
+            var request = new XMLHttpRequest();
+            do {
+                // `false` makes the request synchronous
+                request.open("GET", INPUT_RELATIVE_URL, false);
+                request.send(null);
+            } while (request.status >= 400); // todo better error handling
+            return request.responseText;
+        };
+    }
+}
+var Backend = /** @class */ (function () {
+    function Backend() {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.onEvent = function () { };
+        this.runId = 0;
+    }
+    /**
+     * Initialize the backend, setting up any globals required
+     * @param {function(PapyrosEvent):void} onEvent Callback for when events occur
+     * @param {Uint8Array} inputTextArray Optional shared buffer for input
+     * @param {Int32Array} inputMetaData Optional shared buffer for metadata about input
+     * @return {Promise<void>} Promise of launching
+     */
+    Backend.prototype.launch = function (onEvent, inputTextArray, inputMetaData) {
+        var _this = this;
+        var inputCallback = getInputCallback(inputTextArray, inputMetaData);
+        this.onEvent = function (e) {
+            e.runId = _this.runId;
+            onEvent(e);
+            if (e.type === "input") {
+                return inputCallback();
+            }
+        };
+        return Promise.resolve();
+    };
+    /**
+     * Validate and run arbitrary code
+     * @param {string} code The code to run
+     * @param {string} runId The uuid for this execution
+     * @return {Promise<void>} Promise of execution
+     */
+    Backend.prototype.runCode = function (code, runId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, error_1, errorString;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.runId = runId;
+                        papyrosLog(LogType.Debug, "Running code in worker: ", code);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this._runCodeInternal(code)];
+                    case 2:
+                        data = _a.sent();
+                        papyrosLog(LogType.Important, "ran code: " + code + " and received: ", data);
+                        return [2 /*return*/, this.onEvent({ type: "success", data: data, runId: runId })];
+                    case 3:
+                        error_1 = _a.sent();
+                        errorString = "toString" in error_1 ? error_1.toString() : JSON.stringify(error_1);
+                        papyrosLog(LogType.Error, "Error during execution: ", error_1, errorString);
+                        return [2 /*return*/, this.onEvent({ type: "error", data: errorString, runId: runId })];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Backend;
+}());
+
+
+
+/***/ }),
+
+/***/ 375:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Jj": () => (/* binding */ expose)
+/* harmony export */ });
+/* unused harmony exports createEndpoint, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap */
+/**
+ * Copyright 2019 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.
+ */
+const proxyMarker = Symbol("Comlink.proxy");
+const createEndpoint = Symbol("Comlink.endpoint");
+const releaseProxy = Symbol("Comlink.releaseProxy");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+/**
+ * Internal transfer handle to handle objects marked to proxy.
+ */
+const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+        const { port1, port2 } = new MessageChannel();
+        expose(obj, port1);
+        return [port2, [port2]];
+    },
+    deserialize(port) {
+        port.start();
+        return wrap(port);
+    },
+};
+/**
+ * Internal transfer handler to handle thrown exceptions.
+ */
+const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+        let serialized;
+        if (value instanceof Error) {
+            serialized = {
+                isError: true,
+                value: {
+                    message: value.message,
+                    name: value.name,
+                    stack: value.stack,
+                },
+            };
+        }
+        else {
+            serialized = { isError: false, value };
+        }
+        return [serialized, []];
+    },
+    deserialize(serialized) {
+        if (serialized.isError) {
+            throw Object.assign(new Error(serialized.value.message), serialized.value);
+        }
+        throw serialized.value;
+    },
+};
+/**
+ * Allows customizing the serialization of certain values.
+ */
+const transferHandlers = new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler],
+]);
+function expose(obj, ep = self) {
+    ep.addEventListener("message", function callback(ev) {
+        if (!ev || !ev.data) {
+            return;
+        }
+        const { id, type, path } = Object.assign({ path: [] }, ev.data);
+        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+        let returnValue;
+        try {
+            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+            const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+            switch (type) {
+                case "GET" /* GET */:
+                    {
+                        returnValue = rawValue;
+                    }
+                    break;
+                case "SET" /* SET */:
+                    {
+                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+                        returnValue = true;
+                    }
+                    break;
+                case "APPLY" /* APPLY */:
+                    {
+                        returnValue = rawValue.apply(parent, argumentList);
+                    }
+                    break;
+                case "CONSTRUCT" /* CONSTRUCT */:
+                    {
+                        const value = new rawValue(...argumentList);
+                        returnValue = proxy(value);
+                    }
+                    break;
+                case "ENDPOINT" /* ENDPOINT */:
+                    {
+                        const { port1, port2 } = new MessageChannel();
+                        expose(obj, port2);
+                        returnValue = transfer(port1, [port1]);
+                    }
+                    break;
+                case "RELEASE" /* RELEASE */:
+                    {
+                        returnValue = undefined;
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+        catch (value) {
+            returnValue = { value, [throwMarker]: 0 };
+        }
+        Promise.resolve(returnValue)
+            .catch((value) => {
+            return { value, [throwMarker]: 0 };
+        })
+            .then((returnValue) => {
+            const [wireValue, transferables] = toWireValue(returnValue);
+            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+            if (type === "RELEASE" /* RELEASE */) {
+                // detach and deactive after sending release response above.
+                ep.removeEventListener("message", callback);
+                closeEndPoint(ep);
+            }
+        });
+    });
+    if (ep.start) {
+        ep.start();
+    }
+}
+function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+        endpoint.close();
+}
+function wrap(ep, target) {
+    return createProxy(ep, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+        throw new Error("Proxy has been released and is not useable");
+    }
+}
+function createProxy(ep, path = [], target = function () { }) {
+    let isProxyReleased = false;
+    const proxy = new Proxy(target, {
+        get(_target, prop) {
+            throwIfProxyReleased(isProxyReleased);
+            if (prop === releaseProxy) {
+                return () => {
+                    return requestResponseMessage(ep, {
+                        type: "RELEASE" /* RELEASE */,
+                        path: path.map((p) => p.toString()),
+                    }).then(() => {
+                        closeEndPoint(ep);
+                        isProxyReleased = true;
+                    });
+                };
+            }
+            if (prop === "then") {
+                if (path.length === 0) {
+                    return { then: () => proxy };
+                }
+                const r = requestResponseMessage(ep, {
+                    type: "GET" /* GET */,
+                    path: path.map((p) => p.toString()),
+                }).then(fromWireValue);
+                return r.then.bind(r);
+            }
+            return createProxy(ep, [...path, prop]);
+        },
+        set(_target, prop, rawValue) {
+            throwIfProxyReleased(isProxyReleased);
+            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
+            // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
+            const [value, transferables] = toWireValue(rawValue);
+            return requestResponseMessage(ep, {
+                type: "SET" /* SET */,
+                path: [...path, prop].map((p) => p.toString()),
+                value,
+            }, transferables).then(fromWireValue);
+        },
+        apply(_target, _thisArg, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const last = path[path.length - 1];
+            if (last === createEndpoint) {
+                return requestResponseMessage(ep, {
+                    type: "ENDPOINT" /* ENDPOINT */,
+                }).then(fromWireValue);
+            }
+            // We just pretend that `bind()` didn’t happen.
+            if (last === "bind") {
+                return createProxy(ep, path.slice(0, -1));
+            }
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, {
+                type: "APPLY" /* APPLY */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+        construct(_target, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, {
+                type: "CONSTRUCT" /* CONSTRUCT */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+    });
+    return proxy;
+}
+function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+const transferCache = new WeakMap();
+function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+}
+function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+}
+function windowEndpoint(w, context = self, targetOrigin = "*") {
+    return {
+        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),
+        addEventListener: context.addEventListener.bind(context),
+        removeEventListener: context.removeEventListener.bind(context),
+    };
+}
+function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+        if (handler.canHandle(value)) {
+            const [serializedValue, transferables] = handler.serialize(value);
+            return [
+                {
+                    type: "HANDLER" /* HANDLER */,
+                    name,
+                    value: serializedValue,
+                },
+                transferables,
+            ];
+        }
+    }
+    return [
+        {
+            type: "RAW" /* RAW */,
+            value,
+        },
+        transferCache.get(value) || [],
+    ];
+}
+function fromWireValue(value) {
+    switch (value.type) {
+        case "HANDLER" /* HANDLER */:
+            return transferHandlers.get(value.name).deserialize(value.value);
+        case "RAW" /* RAW */:
+            return value.value;
+    }
+}
+function requestResponseMessage(ep, msg, transfers) {
+    return new Promise((resolve) => {
+        const id = generateUUID();
+        ep.addEventListener("message", function l(ev) {
+            if (!ev.data || !ev.data.id || ev.data.id !== id) {
+                return;
+            }
+            ep.removeEventListener("message", l);
+            resolve(ev.data);
+        });
+        if (ep.start) {
+            ep.start();
+        }
+        ep.postMessage(Object.assign({ id }, msg), transfers);
+    });
+}
+function generateUUID() {
+    return new Array(4)
+        .fill(0)
+        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+        .join("-");
+}
+
+
+//# sourceMappingURL=comlink.mjs.map
+
+
+/***/ })
+
+};
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"114.index.js","mappings":"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AAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAC;;;;;KAE/E;IACL,cAAC;AAAD,CAAC;;;;;;;;;;;;;ACxFD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,eAAe;AAC/B;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,iBAAiB,kBAAkB,UAAU;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,eAAe;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT;AACA;AACA,yDAAyD,gBAAgB,IAAI;AAC7E;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,qBAAqB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,uCAAuC,IAAI;AAC3C,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEsH;AACtH","sources":["webpack://Papyros/./src/ProgrammingLanguage.ts","webpack://Papyros/./src/Constants.ts","webpack://Papyros/./src/util/Logging.ts","webpack://Papyros/./src/Backend.ts","webpack://Papyros/./node_modules/comlink/dist/esm/comlink.mjs"],"sourcesContent":["export enum ProgrammingLanguage {\n    Python = \"Python\",\n    JavaScript = \"JavaScript\"\n}\n\nexport const PROGRAMMING_LANGUAGES = [\n    ProgrammingLanguage.Python,\n    ProgrammingLanguage.JavaScript\n];\n\nconst LANGUAGE_MAP = new Map([\n    [\"python\", ProgrammingLanguage.Python],\n    [\"javascript\", ProgrammingLanguage.JavaScript]\n]);\n\nexport function plFromString(language: string): ProgrammingLanguage {\n    const langLC = language.toLowerCase();\n    if (LANGUAGE_MAP.has(langLC)) {\n        return LANGUAGE_MAP.get(langLC)!;\n    } else {\n        throw new Error(`Unsupported language: ${language}`);\n    }\n}\n","import { ProgrammingLanguage } from \"./ProgrammingLanguage\";\n\nexport const MAIN_APP_ID = \"papyros\";\n\nexport const OUTPUT_TA_ID = \"code-output-area\";\nexport const INPUT_TA_ID = \"code-input-area\";\nexport const EDITOR_WRAPPER_ID = \"code-area\";\n\nexport const STATE_SPINNER_ID = \"state-spinner\";\nexport const APPLICATION_STATE_TEXT_ID = \"application-state-text\";\n\nexport const RUN_BTN_ID = \"run-code-btn\";\nexport const TERMINATE_BTN_ID = \"terminate-btn\";\n\nexport const PROGRAMMING_LANGUAGE_SELECT_ID = \"programming-language-select\";\nexport const DEFAULT_PROGRAMMING_LANGUAGE = ProgrammingLanguage.Python;\n\nexport const LOCALE_SELECT_ID = \"locale-select\";\nexport const DEFAULT_LOCALE = \"nl\";\n\nexport const INPUT_RELATIVE_URL = \"/__papyros_input\";\nexport const SERVICE_WORKER_PATH = \"./inputServiceWorker.js\";\n","export enum LogType {\n    Debug, Error, Important\n}\n\nconst ENVIRONMENT: string = process.env.NODE_ENV || \"development\";\nexport function papyrosLog(logType: LogType, ...args: any[]): void {\n    const doLog = ENVIRONMENT !== \"production\" || logType !== LogType.Debug;\n    if (doLog) {\n        if (logType === LogType.Error) {\n            console.error(...args);\n        } else {\n            console.log(...args);\n        }\n    }\n}\n","import { INPUT_RELATIVE_URL } from \"./Constants\";\nimport { PapyrosEvent } from \"./PapyrosEvent\";\nimport { LogType, papyrosLog } from \"./util/Logging\";\n\nfunction getInputCallback(inputTextArray?: Uint8Array, inputMetaData?: Int32Array): () => string {\n    if (inputTextArray && inputMetaData) {\n        const textDecoder = new TextDecoder();\n        return () => {\n            // eslint-disable-next-line no-constant-condition\n            while (true) {\n                if (Atomics.wait(inputMetaData, 0, 0, 100) === \"timed-out\") {\n                    // papyrosLog.log(\"waiting on input\");\n                    // if (interruptBuffer[0] === 2) {\n                    //  return null;\n                    // }\n                } else {\n                    break;\n                }\n            }\n            Atomics.store(inputMetaData, 0, 0);\n            const size = Atomics.exchange(inputMetaData, 1, 0);\n            const bytes = inputTextArray.slice(0, size);\n            return textDecoder.decode(bytes);\n        };\n    } else {\n        return () => {\n            const request = new XMLHttpRequest();\n            do {\n                // `false` makes the request synchronous\n                request.open(\"GET\", INPUT_RELATIVE_URL, false);\n                request.send(null);\n            } while (request.status >= 400); // todo better error handling\n            return request.responseText;\n        };\n    }\n}\n\nexport abstract class Backend {\n    onEvent: (e: PapyrosEvent) => any;\n    runId: number;\n\n    constructor() {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        this.onEvent = () => { };\n        this.runId = 0;\n    }\n\n    /**\n     * Initialize the backend, setting up any globals required\n     * @param {function(PapyrosEvent):void} onEvent Callback for when events occur\n     * @param {Uint8Array} inputTextArray Optional shared buffer for input\n     * @param {Int32Array} inputMetaData Optional shared buffer for metadata about input\n     * @return {Promise<void>} Promise of launching\n     */\n    launch(onEvent: (e: PapyrosEvent) => void,\n        inputTextArray?: Uint8Array, inputMetaData?: Int32Array): Promise<void> {\n        const inputCallback = getInputCallback(inputTextArray, inputMetaData);\n        this.onEvent = (e: PapyrosEvent) => {\n            e.runId = this.runId;\n            onEvent(e);\n            if (e.type === \"input\") {\n                return inputCallback();\n            }\n        };\n        return Promise.resolve();\n    }\n\n    abstract _runCodeInternal(code: string): Promise<any>;\n\n    /**\n     * Validate and run arbitrary code\n     * @param {string} code The code to run\n     * @param {string} runId The uuid for this execution\n     * @return {Promise<void>} Promise of execution\n     */\n    async runCode(code: string, runId: number): Promise<void> {\n        this.runId = runId;\n        papyrosLog(LogType.Debug, \"Running code in worker: \", code);\n        try {\n            const data = await this._runCodeInternal(code);\n            papyrosLog(LogType.Important, \"ran code: \" + code + \" and received: \", data);\n            return this.onEvent({ type: \"success\", data: data, runId: runId });\n        } catch (error: any) {\n            const errorString = \"toString\" in error ? error.toString() : JSON.stringify(error);\n            papyrosLog(LogType.Error, \"Error during execution: \", error, errorString);\n            return this.onEvent({ type: \"error\", data: errorString, runId: runId });\n        }\n    }\n}\n","/**\r\n * Copyright 2019 Google Inc. All Rights Reserved.\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *     http://www.apache.org/licenses/LICENSE-2.0\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nconst proxyMarker = Symbol(\"Comlink.proxy\");\r\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\r\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\r\nconst throwMarker = Symbol(\"Comlink.thrown\");\r\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\r\n/**\r\n * Internal transfer handle to handle objects marked to proxy.\r\n */\r\nconst proxyTransferHandler = {\r\n    canHandle: (val) => isObject(val) && val[proxyMarker],\r\n    serialize(obj) {\r\n        const { port1, port2 } = new MessageChannel();\r\n        expose(obj, port1);\r\n        return [port2, [port2]];\r\n    },\r\n    deserialize(port) {\r\n        port.start();\r\n        return wrap(port);\r\n    },\r\n};\r\n/**\r\n * Internal transfer handler to handle thrown exceptions.\r\n */\r\nconst throwTransferHandler = {\r\n    canHandle: (value) => isObject(value) && throwMarker in value,\r\n    serialize({ value }) {\r\n        let serialized;\r\n        if (value instanceof Error) {\r\n            serialized = {\r\n                isError: true,\r\n                value: {\r\n                    message: value.message,\r\n                    name: value.name,\r\n                    stack: value.stack,\r\n                },\r\n            };\r\n        }\r\n        else {\r\n            serialized = { isError: false, value };\r\n        }\r\n        return [serialized, []];\r\n    },\r\n    deserialize(serialized) {\r\n        if (serialized.isError) {\r\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\r\n        }\r\n        throw serialized.value;\r\n    },\r\n};\r\n/**\r\n * Allows customizing the serialization of certain values.\r\n */\r\nconst transferHandlers = new Map([\r\n    [\"proxy\", proxyTransferHandler],\r\n    [\"throw\", throwTransferHandler],\r\n]);\r\nfunction expose(obj, ep = self) {\r\n    ep.addEventListener(\"message\", function callback(ev) {\r\n        if (!ev || !ev.data) {\r\n            return;\r\n        }\r\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\r\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\r\n        let returnValue;\r\n        try {\r\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\r\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\r\n            switch (type) {\r\n                case \"GET\" /* GET */:\r\n                    {\r\n                        returnValue = rawValue;\r\n                    }\r\n                    break;\r\n                case \"SET\" /* SET */:\r\n                    {\r\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\r\n                        returnValue = true;\r\n                    }\r\n                    break;\r\n                case \"APPLY\" /* APPLY */:\r\n                    {\r\n                        returnValue = rawValue.apply(parent, argumentList);\r\n                    }\r\n                    break;\r\n                case \"CONSTRUCT\" /* CONSTRUCT */:\r\n                    {\r\n                        const value = new rawValue(...argumentList);\r\n                        returnValue = proxy(value);\r\n                    }\r\n                    break;\r\n                case \"ENDPOINT\" /* ENDPOINT */:\r\n                    {\r\n                        const { port1, port2 } = new MessageChannel();\r\n                        expose(obj, port2);\r\n                        returnValue = transfer(port1, [port1]);\r\n                    }\r\n                    break;\r\n                case \"RELEASE\" /* RELEASE */:\r\n                    {\r\n                        returnValue = undefined;\r\n                    }\r\n                    break;\r\n                default:\r\n                    return;\r\n            }\r\n        }\r\n        catch (value) {\r\n            returnValue = { value, [throwMarker]: 0 };\r\n        }\r\n        Promise.resolve(returnValue)\r\n            .catch((value) => {\r\n            return { value, [throwMarker]: 0 };\r\n        })\r\n            .then((returnValue) => {\r\n            const [wireValue, transferables] = toWireValue(returnValue);\r\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\r\n            if (type === \"RELEASE\" /* RELEASE */) {\r\n                // detach and deactive after sending release response above.\r\n                ep.removeEventListener(\"message\", callback);\r\n                closeEndPoint(ep);\r\n            }\r\n        });\r\n    });\r\n    if (ep.start) {\r\n        ep.start();\r\n    }\r\n}\r\nfunction isMessagePort(endpoint) {\r\n    return endpoint.constructor.name === \"MessagePort\";\r\n}\r\nfunction closeEndPoint(endpoint) {\r\n    if (isMessagePort(endpoint))\r\n        endpoint.close();\r\n}\r\nfunction wrap(ep, target) {\r\n    return createProxy(ep, [], target);\r\n}\r\nfunction throwIfProxyReleased(isReleased) {\r\n    if (isReleased) {\r\n        throw new Error(\"Proxy has been released and is not useable\");\r\n    }\r\n}\r\nfunction createProxy(ep, path = [], target = function () { }) {\r\n    let isProxyReleased = false;\r\n    const proxy = new Proxy(target, {\r\n        get(_target, prop) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            if (prop === releaseProxy) {\r\n                return () => {\r\n                    return requestResponseMessage(ep, {\r\n                        type: \"RELEASE\" /* RELEASE */,\r\n                        path: path.map((p) => p.toString()),\r\n                    }).then(() => {\r\n                        closeEndPoint(ep);\r\n                        isProxyReleased = true;\r\n                    });\r\n                };\r\n            }\r\n            if (prop === \"then\") {\r\n                if (path.length === 0) {\r\n                    return { then: () => proxy };\r\n                }\r\n                const r = requestResponseMessage(ep, {\r\n                    type: \"GET\" /* GET */,\r\n                    path: path.map((p) => p.toString()),\r\n                }).then(fromWireValue);\r\n                return r.then.bind(r);\r\n            }\r\n            return createProxy(ep, [...path, prop]);\r\n        },\r\n        set(_target, prop, rawValue) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\r\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\r\n            const [value, transferables] = toWireValue(rawValue);\r\n            return requestResponseMessage(ep, {\r\n                type: \"SET\" /* SET */,\r\n                path: [...path, prop].map((p) => p.toString()),\r\n                value,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        apply(_target, _thisArg, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const last = path[path.length - 1];\r\n            if (last === createEndpoint) {\r\n                return requestResponseMessage(ep, {\r\n                    type: \"ENDPOINT\" /* ENDPOINT */,\r\n                }).then(fromWireValue);\r\n            }\r\n            // We just pretend that `bind()` didn’t happen.\r\n            if (last === \"bind\") {\r\n                return createProxy(ep, path.slice(0, -1));\r\n            }\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"APPLY\" /* APPLY */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n        construct(_target, rawArgumentList) {\r\n            throwIfProxyReleased(isProxyReleased);\r\n            const [argumentList, transferables] = processArguments(rawArgumentList);\r\n            return requestResponseMessage(ep, {\r\n                type: \"CONSTRUCT\" /* CONSTRUCT */,\r\n                path: path.map((p) => p.toString()),\r\n                argumentList,\r\n            }, transferables).then(fromWireValue);\r\n        },\r\n    });\r\n    return proxy;\r\n}\r\nfunction myFlat(arr) {\r\n    return Array.prototype.concat.apply([], arr);\r\n}\r\nfunction processArguments(argumentList) {\r\n    const processed = argumentList.map(toWireValue);\r\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\r\n}\r\nconst transferCache = new WeakMap();\r\nfunction transfer(obj, transfers) {\r\n    transferCache.set(obj, transfers);\r\n    return obj;\r\n}\r\nfunction proxy(obj) {\r\n    return Object.assign(obj, { [proxyMarker]: true });\r\n}\r\nfunction windowEndpoint(w, context = self, targetOrigin = \"*\") {\r\n    return {\r\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\r\n        addEventListener: context.addEventListener.bind(context),\r\n        removeEventListener: context.removeEventListener.bind(context),\r\n    };\r\n}\r\nfunction toWireValue(value) {\r\n    for (const [name, handler] of transferHandlers) {\r\n        if (handler.canHandle(value)) {\r\n            const [serializedValue, transferables] = handler.serialize(value);\r\n            return [\r\n                {\r\n                    type: \"HANDLER\" /* HANDLER */,\r\n                    name,\r\n                    value: serializedValue,\r\n                },\r\n                transferables,\r\n            ];\r\n        }\r\n    }\r\n    return [\r\n        {\r\n            type: \"RAW\" /* RAW */,\r\n            value,\r\n        },\r\n        transferCache.get(value) || [],\r\n    ];\r\n}\r\nfunction fromWireValue(value) {\r\n    switch (value.type) {\r\n        case \"HANDLER\" /* HANDLER */:\r\n            return transferHandlers.get(value.name).deserialize(value.value);\r\n        case \"RAW\" /* RAW */:\r\n            return value.value;\r\n    }\r\n}\r\nfunction requestResponseMessage(ep, msg, transfers) {\r\n    return new Promise((resolve) => {\r\n        const id = generateUUID();\r\n        ep.addEventListener(\"message\", function l(ev) {\r\n            if (!ev.data || !ev.data.id || ev.data.id !== id) {\r\n                return;\r\n            }\r\n            ep.removeEventListener(\"message\", l);\r\n            resolve(ev.data);\r\n        });\r\n        if (ep.start) {\r\n            ep.start();\r\n        }\r\n        ep.postMessage(Object.assign({ id }, msg), transfers);\r\n    });\r\n}\r\nfunction generateUUID() {\r\n    return new Array(4)\r\n        .fill(0)\r\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\r\n        .join(\"-\");\r\n}\n\nexport { createEndpoint, expose, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\n"],"names":[],"sourceRoot":""}