pxt-core 13.2.4 → 13.2.5

package/built/cli.js

@@ -1859,8 +1859,8 @@ function saveThemeJson(cfg, localDir, packaged) {
                     const url = card.url || card.learnMoreUrl || card.buyUrl || (card.youTubeId && `https://youtu.be/${card.youTubeId}`);
                     tocmd += `  * [${card.name || card.title}](${url})
 `;
-                    if (card.tags)
-                        card.tags.forEach(tag => targetStrings[tag] = tag);
+                    for (const term of (card.tags || []).concat(card.searchTerms || []))
+                        targetStrings[term] = term;
                 }));
             });
             nodeutil.writeFileSync(path.join(docsRoot, "docs/projects/SUMMARY.md"), tocmd, { encoding: "utf8" });

package/built/pxt.js

@@ -108094,7 +108094,7 @@ var pxt;
             if (cards && !Array.isArray(cards))
                 cards = [cards];
             if (cards === null || cards === void 0 ? void 0 : cards.length)
-                return cards;
+                return cards.map(normalizeCodeCardStringArrays);
             // not json, try parsing as sequence of key,value pairs, with line splits
             cards = md.split(/^---$/gm)
                 .filter(cmd => !!cmd)
@@ -108120,7 +108120,7 @@ var pxt;
             })
                 .filter(cc => !!cc);
             if (cards === null || cards === void 0 ? void 0 : cards.length)
-                return cards;
+                return cards.map(normalizeCodeCardStringArrays);
             return undefined;
         }
         gallery_1.parseCodeCards = parseCodeCards;
@@ -108161,9 +108161,18 @@ var pxt;
                 // legacy JSON format
                 cards = pxt.Util.jsonTryParse(el.textContent);
             }
-            return !!(cards === null || cards === void 0 ? void 0 : cards.length) && cards;
+            return !!(cards === null || cards === void 0 ? void 0 : cards.length) && cards.map(normalizeCodeCardStringArrays);
         }
         gallery_1.parseCodeCardsHtml = parseCodeCardsHtml;
+        function normalizeCodeCardStringArrays(card) {
+            ["tags", "searchTerms"].forEach(field => {
+                const value = card[field];
+                if (typeof value === "string") {
+                    card[field] = value.split(',').map(term => term.trim()).filter(term => !!term);
+                }
+            });
+            return card;
+        }
         function parseGalleryMardown(md) {
             if (!md)
                 return [];
@@ -116497,18 +116506,25 @@ var ts;
                 pxt.debug(`Localized block has extra or missing parameters`);
                 return false;
             }
+            if (!!a.thisParameter != !!b.thisParameter
+                || (a.thisParameter && !isEquivalentParameter(a.thisParameter, b.thisParameter))) {
+                pxt.debug(`Localized block's this parameter shadow block or definition name does not match`);
+                return false;
+            }
             for (const aParam of a.parameters) {
                 const bParam = b.actualNameToParam[aParam.actualName];
-                if (!bParam
-                    || aParam.type != bParam.type
-                    || aParam.shadowBlockId != bParam.shadowBlockId
-                    || aParam.definitionName != bParam.definitionName) {
+                if (!bParam || !isEquivalentParameter(aParam, bParam)) {
                     pxt.debug(`Parameter ${aParam.actualName} type, shadow block, or definition name does not match after localization`);
                     return false;
                 }
             }
             return true;
         }
+        function isEquivalentParameter(a, b) {
+            return a.type == b.type
+                && a.shadowBlockId == b.shadowBlockId
+                && a.definitionName == b.definitionName;
+        }
         function emptyExtInfo() {
             let cs = pxt.appTarget.compileService;
             if (!cs)
@@ -135162,6 +135178,7 @@ var ts;
             let currUsingContext = null;
             let needsUsingInfo = false;
             let pendingFunctionDefinitions = [];
+            const loopBlockFunctionDefinitions = {};
             currNodeWave++;
             if (opts.target.isNative) {
                 if (!opts.extinfo || !opts.extinfo.hexinfo) {
@@ -136462,10 +136479,14 @@ ${lbl}: .short 0xffff
                                 args.push(irToNode(expr));
                             }
                             else {
-                                if (!opts.unfetteredInitializers && !isNumericLiteral(prm.initializer)) {
-                                    userError(9212, lf("only numbers, null, true and false supported as default arguments"));
+                                // Emitted functions apply their own defaults, including on
+                                // virtual/interface calls where the implementation may differ.
+                                // Shims and helpers may have no emitted parameter prologue.
+                                const needsCallerDefault = attrs.helper || attrs.shim;
+                                if (needsCallerDefault && !opts.unfetteredInitializers && !isNumericLiteral(prm.initializer)) {
+                                    userError(9212, lf("only numbers, null, true and false supported as default arguments for shims and helpers"));
                                 }
-                                args.push(prm.initializer);
+                                args.push(needsCallerDefault ? prm.initializer : irToNode(emitLit(undefined)));
                             }
                         }
                         else {
@@ -137204,12 +137225,8 @@ ${lbl}: .short 0xffff
                         }
                     }
                 }
-                const destructuredParameters = [];
                 const fieldAssignmentParameters = [];
                 proc.args = getParameters(node).map((p, i) => {
-                    if (p.name.kind === pxtc.SK.ObjectBindingPattern) {
-                        destructuredParameters.push(p);
-                    }
                     if (node.kind == pxtc.SK.Constructor && isCtorField(p)) {
                         fieldAssignmentParameters.push(p);
                     }
@@ -137227,7 +137244,34 @@ ${lbl}: .short 0xffff
                         proc.emitExpr(l.storeDirect(tmp));
                     }
                 });
-                destructuredParameters.forEach(dp => emitVariableDeclaration(dp));
+                // Arity wrappers pad omitted arguments with undefined. Keep defaults in
+                // the shared body so direct, virtual, interface and action calls all run
+                // them, including native entries which can skip the arity wrapper.
+                const attrs = parseComments(node);
+                proc.args.forEach(l => {
+                    const parameter = l.def;
+                    // Simulator shim dummies must match the native caller-side behavior.
+                    if (parameter.initializer && !attrs.shim && !attrs.helper) {
+                        const supplied = proc.mkLabel("defaultarg");
+                        if (isThumb()) {
+                            // Tagged undefined is 0, so the guard is a bare
+                            // compare against zero rather than a runtime call.
+                            proc.emitJmp(supplied, l.load(), pxtc.ir.JmpMode.IfNotZero);
+                        }
+                        else {
+                            // The simulator holds real JS values; a raw zero test
+                            // would treat a supplied 0/false/null as omitted.
+                            proc.emitJmpZ(supplied, pxtc.ir.rtcall("pxt::eqq_bool", [l.load(), emitLit(undefined)]));
+                        }
+                        proc.emitExpr(l.storeByRef(emitEscapedExpression(parameter.initializer, "initializer")));
+                        proc.emitLbl(supplied);
+                        proc.stackEmpty();
+                    }
+                    if (parameter.name.kind === pxtc.SK.ObjectBindingPattern) {
+                        // Destructure the resolved argument, not the initializer again.
+                        emitVarOrParam(parameter, l.load(), typeOf(parameter));
+                    }
+                });
                 // for constructor(public foo:number) generate this.foo = foo;
                 for (let p of fieldAssignmentParameters) {
                     let idx = fieldIndexCore(proc.classInfo, getFieldInfo(proc.classInfo, getName(p)), false);
@@ -137270,11 +137314,25 @@ ${lbl}: .short 0xffff
                 if (info.capturedVars.length &&
                     info.usedBeforeDecl &&
                     node.kind == pxtc.SK.FunctionDeclaration && !bin.finalPass) {
-                    info.capturedVars.sort((a, b) => b.pos - a.pos);
-                    const vinfo = getVarInfo(info.capturedVars[0]);
-                    if (!vinfo.functionsToDefine)
-                        vinfo.functionsToDefine = [];
-                    vinfo.functionsToDefine.push(node);
+                    // Synthetic captures (such as thisParameter) are available before
+                    // source declarations, but may not have a source position.
+                    const capturePos = (capture) => capture.pos == null ? -1 : capture.pos;
+                    info.capturedVars.sort((a, b) => capturePos(b) - capturePos(a));
+                    const scope = node.parent;
+                    if (scope.kind === pxtc.SK.Block && inLoop(scope) && info.capturedVars.every(capture => capturePos(capture) < scope.pos)) {
+                        // All captures precede this loop block. Defining the function at
+                        // the last captured variable would hoist it out of the iteration.
+                        const id = getNodeId(scope);
+                        const definitions = loopBlockFunctionDefinitions[id] || (loopBlockFunctionDefinitions[id] = []);
+                        if (definitions.indexOf(node) < 0)
+                            definitions.push(node);
+                    }
+                    else {
+                        const vinfo = getVarInfo(info.capturedVars[0]);
+                        if (!vinfo.functionsToDefine)
+                            vinfo.functionsToDefine = [];
+                        vinfo.functionsToDefine.push(node);
+                    }
                 }
                 // nothing should be on work list in final pass - everything should be already marked as used
                 pxtc.assert(!bin.finalPass || usedWorkList.length == 0, "!bin.finalPass || usedWorkList.length == 0");
@@ -138231,6 +138289,11 @@ ${lbl}: .short 0xffff
             function emitSpreadElementExpression(node) { }
             function emitYieldExpression(node) { }
             function emitBlock(node) {
+                const definitions = bin.finalPass && loopBlockFunctionDefinitions[getNodeId(node)];
+                if (definitions) {
+                    pxtc.U.pushRange(pendingFunctionDefinitions, definitions);
+                    flushHoistedFunctionDefinitions();
+                }
                 node.statements.forEach(emit);
             }
             function checkForLetOrConst(declList) {
@@ -138416,16 +138479,45 @@ ${lbl}: .short 0xffff
                 proc.emitExpr(v);
                 proc.stackEmpty();
             }
+            function emitForIterationBindings(declList) {
+                // Only `let` loop headers create copied bindings. `const` and variables
+                // declared outside the loop retain their existing binding semantics.
+                if (!declList || !(declList.flags & ts.NodeFlags.Let))
+                    return;
+                const copyBinding = (decl) => {
+                    if (decl.name.kind === pxtc.SK.ObjectBindingPattern || decl.name.kind === pxtc.SK.ArrayBindingPattern) {
+                        decl.name.elements.forEach(element => {
+                            if (element.kind === pxtc.SK.BindingElement)
+                                copyBinding(element);
+                        });
+                        return;
+                    }
+                    const loc = proc.localIndex(decl);
+                    if (!loc || !loc.isByRefLocal())
+                        return;
+                    // Populate the new box before replacing the old cell. Closures already
+                    // created keep the old box; sibling closures in this iteration share the new one.
+                    const next = pxtc.ir.shared(pxtc.ir.rtcall("pxtrt::mklocRef", []));
+                    proc.emitExpr(pxtc.ir.rtcall("pxtrt::stlocRef", [next, loc.load()]));
+                    proc.emitExpr(loc.storeDirect(next));
+                    proc.stackEmpty();
+                };
+                declList.declarations.forEach(copyBinding);
+            }
             function emitForStatement(node) {
+                let declList;
                 if (node.initializer && node.initializer.kind == pxtc.SK.VariableDeclarationList) {
-                    checkForLetOrConst(node.initializer);
-                    node.initializer.declarations.forEach(emit);
+                    declList = node.initializer;
+                    checkForLetOrConst(declList);
+                    declList.declarations.forEach(emit);
                 }
                 else {
                     emitExprAsStmt(node.initializer);
                 }
                 emitBrk(node);
                 let l = getLabels(node);
+                // Initializer closures keep their own binding, separate from the first condition/body.
+                emitForIterationBindings(declList);
                 proc.emitLblDirect(l.fortop);
                 if (node.condition) {
                     emitBrk(node.condition);
@@ -138433,6 +138525,8 @@ ${lbl}: .short 0xffff
                 }
                 emit(node.statement);
                 proc.emitLblDirect(l.cont);
+                // A continue must also create the next binding BEFORE evaluating the incrementor.
+                emitForIterationBindings(declList);
                 emitExprAsStmt(node.incrementor);
                 proc.emitJmp(l.fortop);
                 proc.emitLblDirect(l.brk);
@@ -138492,6 +138586,11 @@ ${lbl}: .short 0xffff
                 };
                 // c = a[i]
                 if (iterVar) {
+                    // A mutable captured for-of variable needs a fresh box for each element,
+                    // rather than overwriting the box retained by closures from earlier elements.
+                    if (iterVar.isByRefLocal()) {
+                        proc.emitExpr(iterVar.storeDirect(pxtc.ir.rtcall("pxtrt::mklocRef", [])));
+                    }
                     proc.emitExpr(iterVar.storeByRef(pxtc.ir.rtcall(indexer, [collectionVar.loadCore(), toInt(intVarIter.loadCore())])));
                     emitBrk(node.initializer);
                 }
@@ -138605,7 +138704,10 @@ ${lbl}: .short 0xffff
             function emitLabeledStatement(node) {
                 let l = getLabels(node.statement);
                 emit(node.statement);
-                proc.emitLblDirect(l.brk);
+                // Loops and switches define their own break target. Emitting it twice
+                // is tolerated by simjs but rejected by the native assembler.
+                if (!ts.isIterationStatement(node.statement, false) && node.statement.kind !== pxtc.SK.SwitchStatement)
+                    proc.emitLblDirect(l.brk);
             }
             function emitThrowStatement(node) {
                 emitBrk(node);
@@ -166649,8 +166751,8 @@ function saveThemeJson(cfg, localDir, packaged) {
                     const url = card.url || card.learnMoreUrl || card.buyUrl || (card.youTubeId && `https://youtu.be/${card.youTubeId}`);
                     tocmd += `  * [${card.name || card.title}](${url})
 `;
-                    if (card.tags)
-                        card.tags.forEach(tag => targetStrings[tag] = tag);
+                    for (const term of (card.tags || []).concat(card.searchTerms || []))
+                        targetStrings[term] = term;
                 }));
             });
             nodeutil.writeFileSync(path.join(docsRoot, "docs/projects/SUMMARY.md"), tocmd, { encoding: "utf8" });

package/built/pxtcompiler.js

@@ -10178,6 +10178,7 @@ var ts;
             let currUsingContext = null;
             let needsUsingInfo = false;
             let pendingFunctionDefinitions = [];
+            const loopBlockFunctionDefinitions = {};
             currNodeWave++;
             if (opts.target.isNative) {
                 if (!opts.extinfo || !opts.extinfo.hexinfo) {
@@ -11478,10 +11479,14 @@ ${lbl}: .short 0xffff
                                 args.push(irToNode(expr));
                             }
                             else {
-                                if (!opts.unfetteredInitializers && !isNumericLiteral(prm.initializer)) {
-                                    userError(9212, lf("only numbers, null, true and false supported as default arguments"));
+                                // Emitted functions apply their own defaults, including on
+                                // virtual/interface calls where the implementation may differ.
+                                // Shims and helpers may have no emitted parameter prologue.
+                                const needsCallerDefault = attrs.helper || attrs.shim;
+                                if (needsCallerDefault && !opts.unfetteredInitializers && !isNumericLiteral(prm.initializer)) {
+                                    userError(9212, lf("only numbers, null, true and false supported as default arguments for shims and helpers"));
                                 }
-                                args.push(prm.initializer);
+                                args.push(needsCallerDefault ? prm.initializer : irToNode(emitLit(undefined)));
                             }
                         }
                         else {
@@ -12220,12 +12225,8 @@ ${lbl}: .short 0xffff
                         }
                     }
                 }
-                const destructuredParameters = [];
                 const fieldAssignmentParameters = [];
                 proc.args = getParameters(node).map((p, i) => {
-                    if (p.name.kind === pxtc.SK.ObjectBindingPattern) {
-                        destructuredParameters.push(p);
-                    }
                     if (node.kind == pxtc.SK.Constructor && isCtorField(p)) {
                         fieldAssignmentParameters.push(p);
                     }
@@ -12243,7 +12244,34 @@ ${lbl}: .short 0xffff
                         proc.emitExpr(l.storeDirect(tmp));
                     }
                 });
-                destructuredParameters.forEach(dp => emitVariableDeclaration(dp));
+                // Arity wrappers pad omitted arguments with undefined. Keep defaults in
+                // the shared body so direct, virtual, interface and action calls all run
+                // them, including native entries which can skip the arity wrapper.
+                const attrs = parseComments(node);
+                proc.args.forEach(l => {
+                    const parameter = l.def;
+                    // Simulator shim dummies must match the native caller-side behavior.
+                    if (parameter.initializer && !attrs.shim && !attrs.helper) {
+                        const supplied = proc.mkLabel("defaultarg");
+                        if (isThumb()) {
+                            // Tagged undefined is 0, so the guard is a bare
+                            // compare against zero rather than a runtime call.
+                            proc.emitJmp(supplied, l.load(), pxtc.ir.JmpMode.IfNotZero);
+                        }
+                        else {
+                            // The simulator holds real JS values; a raw zero test
+                            // would treat a supplied 0/false/null as omitted.
+                            proc.emitJmpZ(supplied, pxtc.ir.rtcall("pxt::eqq_bool", [l.load(), emitLit(undefined)]));
+                        }
+                        proc.emitExpr(l.storeByRef(emitEscapedExpression(parameter.initializer, "initializer")));
+                        proc.emitLbl(supplied);
+                        proc.stackEmpty();
+                    }
+                    if (parameter.name.kind === pxtc.SK.ObjectBindingPattern) {
+                        // Destructure the resolved argument, not the initializer again.
+                        emitVarOrParam(parameter, l.load(), typeOf(parameter));
+                    }
+                });
                 // for constructor(public foo:number) generate this.foo = foo;
                 for (let p of fieldAssignmentParameters) {
                     let idx = fieldIndexCore(proc.classInfo, getFieldInfo(proc.classInfo, getName(p)), false);
@@ -12286,11 +12314,25 @@ ${lbl}: .short 0xffff
                 if (info.capturedVars.length &&
                     info.usedBeforeDecl &&
                     node.kind == pxtc.SK.FunctionDeclaration && !bin.finalPass) {
-                    info.capturedVars.sort((a, b) => b.pos - a.pos);
-                    const vinfo = getVarInfo(info.capturedVars[0]);
-                    if (!vinfo.functionsToDefine)
-                        vinfo.functionsToDefine = [];
-                    vinfo.functionsToDefine.push(node);
+                    // Synthetic captures (such as thisParameter) are available before
+                    // source declarations, but may not have a source position.
+                    const capturePos = (capture) => capture.pos == null ? -1 : capture.pos;
+                    info.capturedVars.sort((a, b) => capturePos(b) - capturePos(a));
+                    const scope = node.parent;
+                    if (scope.kind === pxtc.SK.Block && inLoop(scope) && info.capturedVars.every(capture => capturePos(capture) < scope.pos)) {
+                        // All captures precede this loop block. Defining the function at
+                        // the last captured variable would hoist it out of the iteration.
+                        const id = getNodeId(scope);
+                        const definitions = loopBlockFunctionDefinitions[id] || (loopBlockFunctionDefinitions[id] = []);
+                        if (definitions.indexOf(node) < 0)
+                            definitions.push(node);
+                    }
+                    else {
+                        const vinfo = getVarInfo(info.capturedVars[0]);
+                        if (!vinfo.functionsToDefine)
+                            vinfo.functionsToDefine = [];
+                        vinfo.functionsToDefine.push(node);
+                    }
                 }
                 // nothing should be on work list in final pass - everything should be already marked as used
                 pxtc.assert(!bin.finalPass || usedWorkList.length == 0, "!bin.finalPass || usedWorkList.length == 0");
@@ -13247,6 +13289,11 @@ ${lbl}: .short 0xffff
             function emitSpreadElementExpression(node) { }
             function emitYieldExpression(node) { }
             function emitBlock(node) {
+                const definitions = bin.finalPass && loopBlockFunctionDefinitions[getNodeId(node)];
+                if (definitions) {
+                    pxtc.U.pushRange(pendingFunctionDefinitions, definitions);
+                    flushHoistedFunctionDefinitions();
+                }
                 node.statements.forEach(emit);
             }
             function checkForLetOrConst(declList) {
@@ -13432,16 +13479,45 @@ ${lbl}: .short 0xffff
                 proc.emitExpr(v);
                 proc.stackEmpty();
             }
+            function emitForIterationBindings(declList) {
+                // Only `let` loop headers create copied bindings. `const` and variables
+                // declared outside the loop retain their existing binding semantics.
+                if (!declList || !(declList.flags & ts.NodeFlags.Let))
+                    return;
+                const copyBinding = (decl) => {
+                    if (decl.name.kind === pxtc.SK.ObjectBindingPattern || decl.name.kind === pxtc.SK.ArrayBindingPattern) {
+                        decl.name.elements.forEach(element => {
+                            if (element.kind === pxtc.SK.BindingElement)
+                                copyBinding(element);
+                        });
+                        return;
+                    }
+                    const loc = proc.localIndex(decl);
+                    if (!loc || !loc.isByRefLocal())
+                        return;
+                    // Populate the new box before replacing the old cell. Closures already
+                    // created keep the old box; sibling closures in this iteration share the new one.
+                    const next = pxtc.ir.shared(pxtc.ir.rtcall("pxtrt::mklocRef", []));
+                    proc.emitExpr(pxtc.ir.rtcall("pxtrt::stlocRef", [next, loc.load()]));
+                    proc.emitExpr(loc.storeDirect(next));
+                    proc.stackEmpty();
+                };
+                declList.declarations.forEach(copyBinding);
+            }
             function emitForStatement(node) {
+                let declList;
                 if (node.initializer && node.initializer.kind == pxtc.SK.VariableDeclarationList) {
-                    checkForLetOrConst(node.initializer);
-                    node.initializer.declarations.forEach(emit);
+                    declList = node.initializer;
+                    checkForLetOrConst(declList);
+                    declList.declarations.forEach(emit);
                 }
                 else {
                     emitExprAsStmt(node.initializer);
                 }
                 emitBrk(node);
                 let l = getLabels(node);
+                // Initializer closures keep their own binding, separate from the first condition/body.
+                emitForIterationBindings(declList);
                 proc.emitLblDirect(l.fortop);
                 if (node.condition) {
                     emitBrk(node.condition);
@@ -13449,6 +13525,8 @@ ${lbl}: .short 0xffff
                 }
                 emit(node.statement);
                 proc.emitLblDirect(l.cont);
+                // A continue must also create the next binding BEFORE evaluating the incrementor.
+                emitForIterationBindings(declList);
                 emitExprAsStmt(node.incrementor);
                 proc.emitJmp(l.fortop);
                 proc.emitLblDirect(l.brk);
@@ -13508,6 +13586,11 @@ ${lbl}: .short 0xffff
                 };
                 // c = a[i]
                 if (iterVar) {
+                    // A mutable captured for-of variable needs a fresh box for each element,
+                    // rather than overwriting the box retained by closures from earlier elements.
+                    if (iterVar.isByRefLocal()) {
+                        proc.emitExpr(iterVar.storeDirect(pxtc.ir.rtcall("pxtrt::mklocRef", [])));
+                    }
                     proc.emitExpr(iterVar.storeByRef(pxtc.ir.rtcall(indexer, [collectionVar.loadCore(), toInt(intVarIter.loadCore())])));
                     emitBrk(node.initializer);
                 }
@@ -13621,7 +13704,10 @@ ${lbl}: .short 0xffff
             function emitLabeledStatement(node) {
                 let l = getLabels(node.statement);
                 emit(node.statement);
-                proc.emitLblDirect(l.brk);
+                // Loops and switches define their own break target. Emitting it twice
+                // is tolerated by simjs but rejected by the native assembler.
+                if (!ts.isIterationStatement(node.statement, false) && node.statement.kind !== pxtc.SK.SwitchStatement)
+                    proc.emitLblDirect(l.brk);
             }
             function emitThrowStatement(node) {
                 emitBrk(node);

package/built/pxtlib.js

@@ -10373,7 +10373,7 @@ var pxt;
             if (cards && !Array.isArray(cards))
                 cards = [cards];
             if (cards === null || cards === void 0 ? void 0 : cards.length)
-                return cards;
+                return cards.map(normalizeCodeCardStringArrays);
             // not json, try parsing as sequence of key,value pairs, with line splits
             cards = md.split(/^---$/gm)
                 .filter(cmd => !!cmd)
@@ -10399,7 +10399,7 @@ var pxt;
             })
                 .filter(cc => !!cc);
             if (cards === null || cards === void 0 ? void 0 : cards.length)
-                return cards;
+                return cards.map(normalizeCodeCardStringArrays);
             return undefined;
         }
         gallery_1.parseCodeCards = parseCodeCards;
@@ -10440,9 +10440,18 @@ var pxt;
                 // legacy JSON format
                 cards = pxt.Util.jsonTryParse(el.textContent);
             }
-            return !!(cards === null || cards === void 0 ? void 0 : cards.length) && cards;
+            return !!(cards === null || cards === void 0 ? void 0 : cards.length) && cards.map(normalizeCodeCardStringArrays);
         }
         gallery_1.parseCodeCardsHtml = parseCodeCardsHtml;
+        function normalizeCodeCardStringArrays(card) {
+            ["tags", "searchTerms"].forEach(field => {
+                const value = card[field];
+                if (typeof value === "string") {
+                    card[field] = value.split(',').map(term => term.trim()).filter(term => !!term);
+                }
+            });
+            return card;
+        }
         function parseGalleryMardown(md) {
             if (!md)
                 return [];
@@ -18776,18 +18785,25 @@ var ts;
                 pxt.debug(`Localized block has extra or missing parameters`);
                 return false;
             }
+            if (!!a.thisParameter != !!b.thisParameter
+                || (a.thisParameter && !isEquivalentParameter(a.thisParameter, b.thisParameter))) {
+                pxt.debug(`Localized block's this parameter shadow block or definition name does not match`);
+                return false;
+            }
             for (const aParam of a.parameters) {
                 const bParam = b.actualNameToParam[aParam.actualName];
-                if (!bParam
-                    || aParam.type != bParam.type
-                    || aParam.shadowBlockId != bParam.shadowBlockId
-                    || aParam.definitionName != bParam.definitionName) {
+                if (!bParam || !isEquivalentParameter(aParam, bParam)) {
                     pxt.debug(`Parameter ${aParam.actualName} type, shadow block, or definition name does not match after localization`);
                     return false;
                 }
             }
             return true;
         }
+        function isEquivalentParameter(a, b) {
+            return a.type == b.type
+                && a.shadowBlockId == b.shadowBlockId
+                && a.definitionName == b.definitionName;
+        }
         function emptyExtInfo() {
             let cs = pxt.appTarget.compileService;
             if (!cs)