pxt-core 7.5.2 → 7.5.5

package/built/pxt.js

@@ -101595,6 +101595,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.
@@ -101606,6 +101625,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;
@@ -107513,6 +107535,7 @@ var pxt;
         github.isOrgAsync = isOrgAsync;
         class MemoryGithubDb {
             constructor() {
+                this.latestVersions = {};
                 this.configs = {};
                 this.packages = {};
             }
@@ -107535,8 +107558,10 @@ var pxt;
                 return pxt.U.clone(cfg);
             }
             async loadConfigAsync(repopath, tag) {
-                if (!tag)
+                if (!tag) {
+                    pxt.debug(`dep: default to master branch`);
                     tag = "master";
+                }
                 // cache lookup
                 const key = `${repopath}/${tag}`;
                 let res = this.configs[key];
@@ -107559,9 +107584,19 @@ var pxt;
                 const cfg = await downloadTextAsync(repopath, tag, pxt.CONFIG_NAME);
                 return this.cacheConfig(key, cfg);
             }
+            async latestVersionAsync(repopath, config) {
+                let resolved = this.latestVersions[repopath];
+                if (!resolved) {
+                    pxt.debug(`dep: resolve latest version of ${repopath}`);
+                    this.latestVersions[repopath] = resolved = await pxt.github.latestVersionAsync(repopath, config, true, false);
+                }
+                return resolved;
+            }
             async loadPackageAsync(repopath, tag) {
-                if (!tag)
+                if (!tag) {
+                    pxt.debug(`load pkg: default to master branch`);
                     tag = "master";
+                }
                 // try using github proxy first
                 if (hasProxy()) {
                     try {
@@ -107877,34 +107912,38 @@ var pxt;
                 .then(resolveRefAsync, e => ghGetJsonAsync(`https://api.github.com/repos/${parsed.slug}/git/refs/heads/${tag}`)
                 .then(resolveRefAsync));
         }
-        function pkgConfigAsync(repopath, tag = "master") {
-            return github.db.loadConfigAsync(repopath, tag);
+        async function pkgConfigAsync(repopath, tag, config) {
+            if (!tag)
+                tag = await github.db.latestVersionAsync(repopath, config);
+            return await github.db.loadConfigAsync(repopath, tag);
         }
         github.pkgConfigAsync = pkgConfigAsync;
-        function downloadPackageAsync(repoWithTag, config) {
+        async function downloadPackageAsync(repoWithTag, config) {
             const p = parseRepoId(repoWithTag);
             if (!p) {
                 pxt.log('Unknown GitHub syntax');
-                return Promise.resolve(undefined);
+                return undefined;
             }
             if (isRepoBanned(p, config)) {
                 pxt.tickEvent("github.download.banned");
                 pxt.log('Github repo is banned');
-                return Promise.resolve(undefined);
+                return undefined;
             }
-            return github.db.loadPackageAsync(p.fullName, p.tag)
-                .then(cached => {
-                const dv = upgradedDisablesVariants(config, repoWithTag);
-                if (dv) {
-                    const cfg = pxt.Package.parseAndValidConfig(cached.files[pxt.CONFIG_NAME]);
-                    if (cfg) {
-                        pxt.log(`auto-disable ${dv.join(",")} due to targetconfig entry for ${repoWithTag}`);
-                        cfg.disablesVariants = dv;
-                        cached.files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
-                    }
+            // always try to upgrade unbound versions
+            if (!p.tag) {
+                p.tag = await github.db.latestVersionAsync(p.slug, config);
+            }
+            const cached = await github.db.loadPackageAsync(p.fullName, p.tag);
+            const dv = upgradedDisablesVariants(config, repoWithTag);
+            if (dv) {
+                const cfg = pxt.Package.parseAndValidConfig(cached.files[pxt.CONFIG_NAME]);
+                if (cfg) {
+                    pxt.log(`auto-disable ${dv.join(",")} due to targetconfig entry for ${repoWithTag}`);
+                    cfg.disablesVariants = dv;
+                    cached.files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
                 }
-                return cached;
-            });
+            }
+            return cached;
         }
         github.downloadPackageAsync = downloadPackageAsync;
         async function downloadLatestPackageAsync(repo) {
@@ -107914,7 +107953,7 @@ var pxt;
             const repoWithTag = `${repo.fullName}#${tag}`;
             await pxt.github.downloadPackageAsync(repoWithTag, packageConfig);
             // return config
-            const config = await pkgConfigAsync(repo.fullName, tag);
+            const config = await pkgConfigAsync(repo.fullName, tag, packageConfig);
             const version = `github:${repoWithTag}`;
             return { version, config };
         }
@@ -108244,14 +108283,15 @@ var pxt;
         }
         github.isGithubId = isGithubId;
         function stringifyRepo(p) {
-            return p ? "github:" + p.fullName.toLowerCase() + "#" + (p.tag || "master") : undefined;
+            return p ? "github:" + p.fullName.toLowerCase() + (p.tag ? `#${p.tag}` : '') : undefined;
         }
         github.stringifyRepo = stringifyRepo;
-        function normalizeRepoId(id) {
+        function normalizeRepoId(id, defaultTag) {
             const gid = parseRepoId(id);
             if (!gid)
                 return undefined;
-            gid.tag = gid.tag || "master";
+            if (!gid.tag && defaultTag)
+                gid.tag = defaultTag;
             return stringifyRepo(gid);
         }
         github.normalizeRepoId = normalizeRepoId;
@@ -111393,22 +111433,20 @@ var pxt;
                 && json.dependencies && Object.keys(json.dependencies).every(k => typeof json.dependencies[k] === "string")
                 && json;
         }
-        static getConfigAsync(pkgTargetVersion, id, fullVers) {
-            return Promise.resolve().then(() => {
-                if (pxt.github.isGithubId(fullVers)) {
-                    const repoInfo = pxt.github.parseRepoId(fullVers);
-                    return pxt.packagesConfigAsync()
-                        .then(config => pxt.github.repoAsync(repoInfo.fullName, config)) // Make sure repo exists and is whitelisted
-                        .then(gitRepo => gitRepo ? pxt.github.pkgConfigAsync(repoInfo.fullName, repoInfo.tag) : null);
-                }
-                else {
-                    // If it's not from GH, assume it's a bundled package
-                    // TODO: Add logic for shared packages if we enable that
-                    const updatedRef = pxt.patching.upgradePackageReference(pkgTargetVersion, id, fullVers);
-                    const bundledPkg = pxt.appTarget.bundledpkgs[updatedRef];
-                    return JSON.parse(bundledPkg[pxt.CONFIG_NAME]);
-                }
-            });
+        static async getConfigAsync(pkgTargetVersion, id, fullVers) {
+            if (pxt.github.isGithubId(fullVers)) {
+                const repoInfo = pxt.github.parseRepoId(fullVers);
+                const packagesConfig = await pxt.packagesConfigAsync();
+                const gitRepo = await pxt.github.repoAsync(repoInfo.fullName, packagesConfig); // Make sure repo exists and is whitelisted
+                return gitRepo ? await pxt.github.pkgConfigAsync(repoInfo.fullName, repoInfo.tag, packagesConfig) : null;
+            }
+            else {
+                // If it's not from GH, assume it's a bundled package
+                // TODO: Add logic for shared packages if we enable that
+                const updatedRef = pxt.patching.upgradePackageReference(pkgTargetVersion, id, fullVers);
+                const bundledPkg = pxt.appTarget.bundledpkgs[updatedRef];
+                return JSON.parse(bundledPkg[pxt.CONFIG_NAME]);
+            }
         }
         static corePackages() {
             const pkgs = pxt.appTarget.bundledpkgs;
@@ -120902,6 +120940,9 @@ var pxt;
                 });
             });
         }
+        latestVersionAsync(repopath, config) {
+            return this.db.latestVersionAsync(repopath, config);
+        }
         loadConfigAsync(repopath, tag) {
             return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
         }
@@ -125490,6 +125531,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;
@@ -126370,11 +126413,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]
                                 }
                             });
@@ -126450,11 +126496,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
                                             }
                                         });
@@ -127322,7 +127371,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");
                                 }
                             }
@@ -127597,6 +127647,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) {
@@ -127693,6 +127745,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];
@@ -133485,8 +133562,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);
@@ -140954,6 +141033,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: "-",
@@ -141825,9 +141912,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;
             },
@@ -142615,6 +142717,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) {
@@ -145986,6 +146098,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) {
@@ -146068,6 +146216,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
@@ -156136,6 +156286,9 @@ class FileGithubDb {
             return p;
         });
     }
+    latestVersionAsync(repopath, config) {
+        return this.db.latestVersionAsync(repopath, config);
+    }
     loadConfigAsync(repopath, tag) {
         return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
     }
@@ -156152,46 +156305,6 @@ function searchAsync(...query) {
         }
     });
 }
-function pkginfoAsync(repopath) {
-    let parsed = pxt.github.parseRepoId(repopath);
-    if (!parsed) {
-        console.log('Unknown repo');
-        return Promise.resolve();
-    }
-    const pkgInfo = (cfg, tag) => {
-        pxt.log(`name: ${cfg.name}`);
-        pxt.log(`description: ${cfg.description}`);
-        if (pxt.appTarget.appTheme)
-            pxt.log(`shareable url: ${pxt.appTarget.appTheme.embedUrl}#pub:gh/${parsed.fullName}${tag ? "#" + tag : ""}`);
-    };
-    return pxt.packagesConfigAsync()
-        .then(config => {
-        const status = pxt.github.repoStatus(parsed, config);
-        pxt.log(`github org: ${parsed.owner}`);
-        if (parsed.tag)
-            pxt.log(`github tag: ${parsed.tag}`);
-        pxt.log(`package status: ${status == pxt.github.GitRepoStatus.Approved ? "approved" : status == pxt.github.GitRepoStatus.Banned ? "banned" : "neutral"}`);
-        if (parsed.tag)
-            return pxt.github.downloadPackageAsync(repopath, config)
-                .then(pkg => {
-                let cfg = JSON.parse(pkg.files[pxt.CONFIG_NAME]);
-                pkgInfo(cfg, parsed.tag);
-                pxt.debug(`size: ${JSON.stringify(pkg.files).length}`);
-            });
-        return pxt.github.pkgConfigAsync(parsed.fullName)
-            .then(cfg => {
-            pkgInfo(cfg);
-            return pxt.github.listRefsAsync(repopath)
-                .then(tags => {
-                pxt.log("tags: " + tags.join(", "));
-                return pxt.github.listRefsAsync(repopath, "heads");
-            })
-                .then(heads => {
-                pxt.log("branches: " + heads.join(", "));
-            });
-        });
-    });
-}
 function pokeRepoAsync(parsed) {
     const repo = parsed.args[0];
     let data = {
@@ -156292,7 +156405,8 @@ function pxtFileList(pref) {
         .concat(onlyExts(nodeutil.allFiles(pref + "built/web", 1), [".js", ".css"]))
         .concat(nodeutil.allFiles(pref + "built/web/fonts", 1))
         .concat(nodeutil.allFiles(pref + "built/web/vs", 4))
-        .concat(nodeutil.allFiles(pref + "built/web/skillmap", 4));
+        .concat(nodeutil.allFiles(pref + "built/web/skillmap", 4))
+        .concat(nodeutil.allFiles(pref + "built/web/authcode", 4));
 }
 function semverCmp(a, b) {
     let parse = (s) => {
@@ -156372,7 +156486,8 @@ function ciAsync() {
                     p = p
                         .then(() => buildWebStringsAsync())
                         .then(() => crowdin.execCrowdinAsync("upload", "built/webstrings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/skillmap-strings.json"));
+                        .then(() => crowdin.execCrowdinAsync("upload", "built/skillmap-strings.json"))
+                        .then(() => crowdin.execCrowdinAsync("upload", "built/authcode-strings.json"));
                 if (uploadApiStrings)
                     p = p.then(() => crowdin.execCrowdinAsync("upload", "built/strings.json"));
                 if (uploadDocs || uploadApiStrings)
@@ -156890,6 +157005,7 @@ function uploadCoreAsync(opts) {
             "multiUrl": opts.localDir + "multi.html",
             "asseteditorUrl": opts.localDir + "asseteditor.html",
             "skillmapUrl": opts.localDir + "skillmap.html",
+            "authcodeUrl": opts.localDir + "authcode.html",
             "isStatic": true,
         };
         const targetImagePaths = targetImages.map(k => `${opts.localDir}${path.join('./docs', logos[k])}`);
@@ -156935,13 +157051,15 @@ function uploadCoreAsync(opts) {
         "workerConfig.js",
         "multi.html",
         "asseteditor.html",
-        "skillmap.html"
+        "skillmap.html",
+        "authcode.html"
     ];
     // expandHtml is manually called on these files before upload
     // runs <!-- @include --> substitutions, fills in locale, etc
     let expandFiles = [
         "index.html",
-        "skillmap.html"
+        "skillmap.html",
+        "authcode.html"
     ];
     nodeutil.mkdirP("built/uploadrepl");
     function encodeURLs(urls) {
@@ -157735,7 +157853,7 @@ async function buildSemanticUIAsync(parsed) {
             ]
         });
     }
-    // Generate react-common css for skillmap
+    // Generate react-common css for skillmap and authcode
     const skillmapFile = isPxtCore ? "react-common/styles/react-common-skillmap-core.less" :
         "node_modules/pxt-core/react-common/styles/react-common-skillmap.less";
     await nodeutil.spawnAsync({
@@ -157747,6 +157865,17 @@ async function buildSemanticUIAsync(parsed) {
             "--include-path=" + lessIncludePaths
         ]
     });
+    const authcodeFile = isPxtCore ? "react-common/styles/react-common-authcode-core.less" :
+        "node_modules/pxt-core/react-common/styles/react-common-authcode.less";
+    await nodeutil.spawnAsync({
+        cmd: "node",
+        args: [
+            lessCPath,
+            authcodeFile,
+            "built/web/react-common-authcode.css",
+            "--include-path=" + lessIncludePaths
+        ]
+    });
     let skillmapCss = await readFileAsync(`built/web/react-common-skillmap.css`, "utf8");
     skillmapCss = await linkFontAsync("fa-solid-900", skillmapCss, fontAwesomeSource, "\\.\\.\\/webfonts\\/");
     skillmapCss = await linkFontAsync("fa-regular-400", skillmapCss, fontAwesomeSource, "\\.\\.\\/webfonts\\/");
@@ -157840,6 +157969,31 @@ function buildSkillMapAsync(parsed) {
         });
     });
 }
+function buildAuthcodeAsync(parsed) {
+    // local serve
+    const appRoot = "node_modules/pxt-core/authcode";
+    return rimrafAsync(`${appRoot}/public/blb`, {})
+        .then(() => rimrafAsync(`${appRoot}/build/assets`, {}))
+        .then(() => rimrafAsync(`${appRoot}/public/docs`, {}))
+        .then(() => rimrafAsync(`${appRoot}/public/static`, {}))
+        .then(() => {
+        // read pxtarget.json, save into 'pxtTargetBundle' global variable
+        let cfg = readLocalPxTarget();
+        nodeutil.writeFileSync(`${appRoot}/public/blb/target.js`, "// eslint-disable-next-line \n" + targetJsPrefix + JSON.stringify(cfg));
+        nodeutil.cp("node_modules/pxt-core/built/pxtlib.js", `${appRoot}/public/blb`);
+        nodeutil.cp("built/web/semantic.css", `${appRoot}/public/blb`);
+        nodeutil.cp("node_modules/pxt-core/built/web/icons.css", `${appRoot}/public/blb`);
+        nodeutil.cp("node_modules/pxt-core/built/web/react-common-authcode.css", `${appRoot}/public/blb`);
+        // copy 'assets' over from docs/static
+        nodeutil.cpR("docs/static/authcode/assets", `${appRoot}/public/assets`);
+        return nodeutil.spawnAsync({
+            cmd: os.platform() === "win32" ? "npm.cmd" : "npm",
+            args: ["run-script", "start"],
+            cwd: appRoot,
+            shell: true
+        });
+    });
+}
 function updateDefaultProjects(cfg) {
     let defaultProjects = [
         pxt.BLOCKS_PROJECT_NAME,
@@ -158742,7 +158896,7 @@ function installPackageNameAsync(packageName) {
         return pxt.packagesConfigAsync()
             .then(config => (parsed.tag ? Promise.resolve(parsed.tag) : pxt.github.latestVersionAsync(parsed.slug, config))
             .then(tag => { parsed.tag = tag; })
-            .then(() => pxt.github.pkgConfigAsync(parsed.fullName, parsed.tag))
+            .then(() => pxt.github.pkgConfigAsync(parsed.fullName, parsed.tag, config))
             .then(cfg => mainPkg.loadAsync(true)
             .then(() => {
             let ver = pxt.github.stringifyRepo(parsed);
@@ -162202,6 +162356,17 @@ ${pxt.crowdin.KEY_VARIABLE} - crowdin key
             }
         }
     }, buildSkillMapAsync);
+    p.defineCommand({
+        name: "buildauthcode",
+        aliases: ["authcode"],
+        advanced: true,
+        help: "Serves the authcode webapp",
+        flags: {
+            serve: {
+                description: "Serve the authcode app locally after building (npm start)"
+            }
+        }
+    }, buildAuthcodeAsync);
     advancedCommand("augmentdocs", "test markdown docs replacements", augmnetDocsAsync, "<temlate.md> <doc.md>");
     advancedCommand("crowdin", "upload, download, clean, stats files to/from crowdin", pc => crowdin.execCrowdinAsync.apply(undefined, pc.args), "<cmd> <path> [output]");
     advancedCommand("hidlist", "list HID devices", hid.listAsync);