30:Tb8a,function blocklyCreateVariableWidget(Blockly) { const shim = html`

`; const promptBox = html``; const input = html``; const createVariableButton = html``; const promtMessageBox = html`

`; const alertMessageBox = html`

`; promptBox.appendChild(input); promptBox.appendChild(createVariableButton); promptBox.appendChild(promtMessageBox); promptBox.appendChild(alertMessageBox); shim.appendChild(promptBox); window.alert = message => { const container = document.querySelector('#alertbox'); container.innerHTML = message; }; window.prompt = (caption, defaultText) => { const b = document.querySelector('#promptMessage'); b.innerHTML = caption; return input.value; }; Blockly.Variables.createVariableButtonHandler = function( workspace, opt_callback, opt_type ) { let createVariablePromptButton = document.querySelector( '#createVariablePromptButton' ); var type = opt_type || ''; // This function needs to be named so it can be called recursively. var promptAndCheckWithAlert = function(defaultName) { if (defaultName === input.value && input.value !== undefined) { console.log("defend recurse"); return ""; } Blockly.Variables.promptName( Blockly.Msg['NEW_VARIABLE_TITLE'], defaultName, function(text) { if (text) { var existing = Blockly.Variables.nameUsedWithAnyType( text, workspace ); if (existing) { if (existing.type == type) { var msg = Blockly.Msg['VARIABLE_ALREADY_EXISTS'].replace( '%1', existing.name ); } else { var msg = Blockly.Msg['VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE']; msg = msg .replace('%1', existing.name) .replace('%2', existing.type); } Blockly.alert(msg, function() { promptAndCheckWithAlert(text); // Recurse }); } else { // No conflict workspace.createVariable(text, type); if (opt_callback) { opt_callback(text); } promptBox.style.display = 'none'; } } else { // User canceled prompt. if (opt_callback) { opt_callback(null); } promptBox.style.display = 'none'; } } ); }; createVariablePromptButton.onclick = promptAndCheckWithAlert; promptBox.style.display = 'block'; }; return shim; }31:Ta8bc,function codeMirrorModeJavascript(CodeMirror) { "use strict"; CodeMirror.defineMode("javascript", function(config, parserConfig) { var indentUnit = config.indentUnit; var statementIndent = parserConfig.statementIndent; var jsonldMode = parserConfig.jsonld; var jsonMode = parserConfig.json || jsonldMode; var isTS = parserConfig.typescript; var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/; // Tokenizer var keywords = (function() { function kw(type) { return { type: type, style: "keyword" }; } var A = kw("keyword a"), B = kw("keyword b"), C = kw("keyword c"), D = kw("keyword d"); var operator = kw("operator"), atom = { type: "atom", style: "atom" }; return { if: kw("if"), while: A, with: A, else: B, do: B, try: B, finally: B, return: D, break: D, continue: D, new: kw("new"), delete: C, void: C, throw: C, debugger: kw("debugger"), var: kw("var"), const: kw("var"), let: kw("var"), function: kw("function"), catch: kw("catch"), for: kw("for"), switch: kw("switch"), case: kw("case"), default: kw("default"), in: operator, typeof: operator, instanceof: operator, true: atom, false: atom, null: atom, undefined: atom, NaN: atom, Infinity: atom, this: kw("this"), class: kw("class"), super: kw("atom"), yield: C, export: kw("export"), import: kw("import"), extends: C, await: C }; })(); var isOperatorChar = /[+\-*&%=<>!?|~^@]/; var isJsonldKeyword = /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/; function readRegexp(stream) { var escaped = false, next, inSet = false; while ((next = stream.next()) != null) { if (!escaped) { if (next == "/" && !inSet) return; if (next == "[") inSet = true; else if (inSet && next == "]") inSet = false; } escaped = !escaped && next == "\\"; } } // Used as scratch variables to communicate multiple values without // consing up tons of objects. var type, content; function ret(tp, style, cont) { type = tp; content = cont; return style; } function tokenBase(stream, state) { var ch = stream.next(); if (ch == '"' || ch == "'") { state.tokenize = tokenString(ch); return state.tokenize(stream, state); } else if (ch == "." && stream.match(/^\d[\d_]*(?:[eE][+\-]?[\d_]+)?/)) { return ret("number", "number"); } else if (ch == "." && stream.match("..")) { return ret("spread", "meta"); } else if (/[\[\]{},;\:\.]/.test(ch)) { return ret(ch); } else if (ch == "=" && stream.eat(">")) { return ret("=>", "operator"); } else if ( ch == "0" && stream.match(/^(?:x[\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/) ) { return ret("number", "number"); } else if (/\d/.test(ch)) { stream.match(/^[\d_]*(?:n|(?:\.[\d_]*)?(?:[eE][+\-]?[\d_]+)?)?/); return ret("number", "number"); } else if (ch == "/") { if (stream.eat("*")) { state.tokenize = tokenComment; return tokenComment(stream, state); } else if (stream.eat("/")) { stream.skipToEnd(); return ret("comment", "comment"); } else if (expressionAllowed(stream, state, 1)) { readRegexp(stream); stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/); return ret("regexp", "string-2"); } else { stream.eat("="); return ret("operator", "operator", stream.current()); } } else if (ch == "`") { state.tokenize = tokenQuasi; return tokenQuasi(stream, state); } else if (ch == "#" && stream.peek() == "!") { stream.skipToEnd(); return ret("meta", "meta"); } else if (ch == "#" && stream.eatWhile(wordRE)) { return ret("variable", "property"); } else if ( (ch == "<" && stream.match("!--")) || (ch == "-" && stream.match("->") && !/\S/.test(stream.string.slice(0, stream.start))) ) { stream.skipToEnd(); return ret("comment", "comment"); } else if (isOperatorChar.test(ch)) { if (ch != ">" || !state.lexical || state.lexical.type != ">") { if (stream.eat("=")) { if (ch == "!" || ch == "=") stream.eat("="); } else if (/[<>*+\-|&?]/.test(ch)) { stream.eat(ch); if (ch == ">") stream.eat(ch); } } if (ch == "?" && stream.eat(".")) return ret("."); return ret("operator", "operator", stream.current()); } else if (wordRE.test(ch)) { stream.eatWhile(wordRE); var word = stream.current(); if (state.lastType != ".") { if (keywords.propertyIsEnumerable(word)) { var kw = keywords[word]; return ret(kw.type, kw.style, word); } if ( word == "async" && stream.match(/^(\s|\/\*([^*]|\*(?!\/))*?\*\/)*[\[\(\w]/, false) ) return ret("async", "keyword", word); } return ret("variable", "variable", word); } } function tokenString(quote) { return function(stream, state) { var escaped = false, next; if ( jsonldMode && stream.peek() == "@" && stream.match(isJsonldKeyword) ) { state.tokenize = tokenBase; return ret("jsonld-keyword", "meta"); } while ((next = stream.next()) != null) { if (next == quote && !escaped) break; escaped = !escaped && next == "\\"; } if (!escaped) state.tokenize = tokenBase; return ret("string", "string"); }; } function tokenComment(stream, state) { var maybeEnd = false, ch; while ((ch = stream.next())) { if (ch == "/" && maybeEnd) { state.tokenize = tokenBase; break; } maybeEnd = ch == "*"; } return ret("comment", "comment"); } function tokenQuasi(stream, state) { var escaped = false, next; while ((next = stream.next()) != null) { if (!escaped && (next == "`" || (next == "$" && stream.eat("{")))) { state.tokenize = tokenBase; break; } escaped = !escaped && next == "\\"; } return ret("quasi", "string-2", stream.current()); } var brackets = "([{}])"; // This is a crude lookahead trick to try and notice that we're // parsing the argument patterns for a fat-arrow function before we // actually hit the arrow token. It only works if the arrow is on // the same line as the arguments and there's no strange noise // (comments) in between. Fallback is to only notice when we hit the // arrow, and not declare the arguments as locals for the arrow // body. function findFatArrow(stream, state) { if (state.fatArrowAt) state.fatArrowAt = null; var arrow = stream.string.indexOf("=>", stream.start); if (arrow < 0) return; if (isTS) { // Try to skip TypeScript return type declarations after the arguments var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec( stream.string.slice(stream.start, arrow) ); if (m) arrow = m.index; } var depth = 0, sawSomething = false; for (var pos = arrow - 1; pos >= 0; --pos) { var ch = stream.string.charAt(pos); var bracket = brackets.indexOf(ch); if (bracket >= 0 && bracket < 3) { if (!depth) { ++pos; break; } if (--depth == 0) { if (ch == "(") sawSomething = true; break; } } else if (bracket >= 3 && bracket < 6) { ++depth; } else if (wordRE.test(ch)) { sawSomething = true; } else if (/["'\/`]/.test(ch)) { for (; ; --pos) { if (pos == 0) return; var next = stream.string.charAt(pos - 1); if (next == ch && stream.string.charAt(pos - 2) != "\\") { pos--; break; } } } else if (sawSomething && !depth) { ++pos; break; } } if (sawSomething && !depth) state.fatArrowAt = pos; } // Parser var atomicTypes = { atom: true, number: true, variable: true, string: true, regexp: true, this: true, "jsonld-keyword": true }; function JSLexical(indented, column, type, align, prev, info) { this.indented = indented; this.column = column; this.type = type; this.prev = prev; this.info = info; if (align != null) this.align = align; } function inScope(state, varname) { for (var v = state.localVars; v; v = v.next) if (v.name == varname) return true; for (var cx = state.context; cx; cx = cx.prev) { for (var v = cx.vars; v; v = v.next) if (v.name == varname) return true; } } function parseJS(state, style, type, content, stream) { var cc = state.cc; // Communicate our context to the combinators. // (Less wasteful than consing up a hundred closures on every call.) cx.state = state; cx.stream = stream; (cx.marked = null), (cx.cc = cc); cx.style = style; if (!state.lexical.hasOwnProperty("align")) state.lexical.align = true; while (true) { var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement; if (combinator(type, content)) { while (cc.length && cc[cc.length - 1].lex) cc.pop()(); if (cx.marked) return cx.marked; if (type == "variable" && inScope(state, content)) return "variable-2"; return style; } } } // Combinator utils var cx = { state: null, column: null, marked: null, cc: null }; function pass() { for (var i = arguments.length - 1; i >= 0; i--) cx.cc.push(arguments[i]); } function cont() { pass.apply(null, arguments); return true; } function inList(name, list) { for (var v = list; v; v = v.next) if (v.name == name) return true; return false; } function register(varname) { var state = cx.state; cx.marked = "def"; if (state.context) { if ( state.lexical.info == "var" && state.context && state.context.block ) { // FIXME function decls are also not block scoped var newContext = registerVarScoped(varname, state.context); if (newContext != null) { state.context = newContext; return; } } else if (!inList(varname, state.localVars)) { state.localVars = new Var(varname, state.localVars); return; } } // Fall through means this is global if (parserConfig.globalVars && !inList(varname, state.globalVars)) state.globalVars = new Var(varname, state.globalVars); } function registerVarScoped(varname, context) { if (!context) { return null; } else if (context.block) { var inner = registerVarScoped(varname, context.prev); if (!inner) return null; if (inner == context.prev) return context; return new Context(inner, context.vars, true); } else if (inList(varname, context.vars)) { return context; } else { return new Context(context.prev, new Var(varname, context.vars), false); } } function isModifier(name) { return ( name == "public" || name == "private" || name == "protected" || name == "abstract" || name == "readonly" ); } // Combinators function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block; } function Var(name, next) { this.name = name; this.next = next; } var defaultVars = new Var("this", new Var("arguments", null)); function pushcontext() { cx.state.context = new Context( cx.state.context, cx.state.localVars, false ); cx.state.localVars = defaultVars; } function pushblockcontext() { cx.state.context = new Context( cx.state.context, cx.state.localVars, true ); cx.state.localVars = null; } function popcontext() { cx.state.localVars = cx.state.context.vars; cx.state.context = cx.state.context.prev; } popcontext.lex = true; function pushlex(type, info) { var result = function() { var state = cx.state, indent = state.indented; if (state.lexical.type == "stat") indent = state.lexical.indented; else for ( var outer = state.lexical; outer && outer.type == ")" && outer.align; outer = outer.prev ) indent = outer.indented; state.lexical = new JSLexical( indent, cx.stream.column(), type, null, state.lexical, info ); }; result.lex = true; return result; } function poplex() { var state = cx.state; if (state.lexical.prev) { if (state.lexical.type == ")") state.indented = state.lexical.indented; state.lexical = state.lexical.prev; } } poplex.lex = true; function expect(wanted) { function exp(type) { if (type == wanted) return cont(); else if (wanted == ";" || type == "}" || type == ")" || type == "]") return pass(); else return cont(exp); } return exp; } function statement(type, value) { if (type == "var") return cont(pushlex("vardef", value), vardef, expect(";"), poplex); if (type == "keyword a") return cont(pushlex("form"), parenExpr, statement, poplex); if (type == "keyword b") return cont(pushlex("form"), statement, poplex); if (type == "keyword d") return cx.stream.match(/^\s*$/, false) ? cont() : cont(pushlex("stat"), maybeexpression, expect(";"), poplex); if (type == "debugger") return cont(expect(";")); if (type == "{") return cont(pushlex("}"), pushblockcontext, block, poplex, popcontext); if (type == ";") return cont(); if (type == "if") { if ( cx.state.lexical.info == "else" && cx.state.cc[cx.state.cc.length - 1] == poplex ) cx.state.cc.pop()(); return cont(pushlex("form"), parenExpr, statement, poplex, maybeelse); } if (type == "function") return cont(functiondef); if (type == "for") return cont(pushlex("form"), forspec, statement, poplex); if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont( pushlex("form", type == "class" ? type : value), className, poplex ); } if (type == "variable") { if (isTS && value == "declare") { cx.marked = "keyword"; return cont(statement); } else if ( isTS && (value == "module" || value == "enum" || value == "type") && cx.stream.match(/^\s*\w/, false) ) { cx.marked = "keyword"; if (value == "enum") return cont(enumdef); else if (value == "type") return cont(typename, expect("operator"), typeexpr, expect(";")); else return cont( pushlex("form"), pattern, expect("{"), pushlex("}"), block, poplex, poplex ); } else if (isTS && value == "namespace") { cx.marked = "keyword"; return cont(pushlex("form"), expression, statement, poplex); } else if (isTS && value == "abstract") { cx.marked = "keyword"; return cont(statement); } else { return cont(pushlex("stat"), maybelabel); } } if (type == "switch") return cont( pushlex("form"), parenExpr, expect("{"), pushlex("}", "switch"), pushblockcontext, block, poplex, poplex, popcontext ); if (type == "case") return cont(expression, expect(":")); if (type == "default") return cont(expect(":")); if (type == "catch") return cont( pushlex("form"), pushcontext, maybeCatchBinding, statement, poplex, popcontext ); if (type == "export") return cont(pushlex("stat"), afterExport, poplex); if (type == "import") return cont(pushlex("stat"), afterImport, poplex); if (type == "async") return cont(statement); if (value == "@") return cont(expression, statement); return pass(pushlex("stat"), expression, expect(";"), poplex); } function maybeCatchBinding(type) { if (type == "(") return cont(funarg, expect(")")); } function expression(type, value) { return expressionInner(type, value, false); } function expressionNoComma(type, value) { return expressionInner(type, value, true); } function parenExpr(type) { if (type != "(") return pass(); return cont(pushlex(")"), maybeexpression, expect(")"), poplex); } function expressionInner(type, value, noComma) { if (cx.state.fatArrowAt == cx.stream.start) { var body = noComma ? arrowBodyNoComma : arrowBody; if (type == "(") return cont( pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, expect("=>"), body, popcontext ); else if (type == "variable") return pass(pushcontext, pattern, expect("=>"), body, popcontext); } var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma; if (atomicTypes.hasOwnProperty(type)) return cont(maybeop); if (type == "function") return cont(functiondef, maybeop); if (type == "class" || (isTS && value == "interface")) { cx.marked = "keyword"; return cont(pushlex("form"), classExpression, poplex); } if (type == "keyword c" || type == "async") return cont(noComma ? expressionNoComma : expression); if (type == "(") return cont( pushlex(")"), maybeexpression, expect(")"), poplex, maybeop ); if (type == "operator" || type == "spread") return cont(noComma ? expressionNoComma : expression); if (type == "[") return cont(pushlex("]"), arrayLiteral, poplex, maybeop); if (type == "{") return contCommasep(objprop, "}", null, maybeop); if (type == "quasi") return pass(quasi, maybeop); if (type == "new") return cont(maybeTarget(noComma)); if (type == "import") return cont(expression); return cont(); } function maybeexpression(type) { if (type.match(/[;\}\)\],]/)) return pass(); return pass(expression); } function maybeoperatorComma(type, value) { if (type == ",") return cont(maybeexpression); return maybeoperatorNoComma(type, value, false); } function maybeoperatorNoComma(type, value, noComma) { var me = noComma == false ? maybeoperatorComma : maybeoperatorNoComma; var expr = noComma == false ? expression : expressionNoComma; if (type == "=>") return cont( pushcontext, noComma ? arrowBodyNoComma : arrowBody, popcontext ); if (type == "operator") { if (/\+\+|--/.test(value) || (isTS && value == "!")) return cont(me); if ( isTS && value == "<" && cx.stream.match(/^([^<>]|<[^<>]*>)*>\s*\(/, false) ) return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, me); if (value == "?") return cont(expression, expect(":"), expr); return cont(expr); } if (type == "quasi") { return pass(quasi, me); } if (type == ";") return; if (type == "(") return contCommasep(expressionNoComma, ")", "call", me); if (type == ".") return cont(property, me); if (type == "[") return cont(pushlex("]"), maybeexpression, expect("]"), poplex, me); if (isTS && value == "as") { cx.marked = "keyword"; return cont(typeexpr, me); } if (type == "regexp") { cx.state.lastType = cx.marked = "operator"; cx.stream.backUp(cx.stream.pos - cx.stream.start - 1); return cont(expr); } } function quasi(type, value) { if (type != "quasi") return pass(); if (value.slice(value.length - 2) != "${") return cont(quasi); return cont(expression, continueQuasi); } function continueQuasi(type) { if (type == "}") { cx.marked = "string-2"; cx.state.tokenize = tokenQuasi; return cont(quasi); } } function arrowBody(type) { findFatArrow(cx.stream, cx.state); return pass(type == "{" ? statement : expression); } function arrowBodyNoComma(type) { findFatArrow(cx.stream, cx.state); return pass(type == "{" ? statement : expressionNoComma); } function maybeTarget(noComma) { return function(type) { if (type == ".") return cont(noComma ? targetNoComma : target); else if (type == "variable" && isTS) return cont( maybeTypeArgs, noComma ? maybeoperatorNoComma : maybeoperatorComma ); else return pass(noComma ? expressionNoComma : expression); }; } function target(_, value) { if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorComma); } } function targetNoComma(_, value) { if (value == "target") { cx.marked = "keyword"; return cont(maybeoperatorNoComma); } } function maybelabel(type) { if (type == ":") return cont(poplex, statement); return pass(maybeoperatorComma, expect(";"), poplex); } function property(type) { if (type == "variable") { cx.marked = "property"; return cont(); } } function objprop(type, value) { if (type == "async") { cx.marked = "property"; return cont(objprop); } else if (type == "variable" || cx.style == "keyword") { cx.marked = "property"; if (value == "get" || value == "set") return cont(getterSetter); var m; // Work around fat-arrow-detection complication for detecting typescript typed arrow params if ( isTS && cx.state.fatArrowAt == cx.stream.start && (m = cx.stream.match(/^\s*:\s*/, false)) ) cx.state.fatArrowAt = cx.stream.pos + m[0].length; return cont(afterprop); } else if (type == "number" || type == "string") { cx.marked = jsonldMode ? "property" : cx.style + " property"; return cont(afterprop); } else if (type == "jsonld-keyword") { return cont(afterprop); } else if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(objprop); } else if (type == "[") { return cont(expression, maybetype, expect("]"), afterprop); } else if (type == "spread") { return cont(expressionNoComma, afterprop); } else if (value == "*") { cx.marked = "keyword"; return cont(objprop); } else if (type == ":") { return pass(afterprop); } } function getterSetter(type) { if (type != "variable") return pass(afterprop); cx.marked = "property"; return cont(functiondef); } function afterprop(type) { if (type == ":") return cont(expressionNoComma); if (type == "(") return pass(functiondef); } function commasep(what, end, sep) { function proceed(type, value) { if (sep ? sep.indexOf(type) > -1 : type == ",") { var lex = cx.state.lexical; if (lex.info == "call") lex.pos = (lex.pos || 0) + 1; return cont(function(type, value) { if (type == end || value == end) return pass(); return pass(what); }, proceed); } if (type == end || value == end) return cont(); if (sep && sep.indexOf(";") > -1) return pass(what); return cont(expect(end)); } return function(type, value) { if (type == end || value == end) return cont(); return pass(what, proceed); }; } function contCommasep(what, end, info) { for (var i = 3; i < arguments.length; i++) cx.cc.push(arguments[i]); return cont(pushlex(end, info), commasep(what, end), poplex); } function block(type) { if (type == "}") return cont(); return pass(statement, block); } function maybetype(type, value) { if (isTS) { if (type == ":") return cont(typeexpr); if (value == "?") return cont(maybetype); } } function maybetypeOrIn(type, value) { if (isTS && (type == ":" || value == "in")) return cont(typeexpr); } function mayberettype(type) { if (isTS && type == ":") { if (cx.stream.match(/^\s*\w+\s+is\b/, false)) return cont(expression, isKW, typeexpr); else return cont(typeexpr); } } function isKW(_, value) { if (value == "is") { cx.marked = "keyword"; return cont(); } } function typeexpr(type, value) { if (value == "keyof" || value == "typeof" || value == "infer") { cx.marked = "keyword"; return cont(value == "typeof" ? expressionNoComma : typeexpr); } if (type == "variable" || value == "void") { cx.marked = "type"; return cont(afterType); } if (value == "|" || value == "&") return cont(typeexpr); if (type == "string" || type == "number" || type == "atom") return cont(afterType); if (type == "[") return cont( pushlex("]"), commasep(typeexpr, "]", ","), poplex, afterType ); if (type == "{") return cont(pushlex("}"), typeprops, poplex, afterType); if (type == "(") return cont(commasep(typearg, ")"), maybeReturnType, afterType); if (type == "<") return cont(commasep(typeexpr, ">"), typeexpr); } function maybeReturnType(type) { if (type == "=>") return cont(typeexpr); } function typeprops(type) { if (type.match(/[\}\)\]]/)) return cont(); if (type == "," || type == ";") return cont(typeprops); return pass(typeprop, typeprops); } function typeprop(type, value) { if (type == "variable" || cx.style == "keyword") { cx.marked = "property"; return cont(typeprop); } else if (value == "?" || type == "number" || type == "string") { return cont(typeprop); } else if (type == ":") { return cont(typeexpr); } else if (type == "[") { return cont(expect("variable"), maybetypeOrIn, expect("]"), typeprop); } else if (type == "(") { return pass(functiondecl, typeprop); } else if (!type.match(/[;\}\)\],]/)) { return cont(); } } function typearg(type, value) { if ( (type == "variable" && cx.stream.match(/^\s*[?:]/, false)) || value == "?" ) return cont(typearg); if (type == ":") return cont(typeexpr); if (type == "spread") return cont(typearg); return pass(typeexpr); } function afterType(type, value) { if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType); if (value == "|" || type == "." || value == "&") return cont(typeexpr); if (type == "[") return cont(typeexpr, expect("]"), afterType); if (value == "extends" || value == "implements") { cx.marked = "keyword"; return cont(typeexpr); } if (value == "?") return cont(typeexpr, expect(":"), typeexpr); } function maybeTypeArgs(_, value) { if (value == "<") return cont(pushlex(">"), commasep(typeexpr, ">"), poplex, afterType); } function typeparam() { return pass(typeexpr, maybeTypeDefault); } function maybeTypeDefault(_, value) { if (value == "=") return cont(typeexpr); } function vardef(_, value) { if (value == "enum") { cx.marked = "keyword"; return cont(enumdef); } return pass(pattern, maybetype, maybeAssign, vardefCont); } function pattern(type, value) { if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(pattern); } if (type == "variable") { register(value); return cont(); } if (type == "spread") return cont(pattern); if (type == "[") return contCommasep(eltpattern, "]"); if (type == "{") return contCommasep(proppattern, "}"); } function proppattern(type, value) { if (type == "variable" && !cx.stream.match(/^\s*:/, false)) { register(value); return cont(maybeAssign); } if (type == "variable") cx.marked = "property"; if (type == "spread") return cont(pattern); if (type == "}") return pass(); if (type == "[") return cont(expression, expect(']'), expect(':'), proppattern); return cont(expect(":"), pattern, maybeAssign); } function eltpattern() { return pass(pattern, maybeAssign); } function maybeAssign(_type, value) { if (value == "=") return cont(expressionNoComma); } function vardefCont(type) { if (type == ",") return cont(vardef); } function maybeelse(type, value) { if (type == "keyword b" && value == "else") return cont(pushlex("form", "else"), statement, poplex); } function forspec(type, value) { if (value == "await") return cont(forspec); if (type == "(") return cont(pushlex(")"), forspec1, poplex); } function forspec1(type) { if (type == "var") return cont(vardef, forspec2); if (type == "variable") return cont(forspec2); return pass(forspec2); } function forspec2(type, value) { if (type == ")") return cont(); if (type == ";") return cont(forspec2); if (value == "in" || value == "of") { cx.marked = "keyword"; return cont(expression, forspec2); } return pass(expression, forspec2); } function functiondef(type, value) { if (value == "*") { cx.marked = "keyword"; return cont(functiondef); } if (type == "variable") { register(value); return cont(functiondef); } if (type == "(") return cont( pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, statement, popcontext ); if (isTS && value == "<") return cont( pushlex(">"), commasep(typeparam, ">"), poplex, functiondef ); } function functiondecl(type, value) { if (value == "*") { cx.marked = "keyword"; return cont(functiondecl); } if (type == "variable") { register(value); return cont(functiondecl); } if (type == "(") return cont( pushcontext, pushlex(")"), commasep(funarg, ")"), poplex, mayberettype, popcontext ); if (isTS && value == "<") return cont( pushlex(">"), commasep(typeparam, ">"), poplex, functiondecl ); } function typename(type, value) { if (type == "keyword" || type == "variable") { cx.marked = "type"; return cont(typename); } else if (value == "<") { return cont(pushlex(">"), commasep(typeparam, ">"), poplex); } } function funarg(type, value) { if (value == "@") cont(expression, funarg); if (type == "spread") return cont(funarg); if (isTS && isModifier(value)) { cx.marked = "keyword"; return cont(funarg); } if (isTS && type == "this") return cont(maybetype, maybeAssign); return pass(pattern, maybetype, maybeAssign); } function classExpression(type, value) { // Class expressions may have an optional name. if (type == "variable") return className(type, value); return classNameAfter(type, value); } function className(type, value) { if (type == "variable") { register(value); return cont(classNameAfter); } } function classNameAfter(type, value) { if (value == "<") return cont( pushlex(">"), commasep(typeparam, ">"), poplex, classNameAfter ); if ( value == "extends" || value == "implements" || (isTS && type == ",") ) { if (value == "implements") cx.marked = "keyword"; return cont(isTS ? typeexpr : expression, classNameAfter); } if (type == "{") return cont(pushlex("}"), classBody, poplex); } function classBody(type, value) { if ( type == "async" || (type == "variable" && (value == "static" || value == "get" || value == "set" || (isTS && isModifier(value))) && cx.stream.match(/^\s+[\w$\xa1-\uffff]/, false)) ) { cx.marked = "keyword"; return cont(classBody); } if (type == "variable" || cx.style == "keyword") { cx.marked = "property"; return cont(classfield, classBody); } if (type == "number" || type == "string") return cont(classfield, classBody); if (type == "[") return cont(expression, maybetype, expect("]"), classfield, classBody); if (value == "*") { cx.marked = "keyword"; return cont(classBody); } if (isTS && type == "(") return pass(functiondecl, classBody); if (type == ";" || type == ",") return cont(classBody); if (type == "}") return cont(); if (value == "@") return cont(expression, classBody); } function classfield(type, value) { if (value == "?") return cont(classfield); if (type == ":") return cont(typeexpr, maybeAssign); if (value == "=") return cont(expressionNoComma); var context = cx.state.lexical.prev, isInterface = context && context.info == "interface"; return pass(isInterface ? functiondecl : functiondef); } function afterExport(type, value) { if (value == "*") { cx.marked = "keyword"; return cont(maybeFrom, expect(";")); } if (value == "default") { cx.marked = "keyword"; return cont(expression, expect(";")); } if (type == "{") return cont(commasep(exportField, "}"), maybeFrom, expect(";")); return pass(statement); } function exportField(type, value) { if (value == "as") { cx.marked = "keyword"; return cont(expect("variable")); } if (type == "variable") return pass(expressionNoComma, exportField); } function afterImport(type) { if (type == "string") return cont(); if (type == "(") return pass(expression); return pass(importSpec, maybeMoreImports, maybeFrom); } function importSpec(type, value) { if (type == "{") return contCommasep(importSpec, "}"); if (type == "variable") register(value); if (value == "*") cx.marked = "keyword"; return cont(maybeAs); } function maybeMoreImports(type) { if (type == ",") return cont(importSpec, maybeMoreImports); } function maybeAs(_type, value) { if (value == "as") { cx.marked = "keyword"; return cont(importSpec); } } function maybeFrom(_type, value) { if (value == "from") { cx.marked = "keyword"; return cont(expression); } } function arrayLiteral(type) { if (type == "]") return cont(); return pass(commasep(expressionNoComma, "]")); } function enumdef() { return pass( pushlex("form"), pattern, expect("{"), pushlex("}"), commasep(enummember, "}"), poplex, poplex ); } function enummember() { return pass(pattern, maybeAssign); } function isContinuedStatement(state, textAfter) { return ( state.lastType == "operator" || state.lastType == "," || isOperatorChar.test(textAfter.charAt(0)) || /[,.]/.test(textAfter.charAt(0)) ); } function expressionAllowed(stream, state, backUp) { return ( (state.tokenize == tokenBase && /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test( state.lastType )) || (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0)))) ); } // Interface return { startState: function(basecolumn) { var state = { tokenize: tokenBase, lastType: "sof", cc: [], lexical: new JSLexical( (basecolumn || 0) - indentUnit, 0, "block", false ), localVars: parserConfig.localVars, context: parserConfig.localVars && new Context(null, null, false), indented: basecolumn || 0 }; if ( parserConfig.globalVars && typeof parserConfig.globalVars == "object" ) state.globalVars = parserConfig.globalVars; return state; }, token: function(stream, state) { if (stream.sol()) { if (!state.lexical.hasOwnProperty("align")) state.lexical.align = false; state.indented = stream.indentation(); findFatArrow(stream, state); } if (state.tokenize != tokenComment && stream.eatSpace()) return null; var style = state.tokenize(stream, state); if (type == "comment") return style; state.lastType = type == "operator" && (content == "++" || content == "--") ? "incdec" : type; return parseJS(state, style, type, content, stream); }, indent: function(state, textAfter) { if (state.tokenize == tokenComment || state.tokenize == tokenQuasi) return CodeMirror.Pass; if (state.tokenize != tokenBase) return 0; var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top; // Kludge to prevent 'maybelse' from blocking lexical scope pops if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) { var c = state.cc[i]; if (c == poplex) lexical = lexical.prev; else if (c != maybeelse) break; } while ( (lexical.type == "stat" || lexical.type == "form") && (firstChar == "}" || ((top = state.cc[state.cc.length - 1]) && (top == maybeoperatorComma || top == maybeoperatorNoComma) && !/^[,\.=+\-*:?[\(]/.test(textAfter))) ) lexical = lexical.prev; if ( statementIndent && lexical.type == ")" && lexical.prev.type == "stat" ) lexical = lexical.prev; var type = lexical.type, closing = firstChar == type; if (type == "vardef") return ( lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info.length + 1 : 0) ); else if (type == "form" && firstChar == "{") return lexical.indented; else if (type == "form") return lexical.indented + indentUnit; else if (type == "stat") return ( lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0) ); else if ( lexical.info == "switch" && !closing && parserConfig.doubleIndentSwitch != false ) return ( lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit) ); else if (lexical.align) return lexical.column + (closing ? 0 : 1); else return lexical.indented + (closing ? 0 : indentUnit); }, electricInput: /^\s*(?:case .*?:|default:|\{|\})$/, blockCommentStart: jsonMode ? null : "/*", blockCommentEnd: jsonMode ? null : "*/", blockCommentContinue: jsonMode ? null : " * ", lineComment: jsonMode ? null : "//", fold: "brace", closeBrackets: "()[]{}''\"\"``", helperType: jsonMode ? "json" : "javascript", jsonldMode: jsonldMode, jsonMode: jsonMode, expressionAllowed: expressionAllowed, skipExpression: function(state) { var top = state.cc[state.cc.length - 1]; if (top == expression || top == expressionNoComma) state.cc.pop(); } }; }); CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/); CodeMirror.defineMIME("text/javascript", "javascript"); CodeMirror.defineMIME("text/ecmascript", "javascript"); CodeMirror.defineMIME("application/javascript", "javascript"); CodeMirror.defineMIME("application/x-javascript", "javascript"); CodeMirror.defineMIME("application/ecmascript", "javascript"); CodeMirror.defineMIME("application/json", { name: "javascript", json: true }); CodeMirror.defineMIME("application/x-json", { name: "javascript", json: true }); CodeMirror.defineMIME("application/manifest+json", { name: "javascript", json: true }); CodeMirror.defineMIME("application/ld+json", { name: "javascript", jsonld: true }); CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true }); CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true }); }32:T2222,BasicStyles = ` /* BASICS */ .CodeMirror { /* Set height, width, borders, and global font properties here */ font-family: monospace; height: 300px; color: black; direction: ltr; } /* PADDING */ .CodeMirror-lines { padding: 4px 0; /* Vertical padding around content */ } .CodeMirror pre.CodeMirror-line, .CodeMirror pre.CodeMirror-line-like { padding: 0 4px; /* Horizontal padding of content */ } .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler { background-color: white; /* The little square between H and V scrollbars */ } /* GUTTER */ .CodeMirror-gutters { border-right: 1px solid #ddd; background-color: #f7f7f7; white-space: nowrap; } .CodeMirror-linenumbers {} .CodeMirror-linenumber { padding: 0 3px 0 5px; min-width: 20px; text-align: right; color: #999; white-space: nowrap; } .CodeMirror-guttermarker { color: black; } .CodeMirror-guttermarker-subtle { color: #999; } /* CURSOR */ .CodeMirror-cursor { border-left: 1px solid black; border-right: none; width: 0; } /* Shown when moving in bi-directional text */ .CodeMirror div.CodeMirror-secondarycursor { border-left: 1px solid silver; } .cm-fat-cursor .CodeMirror-cursor { width: auto; border: 0 !important; background: #7e7; } .cm-fat-cursor div.CodeMirror-cursors { z-index: 1; } .cm-fat-cursor-mark { background-color: rgba(20, 255, 20, 0.5); -webkit-animation: blink 1.06s steps(1) infinite; -moz-animation: blink 1.06s steps(1) infinite; animation: blink 1.06s steps(1) infinite; } .cm-animate-fat-cursor { width: auto; border: 0; -webkit-animation: blink 1.06s steps(1) infinite; -moz-animation: blink 1.06s steps(1) infinite; animation: blink 1.06s steps(1) infinite; background-color: #7e7; } @-moz-keyframes blink { 0% {} 50% { background-color: transparent; } 100% {} } @-webkit-keyframes blink { 0% {} 50% { background-color: transparent; } 100% {} } @keyframes blink { 0% {} 50% { background-color: transparent; } 100% {} } /* Can style cursor different in overwrite (non-insert) mode */ .CodeMirror-overwrite .CodeMirror-cursor {} .cm-tab { display: inline-block; text-decoration: inherit; } .CodeMirror-rulers { position: absolute; left: 0; right: 0; top: -50px; bottom: 0; overflow: hidden; } .CodeMirror-ruler { border-left: 1px solid #ccc; top: 0; bottom: 0; position: absolute; } /* DEFAULT THEME */ .cm-s-default .cm-header {color: blue;} .cm-s-default .cm-quote {color: #090;} .cm-negative {color: #d44;} .cm-positive {color: #292;} .cm-header, .cm-strong {font-weight: bold;} .cm-em {font-style: italic;} .cm-link {text-decoration: underline;} .cm-strikethrough {text-decoration: line-through;} .cm-s-default .cm-keyword {color: #708;} .cm-s-default .cm-atom {color: #219;} .cm-s-default .cm-number {color: #164;} .cm-s-default .cm-def {color: #00f;} .cm-s-default .cm-variable, .cm-s-default .cm-punctuation, .cm-s-default .cm-property, .cm-s-default .cm-operator {} .cm-s-default .cm-variable-2 {color: #05a;} .cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;} .cm-s-default .cm-comment {color: #a50;} .cm-s-default .cm-string {color: #a11;} .cm-s-default .cm-string-2 {color: #f50;} .cm-s-default .cm-meta {color: #555;} .cm-s-default .cm-qualifier {color: #555;} .cm-s-default .cm-builtin {color: #30a;} .cm-s-default .cm-bracket {color: #997;} .cm-s-default .cm-tag {color: #170;} .cm-s-default .cm-attribute {color: #00c;} .cm-s-default .cm-hr {color: #999;} .cm-s-default .cm-link {color: #00c;} .cm-s-default .cm-error {color: #f00;} .cm-invalidchar {color: #f00;} .CodeMirror-composing { border-bottom: 2px solid; } /* Default styles for common addons */ div.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;} div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;} .CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); } .CodeMirror-activeline-background {background: #e8f2ff;} /* STOP */ /* The rest of this file contains styles related to the mechanics of the editor. You probably shouldn't touch them. */ .CodeMirror { position: relative; overflow: hidden; background: white; } .CodeMirror-scroll { overflow: scroll !important; /* Things will break if this is overridden */ /* 50px is the magic margin used to hide the element's real scrollbars */ /* See overflow: hidden in .CodeMirror */ margin-bottom: -50px; margin-right: -50px; padding-bottom: 50px; height: 100%; outline: none; /* Prevent dragging from highlighting the element */ position: relative; } .CodeMirror-sizer { position: relative; border-right: 50px solid transparent; } /* The fake, visible scrollbars. Used to force redraw during scrolling before actual scrolling happens, thus preventing shaking and flickering artifacts. */ .CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler { position: absolute; z-index: 6; display: none; outline: none; } .CodeMirror-vscrollbar { right: 0; top: 0; overflow-x: hidden; overflow-y: scroll; } .CodeMirror-hscrollbar { bottom: 0; left: 0; overflow-y: hidden; overflow-x: scroll; } .CodeMirror-scrollbar-filler { right: 0; bottom: 0; } .CodeMirror-gutter-filler { left: 0; bottom: 0; } .CodeMirror-gutters { position: absolute; left: 0; top: 0; min-height: 100%; z-index: 3; } .CodeMirror-gutter { white-space: normal; height: 100%; display: inline-block; vertical-align: top; margin-bottom: -50px; } .CodeMirror-gutter-wrapper { position: absolute; z-index: 4; background: none !important; border: none !important; } .CodeMirror-gutter-background { position: absolute; top: 0; bottom: 0; z-index: 4; } .CodeMirror-gutter-elt { position: absolute; cursor: default; z-index: 4; } .CodeMirror-gutter-wrapper ::selection { background-color: transparent } .CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent } .CodeMirror-lines { cursor: text; min-height: 1px; /* prevents collapsing before first draw */ } .CodeMirror pre.CodeMirror-line, .CodeMirror pre.CodeMirror-line-like { /* Reset some styles that the rest of the page might have set */ -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0; border-width: 0; background: transparent; font-family: inherit; font-size: inherit; margin: 0; white-space: pre; word-wrap: normal; line-height: inherit; color: inherit; z-index: 2; position: relative; overflow: visible; -webkit-tap-highlight-color: transparent; -webkit-font-variant-ligatures: contextual; font-variant-ligatures: contextual; } .CodeMirror-wrap pre.CodeMirror-line, .CodeMirror-wrap pre.CodeMirror-line-like { word-wrap: break-word; white-space: pre-wrap; word-break: normal; } .CodeMirror-linebackground { position: absolute; left: 0; right: 0; top: 0; bottom: 0; z-index: 0; } .CodeMirror-linewidget { position: relative; z-index: 2; padding: 0.1px; /* Force widget margins to stay inside of the container */ } .CodeMirror-widget {} .CodeMirror-rtl pre { direction: rtl; } .CodeMirror-code { outline: none; } /* Force content-box sizing for the elements where we expect it */ .CodeMirror-scroll, .CodeMirror-sizer, .CodeMirror-gutter, .CodeMirror-gutters, .CodeMirror-linenumber { -moz-box-sizing: content-box; box-sizing: content-box; } .CodeMirror-measure { position: absolute; width: 100%; height: 0; overflow: hidden; visibility: hidden; } .CodeMirror-cursor { position: absolute; pointer-events: none; } .CodeMirror-measure pre { position: static; } div.CodeMirror-cursors { visibility: hidden; position: relative; z-index: 3; } div.CodeMirror-dragcursors { visibility: visible; } .CodeMirror-focused div.CodeMirror-cursors { visibility: visible; } .CodeMirror-selected { background: #d9d9d9; } .CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; } .CodeMirror-crosshair { cursor: crosshair; } .CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; } .CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; } .cm-searching { background-color: #ffa; background-color: rgba(255, 255, 0, .4); } /* Used to force a border model for a node */ .cm-force-border { padding-right: .1px; } @media print { /* Hide the cursor when printing */ .CodeMirror div.CodeMirror-cursors { visibility: hidden; } } /* See issue #2901 */ .cm-tab-wrap-hack:after { content: ''; } /* Help users use markselection to safely style text background */ span.CodeMirror-selectedtext { background: none; } `33:T69a,ThemeStyles = ` /** Name: IDEA default theme From IntelliJ IDEA by JetBrains */ .cm-s-idea span.cm-meta { color: #808000; } .cm-s-idea span.cm-number { color: #0000FF; } .cm-s-idea span.cm-keyword { line-height: 1em; font-weight: bold; color: #000080; } .cm-s-idea span.cm-atom { font-weight: bold; color: #000080; } .cm-s-idea span.cm-def { color: #000000; } .cm-s-idea span.cm-variable { color: black; } .cm-s-idea span.cm-variable-2 { color: black; } .cm-s-idea span.cm-variable-3, .cm-s-idea span.cm-type { color: black; } .cm-s-idea span.cm-property { color: black; } .cm-s-idea span.cm-operator { color: black; } .cm-s-idea span.cm-comment { color: #808080; } .cm-s-idea span.cm-string { color: #008000; } .cm-s-idea span.cm-string-2 { color: #008000; } .cm-s-idea span.cm-qualifier { color: #555; } .cm-s-idea span.cm-error { color: #FF0000; } .cm-s-idea span.cm-attribute { color: #0000FF; } .cm-s-idea span.cm-tag { color: #000080; } .cm-s-idea span.cm-link { color: #0000FF; } .cm-s-idea .CodeMirror-activeline-background { background: #FFFAE3; } .cm-s-idea span.cm-builtin { color: #30a; } .cm-s-idea span.cm-bracket { color: #cc7; } .cm-s-idea { font-family: Consolas, Menlo, Monaco, Lucida Console, Liberation Mono, DejaVu Sans Mono, Bitstream Vera Sans Mono, Courier New, monospace, serif;} .cm-s-idea .CodeMirror-matchingbracket { outline:1px solid grey; color:black !important; } .CodeMirror-hints.idea { font-family: Menlo, Monaco, Consolas, 'Courier New', monospace; color: #616569; background-color: #ebf3fd !important; } .CodeMirror-hints.idea .CodeMirror-hint-active { background-color: #a2b8c9 !important; color: #5c6065 !important; } `34:[] 2e:{"title":"Blockly Widgets","cells":[{"id":0,"value":"md`# Blockly Widgets`","pinned":false,"hidden":false,"mode":"ojs"},{"id":5,"value":"$30","pinned":true,"hidden":false,"mode":"ojs"},{"id":13,"value":"md`## Code Mirror`","pinned":false,"hidden":false,"mode":"ojs"},{"id":81,"value":"md`### Hacks`","pinned":false,"hidden":false,"mode":"ojs"},{"id":85,"value":"md`#### Javascript`","pinned":false,"hidden":false,"mode":"ojs"},{"id":61,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":89,"value":"md`### Components`","pinned":false,"hidden":false,"mode":"ojs"},{"id":107,"value":"md`#### Styles`","pinned":false,"hidden":false,"mode":"ojs"},{"id":92,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":99,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":105,"value":"md`#### Creator `","pinned":false,"hidden":false,"mode":"ojs"},{"id":16,"value":"function createCodeMirrorWidget(options) {\n const view = html`\n\n`;\n\n const base = 'https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.59.4';\n\n require(`${base}/codemirror.min.js`).then(CodeMirror => {\n codeMirrorModeJavascript(CodeMirror);\n\n const container = document.querySelector(\"#code_mirror_editor\");\n const editor = CodeMirror.fromTextArea(container, {\n lineNumbers: true,\n mode: \"javascript\",\n theme: \"idea\",\n autofocus: true\n });\n editor.setSize(options.width, options.height);\n editor.on(\"blur\", options.oninput);\n window.editor = editor;\n });\n\n return view;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":199,"value":"md`#### Set Foucs`","pinned":false,"hidden":false,"mode":"ojs"},{"id":202,"value":"function codeMirrorSetFocus(editor) {\n editor.focus();\n editor.setCursor(editor.lineCount(), 0);\n}","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W34","stdlib":"1","titling":"auto"}