{"version":3,"sources":["../../node_modules/codemirror/mode/scheme/scheme.js"],"names":["mod","exports","module","require","define","amd","CodeMirror","defineMode","BUILTIN","COMMENT","STRING","ATOM","NUMBER","BRACKET","INDENT_WORD_SKIP","makeKeywords","str","obj","words","split","i","length","keywords","indentKeys","stateStack","indent","type","prev","this","pushStack","state","indentStack","popStack","binaryMatcher","RegExp","octalMatcher","hexMatcher","decimalMatcher","isBinaryNumber","stream","match","isOctalNumber","isDecimalNumber","backup","backUp","isHexNumber","startState","indentation","mode","sExprComment","sExprQuote","token","sol","eatSpace","returnType","next","escaped","maybeEnd","peek","eatWhile","ch","eat","numTest","hasExactness","hasRadix","test","skipToEnd","keyWord","indentTemp","column","letter","propertyIsEnumerable","eol","current","closeBrackets","pairs","lineComment","defineMIME"],"mappings":"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","file":"scheme.min.js","sourcesContent":["// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n\n/**\n * Author: Koh Zi Han, based on implementation by Koh Zi Chun\n */\n\n(function(mod) {\n  if (typeof exports == \"object\" && typeof module == \"object\") // CommonJS\n    mod(require(\"../../lib/codemirror\"));\n  else if (typeof define == \"function\" && define.amd) // AMD\n    define([\"../../lib/codemirror\"], mod);\n  else // Plain browser env\n    mod(CodeMirror);\n})(function(CodeMirror) {\n\"use strict\";\n\nCodeMirror.defineMode(\"scheme\", function () {\n    var BUILTIN = \"builtin\", COMMENT = \"comment\", STRING = \"string\",\n        ATOM = \"atom\", NUMBER = \"number\", BRACKET = \"bracket\";\n    var INDENT_WORD_SKIP = 2;\n\n    function makeKeywords(str) {\n        var obj = {}, words = str.split(\" \");\n        for (var i = 0; i < words.length; ++i) obj[words[i]] = true;\n        return obj;\n    }\n\n    var keywords = makeKeywords(\"λ case-lambda call/cc class define-class exit-handler field import inherit init-field interface let*-values let-values let/ec mixin opt-lambda override protect provide public rename require require-for-syntax syntax syntax-case syntax-error unit/sig unless when with-syntax and begin call-with-current-continuation call-with-input-file call-with-output-file case cond define define-syntax delay do dynamic-wind else for-each if lambda let let* let-syntax letrec letrec-syntax map or syntax-rules abs acos angle append apply asin assoc assq assv atan boolean? caar cadr call-with-input-file call-with-output-file call-with-values car cdddar cddddr cdr ceiling char->integer char-alphabetic? char-ci<=? char-ci<? char-ci=? char-ci>=? char-ci>? char-downcase char-lower-case? char-numeric? char-ready? char-upcase char-upper-case? char-whitespace? char<=? char<? char=? char>=? char>? char? close-input-port close-output-port complex? cons cos current-input-port current-output-port denominator display eof-object? eq? equal? eqv? eval even? exact->inexact exact? exp expt #f floor force gcd imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment lcm length list list->string list->vector list-ref list-tail list? load log magnitude make-polar make-rectangular make-string make-vector max member memq memv min modulo negative? newline not null-environment null? number->string number? numerator odd? open-input-file open-output-file output-port? pair? peek-char port? positive? procedure? quasiquote quote quotient rational? rationalize read read-char real-part real? remainder reverse round scheme-report-environment set! set-car! set-cdr! sin sqrt string string->list string->number string->symbol string-append string-ci<=? string-ci<? string-ci=? string-ci>=? string-ci>? string-copy string-fill! string-length string-ref string-set! string<=? string<? string=? string>=? string>? string? substring symbol->string symbol? #t tan transcript-off transcript-on truncate values vector vector->list vector-fill! vector-length vector-ref vector-set! with-input-from-file with-output-to-file write write-char zero?\");\n    var indentKeys = makeKeywords(\"define let letrec let* lambda\");\n\n    function stateStack(indent, type, prev) { // represents a state stack object\n        this.indent = indent;\n        this.type = type;\n        this.prev = prev;\n    }\n\n    function pushStack(state, indent, type) {\n        state.indentStack = new stateStack(indent, type, state.indentStack);\n    }\n\n    function popStack(state) {\n        state.indentStack = state.indentStack.prev;\n    }\n\n    var binaryMatcher = new RegExp(/^(?:[-+]i|[-+][01]+#*(?:\\/[01]+#*)?i|[-+]?[01]+#*(?:\\/[01]+#*)?@[-+]?[01]+#*(?:\\/[01]+#*)?|[-+]?[01]+#*(?:\\/[01]+#*)?[-+](?:[01]+#*(?:\\/[01]+#*)?)?i|[-+]?[01]+#*(?:\\/[01]+#*)?)(?=[()\\s;\"]|$)/i);\n    var octalMatcher = new RegExp(/^(?:[-+]i|[-+][0-7]+#*(?:\\/[0-7]+#*)?i|[-+]?[0-7]+#*(?:\\/[0-7]+#*)?@[-+]?[0-7]+#*(?:\\/[0-7]+#*)?|[-+]?[0-7]+#*(?:\\/[0-7]+#*)?[-+](?:[0-7]+#*(?:\\/[0-7]+#*)?)?i|[-+]?[0-7]+#*(?:\\/[0-7]+#*)?)(?=[()\\s;\"]|$)/i);\n    var hexMatcher = new RegExp(/^(?:[-+]i|[-+][\\da-f]+#*(?:\\/[\\da-f]+#*)?i|[-+]?[\\da-f]+#*(?:\\/[\\da-f]+#*)?@[-+]?[\\da-f]+#*(?:\\/[\\da-f]+#*)?|[-+]?[\\da-f]+#*(?:\\/[\\da-f]+#*)?[-+](?:[\\da-f]+#*(?:\\/[\\da-f]+#*)?)?i|[-+]?[\\da-f]+#*(?:\\/[\\da-f]+#*)?)(?=[()\\s;\"]|$)/i);\n    var decimalMatcher = new RegExp(/^(?:[-+]i|[-+](?:(?:(?:\\d+#+\\.?#*|\\d+\\.\\d*#*|\\.\\d+#*|\\d+)(?:[esfdl][-+]?\\d+)?)|\\d+#*\\/\\d+#*)i|[-+]?(?:(?:(?:\\d+#+\\.?#*|\\d+\\.\\d*#*|\\.\\d+#*|\\d+)(?:[esfdl][-+]?\\d+)?)|\\d+#*\\/\\d+#*)@[-+]?(?:(?:(?:\\d+#+\\.?#*|\\d+\\.\\d*#*|\\.\\d+#*|\\d+)(?:[esfdl][-+]?\\d+)?)|\\d+#*\\/\\d+#*)|[-+]?(?:(?:(?:\\d+#+\\.?#*|\\d+\\.\\d*#*|\\.\\d+#*|\\d+)(?:[esfdl][-+]?\\d+)?)|\\d+#*\\/\\d+#*)[-+](?:(?:(?:\\d+#+\\.?#*|\\d+\\.\\d*#*|\\.\\d+#*|\\d+)(?:[esfdl][-+]?\\d+)?)|\\d+#*\\/\\d+#*)?i|(?:(?:(?:\\d+#+\\.?#*|\\d+\\.\\d*#*|\\.\\d+#*|\\d+)(?:[esfdl][-+]?\\d+)?)|\\d+#*\\/\\d+#*))(?=[()\\s;\"]|$)/i);\n\n    function isBinaryNumber (stream) {\n        return stream.match(binaryMatcher);\n    }\n\n    function isOctalNumber (stream) {\n        return stream.match(octalMatcher);\n    }\n\n    function isDecimalNumber (stream, backup) {\n        if (backup === true) {\n            stream.backUp(1);\n        }\n        return stream.match(decimalMatcher);\n    }\n\n    function isHexNumber (stream) {\n        return stream.match(hexMatcher);\n    }\n\n    return {\n        startState: function () {\n            return {\n                indentStack: null,\n                indentation: 0,\n                mode: false,\n                sExprComment: false,\n                sExprQuote: false\n            };\n        },\n\n        token: function (stream, state) {\n            if (state.indentStack == null && stream.sol()) {\n                // update indentation, but only if indentStack is empty\n                state.indentation = stream.indentation();\n            }\n\n            // skip spaces\n            if (stream.eatSpace()) {\n                return null;\n            }\n            var returnType = null;\n\n            switch(state.mode){\n                case \"string\": // multi-line string parsing mode\n                    var next, escaped = false;\n                    while ((next = stream.next()) != null) {\n                        if (next == \"\\\"\" && !escaped) {\n\n                            state.mode = false;\n                            break;\n                        }\n                        escaped = !escaped && next == \"\\\\\";\n                    }\n                    returnType = STRING; // continue on in scheme-string mode\n                    break;\n                case \"comment\": // comment parsing mode\n                    var next, maybeEnd = false;\n                    while ((next = stream.next()) != null) {\n                        if (next == \"#\" && maybeEnd) {\n\n                            state.mode = false;\n                            break;\n                        }\n                        maybeEnd = (next == \"|\");\n                    }\n                    returnType = COMMENT;\n                    break;\n                case \"s-expr-comment\": // s-expr commenting mode\n                    state.mode = false;\n                    if(stream.peek() == \"(\" || stream.peek() == \"[\"){\n                        // actually start scheme s-expr commenting mode\n                        state.sExprComment = 0;\n                    }else{\n                        // if not we just comment the entire of the next token\n                        stream.eatWhile(/[^\\s\\(\\)\\[\\]]/); // eat symbol atom\n                        returnType = COMMENT;\n                        break;\n                    }\n                default: // default parsing mode\n                    var ch = stream.next();\n\n                    if (ch == \"\\\"\") {\n                        state.mode = \"string\";\n                        returnType = STRING;\n\n                    } else if (ch == \"'\") {\n                        if (stream.peek() == \"(\" || stream.peek() == \"[\"){\n                            if (typeof state.sExprQuote != \"number\") {\n                                state.sExprQuote = 0;\n                            } // else already in a quoted expression\n                            returnType = ATOM;\n                        } else {\n                            stream.eatWhile(/[\\w_\\-!$%&*+\\.\\/:<=>?@\\^~]/);\n                            returnType = ATOM;\n                        }\n                    } else if (ch == '#') {\n                        if (stream.eat(\"|\")) {                    // Multi-line comment\n                            state.mode = \"comment\"; // toggle to comment mode\n                            returnType = COMMENT;\n                        } else if (stream.eat(/[tf]/i)) {            // #t/#f (atom)\n                            returnType = ATOM;\n                        } else if (stream.eat(';')) {                // S-Expr comment\n                            state.mode = \"s-expr-comment\";\n                            returnType = COMMENT;\n                        } else {\n                            var numTest = null, hasExactness = false, hasRadix = true;\n                            if (stream.eat(/[ei]/i)) {\n                                hasExactness = true;\n                            } else {\n                                stream.backUp(1);       // must be radix specifier\n                            }\n                            if (stream.match(/^#b/i)) {\n                                numTest = isBinaryNumber;\n                            } else if (stream.match(/^#o/i)) {\n                                numTest = isOctalNumber;\n                            } else if (stream.match(/^#x/i)) {\n                                numTest = isHexNumber;\n                            } else if (stream.match(/^#d/i)) {\n                                numTest = isDecimalNumber;\n                            } else if (stream.match(/^[-+0-9.]/, false)) {\n                                hasRadix = false;\n                                numTest = isDecimalNumber;\n                            // re-consume the intial # if all matches failed\n                            } else if (!hasExactness) {\n                                stream.eat('#');\n                            }\n                            if (numTest != null) {\n                                if (hasRadix && !hasExactness) {\n                                    // consume optional exactness after radix\n                                    stream.match(/^#[ei]/i);\n                                }\n                                if (numTest(stream))\n                                    returnType = NUMBER;\n                            }\n                        }\n                    } else if (/^[-+0-9.]/.test(ch) && isDecimalNumber(stream, true)) { // match non-prefixed number, must be decimal\n                        returnType = NUMBER;\n                    } else if (ch == \";\") { // comment\n                        stream.skipToEnd(); // rest of the line is a comment\n                        returnType = COMMENT;\n                    } else if (ch == \"(\" || ch == \"[\") {\n                      var keyWord = ''; var indentTemp = stream.column(), letter;\n                        /**\n                        Either\n                        (indent-word ..\n                        (non-indent-word ..\n                        (;something else, bracket, etc.\n                        */\n\n                        while ((letter = stream.eat(/[^\\s\\(\\[\\;\\)\\]]/)) != null) {\n                            keyWord += letter;\n                        }\n\n                        if (keyWord.length > 0 && indentKeys.propertyIsEnumerable(keyWord)) { // indent-word\n\n                            pushStack(state, indentTemp + INDENT_WORD_SKIP, ch);\n                        } else { // non-indent word\n                            // we continue eating the spaces\n                            stream.eatSpace();\n                            if (stream.eol() || stream.peek() == \";\") {\n                                // nothing significant after\n                                // we restart indentation 1 space after\n                                pushStack(state, indentTemp + 1, ch);\n                            } else {\n                                pushStack(state, indentTemp + stream.current().length, ch); // else we match\n                            }\n                        }\n                        stream.backUp(stream.current().length - 1); // undo all the eating\n\n                        if(typeof state.sExprComment == \"number\") state.sExprComment++;\n                        if(typeof state.sExprQuote == \"number\") state.sExprQuote++;\n\n                        returnType = BRACKET;\n                    } else if (ch == \")\" || ch == \"]\") {\n                        returnType = BRACKET;\n                        if (state.indentStack != null && state.indentStack.type == (ch == \")\" ? \"(\" : \"[\")) {\n                            popStack(state);\n\n                            if(typeof state.sExprComment == \"number\"){\n                                if(--state.sExprComment == 0){\n                                    returnType = COMMENT; // final closing bracket\n                                    state.sExprComment = false; // turn off s-expr commenting mode\n                                }\n                            }\n                            if(typeof state.sExprQuote == \"number\"){\n                                if(--state.sExprQuote == 0){\n                                    returnType = ATOM; // final closing bracket\n                                    state.sExprQuote = false; // turn off s-expr quote mode\n                                }\n                            }\n                        }\n                    } else {\n                        stream.eatWhile(/[\\w_\\-!$%&*+\\.\\/:<=>?@\\^~]/);\n\n                        if (keywords && keywords.propertyIsEnumerable(stream.current())) {\n                            returnType = BUILTIN;\n                        } else returnType = \"variable\";\n                    }\n            }\n            return (typeof state.sExprComment == \"number\") ? COMMENT : ((typeof state.sExprQuote == \"number\") ? ATOM : returnType);\n        },\n\n        indent: function (state) {\n            if (state.indentStack == null) return state.indentation;\n            return state.indentStack.indent;\n        },\n\n        closeBrackets: {pairs: \"()[]{}\\\"\\\"\"},\n        lineComment: \";;\"\n    };\n});\n\nCodeMirror.defineMIME(\"text/x-scheme\", \"scheme\");\n\n});\n"]}