pxt-core 13.2.14 → 13.2.15

package/built/backendutils.js

@@ -119,6 +119,14 @@ var pxtc = ts.pxtc;
     (function (pxtc) {
         var Util;
         (function (Util) {
+            function contains(str, contains) {
+                if (str.length < contains.length)
+                    return false;
+                if (contains.length == 0)
+                    return true;
+                return str.indexOf(contains) > -1;
+            }
+            Util.contains = contains;
             function assert(cond, msg = "Assertion failed") {
                 if (!cond) {
                     debugger;
@@ -469,10 +477,180 @@ var pxtc = ts.pxtc;
     })(pxtc = ts.pxtc || (ts.pxtc = {}));
 })(ts || (ts = {}));
 const lf = ts.pxtc.Util.lf;
-/// <reference path='../localtypings/pxtarget.d.ts' />
-/// <reference path='../localtypings/dompurify.d.ts' />
-/// <reference path="commonutil.ts"/>
-/// <reference path="./logger.ts" />
+(function (ts) {
+    var pxtc;
+    (function (pxtc) {
+        /**
+         * atob replacement
+         * @param s
+         */
+        pxtc.decodeBase64 = function (s) { return atob(s); };
+        /**
+         * bota replacement
+         * @param s
+         */
+        pxtc.encodeBase64 = function (s) { return btoa(s); };
+    })(pxtc = ts.pxtc || (ts.pxtc = {}));
+})(ts || (ts = {}));
+(function (ts) {
+    var pxtc;
+    (function (pxtc) {
+        var Util;
+        (function (Util) {
+            function iterMap(m, f) {
+                Object.keys(m).forEach(k => f(k, m[k]));
+            }
+            Util.iterMap = iterMap;
+            function values(m) {
+                return Object.keys(m || {}).map(k => m[k]);
+            }
+            Util.values = values;
+            function pushRange(trg, src) {
+                if (src)
+                    for (let i = 0; i < src.length; ++i)
+                        trg.push(src[i]);
+            }
+            Util.pushRange = pushRange;
+            // TS gets lost in type inference when this is passed an array
+            function concatArrayLike(arrays) {
+                return concat(arrays);
+            }
+            Util.concatArrayLike = concatArrayLike;
+            function concat(arrays) {
+                let r = [];
+                for (let i = 0; i < arrays.length; ++i) {
+                    pushRange(r, arrays[i]);
+                }
+                return r;
+            }
+            Util.concat = concat;
+            function isKV(v) {
+                return !!v && typeof v === "object" && !Array.isArray(v);
+            }
+            function jsonMergeFrom(trg, src) {
+                if (!src)
+                    return;
+                Object.keys(src).forEach(k => {
+                    if (isKV(trg[k]) && isKV(src[k]))
+                        jsonMergeFrom(trg[k], src[k]);
+                    else
+                        trg[k] = Util.clone(src[k]);
+                });
+            }
+            Util.jsonMergeFrom = jsonMergeFrom;
+            function jsonCopyFrom(trg, src) {
+                let v = Util.clone(src);
+                for (let k of Object.keys(src)) {
+                    trg[k] = v[k];
+                }
+            }
+            Util.jsonCopyFrom = jsonCopyFrom;
+            // { a: { b: 1 }, c: 2} => { "a.b": 1, c: 2 }
+            function jsonFlatten(v) {
+                let res = {};
+                let loop = (pref, v) => {
+                    if (v !== null && typeof v == "object") {
+                        Util.assert(!Array.isArray(v));
+                        if (pref)
+                            pref += ".";
+                        for (let k of Object.keys(v)) {
+                            loop(pref + k, v[k]);
+                        }
+                    }
+                    else {
+                        res[pref] = v;
+                    }
+                };
+                loop("", v);
+                return res;
+            }
+            Util.jsonFlatten = jsonFlatten;
+            function jsonUnFlatten(v) {
+                let res = {};
+                for (let k of Object.keys(v)) {
+                    let ptr = res;
+                    let parts = k.split(".");
+                    for (let i = 0; i < parts.length; ++i) {
+                        let part = parts[i];
+                        if (i == parts.length - 1)
+                            ptr[part] = v[k];
+                        else {
+                            if (typeof ptr[part] != "object")
+                                ptr[part] = {};
+                            ptr = ptr[part];
+                        }
+                    }
+                }
+                return res;
+            }
+            Util.jsonUnFlatten = jsonUnFlatten;
+            function strcmp(a, b) {
+                if (a == b)
+                    return 0;
+                if (a < b)
+                    return -1;
+                else
+                    return 1;
+            }
+            Util.strcmp = strcmp;
+            function endsWith(str, suffix) {
+                if (str.length < suffix.length)
+                    return false;
+                if (suffix.length == 0)
+                    return true;
+                return str.slice(-suffix.length) == suffix;
+            }
+            Util.endsWith = endsWith;
+            function startsWith(str, prefix) {
+                if (str.length < prefix.length)
+                    return false;
+                if (prefix.length == 0)
+                    return true;
+                return str.slice(0, prefix.length) == prefix;
+            }
+            Util.startsWith = startsWith;
+            function toUTF8(str, cesu8) {
+                let res = "";
+                if (!str)
+                    return res;
+                for (let i = 0; i < str.length; ++i) {
+                    let code = str.charCodeAt(i);
+                    if (code <= 0x7f)
+                        res += str.charAt(i);
+                    else if (code <= 0x7ff) {
+                        res += String.fromCharCode(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+                    }
+                    else {
+                        if (!cesu8 && 0xd800 <= code && code <= 0xdbff) {
+                            let next = str.charCodeAt(++i);
+                            if (!isNaN(next))
+                                code = 0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00);
+                        }
+                        if (code <= 0xffff)
+                            res += String.fromCharCode(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+                        else
+                            res += String.fromCharCode(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+                    }
+                }
+                return res;
+            }
+            Util.toUTF8 = toUTF8;
+            function toUTF8Array(s) {
+                return (new TextEncoder()).encode(s);
+            }
+            Util.toUTF8Array = toUTF8Array;
+        })(Util = pxtc.Util || (pxtc.Util = {}));
+    })(pxtc = ts.pxtc || (ts.pxtc = {}));
+})(ts || (ts = {}));
+var pxt;
+(function (pxt) {
+    pxt.U = pxtc.Util;
+    pxt.Util = pxtc.Util;
+})(pxt || (pxt = {}));
+/// <reference path='../../localtypings/pxtarget.d.ts' />
+/// <reference path='../../localtypings/dompurify.d.ts' />
+/// <reference path="../commonutil.ts"/>
+/// <reference path="../logger.ts" />
 var pxt;
 (function (pxt) {
     var docs;
@@ -1617,5 +1795,1993 @@ My links
         docs.hydrateYouTubeEmbeds = hydrateYouTubeEmbeds;
     })(docs = pxt.docs || (pxt.docs = {}));
 })(pxt || (pxt = {}));
-/// <reference path="../pxtlib/docsrender.ts"/>
+/// <reference path="../commonutil.ts"/>
+var ts;
+(function (ts) {
+    var pxtc;
+    (function (pxtc) {
+        var BrowserImpl;
+        (function (BrowserImpl) {
+            function rotr(v, b) {
+                return (v >>> b) | (v << (32 - b));
+            }
+            const sha256_k = new Uint32Array([
+                0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+                0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+                0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+                0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+                0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+                0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+                0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+                0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+            ]);
+            function sha256round(hs, w) {
+                pxtc.Util.assert(hs.length == 8);
+                pxtc.Util.assert(w.length == 64);
+                for (let i = 16; i < 64; ++i) {
+                    let s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+                    let s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+                    w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+                }
+                let a = hs[0];
+                let b = hs[1];
+                let c = hs[2];
+                let d = hs[3];
+                let e = hs[4];
+                let f = hs[5];
+                let g = hs[6];
+                let h = hs[7];
+                for (let i = 0; i < 64; ++i) {
+                    let s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+                    let ch = (e & f) ^ (~e & g);
+                    let temp1 = (h + s1 + ch + sha256_k[i] + w[i]) | 0;
+                    let s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+                    let maj = (a & b) ^ (a & c) ^ (b & c);
+                    let temp2 = (s0 + maj) | 0;
+                    h = g;
+                    g = f;
+                    f = e;
+                    e = (d + temp1) | 0;
+                    d = c;
+                    c = b;
+                    b = a;
+                    a = (temp1 + temp2) | 0;
+                }
+                hs[0] += a;
+                hs[1] += b;
+                hs[2] += c;
+                hs[3] += d;
+                hs[4] += e;
+                hs[5] += f;
+                hs[6] += g;
+                hs[7] += h;
+            }
+            function sha256buffer(buf) {
+                let h = new Uint32Array(8);
+                h[0] = 0x6a09e667;
+                h[1] = 0xbb67ae85;
+                h[2] = 0x3c6ef372;
+                h[3] = 0xa54ff53a;
+                h[4] = 0x510e527f;
+                h[5] = 0x9b05688c;
+                h[6] = 0x1f83d9ab;
+                h[7] = 0x5be0cd19;
+                let work = new Uint32Array(64);
+                let chunkLen = 16 * 4;
+                function addBuf(buf) {
+                    let end = buf.length - (chunkLen - 1);
+                    for (let i = 0; i < end; i += chunkLen) {
+                        for (let j = 0; j < 16; j++) {
+                            let off = (j << 2) + i;
+                            work[j] = (buf[off] << 24) | (buf[off + 1] << 16) | (buf[off + 2] << 8) | buf[off + 3];
+                        }
+                        sha256round(h, work);
+                    }
+                }
+                addBuf(buf);
+                let padSize = 64 - (buf.length + 9) % 64;
+                if (padSize == 64)
+                    padSize = 0;
+                let endPos = buf.length - (buf.length % chunkLen);
+                let padBuf = new Uint8Array((buf.length - endPos) + 1 + padSize + 8);
+                let dst = 0;
+                while (endPos < buf.length)
+                    padBuf[dst++] = buf[endPos++];
+                padBuf[dst++] = 0x80;
+                while (padSize-- > 0)
+                    padBuf[dst++] = 0x00;
+                let len = buf.length * 8;
+                dst = padBuf.length;
+                while (len > 0) {
+                    padBuf[--dst] = len & 0xff;
+                    len >>= 8;
+                }
+                addBuf(padBuf);
+                let res = "";
+                for (let i = 0; i < h.length; ++i)
+                    res += ("000000000" + h[i].toString(16)).slice(-8);
+                return res.toLowerCase();
+            }
+            BrowserImpl.sha256buffer = sha256buffer;
+        })(BrowserImpl = pxtc.BrowserImpl || (pxtc.BrowserImpl = {}));
+    })(pxtc = ts.pxtc || (ts.pxtc = {}));
+})(ts || (ts = {}));
+var Measurements;
+(function (Measurements) {
+    Measurements.TutorialInfoDbSetAsync = "tutorial info db setAsync";
+    Measurements.ReloadAppTargetVariant = "reloadAppTargetVariant";
+    Measurements.Sha256Buffer = "sha256buffer";
+    Measurements.WebworkerRecvHandler = "webworker recvHandler";
+    Measurements.NetworkRequest = "network.request";
+})(Measurements || (Measurements = {}));
+/// <reference path="../../localtypings/pxtpackage.d.ts"/>
+/// <reference path="../commonutil.ts"/>
+var pxt;
+(function (pxt) {
+    var packageUtils;
+    (function (packageUtils) {
+        var U = pxtc.Util;
+        function getVersionProtocol(version) {
+            const separator = version.indexOf(":");
+            return separator < 0 ? "" : version.slice(0, separator);
+        }
+        packageUtils.getVersionProtocol = getVersionProtocol;
+        function isVariantDisabled(config, variant) {
+            return !!config && !!config.disablesVariants && config.disablesVariants.indexOf(variant) >= 0;
+        }
+        packageUtils.isVariantDisabled = isVariantDisabled;
+        function getConfigDependencies(config, includeTests, includeCpp, isTestDependencyAvailable) {
+            if (!config)
+                return {};
+            const dependencies = Object.assign({}, config.dependencies);
+            if (includeTests) {
+                for (const id of Object.keys(config.testDependencies || {})) {
+                    const version = config.testDependencies[id];
+                    if (isTestDependencyAvailable(id, version))
+                        dependencies[id] = version;
+                }
+            }
+            if (includeCpp)
+                U.jsonMergeFrom(dependencies, config.cppDependencies);
+            return dependencies;
+        }
+        packageUtils.getConfigDependencies = getConfigDependencies;
+        /** Evaluates fileDependencies with && taking precedence over ||, without reading target or package globals. */
+        function evaluateDependencyCondition(condition, target, hasDependency, onInvalidCondition) {
+            if (!condition || !condition.trim())
+                return true;
+            const evaluate = (term) => {
+                term = term.trim();
+                if (term[0] == "!")
+                    return !evaluate(term.slice(1));
+                if (/^[\w-]+$/.test(term))
+                    return hasDependency(term);
+                const match = /^target:(\w+)$/.exec(term);
+                if (match)
+                    return match[1] == target.id || match[1] == target.platformid;
+                onInvalidCondition(term);
+                return false;
+            };
+            return condition.split("||").some(c => c.split("&&").every(evaluate));
+        }
+        packageUtils.evaluateDependencyCondition = evaluateDependencyCondition;
+        function getConfigFiles(config, includeTests, target, hasDependency, onInvalidCondition) {
+            const files = config.files.concat(includeTests ? config.testFiles || [] : []);
+            if (!config.fileDependencies)
+                return files;
+            return files.filter(filename => evaluateDependencyCondition(U.lookup(config.fileDependencies, filename), target, hasDependency, condition => onInvalidCondition(condition, filename)));
+        }
+        packageUtils.getConfigFiles = getConfigFiles;
+    })(packageUtils = pxt.packageUtils || (pxt.packageUtils = {}));
+})(pxt || (pxt = {}));
+/// <reference path="../../localtypings/pxtarget.d.ts"/>
+/// <reference path="../commonutil.ts"/>
+var pxt;
+(function (pxt) {
+    /** Resolves compile defaults and a variant without modifying the supplied target. */
+    function getAppTargetVariant(target, variant) {
+        const result = pxt.U.cloneTargetBundle(target);
+        if (variant) {
+            const overrides = result.variants && result.variants[variant];
+            if (!overrides)
+                pxt.U.userError(pxt.U.lf("Variant '{0}' not defined in pxtarget.json", variant));
+            pxt.U.jsonMergeFrom(result, overrides);
+        }
+        patchCompileTarget(result);
+        return result;
+    }
+    pxt.getAppTargetVariant = getAppTargetVariant;
+    function patchCompileTarget(target) {
+        let comp = target.compile;
+        if (!comp)
+            comp = target.compile = { isNative: false, hasHex: false, switches: {} };
+        if (comp.hasHex) {
+            if (!comp.nativeType)
+                comp.nativeType = pxtc.NATIVE_TYPE_THUMB;
+        }
+        if (!comp.switches)
+            comp.switches = {};
+        if (comp.nativeType == pxtc.NATIVE_TYPE_VM)
+            comp.sourceMap = true;
+        // JS ref counting currently not supported
+        comp.jsRefCounting = false;
+        if (!comp.useUF2 && !comp.useELF && comp.noSourceInFlash == undefined)
+            comp.noSourceInFlash = true; // no point putting sources in hex to be flashed
+        if (comp.utf8 === undefined)
+            comp.utf8 = true;
+        let cs = target.compileService;
+        if (cs) {
+            if (cs.yottaTarget && !cs.yottaBinary)
+                cs.yottaBinary = "pxt-microbit-app-combined.hex";
+        }
+    }
+    pxt.patchCompileTarget = patchCompileTarget;
+})(pxt || (pxt = {}));
+var ts;
+(function (ts) {
+    var pxtc;
+    (function (pxtc) {
+        var Util;
+        (function (Util) {
+            function cloneTargetBundle(target) {
+                target = Object.assign({}, target);
+                const apiInfo = target.apiInfo;
+                delete target.apiInfo;
+                const bundleddirs = target.bundleddirs;
+                delete target.bundleddirs;
+                const bundledpkgs = target.bundledpkgs;
+                delete target.bundledpkgs;
+                const tutorialInfo = target.tutorialInfo;
+                delete target.tutorialInfo;
+                const res = Util.clone(target);
+                if (apiInfo) {
+                    res.apiInfo = {};
+                    for (const key of Object.keys(apiInfo)) {
+                        const apis = apiInfo[key].apis;
+                        res.apiInfo[key] = {
+                            sha: apiInfo[key].sha,
+                            apis: {
+                                jres: Object.assign({}, apis.jres),
+                                byQName: cloneApis(apis.byQName)
+                            }
+                        };
+                    }
+                }
+                if (bundleddirs) {
+                    res.bundleddirs = [...bundleddirs];
+                }
+                if (bundledpkgs) {
+                    res.bundledpkgs = {};
+                    for (const key of Object.keys(bundledpkgs)) {
+                        res.bundledpkgs[key] = Object.assign({}, bundledpkgs[key]);
+                    }
+                }
+                if (tutorialInfo) {
+                    res.tutorialInfo = {};
+                    for (const key of Object.keys(tutorialInfo)) {
+                        const built = tutorialInfo[key];
+                        res.tutorialInfo[key] = {
+                            hash: built.hash,
+                            usedBlocks: Object.assign({}, built.usedBlocks),
+                            snippetBlocks: Object.assign({}, built.snippetBlocks),
+                            highlightBlocks: Object.assign({}, built.highlightBlocks),
+                            validateBlocks: Object.assign({}, built.validateBlocks),
+                        };
+                    }
+                }
+                return res;
+            }
+            Util.cloneTargetBundle = cloneTargetBundle;
+            function cloneApis(byQName) {
+                const res = {};
+                for (const key of Object.keys(byQName)) {
+                    res[key] = cloneSymbolInfo(byQName[key]);
+                }
+                return res;
+            }
+            Util.cloneApis = cloneApis;
+            function cloneSymbolInfo(sym) {
+                var _a;
+                return {
+                    // FIXME: This is a little dangerous, because we do edit the symbol attributes in some places
+                    // for localization. However, most of those edits are to top-level properties and only edits
+                    // to child objects matter so it *should* be fine
+                    attributes: Object.assign({}, sym.attributes),
+                    parameters: (_a = sym.parameters) === null || _a === void 0 ? void 0 : _a.map(cloneParameterDesc),
+                    extendsTypes: sym.extendsTypes ? [...sym.extendsTypes] : undefined,
+                    pkgs: sym.pkgs ? [...sym.pkgs] : undefined,
+                    combinedProperties: sym.combinedProperties ? [...sym.combinedProperties] : undefined,
+                    name: sym.name,
+                    namespace: sym.namespace,
+                    fileName: sym.fileName,
+                    kind: sym.kind,
+                    retType: sym.retType,
+                    isInstance: sym.isInstance,
+                    isContextual: sym.isContextual,
+                    qName: sym.qName,
+                    pkg: sym.pkg,
+                    snippet: sym.snippet,
+                    snippetName: sym.snippetName,
+                    snippetWithMarkers: sym.snippetWithMarkers,
+                    pySnippet: sym.pySnippet,
+                    pySnippetName: sym.pySnippetName,
+                    pySnippetWithMarkers: sym.pySnippetWithMarkers,
+                    blockFields: sym.blockFields,
+                    isReadOnly: sym.isReadOnly,
+                    pyName: sym.pyName,
+                    pyQName: sym.pyQName,
+                    snippetAddsDefinitions: sym.snippetAddsDefinitions,
+                };
+            }
+            Util.cloneSymbolInfo = cloneSymbolInfo;
+            function cloneParameterDesc(param) {
+                var _a, _b;
+                return {
+                    name: param.name,
+                    description: param.description,
+                    type: param.type,
+                    pyTypeString: param.pyTypeString,
+                    initializer: param.initializer,
+                    default: param.default,
+                    properties: (_a = param.properties) === null || _a === void 0 ? void 0 : _a.map(clonePropertyDesc),
+                    handlerParameters: (_b = param.handlerParameters) === null || _b === void 0 ? void 0 : _b.map(clonePropertyDesc),
+                    options: param.options ? Util.clone(param.options) : undefined,
+                    isEnum: param.isEnum
+                };
+            }
+            function clonePropertyDesc(prop) {
+                return {
+                    name: prop.name,
+                    type: prop.type
+                };
+            }
+        })(Util = pxtc.Util || (pxtc.Util = {}));
+    })(pxtc = ts.pxtc || (ts.pxtc = {}));
+})(ts || (ts = {}));
+/// <reference path="../commonutil.ts"/>
+var ts;
+(function (ts) {
+    var pxtc;
+    (function (pxtc) {
+        var U = pxtc.Util;
+        const numberAttributes = [
+            "weight",
+            "imageLiteral",
+            "gridLiteral",
+            "colorGridLiteral",
+            "topblockWeight",
+            "inlineInputModeLimit",
+            "gridLiteralVerticalSpacing",
+            "gridLiteralHorizontalSpacing",
+            "gridLiteralBorderRadius",
+        ];
+        const booleanAttributes = [
+            "advanced",
+            "handlerStatement",
+            "forceStatement",
+            "afterOnStart",
+            "optionalVariableArgs",
+            "blockHidden",
+            "constantShim",
+            "blockCombine",
+            "enumIsBitMask",
+            "enumIsHash",
+            "decompileIndirectFixedInstances",
+            "topblock",
+            "callInDebugger",
+            "duplicateShadowOnDrag",
+            "argsNullable",
+            "compileHiddenArguments",
+            "expandArgumentsInToolbox",
+            "gridLiteralUseProjectPalette"
+        ];
+        function parseCommentString(cmt) {
+            let res = {
+                paramDefl: {},
+                callingConvention: 0 /* ir.CallingConvention.Plain */,
+                _source: cmt
+            };
+            let didSomething = true;
+            while (didSomething) {
+                didSomething = false;
+                cmt = cmt.replace(/\/\/%[ \t]*([\w\.-]+)(=(("[^"\n]*")|'([^'\n]*)'|([^\s]*)))?/, (f, n, d0, d1, v0, v1, v2) => {
+                    let v = v0 ? JSON.parse(v0) : (d0 ? (v0 || v1 || v2) : "true");
+                    if (!v)
+                        v = "";
+                    if (U.startsWith(n, "block.loc.")) {
+                        if (!res.locs)
+                            res.locs = {};
+                        res.locs[n.slice("block.loc.".length).toLowerCase() + "|block"] = v;
+                    }
+                    else if (U.startsWith(n, "jsdoc.loc.")) {
+                        if (!res.locs)
+                            res.locs = {};
+                        res.locs[n.slice("jsdoc.loc.".length).toLowerCase() + "|jsdoc"] = v;
+                    }
+                    else if (U.startsWith(n, "ariaLabel.loc.")) {
+                        if (!res.locs)
+                            res.locs = {};
+                        res.locs[n.slice("ariaLabel.loc.".length).toLowerCase() + "|ariaLabel"] = v;
+                    }
+                    else if (U.contains(n, ".loc.")) {
+                        if (!res.locs)
+                            res.locs = {};
+                        const p = n.slice(0, n.indexOf('.loc.'));
+                        const l = n.slice(n.indexOf('.loc.') + '.loc.'.length);
+                        res.locs[l + "|param|" + p] = v;
+                    }
+                    else if (U.endsWith(n, ".defl")) {
+                        if (v.indexOf(" ") > -1) {
+                            res.paramDefl[n.slice(0, n.length - 5)] = `"${v}"`;
+                        }
+                        else {
+                            res.paramDefl[n.slice(0, n.length - 5)] = v;
+                        }
+                        if (!res.explicitDefaults)
+                            res.explicitDefaults = [];
+                        res.explicitDefaults.push(n.slice(0, n.length - 5));
+                    }
+                    else if (U.endsWith(n, ".shadow")) {
+                        if (!res._shadowOverrides)
+                            res._shadowOverrides = {};
+                        res._shadowOverrides[n.slice(0, n.length - 7)] = v;
+                    }
+                    else if (U.endsWith(n, ".snippet")) {
+                        if (!res.paramSnippets)
+                            res.paramSnippets = {};
+                        const paramName = n.slice(0, n.length - 8);
+                        if (!res.paramSnippets[paramName])
+                            res.paramSnippets[paramName] = {};
+                        res.paramSnippets[paramName].ts = v;
+                    }
+                    else if (U.endsWith(n, ".pySnippet")) {
+                        if (!res.paramSnippets)
+                            res.paramSnippets = {};
+                        const paramName = n.slice(0, n.length - 10);
+                        if (!res.paramSnippets[paramName])
+                            res.paramSnippets[paramName] = {};
+                        res.paramSnippets[paramName].python = v;
+                    }
+                    else if (U.endsWith(n, ".fieldEditor")) {
+                        if (!res.paramFieldEditor)
+                            res.paramFieldEditor = {};
+                        res.paramFieldEditor[n.slice(0, n.length - 12)] = v;
+                    }
+                    else if (U.contains(n, ".fieldOptions.")) {
+                        if (!res.paramFieldEditorOptions)
+                            res.paramFieldEditorOptions = {};
+                        const field = n.slice(0, n.indexOf('.fieldOptions.'));
+                        const key = n.slice(n.indexOf('.fieldOptions.') + 14, n.length);
+                        if (!res.paramFieldEditorOptions[field])
+                            res.paramFieldEditorOptions[field] = {};
+                        res.paramFieldEditorOptions[field][key] = v;
+                    }
+                    else if (U.contains(n, ".shadowOptions.")) {
+                        if (!res.paramShadowOptions)
+                            res.paramShadowOptions = {};
+                        const field = n.slice(0, n.indexOf('.shadowOptions.'));
+                        const key = n.slice(n.indexOf('.shadowOptions.') + 15, n.length);
+                        if (!res.paramShadowOptions[field])
+                            res.paramShadowOptions[field] = {};
+                        res.paramShadowOptions[field][key] = v;
+                    }
+                    else if (U.endsWith(n, ".label")) {
+                        if (!res.paramLabels)
+                            res.paramLabels = {};
+                        res.paramLabels[n.slice(0, n.length - 6)] = v;
+                    }
+                    else if (U.endsWith(n, ".min")) {
+                        if (!res.paramMin)
+                            res.paramMin = {};
+                        res.paramMin[n.slice(0, n.length - 4)] = v;
+                    }
+                    else if (U.endsWith(n, ".max")) {
+                        if (!res.paramMax)
+                            res.paramMax = {};
+                        res.paramMax[n.slice(0, n.length - 4)] = v;
+                    }
+                    else {
+                        res[n] = v;
+                    }
+                    didSomething = true;
+                    return "//% ";
+                });
+            }
+            for (let n of numberAttributes) {
+                if (typeof res[n] == "string")
+                    res[n] = parseInt(res[n]);
+            }
+            for (let n of booleanAttributes) {
+                if (typeof res[n] == "string")
+                    res[n] = res[n] == 'true' || res[n] == '1' ? true : false;
+            }
+            if (res.trackArgs) {
+                res.trackArgs = res.trackArgs.split(/[ ,]+/).map(s => parseInt(s) || 0);
+            }
+            if (res.enumInitialMembers) {
+                res.enumInitialMembers = res.enumInitialMembers.split(/[ ,]+/);
+            }
+            if (res.blockExternalInputs && !res.inlineInputMode) {
+                res.inlineInputMode = "external";
+            }
+            res.paramHelp = {};
+            res.jsDoc = "";
+            cmt = cmt.replace(/\/\*\*([^]*?)\*\//g, (full, doccmt) => {
+                doccmt = doccmt.replace(/\n\s*(\*\s*)?/g, "\n");
+                doccmt = doccmt.replace(/^\s*@param\s+(\w+)\s+(.*)$/mg, (full, name, desc) => {
+                    res.paramHelp[name] = desc;
+                    if (!res.paramDefl[name]) {
+                        // these don't add to res.explicitDefaults
+                        let m = /\beg\.?:\s*(.+)/.exec(desc);
+                        if (m && m[1]) {
+                            let defaultValue = /(?:"([^"]*)")|(?:'([^']*)')|(?:([^\s,]+))/g.exec(m[1]);
+                            if (defaultValue) {
+                                let val = defaultValue[1] || defaultValue[2] || defaultValue[3];
+                                if (!val)
+                                    val = "";
+                                // If there are spaces in the value, it means the value was surrounded with quotes, so add them back
+                                if (val.indexOf(" ") > -1) {
+                                    res.paramDefl[name] = `"${val}"`;
+                                }
+                                else {
+                                    res.paramDefl[name] = val;
+                                }
+                            }
+                        }
+                    }
+                    return "";
+                });
+                res.jsDoc += doccmt;
+                return "";
+            });
+            res.jsDoc = res.jsDoc.trim();
+            if (res.async)
+                res.callingConvention = 1 /* ir.CallingConvention.Async */;
+            if (res.promise)
+                res.callingConvention = 2 /* ir.CallingConvention.Promise */;
+            if (res.jres)
+                res.whenUsed = true;
+            if (res.subcategories) {
+                try {
+                    res.subcategories = JSON.parse(res.subcategories);
+                }
+                catch (e) {
+                    res.subcategories = undefined;
+                }
+            }
+            if (res.groups) {
+                try {
+                    res.groups = JSON.parse(res.groups);
+                }
+                catch (e) {
+                    res.groups = undefined;
+                }
+            }
+            if (res.groupIcons) {
+                try {
+                    res.groupIcons = JSON.parse(res.groupIcons);
+                }
+                catch (e) {
+                    res.groupIcons = undefined;
+                }
+            }
+            if (res.groupHelp) {
+                try {
+                    res.groupHelp = JSON.parse(res.groupHelp);
+                }
+                catch (e) {
+                    res.groupHelp = undefined;
+                }
+            }
+            updateBlockDef(res);
+            return res;
+        }
+        pxtc.parseCommentString = parseCommentString;
+        function updateBlockDef(attrs) {
+            if (attrs.block) {
+                const parts = attrs.block.split("||");
+                attrs._def = applyOverrides(parseBlockDefinition(parts[0]));
+                if (!attrs._def)
+                    pxt.debug("Unable to parse block def for id: " + attrs.blockId);
+                if (parts[1])
+                    attrs._expandedDef = applyOverrides(parseBlockDefinition(parts[1]));
+                if (parts[1] && !attrs._expandedDef)
+                    pxt.debug("Unable to parse expanded block def for id: " + attrs.blockId);
+            }
+            function applyOverrides(def) {
+                if (attrs._shadowOverrides) {
+                    def.parameters.forEach(p => {
+                        const shadow = attrs._shadowOverrides[p.name];
+                        if (shadow === "unset")
+                            delete p.shadowBlockId;
+                        else if (shadow != null)
+                            p.shadowBlockId = shadow;
+                    });
+                }
+                return def;
+            }
+        }
+        pxtc.updateBlockDef = updateBlockDef;
+        function parseBlockDefinition(def) {
+            const tokens = [];
+            let currentWord;
+            let strIndex = 0;
+            for (; strIndex < def.length; strIndex++) {
+                const char = def[strIndex];
+                const restoreIndex = strIndex;
+                let newToken;
+                switch (char) {
+                    case "*":
+                    case "_":
+                        const tk = eatToken(c => c == char);
+                        const offset = char === "_" ? 2 : 0;
+                        if (tk.length === 1)
+                            newToken = { kind: 1 /* TokenKind.SingleAsterisk */ << offset, content: tk };
+                        else if (tk.length === 2)
+                            newToken = { kind: 2 /* TokenKind.DoubleAsterisk */ << offset, content: tk };
+                        else if (tk.length === 3)
+                            newToken = { kind: 3 /* TokenKind.TripleAsterisk */ << offset, content: tk };
+                        else
+                            strIndex = restoreIndex; // error: no more than three style marks
+                        break;
+                    case "`":
+                        const image = eatEnclosure("`");
+                        if (image === undefined) {
+                            strIndex = restoreIndex; // error: not terminated
+                            break;
+                        }
+                        newToken = { kind: 256 /* TokenKind.Image */, content: image };
+                        break;
+                    case "|":
+                        newToken = { kind: 32 /* TokenKind.Pipe */ };
+                        break;
+                    case "\\":
+                        if (strIndex < (def.length - 1))
+                            newToken = { kind: 16 /* TokenKind.Escape */, content: def[1 + (strIndex++)] };
+                        break;
+                    case "[":
+                        const contentText = eatEnclosure("]");
+                        if (contentText !== undefined && def[strIndex++ + 1] === "(") {
+                            const contentClass = eatEnclosure(")");
+                            if (contentClass !== undefined) {
+                                newToken = { kind: 512 /* TokenKind.TaggedText */, content: contentText, type: contentClass };
+                                break;
+                            }
+                        }
+                        strIndex = restoreIndex; // error: format should be [text](class)
+                        break;
+                    case "$":
+                    case "%":
+                        const param = eatToken(c => /[a-zA-Z0-9_=]/.test(c), true).split("=");
+                        if (param.length > 2) {
+                            strIndex = restoreIndex; // error: too many equals signs
+                            break;
+                        }
+                        let varName;
+                        if (def[strIndex + 1] === "(") {
+                            const oldIndex = strIndex;
+                            ++strIndex;
+                            varName = eatEnclosure(")");
+                            if (!varName)
+                                strIndex = oldIndex;
+                        }
+                        newToken = { kind: (char === "$") ? 1024 /* TokenKind.ParamRef */ : 64 /* TokenKind.Parameter */, content: param[0], type: param[1], name: varName };
+                        break;
+                }
+                if (newToken) {
+                    if (currentWord)
+                        tokens.push({ kind: 128 /* TokenKind.Word */, content: currentWord });
+                    currentWord = undefined;
+                    tokens.push(newToken);
+                }
+                else if (!currentWord) {
+                    currentWord = char;
+                }
+                else {
+                    currentWord += char;
+                }
+            }
+            if (currentWord)
+                tokens.push({ kind: 128 /* TokenKind.Word */, content: currentWord });
+            const parts = [];
+            const parameters = [];
+            let stack = [];
+            let open = 0;
+            let currentLabel = "";
+            let labelStack = [];
+            for (let i = 0; i < tokens.length; i++) {
+                const token = tokens[i].kind;
+                const top = stack[stack.length - 1];
+                if (token & 15 /* TokenKind.StyleMarks */) {
+                    pushCurrentLabel(tokens[i].content);
+                    if (token & open) {
+                        if (top & token) {
+                            stack.pop();
+                            open ^= token;
+                            // Handle triple tokens
+                            const remainder = (top & open) | (token & open);
+                            if (remainder) {
+                                stack.push(remainder);
+                            }
+                        }
+                        else {
+                            // We encountered a mismatched mark, so clear previous styles
+                            collapseLabels();
+                        }
+                    }
+                    else {
+                        open |= token;
+                        stack.push(token);
+                    }
+                }
+                else if (token & 144 /* TokenKind.Text */) {
+                    currentLabel += tokens[i].content;
+                }
+                else if (token & 1120 /* TokenKind.Unstylable */) {
+                    pushLabels();
+                }
+                if (token == 64 /* TokenKind.Parameter */) {
+                    const param = { kind: "param", name: tokens[i].content, shadowBlockId: tokens[i].type, ref: false };
+                    if (tokens[i].name)
+                        param.varName = tokens[i].name;
+                    parts.push(param);
+                    parameters.push(param);
+                }
+                else if (token == 1024 /* TokenKind.ParamRef */) {
+                    const param = { kind: "param", name: tokens[i].content, shadowBlockId: tokens[i].type, ref: true };
+                    if (tokens[i].name)
+                        param.varName = tokens[i].name;
+                    parts.push(param);
+                    parameters.push(param);
+                }
+                else if (token == 256 /* TokenKind.Image */) {
+                    pushCurrentLabel();
+                    labelStack.push({ kind: "image", uri: tokens[i].content });
+                }
+                else if (token == 512 /* TokenKind.TaggedText */) {
+                    pushCurrentLabel();
+                    labelStack.push({ kind: "label", text: tokens[i].content, cssClass: tokens[i].type });
+                }
+                else if (token == 32 /* TokenKind.Pipe */) {
+                    parts.push({ kind: "break" });
+                }
+            }
+            pushLabels();
+            return { parts, parameters };
+            function eatToken(pred, skipCurrent = false) {
+                let current = "";
+                if (skipCurrent)
+                    strIndex++;
+                while (strIndex < def.length && pred(def[strIndex])) {
+                    current += def[strIndex];
+                    ++strIndex;
+                }
+                if (current)
+                    strIndex--;
+                return current;
+            }
+            function eatEnclosure(endMark) {
+                const content = eatToken(c => c !== endMark, true);
+                if (def[strIndex + 1] !== endMark)
+                    return undefined;
+                ++strIndex;
+                return content;
+            }
+            function collapseLabels() {
+                let combined = "";
+                let newStack = [];
+                for (const item of labelStack) {
+                    if (isBlockPart(item)) {
+                        newStack.push({
+                            content: combined,
+                            styles: 0
+                        });
+                        newStack.push(item);
+                        combined = "";
+                    }
+                    else {
+                        combined += item.content;
+                        if (item.endingToken) {
+                            combined += item.endingToken;
+                        }
+                    }
+                }
+                labelStack = newStack;
+                if (combined) {
+                    labelStack.push({
+                        content: combined,
+                        styles: 0
+                    });
+                }
+                // Clear the style state as well
+                stack = [];
+                open = 0;
+            }
+            function pushLabels() {
+                pushCurrentLabel();
+                if (open) {
+                    collapseLabels();
+                }
+                while (labelStack.length) {
+                    const label = labelStack.shift();
+                    if (isBlockPart(label)) {
+                        parts.push(label);
+                    }
+                    else {
+                        if (!label.content)
+                            continue;
+                        const styles = [];
+                        if (label.styles & 10 /* TokenKind.Bold */)
+                            styles.push("bold");
+                        if (label.styles & 5 /* TokenKind.Italics */)
+                            styles.push("italics");
+                        parts.push({ kind: "label", text: label.content, style: styles });
+                    }
+                }
+            }
+            function pushCurrentLabel(endingToken) {
+                labelStack.push({
+                    content: currentLabel,
+                    styles: open,
+                    endingToken
+                });
+                currentLabel = "";
+            }
+        }
+        pxtc.parseBlockDefinition = parseBlockDefinition;
+        function isBlockPart(p) {
+            return !!(p.kind);
+        }
+    })(pxtc = ts.pxtc || (ts.pxtc = {}));
+})(ts || (ts = {}));
+var pxt;
+(function (pxt) {
+    var github;
+    (function (github) {
+        // parse https://github.com/[company]/[project](/filepath)(#tag)
+        function parseRepoId(repo) {
+            if (!repo)
+                return undefined;
+            // clean out whitespaces
+            repo = repo.trim();
+            // trim trailing /
+            repo = repo.replace(/\/$/, '');
+            // convert github pages into github repo
+            const mgh = /^https:\/\/([^./#]+)\.github\.io\/([^/#]+)\/?$/i.exec(repo);
+            if (mgh)
+                repo = `github:${mgh[1]}/${mgh[2]}`;
+            repo = repo.replace(/^github:/i, "");
+            repo = repo.replace(/^https:\/\/github\.com\//i, "");
+            repo = repo.replace(/\.git\b/i, "");
+            const m = /^([^#\/:]+)\/([^#\/:]+)(\/([^#]+))?(#([^\/:]*))?$/.exec(repo);
+            if (!m)
+                return undefined;
+            const owner = m[1];
+            const project = m[2];
+            let fileName = m[4];
+            const tag = m[6];
+            const treeM = fileName && /^tree\/([^\/]+\/)/.exec(fileName);
+            if (treeM) {
+                // https://github.com/pelikhan/mono-demo/tree/master/demo2
+                fileName = fileName.slice(treeM[0].length);
+                // branch info?
+            }
+            return {
+                owner,
+                project,
+                slug: join(owner, project),
+                fullName: join(owner, project, fileName),
+                tag,
+                fileName
+            };
+        }
+        github.parseRepoId = parseRepoId;
+        function stringifyRepo(p, ignoreCase = false) {
+            return p ? "github:" + (ignoreCase ? p.fullName : p.fullName.toLowerCase()) + (p.tag ? `#${p.tag}` : '') : undefined;
+        }
+        github.stringifyRepo = stringifyRepo;
+        function join(...parts) {
+            return parts.filter(p => !!p).join('/');
+        }
+        github.join = join;
+    })(github = pxt.github || (pxt.github = {}));
+})(pxt || (pxt = {}));
+/// <reference path="../../localtypings/pxtarget.d.ts"/>
+/// <reference path="../commonutil.ts"/>
+/// <reference path="sha256.ts"/>
+/// <reference path="../constants.ts"/>
+/// <reference path="packageutils.ts"/>
+/// <reference path="targetutils.ts"/>
+/// <reference path="commentattrs.ts"/>
+/// <reference path="githubid.ts"/>
+var ts;
+(function (ts) {
+    var pxtc;
+    (function (pxtc) {
+        pxtc.NATIVE_TYPE_THUMB = "thumb";
+        pxtc.NATIVE_TYPE_VM = "vm";
+        function emptyExtInfo(compileService) {
+            let cs = compileService;
+            if (!cs)
+                cs = {};
+            const pio = !!cs.platformioIni;
+            const docker = cs.buildEngine == "dockermake" || cs.buildEngine == "dockercross" || cs.buildEngine == "dockerespidf";
+            const r = {
+                functions: [],
+                generatedFiles: {},
+                extensionFiles: {},
+                sha: "",
+                compileData: "",
+                shimsDTS: "",
+                enumsDTS: "",
+                onlyPublic: true
+            };
+            if (pio)
+                r.platformio = { dependencies: {} };
+            else if (docker)
+                r.npmDependencies = {};
+            else
+                r.yotta = { config: {}, dependencies: {} };
+            return r;
+        }
+        pxtc.emptyExtInfo = emptyExtInfo;
+    })(pxtc = ts.pxtc || (ts.pxtc = {}));
+})(ts || (ts = {}));
+var pxt;
+(function (pxt) {
+    var cpp;
+    (function (cpp) {
+        var U = pxtc.Util;
+        const lf = U.lf;
+        const vmKeepFunctions = {
+            "pxt::mkAction": 1,
+            "pxt::dumpPerfCounters": 1,
+            "pxt::deepSleep": 1,
+            "pxt::getConfig": 1,
+            "pxtrt::mkMap": 1,
+            "pxtrt::mapSet": 1,
+            "pxtrt::stclo": 1,
+            "pxtrt::mklocRef": 1,
+            "pxtrt::stlocRef": 1,
+            "pxtrt::ldlocRef": 1,
+            "pxtrt::panic": 1,
+        };
+        function nsWriter(nskw = "namespace") {
+            let text = "";
+            let currNs = "";
+            let setNs = (ns, over = "") => {
+                if (currNs == ns)
+                    return;
+                if (currNs)
+                    text += "}\n";
+                if (ns)
+                    text += over || (nskw + " " + ns + " {\n");
+                currNs = ns;
+            };
+            let indent = "    ";
+            return {
+                setNs,
+                clear: () => {
+                    text = "";
+                    currNs = "";
+                },
+                write: (s) => {
+                    if (!s.trim())
+                        text += "\n";
+                    else {
+                        s = s.trim()
+                            .replace(/^\s*/mg, indent)
+                            .replace(/^(\s*)\*/mg, (f, s) => s + " *");
+                        text += s + "\n";
+                    }
+                },
+                incrIndent: () => {
+                    indent += "    ";
+                },
+                decrIndent: () => {
+                    indent = indent.slice(4);
+                },
+                finish: () => {
+                    setNs("");
+                    return text;
+                }
+            };
+        }
+        cpp.nsWriter = nsWriter;
+        function parseCppInt(v) {
+            if (!v)
+                return null;
+            v = v.trim();
+            let mm = /^\((.*)\)/.exec(v);
+            if (mm)
+                v = mm[1];
+            if (/^-?(\d+|0[xX][0-9a-fA-F]+)$/.test(v))
+                return parseInt(v);
+            return null;
+        }
+        cpp.parseCppInt = parseCppInt;
+        class PkgConflictError extends Error {
+            constructor(msg) {
+                super(msg);
+                this.isUserError = true;
+                this.message = msg;
+            }
+        }
+        cpp.PkgConflictError = PkgConflictError;
+        /**
+         * Generates native extension files from pxt.json and project files, with dependencies
+         * under pxt_modules/<directory>/. Dependencies resolve by directory, pxt.json name,
+         * or their prefix before "---".
+         * The target must not have variant overrides applied.
+         * @example getExtensionInfo({ "pxt.json": config, "main.cpp": source }, target, "v2", host)
+         */
+        function getExtensionInfo(files, target, variant, host) {
+            const appTarget = pxt.getAppTargetVariant(target, variant);
+            const constsName = "dal.d.ts";
+            let sourcePath = "/source/";
+            let disabledDeps = "";
+            const packages = {};
+            const runtimePackages = {};
+            const packagePaths = Object.create(null);
+            for (const path of Object.keys(files)) {
+                const match = /^pxt_modules\/([^/]+)\/pxt\.json$/.exec(path);
+                if (!match)
+                    continue;
+                const config = JSON.parse(files[path]);
+                const directory = path.slice(0, -"pxt.json".length);
+                for (const id of [match[1], config.name]) {
+                    if (!id)
+                        continue;
+                    for (const alias of [id, id.replace(/---.*/, "")]) {
+                        const paths = packagePaths[alias] || (packagePaths[alias] = []);
+                        if (paths.indexOf(directory) < 0)
+                            paths.push(directory);
+                    }
+                }
+            }
+            const resolvePath = (id) => {
+                if (id == "this")
+                    return "";
+                const path = "pxt_modules/" + id + "/";
+                if (files[path + "pxt.json"] != null)
+                    return path;
+                const paths = packagePaths[id];
+                if (paths && paths.length > 1)
+                    U.userError(`extension ${id} matches multiple directories: ${paths.join(", ")}`);
+                return paths && paths[0];
+            };
+            const readFile = (pkg, name) => files[pkg.path + name];
+            const dependencies = (pkg) => pxt.packageUtils.getConfigDependencies(pkg.config, pkg.id == "this", false, id => resolvePath(id) != null);
+            const visit = (id, version, runtime) => {
+                const path = resolvePath(id);
+                if (path == null)
+                    U.userError(`extension ${id} is missing pxt.json`);
+                if (runtimePackages[path] || (!runtime && packages[path]))
+                    return;
+                if (runtime)
+                    runtimePackages[path] = true;
+                let pkg = packages[path];
+                if (!pkg) {
+                    const configText = files[path + "pxt.json"];
+                    if (!configText)
+                        U.userError(`extension ${id} is missing pxt.json`);
+                    const config = JSON.parse(configText);
+                    if (!config.dependencies || !Array.isArray(config.files))
+                        U.userError(`Invalid pxt.json in extension ${id}`);
+                    const packageId = path ? path.slice("pxt_modules/".length, -1) : "this";
+                    pkg = packages[path] = { id: packageId, path, config, files: [], version };
+                }
+                const deps = dependencies(pkg);
+                for (const dep of Object.keys(deps))
+                    visit(dep, deps[dep], runtime);
+                for (const dep of Object.keys(pkg.config.cppDependencies || {}))
+                    visit(dep, pkg.config.cppDependencies[dep], false);
+            };
+            visit("this", "file:.", true);
+            const mainPkg = packages[""];
+            const mainPkgDeps = U.values(packages).sort((a, b) => a.id == b.id ? 0 : a.id == "this" ? 1 : b.id == "this" ? -1 : U.strcmp(a.id, b.id));
+            for (const pkg of mainPkgDeps) {
+                pkg.files = pxt.packageUtils.getConfigFiles(pkg.config, pkg == mainPkg, appTarget, id => !!runtimePackages[resolvePath(id)], condition => host.logger.log(`invalid dependency expression: ${condition} in ${pkg.id}`));
+            }
+            const mainDeps = [];
+            const disablesVariant = (pkg) => pxt.packageUtils.isVariantDisabled(pkg.config, variant);
+            for (let pkg of mainPkgDeps) {
+                if (disablesVariant(pkg) ||
+                    Object.keys(dependencies(pkg)).some(id => disablesVariant(packages[resolvePath(id)]))) {
+                    if (disabledDeps)
+                        disabledDeps += ", ";
+                    disabledDeps += pkg.id;
+                    host.logger.debug(`disable variant ${variant} due to ${pkg.id}`);
+                    continue;
+                }
+                mainDeps.push(pkg);
+            }
+            let compileService = appTarget.compileService;
+            if (!compileService)
+                compileService = {
+                    gittag: "none",
+                    serviceId: "nocompile"
+                };
+            compileService = U.clone(compileService);
+            const compile = appTarget.compile;
+            if (mainPkgDeps.some(pkg => pkg.config.utf8))
+                compile.utf8 = true;
+            const key = JSON.stringify({
+                variant: variant || "",
+                targetId: appTarget.id,
+                compile,
+                compileService,
+                mainConfig: mainPkg.config,
+                packages: mainDeps.map(pkg => ({
+                    id: pkg.id,
+                    config: pkg.config,
+                    version: pkg.version,
+                    files: pkg.files.filter(fn => fn == constsName ||
+                        /\.(h|cpp|c|S|s|mk)$/.test(fn) ||
+                        ["Makefile", "sdkconfig.defaults", "CMakeLists.txt"].indexOf(fn) >= 0)
+                        .map(fn => [fn, readFile(pkg, fn)])
+                }))
+            });
+            const prevInfo = host.cache[key];
+            if (prevInfo) {
+                host.logger.debug("Using cached extinfo");
+                const result = U.clone(prevInfo);
+                result.disabledDeps = disabledDeps;
+                return result;
+            }
+            host.logger.debug("Generating new extinfo");
+            const res = pxtc.emptyExtInfo(compileService);
+            res.disabledDeps = disabledDeps;
+            const isPlatformio = !!compileService.platformioIni;
+            const isCodal = compileService.buildEngine == "codal" || compileService.buildEngine == "dockercodal";
+            const isDockerMake = compileService.buildEngine == "dockermake" || compileService.buildEngine == "dockercross";
+            const isEspIdf = compileService.buildEngine == "dockerespidf";
+            const isYotta = !isPlatformio && !isCodal && !isDockerMake && !isEspIdf;
+            const isVM = compile.nativeType == pxtc.NATIVE_TYPE_VM;
+            if (isPlatformio)
+                sourcePath = "/src/";
+            else if (isCodal || isDockerMake)
+                sourcePath = "/pxtapp/";
+            else if (isEspIdf)
+                sourcePath = "/main/";
+            let pxtConfig = "// Configuration defines\n";
+            let pointersInc = "\nPXT_SHIMS_BEGIN\n";
+            let pointerIncPre = "";
+            let abiInc = "";
+            let includesInc = `#include "pxt.h"\n`;
+            let thisErrors = "";
+            let dTsNamespace = "";
+            let err = (s) => thisErrors += `   ${fileName}(${lineNo}): ${s}\n`;
+            let lineNo = 0;
+            let fileName = "";
+            let protos = nsWriter("namespace");
+            let shimsDTS = nsWriter("declare namespace");
+            let enumsDTS = nsWriter("declare namespace");
+            let allErrors = "";
+            let knownEnums = {};
+            let vmVisitedFunctions = {};
+            const enumVals = {
+                "true": "1",
+                "false": "0",
+                "null": "0",
+                "NULL": "0",
+            };
+            // we sometimes append _ to C++ names to avoid name clashes
+            function toJs(name) {
+                return name.trim().replace(/[\_\*]$/, "");
+            }
+            for (const pkg of mainDeps) {
+                if (pkg.files.indexOf(constsName) >= 0) {
+                    const src = readFile(pkg, constsName);
+                    pxt.Util.assert(!!src, `${constsName} not found in ${pkg.id}`);
+                    src.split(/\r?\n/).forEach(ln => {
+                        let m = /^\s*(\w+) = (.*),/.exec(ln);
+                        if (m) {
+                            enumVals[m[1]] = m[2];
+                        }
+                    });
+                }
+                for (const fn of pkg.files) {
+                    if (["Makefile", "sdkconfig.defaults", "CMakeLists.txt"].indexOf(fn) >= 0 || U.endsWith(fn, ".mk")) {
+                        res.generatedFiles["/" + fn] = readFile(pkg, fn);
+                    }
+                }
+            }
+            let hash_if_options = ["0", "false", "PXT_UTF8"];
+            let cpp_options = {};
+            if (compile.switches.boxDebug)
+                cpp_options["PXT_BOX_DEBUG"] = 1;
+            if (compile.utf8)
+                cpp_options["PXT_UTF8"] = 1;
+            if (compile.switches.profile)
+                cpp_options["PXT_PROFILE"] = 1;
+            if (compile.switches.gcDebug)
+                cpp_options["PXT_GC_DEBUG"] = 1;
+            if (compile.switches.numFloat)
+                cpp_options["PXT_USE_FLOAT"] = 1;
+            if (compile.nativeType == pxtc.NATIVE_TYPE_VM)
+                cpp_options["PXT_VM"] = 1;
+            function stripComments(ln) {
+                return ln.replace(/\/\/.*/, "").replace(/\/\*/, "");
+            }
+            let enumVal = 0;
+            let inEnum = false;
+            let currNs = "";
+            let currDocComment = "";
+            let currAttrs = "";
+            let inDocComment = false;
+            function handleComments(ln) {
+                if (inEnum)
+                    return true;
+                if (/^\s*\/\*\*/.test(ln)) {
+                    inDocComment = true;
+                    currDocComment = ln + "\n";
+                    if (/\*\//.test(ln))
+                        inDocComment = false;
+                    return true;
+                }
+                if (inDocComment) {
+                    currDocComment += ln + "\n";
+                    if (/\*\//.test(ln)) {
+                        inDocComment = false;
+                    }
+                    return true;
+                }
+                if (/^\s*\/\/%/.test(ln)) {
+                    currAttrs += ln + "\n";
+                    return true;
+                }
+                return false;
+            }
+            function enterEnum(cpname, brace) {
+                inEnum = true;
+                enumVal = -1;
+                enumsDTS.write("");
+                enumsDTS.write("");
+                if (currAttrs || currDocComment) {
+                    enumsDTS.write(currDocComment);
+                    enumsDTS.write(currAttrs);
+                    currAttrs = "";
+                    currDocComment = "";
+                }
+                enumsDTS.write(`declare const enum ${toJs(cpname)} ${brace}`);
+                knownEnums[cpname] = true;
+            }
+            function processEnumLine(ln) {
+                let lnNC = stripComments(ln);
+                if (inEnum && lnNC.indexOf("}") >= 0) {
+                    inEnum = false;
+                    enumsDTS.write("}");
+                }
+                if (!inEnum)
+                    return;
+                // parse the enum case, with lots of optional stuff (?)
+                let mm = /^\s*(\w+)\s*(=\s*(.*?))?,?\s*$/.exec(lnNC);
+                if (mm) {
+                    let nm = mm[1];
+                    let v = mm[3];
+                    let opt = "";
+                    if (v) {
+                        // user-supplied value
+                        v = v.trim();
+                        let curr = U.lookup(enumVals, v);
+                        if (curr != null) {
+                            opt = "  // " + v;
+                            v = curr;
+                        }
+                        enumVal = parseCppInt(v);
+                        if (enumVal == null)
+                            err("cannot determine value of " + lnNC);
+                    }
+                    else {
+                        // no user-supplied value
+                        enumVal++;
+                        v = enumVal + "";
+                    }
+                    enumsDTS.write(`    ${toJs(nm)} = ${v},${opt}`);
+                }
+                else {
+                    enumsDTS.write(ln);
+                }
+            }
+            function finishNamespace() {
+                shimsDTS.setNs("");
+                shimsDTS.write("");
+                shimsDTS.write("");
+                if (currAttrs || currDocComment) {
+                    shimsDTS.write(currDocComment);
+                    shimsDTS.write(currAttrs);
+                    currAttrs = "";
+                    currDocComment = "";
+                }
+            }
+            function parseArg(parsedAttrs, s) {
+                s = s.trim();
+                let m = /(.*)=\s*(-?\w+)$/.exec(s);
+                let defl = "";
+                let qm = "";
+                if (m) {
+                    defl = m[2];
+                    qm = "?";
+                    s = m[1].trim();
+                }
+                m = /^(.*?)(\w+)$/.exec(s);
+                if (!m) {
+                    err("invalid argument: " + s);
+                    return {
+                        name: "???",
+                        type: "int"
+                    };
+                }
+                let argName = m[2];
+                if (parsedAttrs.paramDefl[argName]) {
+                    defl = parsedAttrs.paramDefl[argName];
+                    qm = "?";
+                }
+                let numVal = defl ? U.lookup(enumVals, defl) : null;
+                if (numVal != null)
+                    defl = numVal;
+                if (defl) {
+                    if (parseCppInt(defl) == null)
+                        err("Invalid default value (non-integer): " + defl);
+                    currAttrs += ` ${argName}.defl=${defl}`;
+                }
+                return {
+                    name: argName + qm,
+                    type: m[1]
+                };
+            }
+            function parseCpp(src, isHeader) {
+                currNs = "";
+                currDocComment = "";
+                currAttrs = "";
+                inDocComment = false;
+                let indexedInstanceAttrs;
+                let indexedInstanceIdx = -1;
+                // replace #if 0 .... #endif with newlines
+                src = src.replace(/^(\s*#\s*if\s+(\w+)\s*$)([^]*?)(^\s*#\s*(elif|else|endif)\s*$)/mg, (f, _if, arg, middle, _endif) => hash_if_options.indexOf(arg) >= 0 && !cpp_options[arg] ?
+                    _if + middle.replace(/[^\n]/g, "") + _endif : f);
+                // special handling of C++ namespace that ends with Methods (e.g. FooMethods)
+                // such a namespace will be converted into a TypeScript interface
+                // this enables simple objects with methods to be defined. See, for example:
+                // https://github.com/microsoft/pxt-microbit/blob/master/libs/core/buffer.cpp
+                // within that namespace, the first parameter of each function should have
+                // the type Foo
+                function interfaceName() {
+                    let n = currNs.replace(/Methods$/, "");
+                    if (n == currNs)
+                        return null;
+                    return n;
+                }
+                lineNo = 0;
+                // the C++ types we can map to TypeScript
+                function mapType(tp) {
+                    switch (tp.replace(/\s+/g, "")) {
+                        case "void": return "void";
+                        // TODO: need int16_t
+                        case "int32_t":
+                        case "int":
+                            return "int32";
+                        case "uint32_t":
+                        case "unsigned":
+                            return "uint32";
+                        case "TNumber":
+                        case "float":
+                        case "double":
+                            return "number";
+                        case "uint16_t": return "uint16";
+                        case "int16_t":
+                        case "short": return "int16";
+                        case "uint8_t":
+                        case "byte": return "uint8";
+                        case "int8_t":
+                        case "sbyte": return "int8";
+                        case "bool":
+                            if (compile.shortPointers)
+                                err("use 'boolean' not 'bool' on 8 bit targets");
+                            return "boolean";
+                        case "StringData*": return "string";
+                        case "String": return "string";
+                        case "ImageLiteral_": return "string";
+                        case "ImageLiteral": return "string";
+                        case "Action": return "() => void";
+                        case "TValue": return "any";
+                        default:
+                            return toJs(tp);
+                        //err("Don't know how to map type: " + tp)
+                        //return "any"
+                    }
+                }
+                function mapRunTimeType(tp) {
+                    tp = tp.replace(/\s+/g, "");
+                    switch (tp) {
+                        case "int32_t":
+                        case "uint32_t":
+                        case "unsigned":
+                        case "uint16_t":
+                        case "int16_t":
+                        case "short":
+                        case "uint8_t":
+                        case "byte":
+                        case "int8_t":
+                        case "sbyte":
+                        case "int":
+                        case "ramint_t":
+                            return "I";
+                        case "void": return "V";
+                        case "float": return "F";
+                        case "TNumber": return "N";
+                        case "TValue": return "T";
+                        case "bool": return "B";
+                        case "double": return "D";
+                        case "ImageLiteral_":
+                            return "T";
+                        case "String":
+                            return "S";
+                        default:
+                            if (U.lookup(knownEnums, tp))
+                                return "I";
+                            return "_" + tp.replace(/[\*_]+$/, "");
+                    }
+                }
+                function generateVMWrapper(fi, argTypes) {
+                    if (argTypes[0] == "FiberContext*")
+                        return "::" + fi.name; // no wrapper
+                    let wrap = "_wrp_" + fi.name.replace(/:/g, "_");
+                    if (vmVisitedFunctions[fi.name])
+                        return wrap;
+                    vmVisitedFunctions[fi.name] = true;
+                    /*
+                    void call_getConfig(FiberContext *ctx) {
+                        int a0 = toInt(ctx->sp[0]);
+                        int a1 = toInt(ctx->r0); // last argument in r0
+                        int r = getConfig(a0, a1);
+                        ctx->r0 = fromInt(r);
+                        ctx->sp += 1;
+                    }
+                    */
+                    pointerIncPre += `\nvoid ${wrap}(FiberContext *ctx) {\n`;
+                    const numArgs = argTypes.length;
+                    let refs = [];
+                    let needsStackSave = false;
+                    let allConvs = "";
+                    for (let i = 0; i < numArgs; ++i) {
+                        const ind = fi.argsFmt[i + 1];
+                        const tp = argTypes[i];
+                        let conv = ind == "I" ? "toInt" :
+                            ind == "B" ? "numops::toBool" :
+                                "";
+                        const inp = i == numArgs - 1 ? "ctx->r0" : `ctx->sp[${numArgs - i - 2}]`;
+                        let argPref = "";
+                        switch (tp) {
+                            case "TValue":
+                            case "TNumber":
+                                break;
+                            case "Action":
+                                conv = "asRefAction";
+                                break;
+                            case "String":
+                                conv = "convertToString";
+                                argPref = "ctx, ";
+                                needsStackSave = true;
+                                break;
+                            default:
+                                if (!conv)
+                                    conv = "as" + tp.replace(/\*/g, "");
+                                break;
+                        }
+                        allConvs += `  ${tp} a${i} = (${tp}) ${conv}(${argPref}${inp});\n`;
+                        refs.push("a" + i);
+                    }
+                    if (needsStackSave)
+                        pointerIncPre += "  auto prevSP = ctx->sp;\n";
+                    pointerIncPre += allConvs;
+                    if (needsStackSave)
+                        pointerIncPre += "  if (panicCode) { ctx->sp = prevSP; return; }\n";
+                    const call = `::${fi.name}(${refs.join(", ")})`;
+                    if (fi.argsFmt[0] == "V") {
+                        pointerIncPre += `  ${call};\n`;
+                        pointerIncPre += `  ctx->r0 = NULL;\n`;
+                    }
+                    else if (fi.argsFmt[0] == "I") {
+                        pointerIncPre += `  ctx->r0 = fromInt(${call});\n`;
+                    }
+                    else if (fi.argsFmt[0] == "B") {
+                        pointerIncPre += `  ctx->r0 = fromBool(${call});\n`;
+                    }
+                    else {
+                        pointerIncPre += `  ctx->r0 = (TValue)${call};\n`;
+                    }
+                    if (needsStackSave)
+                        pointerIncPre += "  ctx->sp = prevSP;\n";
+                    if (numArgs > 1)
+                        pointerIncPre += `  ctx->sp += ${numArgs - 1};\n`;
+                    pointerIncPre += `}\n`;
+                    return wrap;
+                }
+                inEnum = false;
+                enumVal = 0;
+                enumsDTS.setNs("");
+                shimsDTS.setNs("");
+                src.split(/\r?\n/).forEach(ln => {
+                    ++lineNo;
+                    // remove comments (NC = no comments)
+                    let lnNC = stripComments(ln);
+                    processEnumLine(ln);
+                    // "enum class" and "enum struct" is C++ syntax to force scoping of
+                    // enum members
+                    let enM = /^\s*enum\s+(|class\s+|struct\s+)(\w+)\s*({|$)/.exec(lnNC);
+                    if (enM) {
+                        enterEnum(enM[2], enM[3]);
+                        if (!isHeader) {
+                            protos.setNs(currNs);
+                            protos.write(`enum ${enM[2]} : int;`);
+                        }
+                    }
+                    if (handleComments(ln))
+                        return;
+                    if (/^typedef.*;\s*$/.test(ln)) {
+                        protos.setNs(currNs);
+                        protos.write(ln);
+                    }
+                    let m = /^\s*namespace\s+(\w+)/.exec(ln);
+                    if (m) {
+                        //if (currNs) err("more than one namespace declaration not supported")
+                        currNs = m[1];
+                        if (interfaceName()) {
+                            finishNamespace();
+                            let tpName = interfaceName();
+                            shimsDTS.setNs(currNs, `declare interface ${tpName} {`);
+                        }
+                        else if (currAttrs || currDocComment) {
+                            finishNamespace();
+                            shimsDTS.setNs(toJs(currNs));
+                            enumsDTS.setNs(toJs(currNs));
+                        }
+                        return;
+                    }
+                    m = /^PXT_ABI\((\w+)\)/.exec(ln);
+                    if (m && !isVM) {
+                        pointersInc += `PXT_FNPTR(::${m[1]}),\n`;
+                        abiInc += `extern "C" void ${m[1]}();\n`;
+                        res.functions.push({
+                            name: m[1],
+                            argsFmt: [],
+                            value: 0
+                        });
+                    }
+                    m = /^\s*PXT_EXPORT\(([:\&\w]+)\)/.exec(ln);
+                    if (m) {
+                        if (!res.vmPointers)
+                            res.vmPointers = [];
+                        res.vmPointers.push(m[1]);
+                    }
+                    m = /^#define\s+PXT_COMM_BASE\s+([0-9a-fx]+)/.exec(ln);
+                    if (m)
+                        res.commBase = parseInt(m[1]);
+                    // function definition
+                    m = /^\s*(\w+)([\*\&]*\s+[\*\&]*)(\w+)\s*\(([^\(\)]*)\)\s*(;\s*$|\{|$)/.exec(ln);
+                    if (currAttrs && m) {
+                        indexedInstanceAttrs = null;
+                        let parsedAttrs = pxtc.parseCommentString(currAttrs);
+                        // top-level functions (outside of a namespace) are not permitted
+                        if (!currNs)
+                            err("missing namespace declaration");
+                        let retTp = (m[1] + m[2]).replace(/\s+/g, "");
+                        let funName = m[3];
+                        let origArgs = m[4];
+                        currAttrs = currAttrs.trim().replace(/ \w+\.defl=\w+/g, "");
+                        let argsFmt = [mapRunTimeType(retTp)];
+                        let argTypes = [];
+                        let args = origArgs.split(/,/).filter(s => !!s).map(s => {
+                            let r = parseArg(parsedAttrs, s);
+                            argsFmt.push(mapRunTimeType(r.type));
+                            argTypes.push(r.type.replace(/ /g, ""));
+                            return `${r.name}: ${mapType(r.type)}`;
+                        });
+                        let fi = {
+                            name: currNs + "::" + funName,
+                            argsFmt,
+                            value: null
+                        };
+                        //pxt.log(`${ln.trim()} : ${argsFmt}`)
+                        if (currDocComment) {
+                            shimsDTS.setNs(toJs(currNs));
+                            shimsDTS.write("");
+                            shimsDTS.write(currDocComment);
+                            if (/ImageLiteral/.test(m[4]) && !/imageLiteral=/.test(currAttrs))
+                                currAttrs += ` imageLiteral=1`;
+                            currAttrs += ` shim=${fi.name}`;
+                            shimsDTS.write(currAttrs);
+                            funName = toJs(funName);
+                            if (interfaceName()) {
+                                let tp0 = (args[0] || "").replace(/^.*:\s*/, "").trim();
+                                if (tp0.toLowerCase() != interfaceName().toLowerCase()) {
+                                    err(lf("Invalid first argument; should be of type '{0}', but is '{1}'", interfaceName(), tp0));
+                                }
+                                args.shift();
+                                if (args.length == 0 && /\bproperty\b/.test(currAttrs))
+                                    shimsDTS.write(`${funName}: ${mapType(retTp)};`);
+                                else
+                                    shimsDTS.write(`${funName}(${args.join(", ")}): ${mapType(retTp)};`);
+                            }
+                            else {
+                                shimsDTS.write(`function ${funName}(${args.join(", ")}): ${mapType(retTp)};`);
+                            }
+                        }
+                        currDocComment = "";
+                        currAttrs = "";
+                        if (!isHeader) {
+                            protos.setNs(currNs);
+                            protos.write(`${retTp} ${funName}(${origArgs});`);
+                        }
+                        res.functions.push(fi);
+                        if (isYotta)
+                            pointersInc += "(uint32_t)(void*)::" + fi.name + ",\n";
+                        else if (isVM) {
+                            if (U.startsWith(fi.name, "pxt::op_") ||
+                                vmKeepFunctions[fi.name] ||
+                                parsedAttrs.expose ||
+                                (!U.startsWith(fi.name, "pxt::") && !U.startsWith(fi.name, "pxtrt::"))) {
+                                const wrap = generateVMWrapper(fi, argTypes);
+                                const nargs = fi.argsFmt.length - 1;
+                                pointersInc += `{ "${fi.name}", (OpFun)(void*)${wrap}, ${nargs} },\n`;
+                            }
+                        }
+                        else
+                            pointersInc += "PXT_FNPTR(::" + fi.name + "),\n";
+                        return;
+                    }
+                    m = /^\s*extern const (\w+) (\w+);/.exec(ln);
+                    if (currAttrs && m) {
+                        let fi = {
+                            name: currNs + "::" + m[2],
+                            argsFmt: [],
+                            value: null
+                        };
+                        res.functions.push(fi);
+                        if (!isVM)
+                            pointersInc += "PXT_FNPTR(&::" + fi.name + "),\n";
+                        currAttrs = "";
+                        return;
+                    }
+                    m = /^\s*(\w+)\s+(\w+)\s*;/.exec(ln);
+                    if (currAttrs && m) {
+                        let parsedAttrs = pxtc.parseCommentString(currAttrs);
+                        if (parsedAttrs.indexedInstanceNS) {
+                            indexedInstanceAttrs = parsedAttrs;
+                            shimsDTS.setNs(parsedAttrs.indexedInstanceNS);
+                            indexedInstanceIdx = 0;
+                        }
+                        let tp = m[1];
+                        let nm = m[2];
+                        if (indexedInstanceAttrs) {
+                            currAttrs = currAttrs.trim();
+                            currAttrs += ` fixedInstance shim=${indexedInstanceAttrs.indexedInstanceShim}(${indexedInstanceIdx++})`;
+                            shimsDTS.write("");
+                            shimsDTS.write(currDocComment);
+                            shimsDTS.write(currAttrs);
+                            shimsDTS.write(`const ${nm}: ${mapType(tp)};`);
+                            currDocComment = "";
+                            currAttrs = "";
+                            return;
+                        }
+                    }
+                    if (currAttrs && ln.trim()) {
+                        err("declaration not understood: " + ln);
+                        currAttrs = "";
+                        currDocComment = "";
+                        return;
+                    }
+                });
+            }
+            const currSettings = U.clone(compileService.yottaConfig || {});
+            const optSettings = {};
+            const settingSrc = {};
+            const codalLibraries = {};
+            function parseJson(pkg) {
+                const j0 = pkg.config.platformio;
+                if (j0 && j0.dependencies) {
+                    U.jsonCopyFrom(res.platformio.dependencies, j0.dependencies);
+                }
+                if (res.npmDependencies && pkg.config.npmDependencies)
+                    U.jsonCopyFrom(res.npmDependencies, pkg.config.npmDependencies);
+                const codal = pkg.config.codal;
+                if (isCodal && codal) {
+                    for (const lib of codal.libraries || []) {
+                        const repo = pxt.github.parseRepoId(lib);
+                        if (!repo)
+                            U.userError(lf("codal library {0} doesn't look like github repo", lib));
+                        const canonical = pxt.github.stringifyRepo(repo);
+                        const existing = U.lookup(codalLibraries, repo.project);
+                        if (existing) {
+                            if (pxt.github.stringifyRepo(existing) != canonical)
+                                U.userError(lf("conflict between codal libraries: {0} and {1}", pxt.github.stringifyRepo(existing), canonical));
+                        }
+                        else {
+                            codalLibraries[repo.project] = repo;
+                        }
+                    }
+                }
+                const json = pkg.config.yotta;
+                if (!json)
+                    return;
+                // TODO check for conflicts
+                if (json.dependencies) {
+                    U.jsonCopyFrom(res.yotta.dependencies, json.dependencies);
+                }
+                if (json.config) {
+                    const cfg = U.jsonFlatten(json.config);
+                    for (const settingName of Object.keys(cfg)) {
+                        const prev = U.lookup(settingSrc, settingName);
+                        const settingValue = cfg[settingName];
+                        if (!prev || prev.config.yotta.configIsJustDefaults) {
+                            settingSrc[settingName] = pkg;
+                            currSettings[settingName] = settingValue;
+                        }
+                        else if (currSettings[settingName] === settingValue) {
+                            // OK
+                        }
+                        else if (!mainPkg.config.yotta || !mainPkg.config.yotta.ignoreConflicts) {
+                            let err = new PkgConflictError(lf("conflict on yotta setting {0} between extensions {1} and {2}", settingName, pkg.id, prev.id));
+                            err.pkg0Id = prev.id;
+                            err.pkg1Id = pkg.id;
+                            err.settingName = settingName;
+                            throw err;
+                        }
+                    }
+                }
+                if (json.optionalConfig) {
+                    const cfg = U.jsonFlatten(json.optionalConfig);
+                    for (const settingName of Object.keys(cfg)) {
+                        const settingValue = cfg[settingName];
+                        // last one wins
+                        optSettings[settingName] = settingValue;
+                    }
+                }
+            }
+            // This is overridden on the build server, but we need it for command line build
+            if (isYotta && compile.hasHex) {
+                let cs = compileService;
+                U.assert(!!cs.yottaCorePackage);
+                U.assert(!!cs.githubCorePackage);
+                U.assert(!!cs.gittag);
+                let tagged = cs.githubCorePackage + "#" + compileService.gittag;
+                res.yotta.dependencies[cs.yottaCorePackage] = tagged;
+            }
+            if (mainPkg) {
+                let seenMain = false;
+                for (let pkg of mainDeps) {
+                    thisErrors = "";
+                    parseJson(pkg);
+                    if (pkg == mainPkg) {
+                        seenMain = true;
+                        // we only want the main package in generated .d.ts
+                        shimsDTS.clear();
+                        enumsDTS.clear();
+                    }
+                    else {
+                        U.assert(!seenMain);
+                    }
+                    // Generally, headers need to be processed before sources, as they contain definitions
+                    // (in particular of enums, which are needed to decide if we're doing conversions for
+                    // function arguments). This can still fail if one header uses another and they are
+                    // listed in invalid order...
+                    const isHeaderFn = (fn) => U.endsWith(fn, ".h");
+                    const ext = ".cpp";
+                    const files = pkg.files.filter(isHeaderFn)
+                        .concat(pkg.files.filter(s => !isHeaderFn(s)));
+                    for (let fn of files) {
+                        const isHeader = isHeaderFn(fn);
+                        if (isHeader || U.endsWith(fn, ext)) {
+                            let fullName = pkg.config.name + "/" + fn;
+                            if ((pkg.config.name == "base" || /^core($|---)/.test(pkg.config.name)) && isHeader)
+                                fullName = fn;
+                            if (isHeader)
+                                includesInc += `#include "${isYotta ? sourcePath.slice(1) : ""}${fullName}"\n`;
+                            let src = readFile(pkg, fn);
+                            if (src == null)
+                                U.userError(lf("C++ file {0} is missing in extension {1}.", fn, pkg.config.name));
+                            fileName = fullName;
+                            parseCpp(src, isHeader);
+                            // src = src.replace(/^[ \t]*/mg, "") // HACK: shrink the files
+                            res.extensionFiles[sourcePath + fullName] = src;
+                            if (pkg == mainPkg)
+                                res.onlyPublic = false;
+                            const protocol = pxt.packageUtils.getVersionProtocol(pkg.version);
+                            if (protocol && protocol != "pub" && protocol != "embed")
+                                res.onlyPublic = false;
+                        }
+                        if (U.endsWith(fn, ".c") || U.endsWith(fn, ".S") || U.endsWith(fn, ".s")) {
+                            let src = readFile(pkg, fn);
+                            res.extensionFiles[sourcePath + pkg.config.name + "/" + fn.replace(/\.S$/, ".s")] = src;
+                        }
+                    }
+                    if (thisErrors) {
+                        allErrors += lf("Extension {0}:\n", pkg.id) + thisErrors;
+                    }
+                }
+                if (!seenMain) {
+                    // this can happen if the main package is disabled in current variant
+                    shimsDTS.clear();
+                    enumsDTS.clear();
+                }
+            }
+            if (allErrors)
+                U.userError(allErrors);
+            // merge optional settings
+            U.jsonCopyFrom(optSettings, currSettings);
+            U.iterMap(optSettings, (k, v) => {
+                if (v === null) {
+                    delete optSettings[k];
+                }
+            });
+            // fix keys - ==> _
+            Object.keys(optSettings)
+                .filter(k => /-/.test(k)).forEach(k => {
+                const v = optSettings[k];
+                delete optSettings[k];
+                optSettings[k.replace(/-/g, '_')] = v;
+            });
+            if (!isYotta && compileService.yottaConfigCompatibility) { // yotta automatically adds YOTTA_CFG_
+                Object.keys(optSettings)
+                    .forEach(k => optSettings["YOTTA_CFG_" + k] = optSettings[k]);
+            }
+            optSettings["PXT_TARGET"] = JSON.stringify(appTarget.id);
+            function allFilesWithExt(ext) {
+                let allfiles = Object.keys(res.extensionFiles).concat(Object.keys(res.generatedFiles));
+                return allfiles.filter(f => U.endsWith(f, ext)).map(s => s.slice(1));
+            }
+            const configJson = U.jsonUnFlatten(optSettings);
+            if (isDockerMake) {
+                let packageJson = {
+                    name: "pxt-app",
+                    private: true,
+                    dependencies: res.npmDependencies,
+                };
+                res.generatedFiles["/package.json"] = JSON.stringify(packageJson, null, 4) + "\n";
+            }
+            else if (isEspIdf) {
+                const files = U.concatArrayLike([
+                    allFilesWithExt(".c"),
+                    allFilesWithExt(".cpp"),
+                    allFilesWithExt(".s")
+                ]).map(s => s.slice(sourcePath.length - 1)).concat(["main.cpp"]);
+                files.push("pointers.cpp");
+                res.generatedFiles[sourcePath + "CMakeLists.txt"] =
+                    `idf_component_register(\n  SRCS\n` +
+                        files.map(f => `    "${f}"\n`).join("") +
+                        `  INCLUDE_DIRS\n    "."\n)\n`;
+            }
+            else if (isCodal) {
+                let cs = compileService;
+                let cfg = U.clone(cs.codalDefinitions) || {};
+                let trg = cs.codalTarget;
+                if (typeof trg == "string")
+                    trg = trg + ".json";
+                let codalJson = {
+                    "target": trg,
+                    "definitions": cfg,
+                    "config": cfg,
+                    "application": "pxtapp",
+                    "output_folder": "build",
+                    // include these, because we use hash of this file to see if anything changed
+                    "pxt_gitrepo": cs.githubCorePackage,
+                    "pxt_gittag": cs.gittag,
+                    "libraries": U.values(codalLibraries).map(r => ({
+                        "name": r.project,
+                        "url": "https://github.com/" + r.fullName,
+                        "branch": r.tag || "master",
+                        "type": "git"
+                    }))
+                };
+                if (codalJson.libraries.length == 0)
+                    delete codalJson.libraries;
+                U.iterMap(U.jsonFlatten(configJson), (k, v) => {
+                    k = k.replace(/^codal\./, "device.").toUpperCase().replace(/\./g, "_");
+                    cfg[k] = v;
+                });
+                res.generatedFiles["/codal.json"] = JSON.stringify(codalJson, null, 4) + "\n";
+                host.logger.debug(`codal.json: ${res.generatedFiles["/codal.json"]}`);
+                res.codal = codalJson;
+            }
+            else if (isPlatformio) {
+                const iniLines = compileService.platformioIni.slice();
+                // TODO merge configjson
+                iniLines.push("lib_deps =");
+                U.iterMap(res.platformio.dependencies, (pkg, ver) => {
+                    let pkgSpec = /[@#\/]/.test(ver) ? ver : pkg + "@" + ver;
+                    iniLines.push("  " + pkgSpec);
+                });
+                res.generatedFiles["/platformio.ini"] = iniLines.join("\n") + "\n";
+            }
+            else {
+                res.yotta.config = configJson;
+                let name = "pxt-app";
+                if (compileService.yottaBinary)
+                    name = compileService.yottaBinary.replace(/-combined/, "").replace(/\.hex$/, "");
+                let moduleJson = {
+                    "name": name,
+                    "version": "0.0.0",
+                    "description": "Auto-generated. Do not edit.",
+                    "license": "n/a",
+                    "dependencies": res.yotta.dependencies,
+                    "targetDependencies": {},
+                    "bin": "./source"
+                };
+                res.generatedFiles["/module.json"] = JSON.stringify(moduleJson, null, 4) + "\n";
+                host.logger.debug(`module.json: ${res.generatedFiles["/module.json"]}`);
+            }
+            for (let k of Object.keys(cpp_options)) {
+                pxtConfig += `#define ${k} ${cpp_options[k]}\n`;
+            }
+            if (compile.uf2Family)
+                pxtConfig += `#define PXT_UF2_FAMILY ${compile.uf2Family}\n`;
+            res.generatedFiles[sourcePath + "pointers.cpp"] = includesInc + protos.finish() + abiInc +
+                pointerIncPre + pointersInc + "\nPXT_SHIMS_END\n";
+            res.generatedFiles[sourcePath + "pxtconfig.h"] = pxtConfig;
+            host.logger.debug(`pxtconfig.h: ${res.generatedFiles[sourcePath + "pxtconfig.h"]}`);
+            if (isYotta) {
+                res.generatedFiles["/config.json"] = JSON.stringify(configJson, null, 4) + "\n";
+                host.logger.debug(`yotta config.json: ${res.generatedFiles["/config.json"]}`);
+            }
+            res.generatedFiles[sourcePath + "main.cpp"] = `
+#include "pxt.h"
+#ifdef PXT_MAIN
+PXT_MAIN
+#else
+int main() {
+    uBit.init();
+    pxt::start();
+    release_fiber();
+    return 0;   // your program will never reach this line.
+}
+#endif
+`;
+            if (res.generatedFiles["/Makefile"]) {
+                let inc = "";
+                let add = (name, ext) => {
+                    inc += `${name} = ${allFilesWithExt(ext).join(" ")}\n`;
+                };
+                add("PXT_C", ".c");
+                add("PXT_CPP", ".cpp");
+                add("PXT_S", ".s");
+                add("PXT_HEADERS", ".h");
+                inc += "PXT_SOURCES := $(PXT_C) $(PXT_S) $(PXT_CPP)\n";
+                inc += "PXT_OBJS := $(addprefix bld/, $(PXT_C:.c=.o) $(PXT_S:.s=.o) $(PXT_CPP:.cpp=.o))\n";
+                res.generatedFiles["/Makefile.inc"] = inc;
+            }
+            res.generatedFiles["/functions.json"] = JSON.stringify(res.functions, null, 1);
+            let tmp = res.extensionFiles;
+            U.jsonCopyFrom(tmp, res.generatedFiles);
+            let creq = {
+                config: compileService.serviceId,
+                tag: compileService.gittag,
+                replaceFiles: tmp,
+                dependencies: (isYotta ? res.yotta.dependencies : null)
+            };
+            let data = JSON.stringify(creq);
+            host.perf.measureStart(Measurements.Sha256Buffer);
+            try {
+                res.sha = pxtc.BrowserImpl.sha256buffer(U.toUTF8Array(data));
+            }
+            finally {
+                host.perf.measureEnd(Measurements.Sha256Buffer);
+            }
+            res.skipCloudBuild = !!compileService.skipCloudBuild;
+            res.compileData = ts.pxtc.encodeBase64(U.toUTF8(data));
+            res.shimsDTS = shimsDTS.finish();
+            res.enumsDTS = enumsDTS.finish();
+            if (Object.keys(host.cache).length > 10) {
+                for (const key of Object.keys(host.cache))
+                    delete host.cache[key];
+            }
+            host.cache[key] = U.clone(res);
+            return res;
+        }
+        cpp.getExtensionInfo = getExtensionInfo;
+    })(cpp = pxt.cpp || (pxt.cpp = {}));
+})(pxt || (pxt = {}));
+/// <reference path="../pxtlib/shared/docsrender.ts"/>
+/// <reference path="../pxtlib/shared/extensioninfo.ts"/>
 global.pxt = pxt;