pxt-core 7.5.1 → 7.5.4

package/built/pxtblocks.d.ts

@@ -39,6 +39,7 @@ declare namespace pxt.blocks {
         alreadyDeclared?: BlockDeclarationType;
         firstReference?: Blockly.Block;
         isAssigned?: boolean;
+        isFunctionParameter?: boolean;
     }
     function compileExpression(e: Environment, b: Blockly.Block, comments: string[]): JsNode;
     interface Environment {
@@ -264,6 +265,12 @@ declare namespace pxt.blocks {
         protected createDom_(): void;
         protected highlightSearchGroup_(blocks: Blockly.BlockSvg[]): void;
         protected unhighlightSearchGroup_(blocks: Blockly.BlockSvg[]): void;
+        /**
+         * https://github.com/google/blockly-samples/blob/master/plugins/workspace-search/src/WorkspaceSearch.js#L633
+         *
+         * Modified to center offscreen blocks.
+         */
+        protected scrollToVisible_(block: Blockly.BlockSvg): void;
         open(): void;
         close(): void;
     }

package/built/pxtblocks.js

@@ -179,7 +179,7 @@ var pxt;
                 }
                 else if (b.type == "argument_reporter_array") {
                     if (!tp) {
-                        tp = ground("any[]");
+                        tp = lookup(e, b, b.getFieldValue("VALUE")).type;
                     }
                 }
                 if (tp)
@@ -492,8 +492,14 @@ var pxt;
             // Last pass: if some variable has no type (because it was never used or
             // assigned to), just unify it with int...
             e.allVariables.forEach((v) => {
-                if (getConcreteType(v.type).type == null)
-                    union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                if (getConcreteType(v.type).type == null) {
+                    if (!v.isFunctionParameter) {
+                        union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                    }
+                    else if (v.type.isArrayType) {
+                        v.type.type = "any[]";
+                    }
+                }
             });
             function connectionCheck(i) {
                 return i.name ? i.connection && i.connection.check_ && i.connection.check_.length ? i.connection.check_[0] : "T" : undefined;
@@ -582,9 +588,31 @@ var pxt;
         function compileNumber(e, b, comments) {
             return blocks_1.H.mkNumberLiteral(extractNumber(b));
         }
+        function isNumericLiteral(e, b) {
+            if (!b)
+                return false;
+            if (b.type === "math_number" || b.type === "math_integer" || b.type === "math_number_minmax" || b.type === "math_whole_number") {
+                return true;
+            }
+            const blockInfo = e.stdCallTable[b.type];
+            if (!blockInfo)
+                return false;
+            const { comp } = blockInfo;
+            if (blockInfo.attrs.shim === "TD_ID" && comp.parameters.length === 1) {
+                const fieldValue = b.getFieldValue(comp.parameters[0].definitionName);
+                if (fieldValue) {
+                    return !isNaN(parseInt(fieldValue));
+                }
+                else {
+                    return isNumericLiteral(e, getInputTargetBlock(b, comp.parameters[0].definitionName));
+                }
+            }
+            return false;
+        }
+        function isLiteral(e, b) {
+            return isNumericLiteral(e, b) || b.type === "logic_boolean" || b.type === "text";
+        }
         let opToTok = {
-            // POWER gets a special treatment because there's no operator for it in
-            // TouchDevelop
             "ADD": "+",
             "MINUS": "-",
             "MULTIPLY": "*",
@@ -599,11 +627,21 @@ var pxt;
             "NEQ": "!=",
             "POWER": "**"
         };
+        function isComparisonOp(op) {
+            return ["LT", "LTE", "GT", "GTE", "EQ", "NEQ"].indexOf(op) !== -1;
+        }
         function compileArithmetic(e, b, comments) {
             let bOp = b.getFieldValue("OP");
             let left = getInputTargetBlock(b, "A");
             let right = getInputTargetBlock(b, "B");
             let args = [compileExpression(e, left, comments), compileExpression(e, right, comments)];
+            // Special handling for the case of comparing two literals (e.g. 0 === 5). TypeScript
+            // throws an error if we don't first cast to any
+            if (isComparisonOp(bOp) && isLiteral(e, left) && isLiteral(e, right)) {
+                if (blocks_1.flattenNode([args[0]]).output !== blocks_1.flattenNode([args[1]]).output) {
+                    args = args.map(arg => blocks_1.H.mkParenthesizedExpression(blocks_1.mkGroup([arg, blocks_1.mkText(" as any")])));
+                }
+            }
             let t = returnType(e, left).type;
             if (t == pString.type) {
                 if (bOp == "EQ")
@@ -711,7 +749,10 @@ var pxt;
             const stmts = getInputTargetBlock(b, "STACK");
             const argsDeclaration = b.getArguments().map(a => {
                 if (a.type == "Array") {
-                    return `${escapeVarName(a.name, e)}: any[]`;
+                    const binding = lookup(e, b, a.name);
+                    const declaredType = getConcreteType(binding.type);
+                    const paramType = ((declaredType === null || declaredType === void 0 ? void 0 : declaredType.type) && declaredType.type !== "Array") ? declaredType.type : "any[]";
+                    return `${escapeVarName(a.name, e)}: ${paramType}`;
                 }
                 return `${escapeVarName(a.name, e)}: ${a.type}`;
             });
@@ -1859,7 +1900,7 @@ var pxt;
             return res;
         }
         function getEscapedCBParameters(b, stdfun, e) {
-            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding[0]).escapedName);
+            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding.name).escapedName);
         }
         function getCBParameters(b, stdfun) {
             let handlerArgs = [];
@@ -1875,7 +1916,10 @@ var pxt;
                         varName = varBlock && varBlock.getField("VAR").getText();
                     }
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -1888,7 +1932,10 @@ var pxt;
                     const varField = b.getField("HANDLER_" + arg.name);
                     const varName = varField && varField.getText();
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -2091,11 +2138,7 @@ var pxt;
                 }
                 if (hasStatementInput(block)) {
                     const vars = getDeclaredVariables(block, e).map(binding => {
-                        return {
-                            name: binding[0],
-                            type: binding[1],
-                            id: id++
-                        };
+                        return Object.assign(Object.assign({}, binding), { id: id++ });
                     });
                     let parentScope = currentScope;
                     if (vars.length) {
@@ -2179,17 +2222,37 @@ var pxt;
             switch (block.type) {
                 case 'pxt_controls_for':
                 case 'controls_simple_for':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), pNumber]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: pNumber
+                        }];
                 case 'pxt_controls_for_of':
                 case 'controls_for_of':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), mkPoint(null)]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: mkPoint(null)
+                        }];
+                case 'function_definition':
+                    return block.getArguments().filter(arg => arg.type === "Array")
+                        .map(arg => {
+                        const point = mkPoint(null);
+                        point.isArrayType = true;
+                        return {
+                            name: arg.name,
+                            type: point,
+                            isFunctionParameter: true
+                        };
+                    });
                 default:
                     break;
             }
             if (isMutatingBlock(block)) {
                 const declarations = block.mutation.getDeclaredVariables();
                 if (declarations) {
-                    return Object.keys(declarations).map(varName => [varName, mkPoint(declarations[varName])]);
+                    return Object.keys(declarations).map(varName => ({
+                        name: varName,
+                        type: mkPoint(declarations[varName])
+                    }));
                 }
             }
             let stdFunc = e.stdCallTable[block.type];
@@ -4078,21 +4141,9 @@ var pxt;
                 || (nsinfo && nsinfo.attributes.color)
                 || pxt.toolbox.getNamespaceColor(ns)
                 || 255;
-            if (fn.attributes.help) {
-                const helpUrl = fn.attributes.help.replace(/^\//, '');
-                if (/^github:/.test(helpUrl)) {
-                    block.setHelpUrl(helpUrl);
-                }
-                else if (helpUrl !== "none") {
-                    block.setHelpUrl("/reference/" + helpUrl);
-                }
-            }
-            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
-                let anchor = fn.qName.toLowerCase().split('.');
-                if (anchor[0] == fn.pkg)
-                    anchor.shift();
-                block.setHelpUrl(`/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`);
-            }
+            const helpUrl = pxt.blocks.getHelpUrl(fn);
+            if (helpUrl)
+                block.setHelpUrl(helpUrl);
             block.setColour(color);
             let blockShape = Blockly.OUTPUT_SHAPE_ROUND;
             if (fn.retType == "boolean")
@@ -6324,8 +6375,71 @@ var pxt;
                     Blockly.utils.dom.removeClass(blockPath, 'blockly-ws-search-highlight-pxt');
                 });
             }
+            /**
+             * https://github.com/google/blockly-samples/blob/master/plugins/workspace-search/src/WorkspaceSearch.js#L633
+             *
+             * Modified to center offscreen blocks.
+             */
+            scrollToVisible_(block) {
+                if (!this.workspace_.isMovable()) {
+                    // Cannot scroll to block in a non-movable workspace.
+                    return;
+                }
+                // XY is in workspace coordinates.
+                const xy = block.getRelativeToSurfaceXY();
+                const scale = this.workspace_.scale;
+                // Block bounds in pixels relative to the workspace origin (0,0 is centre).
+                const width = block.width * scale;
+                const height = block.height * scale;
+                const top = xy.y * scale;
+                const bottom = (xy.y + block.height) * scale;
+                // In RTL the block's position is the top right of the block, not top left.
+                const left = this.workspace_.RTL ? xy.x * scale - width : xy.x * scale;
+                const right = this.workspace_.RTL ? xy.x * scale : xy.x * scale + width;
+                const metrics = this.workspace_.getMetrics();
+                let targetLeft = metrics.viewLeft;
+                const overflowLeft = left < metrics.viewLeft;
+                const overflowRight = right > metrics.viewLeft + metrics.viewWidth;
+                const wideBlock = width > metrics.viewWidth;
+                if ((!wideBlock && overflowLeft) || (wideBlock && !this.workspace_.RTL)) {
+                    // Scroll to show left side of block
+                    targetLeft = left;
+                }
+                else if ((!wideBlock && overflowRight) ||
+                    (wideBlock && this.workspace_.RTL)) {
+                    // Scroll to show right side of block
+                    targetLeft = right - metrics.viewWidth;
+                }
+                let targetTop = metrics.viewTop;
+                const overflowTop = top < metrics.viewTop;
+                const overflowBottom = bottom > metrics.viewTop + metrics.viewHeight;
+                const tallBlock = height > metrics.viewHeight;
+                if (overflowTop || (tallBlock && overflowBottom)) {
+                    // Scroll to show top of block
+                    targetTop = top;
+                }
+                else if (overflowBottom) {
+                    // Scroll to show bottom of block
+                    targetTop = bottom - metrics.viewHeight;
+                }
+                if (targetLeft !== metrics.viewLeft || targetTop !== metrics.viewTop) {
+                    const activeEl = document.activeElement;
+                    if (wideBlock || tallBlock) {
+                        this.workspace_.scroll(-targetLeft, -targetTop);
+                    }
+                    else {
+                        this.workspace_.centerOnBlock(block.id);
+                    }
+                    if (activeEl) {
+                        // Blockly.WidgetDiv.hide called in scroll is taking away focus.
+                        // TODO: Review setFocused call in Blockly.WidgetDiv.hide.
+                        activeEl.focus();
+                    }
+                }
+            }
             open() {
                 super.open();
+                this.inputElement_.select();
                 Blockly.utils.dom.addClass(this.workspace_.getInjectionDiv(), 'blockly-ws-searching');
             }
             close() {
@@ -12128,15 +12242,20 @@ var pxtblockly;
                 let leftPadding = 0, rightPadding = 0;
                 switch (outputShape) {
                     case Blockly.OUTPUT_SHAPE_HEXAGONAL:
-                        width = innerWidth;
+                        width = size.width / 2;
                         halfWidth = width / 2;
-                        let quarterWidth = halfWidth / 2;
-                        // TODO: the left padding calculation is a hack, we should calculate left padding based on width (generic case)
-                        leftPadding = -halfWidth + quarterWidth;
-                        rightPadding = -quarterWidth;
-                        const topLeftPoint = -quarterWidth;
-                        const bottomRightPoint = halfWidth;
-                        this.toggleThumb_.setAttribute('points', `${topLeftPoint},-14 ${topLeftPoint - 14},0 ${topLeftPoint},14 ${bottomRightPoint},14 ${bottomRightPoint + 14},0 ${bottomRightPoint},-14`);
+                        leftPadding = -halfWidth; // total translation when toggle is left-aligned = 0
+                        rightPadding = halfWidth - innerWidth; // total translation when right-aligned = width
+                        /**
+                         *  Toggle defined clockwise from bottom left:
+                         *
+                         *        0,  14 ----------- width, 14
+                         *       /                           \
+                         *  -14, 0                            width + 14, 0
+                         *       \                           /
+                         *        0, -14 ----------- width, -14
+                         */
+                        this.toggleThumb_.setAttribute('points', `${0},-14 -14,0 ${0},14 ${width},14 ${width + 14},0 ${width},-14`);
                         break;
                     case Blockly.OUTPUT_SHAPE_ROUND:
                     case Blockly.OUTPUT_SHAPE_SQUARE:

package/built/pxtcompiler.js

@@ -4620,6 +4620,8 @@ ${output}</xml>`;
                                 return getTaggedTemplateExpression(n);
                             case SK.CallExpression:
                                 return getStatementBlock(n, undefined, undefined, true);
+                            case SK.AsExpression:
+                                return getOutputBlock(n.expression);
                             default:
                                 error(n, pxtc.Util.lf("Unsupported syntax kind for output expression block: {0}", SK[n.kind]));
                                 break;
@@ -5500,11 +5502,14 @@ ${output}</xml>`;
                         r.mutationChildren = [];
                         n.parameters.forEach(p => {
                             const paramName = p.name.getText();
+                            let type = normalizeType(p.type.getText());
+                            if (pxt.U.endsWith(type, "[]"))
+                                type = "Array";
                             r.mutationChildren.push({
                                 nodeName: "arg",
                                 attributes: {
                                     name: paramName,
-                                    type: p.type.getText(),
+                                    type,
                                     id: env.functionParamIds[name][paramName]
                                 }
                             });
@@ -5580,11 +5585,14 @@ ${output}</xml>`;
                                     env.declaredFunctions[name].parameters.forEach((p, i) => {
                                         const paramName = p.name.getText();
                                         const argId = env.functionParamIds[name][paramName];
+                                        let type = normalizeType(p.type.getText());
+                                        if (pxt.U.endsWith(type, "[]"))
+                                            type = "Array";
                                         r.mutationChildren.push({
                                             nodeName: "arg",
                                             attributes: {
                                                 name: paramName,
-                                                type: p.type.getText(),
+                                                type: type,
                                                 id: argId
                                             }
                                         });
@@ -6452,7 +6460,8 @@ ${output}</xml>`;
                                 if (!type) {
                                     return pxtc.Util.lf("Function parameters must declare a type");
                                 }
-                                if (env.opts.allowedArgumentTypes.indexOf(normalizeType(type)) === -1) {
+                                const normalized = normalizeType(type);
+                                if (env.opts.allowedArgumentTypes.indexOf(normalized) === -1 && !pxtc.U.endsWith(normalized, "[]")) {
                                     return pxtc.Util.lf("Only types that can be added in blocks can be used for function arguments");
                                 }
                             }
@@ -6727,6 +6736,8 @@ ${output}</xml>`;
                         return checkStatement(n, env, true, undefined);
                     case SK.TaggedTemplateExpression:
                         return checkTaggedTemplateExpression(n, env);
+                    case SK.AsExpression:
+                        return checkAsExpression(n);
                 }
                 return pxtc.Util.lf("Unsupported syntax kind for output expression block: {0}", SK[n.kind]);
                 function checkStringLiteral(n) {
@@ -6823,6 +6834,31 @@ ${output}</xml>`;
                 // The compiler will have already caught any invalid tags or templates
                 return undefined;
             }
+            function checkAsExpression(n) {
+                // The only time we allow casts to decompile is in the very special case where someone has
+                // written a program comparing two string, boolean, or numeric literals in blocks and
+                // converted to text. e.g. 3 == 5 or true != false
+                if (n.type.getText().trim() === "any" && (ts.isStringOrNumericLiteral(n.expression) ||
+                    n.expression.kind === SK.TrueKeyword || n.expression.kind === SK.FalseKeyword)) {
+                    const [parent] = getParent(n);
+                    if (parent.kind === SK.BinaryExpression) {
+                        switch (parent.operatorToken.kind) {
+                            case SK.EqualsEqualsToken:
+                            case SK.EqualsEqualsEqualsToken:
+                            case SK.ExclamationEqualsToken:
+                            case SK.ExclamationEqualsEqualsToken:
+                            case SK.LessThanToken:
+                            case SK.LessThanEqualsToken:
+                            case SK.GreaterThanToken:
+                            case SK.GreaterThanEqualsToken:
+                                return undefined;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                return pxtc.Util.lf("Casting not supported in blocks");
+            }
             function getParent(node) {
                 if (!node.parent) {
                     return [undefined, node];
@@ -12615,8 +12651,10 @@ ${lbl}: .short 0xffff
                     return needsNumberConversions() ? pxtc.ir.rtcall("pxt::toInt", [e]) : e;
                 };
                 // c = a[i]
-                if (iterVar)
+                if (iterVar) {
                     proc.emitExpr(iterVar.storeByRef(pxtc.ir.rtcall(indexer, [collectionVar.loadCore(), toInt(intVarIter.loadCore())])));
+                    emitBrk(node.initializer);
+                }
                 flushHoistedFunctionDefinitions();
                 emit(node.statement);
                 proc.emitLblDirect(l.cont);

package/built/pxtlib.d.ts

@@ -552,6 +552,7 @@ declare namespace pxt {
         multiUrl?: string;
         asseteditorUrl?: string;
         skillmapUrl?: string;
+        authcodeUrl?: string;
         isStatic?: boolean;
         verprefix?: string;
     }
@@ -656,6 +657,7 @@ declare namespace pxt.blocks {
     function normalizeBlock(b: string, err?: (msg: string) => void): string;
     function compileInfo(fn: pxtc.SymbolInfo): BlockCompileInfo;
     function hasHandler(fn: pxtc.SymbolInfo): boolean;
+    function getHelpUrl(fn: pxtc.SymbolInfo): string;
     /**
      * Returns which Blockly block type to use for an argument reporter based
      * on the specified TypeScript type.

package/built/pxtlib.js

@@ -3909,6 +3909,25 @@ var pxt;
             });
         }
         blocks.hasHandler = hasHandler;
+        function getHelpUrl(fn) {
+            if (fn.attributes.help) {
+                const helpUrl = fn.attributes.help.replace(/^\//, '');
+                if (/^github:/.test(helpUrl)) {
+                    return helpUrl;
+                }
+                else if (helpUrl !== "none") {
+                    return "/reference/" + helpUrl;
+                }
+            }
+            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
+                let anchor = fn.qName.toLowerCase().split('.');
+                if (anchor[0] == fn.pkg)
+                    anchor.shift();
+                return `/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`;
+            }
+            return undefined;
+        }
+        blocks.getHelpUrl = getHelpUrl;
         /**
          * Returns which Blockly block type to use for an argument reporter based
          * on the specified TypeScript type.
@@ -3920,6 +3939,9 @@ var pxt;
             if (varType === "boolean" || varType === "number" || varType === "string") {
                 reporterType = `argument_reporter_${varType}`;
             }
+            if (/^(?:Array<(?:.+)>)|(?:(?:.+)\[\])$/.test(varType)) {
+                reporterType = "argument_reporter_array";
+            }
             return reporterType;
         }
         blocks.reporterTypeForArgType = reporterTypeForArgType;

package/built/pxtpy.js

@@ -955,6 +955,14 @@ var pxt;
             FloorDiv: 1,
             Mult: 1, // this can be also used on strings and arrays, but let's ignore that for now
         };
+        const arithmeticCompareOps = {
+            Eq: 1,
+            NotEq: 1,
+            Lt: 1,
+            LtE: 1,
+            Gt: 1,
+            GtE: 1
+        };
         const opMapping = {
             Add: "+",
             Sub: "-",
@@ -1826,9 +1834,24 @@ var pxt;
                     let idx = B.mkInfix(expr(n.comparators[0]), ".", B.H.mkCall("indexOf", [expr(n.left)]));
                     return B.mkInfix(idx, n.ops[0] == "In" ? ">=" : "<", B.mkText("0"));
                 }
-                let r = binop(expr(n.left), n.ops[0], expr(n.comparators[0]));
+                let left = expr(n.left);
+                let right = expr(n.comparators[0]);
+                // Special handling for comparisons of literal types, e.g. 0 === 5
+                const castIfLiteralComparison = (op, leftExpr, rightExpr) => {
+                    if (arithmeticCompareOps[op]) {
+                        if (isNumStringOrBool(leftExpr) && isNumStringOrBool(rightExpr) && B.flattenNode([left]) !== B.flattenNode([right])) {
+                            left = B.H.mkParenthesizedExpression(B.mkGroup([left, B.mkText(" as any")]));
+                            right = B.H.mkParenthesizedExpression(B.mkGroup([right, B.mkText(" as any")]));
+                        }
+                    }
+                };
+                castIfLiteralComparison(n.ops[0], n.left, n.comparators[0]);
+                let r = binop(left, n.ops[0], right);
                 for (let i = 1; i < n.ops.length; ++i) {
-                    r = binop(r, "And", binop(expr(n.comparators[i - 1]), n.ops[i], expr(n.comparators[i])));
+                    left = expr(n.comparators[i - 1]);
+                    right = expr(n.comparators[i]);
+                    castIfLiteralComparison(n.ops[i], n.comparators[i - 1], n.comparators[i]);
+                    r = binop(r, "And", binop(left, n.ops[i], right));
                 }
                 return r;
             },
@@ -2616,6 +2639,16 @@ var pxt;
             const t = canonicalize(typeOf(expr));
             return t && t.primType === "@array";
         }
+        function isNumStringOrBool(expr) {
+            switch (expr.kind) {
+                case "Num":
+                case "Str":
+                    return true;
+                case "NameConstant":
+                    return expr.value !== null;
+            }
+            return false;
+        }
         function buildOverride(override, args, recv) {
             const result = [];
             for (const part of override.parts) {
@@ -5987,6 +6020,42 @@ var pxt;
                 }
                 return fn(s);
             }
+            function getParent(node) {
+                if (!node.parent) {
+                    return undefined;
+                }
+                else if (node.parent.kind === ts.SyntaxKind.ParenthesizedExpression) {
+                    return getParent(node.parent);
+                }
+                else {
+                    return node.parent;
+                }
+            }
+            function isDecompilableAsExpression(n) {
+                // The only time we allow casts to decompile is in the very special case where someone has
+                // written a program comparing two string, boolean, or numeric literals in blocks and
+                // converted to text. e.g. 3 == 5 or true != false
+                if (n.type.getText().trim() === "any" && (ts.isNumericLiteral(n.expression) || ts.isStringLiteral(n.expression) ||
+                    n.expression.kind === ts.SyntaxKind.TrueKeyword || n.expression.kind === ts.SyntaxKind.FalseKeyword)) {
+                    const parent = getParent(n);
+                    if ((parent === null || parent === void 0 ? void 0 : parent.kind) === ts.SyntaxKind.BinaryExpression) {
+                        switch (parent.operatorToken.kind) {
+                            case ts.SyntaxKind.EqualsEqualsToken:
+                            case ts.SyntaxKind.EqualsEqualsEqualsToken:
+                            case ts.SyntaxKind.ExclamationEqualsToken:
+                            case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+                            case ts.SyntaxKind.LessThanToken:
+                            case ts.SyntaxKind.LessThanEqualsToken:
+                            case ts.SyntaxKind.GreaterThanToken:
+                            case ts.SyntaxKind.GreaterThanEqualsToken:
+                                return true;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                return false;
+            }
             function isConstExp(s) {
                 let isConst = (s) => {
                     switch (s.kind) {
@@ -6069,6 +6138,8 @@ var pxt;
                     return asExpRes(s.getText());
                 if (ts.isConditionalExpression(s))
                     return emitCondExp(s);
+                if (ts.isAsExpression(s) && isDecompilableAsExpression(s))
+                    return emitExp(s.expression);
                 // TODO handle more expressions
                 pxt.tickEvent("depython.todo.expression", { kind: s.kind });
                 // return asExpRes(s.getText(), ["# unknown expression:  " + s.kind]) // uncomment for easier locating

package/built/server.js

@@ -1046,6 +1046,10 @@ function serveAsync(options) {
             sendFile(path.join(publicDir, 'skillmap.html'));
             return;
         }
+        if (pathname == "/--authcode") {
+            sendFile(path.join(publicDir, 'authcode.html'));
+            return;
+        }
         if (/\/-[-]*docs.*$/.test(pathname)) {
             sendFile(path.join(publicDir, 'docs.html'));
             return;