pxt-core 8.2.13 → 8.2.14

package/built/pxt.js

@@ -101488,7 +101488,7 @@ var pxt;
                 definitionNameToParam: {},
                 handlerArgs: []
             };
-            const instance = (fn.kind == 1 /* Method */ || fn.kind == 2 /* Property */) && !fn.attributes.defaultInstance;
+            const instance = (fn.kind == 1 /* ts.pxtc.SymbolKind.Method */ || fn.kind == 2 /* ts.pxtc.SymbolKind.Property */) && !fn.attributes.defaultInstance;
             const hasBlockDef = !!fn.attributes._def;
             const defParameters = hasBlockDef ? fn.attributes._def.parameters.slice(0) : undefined;
             const optionalStart = hasBlockDef ? defParameters.length : (fn.parameters ? fn.parameters.length : 0);
@@ -102147,6 +102147,7 @@ var pxt;
         }
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
+/// <reference path="../localtypings/dom.d.ts" />
 var pxt;
 (function (pxt) {
     var BrowserUtils;
@@ -110685,7 +110686,7 @@ var pxt;
         }
         sprite_1.base64EncodeBitmap = base64EncodeBitmap;
         function getFixedInstanceDropdownValues(apis, qName) {
-            return pxt.Util.values(apis.byQName).filter(sym => sym.kind === 4 /* Variable */
+            return pxt.Util.values(apis.byQName).filter(sym => sym.kind === 4 /* pxtc.SymbolKind.Variable */
                 && sym.attributes.fixedInstance
                 && isSubtype(apis, sym.retType, qName));
         }
@@ -113201,7 +113202,7 @@ var ts;
                     ex = m[mkey] = {
                         attributes: {
                             blockId: `${isNumberType ? s.namespace : mkey}_blockCombine_${rtp}`,
-                            callingConvention: 0 /* Plain */,
+                            callingConvention: 0 /* ir.CallingConvention.Plain */,
                             group: s.attributes.group,
                             paramDefl: {},
                             jsDoc: isGet
@@ -113213,7 +113214,7 @@ var ts;
                         fileName: s.fileName,
                         qName: `${mkey}.${tp}`,
                         pkg: s.pkg,
-                        kind: 2 /* Property */,
+                        kind: 2 /* SymbolKind.Property */,
                         parameters: [
                             {
                                 name: "property",
@@ -113327,15 +113328,15 @@ var ts;
                 }
                 else if (!!s.attributes.block
                     && !s.attributes.fixedInstance
-                    && s.kind != 7 /* EnumMember */
-                    && s.kind != 5 /* Module */
-                    && s.kind != 9 /* Interface */
-                    && s.kind != 8 /* Class */) {
+                    && s.kind != 7 /* pxtc.SymbolKind.EnumMember */
+                    && s.kind != 5 /* pxtc.SymbolKind.Module */
+                    && s.kind != 9 /* pxtc.SymbolKind.Interface */
+                    && s.kind != 8 /* pxtc.SymbolKind.Class */) {
                     if (!s.attributes.blockId)
                         s.attributes.blockId = s.qName.replace(/\./g, "_");
                     if (s.attributes.block == "true") {
                         let b = pxtc.U.uncapitalize(s.name);
-                        if (s.kind == 1 /* Method */ || s.kind == 2 /* Property */) {
+                        if (s.kind == 1 /* SymbolKind.Method */ || s.kind == 2 /* SymbolKind.Property */) {
                             b += " %" + s.namespace.toLowerCase();
                         }
                         const params = (_b = (_a = s.parameters) === null || _a === void 0 ? void 0 : _a.filter(pr => !parameterTypeIsArrowFunction(pr))) !== null && _b !== void 0 ? _b : [];
@@ -113389,7 +113390,7 @@ var ts;
             if (key) {
                 return key;
             }
-            if ((symbol && symbol.kind == 6 /* Enum */) || (!symbol && param.includes("."))) {
+            if ((symbol && symbol.kind == 6 /* SymbolKind.Enum */) || (!symbol && param.includes("."))) {
                 // Python enums are all caps
                 const dotIdx = param.lastIndexOf(".");
                 const left = param.substr(0, dotIdx);
@@ -113572,7 +113573,7 @@ var ts;
         function parseCommentString(cmt) {
             let res = {
                 paramDefl: {},
-                callingConvention: 0 /* Plain */,
+                callingConvention: 0 /* ir.CallingConvention.Plain */,
                 _source: cmt
             };
             let didSomething = true;
@@ -113704,9 +113705,9 @@ var ts;
             });
             res.jsDoc = res.jsDoc.trim();
             if (res.async)
-                res.callingConvention = 1 /* Async */;
+                res.callingConvention = 1 /* ir.CallingConvention.Async */;
             if (res.promise)
-                res.callingConvention = 2 /* Promise */;
+                res.callingConvention = 2 /* ir.CallingConvention.Promise */;
             if (res.jres)
                 res.whenUsed = true;
             if (res.subcategories) {
@@ -113788,11 +113789,11 @@ var ts;
                         const tk = eatToken(c => c == char);
                         const offset = char === "_" ? 2 : 0;
                         if (tk.length === 1)
-                            newToken = { kind: 1 /* SingleAsterisk */ << offset, content: tk };
+                            newToken = { kind: 1 /* TokenKind.SingleAsterisk */ << offset, content: tk };
                         else if (tk.length === 2)
-                            newToken = { kind: 2 /* DoubleAsterisk */ << offset, content: tk };
+                            newToken = { kind: 2 /* TokenKind.DoubleAsterisk */ << offset, content: tk };
                         else if (tk.length === 3)
-                            newToken = { kind: 3 /* TripleAsterisk */ << offset, content: tk };
+                            newToken = { kind: 3 /* TokenKind.TripleAsterisk */ << offset, content: tk };
                         else
                             strIndex = restoreIndex; // error: no more than three style marks
                         break;
@@ -113802,21 +113803,21 @@ var ts;
                             strIndex = restoreIndex; // error: not terminated
                             break;
                         }
-                        newToken = { kind: 256 /* Image */, content: image };
+                        newToken = { kind: 256 /* TokenKind.Image */, content: image };
                         break;
                     case "|":
-                        newToken = { kind: 32 /* Pipe */ };
+                        newToken = { kind: 32 /* TokenKind.Pipe */ };
                         break;
                     case "\\":
                         if (strIndex < (def.length - 1))
-                            newToken = { kind: 16 /* Escape */, content: def[1 + (strIndex++)] };
+                            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 /* TaggedText */, content: contentText, type: contentClass };
+                                newToken = { kind: 512 /* TokenKind.TaggedText */, content: contentText, type: contentClass };
                                 break;
                             }
                         }
@@ -113837,12 +113838,12 @@ var ts;
                             if (!varName)
                                 strIndex = oldIndex;
                         }
-                        newToken = { kind: (char === "$") ? 1024 /* ParamRef */ : 64 /* Parameter */, content: param[0], type: param[1], name: varName };
+                        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 /* Word */, content: currentWord });
+                        tokens.push({ kind: 128 /* TokenKind.Word */, content: currentWord });
                     currentWord = undefined;
                     tokens.push(newToken);
                 }
@@ -113854,7 +113855,7 @@ var ts;
                 }
             }
             if (currentWord)
-                tokens.push({ kind: 128 /* Word */, content: currentWord });
+                tokens.push({ kind: 128 /* TokenKind.Word */, content: currentWord });
             const parts = [];
             const parameters = [];
             let stack = [];
@@ -113864,7 +113865,7 @@ var ts;
             for (let i = 0; i < tokens.length; i++) {
                 const token = tokens[i].kind;
                 const top = stack[stack.length - 1];
-                if (token & 15 /* StyleMarks */) {
+                if (token & 15 /* TokenKind.StyleMarks */) {
                     pushCurrentLabel(tokens[i].content);
                     if (token & open) {
                         if (top & token) {
@@ -113886,35 +113887,35 @@ var ts;
                         stack.push(token);
                     }
                 }
-                else if (token & 144 /* Text */) {
+                else if (token & 144 /* TokenKind.Text */) {
                     currentLabel += tokens[i].content;
                 }
-                else if (token & 1120 /* Unstylable */) {
+                else if (token & 1120 /* TokenKind.Unstylable */) {
                     pushLabels();
                 }
-                if (token == 64 /* Parameter */) {
+                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 /* ParamRef */) {
+                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 /* Image */) {
+                else if (token == 256 /* TokenKind.Image */) {
                     pushCurrentLabel();
                     labelStack.push({ kind: "image", uri: tokens[i].content });
                 }
-                else if (token == 512 /* TaggedText */) {
+                else if (token == 512 /* TokenKind.TaggedText */) {
                     pushCurrentLabel();
                     labelStack.push({ kind: "label", text: tokens[i].content, cssClass: tokens[i].type });
                 }
-                else if (token == 32 /* Pipe */) {
+                else if (token == 32 /* TokenKind.Pipe */) {
                     parts.push({ kind: "break" });
                 }
             }
@@ -113983,9 +113984,9 @@ var ts;
                         if (!label.content)
                             continue;
                         const styles = [];
-                        if (label.styles & 10 /* Bold */)
+                        if (label.styles & 10 /* TokenKind.Bold */)
                             styles.push("bold");
-                        if (label.styles & 5 /* Italics */)
+                        if (label.styles & 5 /* TokenKind.Italics */)
                             styles.push("italics");
                         parts.push({ kind: "label", text: label.content, style: styles });
                     }
@@ -114470,7 +114471,7 @@ var pxt;
             }
             getProjectAsync(headerId) {
                 return this.db.getAsync(IndexedDBWorkspace.projectTable, headerId)
-                    .then(entry => { var _a; return (_a = entry) === null || _a === void 0 ? void 0 : _a.project; });
+                    .then(entry => entry === null || entry === void 0 ? void 0 : entry.project);
             }
             saveProjectAsync(project) {
                 return this.db.setAsync(IndexedDBWorkspace.projectTable, {
@@ -114480,7 +114481,7 @@ var pxt;
             }
             getUserStateAsync() {
                 return this.db.getAsync(IndexedDBWorkspace.userTable, "local-user")
-                    .then(entry => { var _a; return (_a = entry) === null || _a === void 0 ? void 0 : _a.user; });
+                    .then(entry => entry === null || entry === void 0 ? void 0 : entry.user);
             }
             saveUserStateAsync(user) {
                 return this.db.setAsync(IndexedDBWorkspace.userTable, {
@@ -115639,12 +115640,12 @@ var pxt;
             return this.nextInternalID++;
         }
         createNewImage(width = 16, height = 16) {
-            const id = this.generateNewID("image" /* Image */);
+            const id = this.generateNewID("image" /* AssetType.Image */);
             const bitmap = new pxt.sprite.Bitmap(width, height).data();
             const newImage = {
                 internalID: this.getNewInternalId(),
                 id,
-                type: "image" /* Image */,
+                type: "image" /* AssetType.Image */,
                 bitmap: bitmap,
                 meta: {},
                 jresData: pxt.sprite.base64EncodeBitmap(bitmap)
@@ -115652,12 +115653,12 @@ var pxt;
             return this.state.images.add(newImage);
         }
         createNewAnimation(width = 16, height = 16) {
-            const id = this.generateNewID("animation" /* Animation */);
+            const id = this.generateNewID("animation" /* AssetType.Animation */);
             const bitmap = new pxt.sprite.Bitmap(width, height).data();
             const newAnimation = {
                 internalID: this.getNewInternalId(),
                 id,
-                type: "animation" /* Animation */,
+                type: "animation" /* AssetType.Animation */,
                 frames: [bitmap],
                 interval: 500,
                 meta: {},
@@ -115665,11 +115666,11 @@ var pxt;
             return this.state.animations.add(newAnimation);
         }
         createNewAnimationFromData(frames, interval = 500, displayName) {
-            const id = this.generateNewID("animation" /* Animation */);
+            const id = this.generateNewID("animation" /* AssetType.Animation */);
             const newAnimation = {
                 internalID: this.getNewInternalId(),
                 id,
-                type: "animation" /* Animation */,
+                type: "animation" /* AssetType.Animation */,
                 frames,
                 interval,
                 meta: { displayName },
@@ -115702,13 +115703,13 @@ var pxt;
         }
         createNewTile(data, id, displayName) {
             this.onChange();
-            if (!id || this.isNameTaken("tile" /* Tile */, id)) {
-                id = this.generateNewID("tile" /* Tile */);
+            if (!id || this.isNameTaken("tile" /* AssetType.Tile */, id)) {
+                id = this.generateNewID("tile" /* AssetType.Tile */);
             }
             const newTile = {
                 internalID: this.getNewInternalId(),
                 id,
-                type: "tile" /* Tile */,
+                type: "tile" /* AssetType.Tile */,
                 jresData: pxt.sprite.base64EncodeBitmap(data),
                 bitmap: data,
                 meta: {
@@ -115722,8 +115723,8 @@ var pxt;
             this.onChange();
             const newImage = {
                 internalID: this.getNewInternalId(),
-                id: this.generateNewID("image" /* Image */),
-                type: "image" /* Image */,
+                id: this.generateNewID("image" /* AssetType.Image */),
+                type: "image" /* AssetType.Image */,
                 jresData: pxt.sprite.base64EncodeBitmap(data),
                 meta: {
                     displayName
@@ -115738,7 +115739,7 @@ var pxt;
             if (existing) {
                 this.state.tiles.update(existing.id, tile);
                 if (existing.id !== tile.id || !pxt.sprite.bitmapEquals(existing.bitmap, tile.bitmap)) {
-                    for (const tm of this.getAssets("tilemap" /* Tilemap */)) {
+                    for (const tm of this.getAssets("tilemap" /* AssetType.Tilemap */)) {
                         if (tm.data.tileset.tiles.some(t => t.internalID === tile.internalID)) {
                             tm.data.tileset.tiles = tm.data.tileset.tiles.map(t => t.internalID === tile.internalID ? tile : t);
                             this.updateTilemap(tm.id, tm.data);
@@ -115801,7 +115802,7 @@ var pxt;
             return new pxt.sprite.TilemapData(tilemap, tileset, layers.data());
         }
         resolveTile(id) {
-            return this.lookupAsset("tile" /* Tile */, id);
+            return this.lookupAsset("tile" /* AssetType.Tile */, id);
         }
         resolveProjectTileByInternalID(id) {
             return this.state.tiles.getSnapshot(tile => tile.internalID === id)[0];
@@ -115818,7 +115819,7 @@ var pxt;
                 tile = {
                     internalID: this.getNewInternalId(),
                     id,
-                    type: "tile" /* Tile */,
+                    type: "tile" /* AssetType.Tile */,
                     bitmap: bitmap,
                     jresData: pxt.sprite.base64EncodeBitmap(bitmap),
                     meta: {},
@@ -115830,11 +115831,11 @@ var pxt;
         }
         createNewTilemapFromData(data, name) {
             this.onChange();
-            const id = this.generateNewIDInternal("tilemap" /* Tilemap */, name || lf("level"));
+            const id = this.generateNewIDInternal("tilemap" /* AssetType.Tilemap */, name || lf("level"));
             this.state.tilemaps.add({
                 internalID: this.getNewInternalId(),
                 id,
-                type: "tilemap" /* Tilemap */,
+                type: "tilemap" /* AssetType.Tilemap */,
                 meta: {
                     displayName: name || id
                 },
@@ -115921,13 +115922,13 @@ var pxt;
         isNameTaken(assetType, name) {
             const isTaken = (id) => {
                 switch (assetType) {
-                    case "image" /* Image */:
+                    case "image" /* AssetType.Image */:
                         return this.state.images.isIDTaken(id) || this.gallery.images.isIDTaken(id);
-                    case "tile" /* Tile */:
+                    case "tile" /* AssetType.Tile */:
                         return this.state.tiles.isIDTaken(id) || this.gallery.tiles.isIDTaken(id);
-                    case "tilemap" /* Tilemap */:
+                    case "tilemap" /* AssetType.Tilemap */:
                         return this.state.tilemaps.isIDTaken(id) || this.gallery.tilemaps.isIDTaken(id);
-                    case "animation" /* Animation */:
+                    case "animation" /* AssetType.Animation */:
                         return this.state.animations.isIDTaken(id) || this.gallery.animations.isIDTaken(id);
                 }
             };
@@ -115965,8 +115966,8 @@ var pxt;
             let blockIds = ((_b = (_a = asset.meta) === null || _a === void 0 ? void 0 : _a.blockIDs) === null || _b === void 0 ? void 0 : _b.filter(id => !skipIDs || (skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(id)) < 0)) || [];
             if (blockIds.length > 0)
                 return true;
-            if (asset.type == "tile" /* Tile */) {
-                for (const tm of this.getAssets("tilemap" /* Tilemap */)) {
+            if (asset.type == "tile" /* pxt.AssetType.Tile */) {
+                for (const tm of this.getAssets("tilemap" /* AssetType.Tilemap */)) {
                     if ((skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(tm.id)) >= 0) {
                         continue;
                     }
@@ -115980,15 +115981,15 @@ var pxt;
                 const displayName = pxt.Util.escapeForRegex((_c = asset.meta) === null || _c === void 0 ? void 0 : _c.displayName) || "";
                 let assetTsRefs;
                 switch (asset.type) {
-                    case "tile" /* Tile */:
+                    case "tile" /* pxt.AssetType.Tile */:
                         assetTsRefs = `myTiles.${shortId}|assets.tile\`${shortId}\``;
                         if (displayName)
                             assetTsRefs += `|assets.tile\`${displayName}\``;
                         break;
-                    case "tilemap" /* Tilemap */:
+                    case "tilemap" /* pxt.AssetType.Tilemap */:
                         assetTsRefs = `tilemap\`${shortId}\``;
                         break;
-                    case "animation" /* Animation */:
+                    case "animation" /* pxt.AssetType.Animation */:
                         assetTsRefs = `assets.animation\`${shortId}\``;
                         if (displayName)
                             assetTsRefs += `|assets.animation\`${displayName}\``;
@@ -116002,15 +116003,15 @@ var pxt;
                 const assetTsRegex = new RegExp(assetTsRefs, "gm");
                 let assetPyRefs;
                 switch (asset.type) {
-                    case "tile" /* Tile */:
+                    case "tile" /* pxt.AssetType.Tile */:
                         assetPyRefs = `myTiles.${shortId}|assets.tile\("""${shortId}"""\)`;
                         if (displayName)
                             assetPyRefs += `|assets.tile\("""${displayName}"""\)`;
                         break;
-                    case "tilemap" /* Tilemap */:
+                    case "tilemap" /* pxt.AssetType.Tilemap */:
                         assetPyRefs = `assets.tilemap\("""${shortId}"""\)`;
                         break;
-                    case "animation" /* Animation */:
+                    case "animation" /* pxt.AssetType.Animation */:
                         assetPyRefs = `assets.animation\("""${shortId}"""\)`;
                         if (displayName)
                             assetPyRefs += `|assets.animation\("""${displayName}"""\)`;
@@ -116041,63 +116042,63 @@ var pxt;
         }
         lookupAsset(assetType, name) {
             switch (assetType) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     return this.state.images.getByID(name) || this.gallery.images.getByID(name);
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     return this.state.tiles.getByID(name) || this.gallery.tiles.getByID(name);
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     return this.state.tilemaps.getByID(name) || this.gallery.tilemaps.getByID(name);
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     return this.state.animations.getByID(name) || this.gallery.animations.getByID(name);
             }
         }
         lookupAssetByName(assetType, name) {
             switch (assetType) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     return this.state.images.getByDisplayName(name);
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     return this.state.tiles.getByDisplayName(name);
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     return this.state.tilemaps.getByDisplayName(name);
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     return this.state.animations.getByDisplayName(name);
             }
         }
         getAssets(type) {
             switch (type) {
-                case "image" /* Image */: return this.state.images.getSnapshot();
-                case "tile" /* Tile */: return this.state.tiles.getSnapshot();
-                case "tilemap" /* Tilemap */: return this.state.tilemaps.getSnapshot();
-                case "animation" /* Animation */: return this.state.animations.getSnapshot();
+                case "image" /* AssetType.Image */: return this.state.images.getSnapshot();
+                case "tile" /* AssetType.Tile */: return this.state.tiles.getSnapshot();
+                case "tilemap" /* AssetType.Tilemap */: return this.state.tilemaps.getSnapshot();
+                case "animation" /* AssetType.Animation */: return this.state.animations.getSnapshot();
             }
         }
         getGalleryAssets(type) {
             switch (type) {
-                case "image" /* Image */: return this.gallery.images.getSnapshot();
-                case "tile" /* Tile */: return this.gallery.tiles.getSnapshot();
-                case "tilemap" /* Tilemap */: return this.gallery.tilemaps.getSnapshot();
-                case "animation" /* Animation */: return this.gallery.animations.getSnapshot();
+                case "image" /* AssetType.Image */: return this.gallery.images.getSnapshot();
+                case "tile" /* AssetType.Tile */: return this.gallery.tiles.getSnapshot();
+                case "tilemap" /* AssetType.Tilemap */: return this.gallery.tilemaps.getSnapshot();
+                case "animation" /* AssetType.Animation */: return this.gallery.animations.getSnapshot();
             }
         }
         lookupBlockAsset(type, blockID) {
             let filter = (a) => { var _a, _b; return ((_b = (_a = a.meta) === null || _a === void 0 ? void 0 : _a.blockIDs) === null || _b === void 0 ? void 0 : _b.indexOf(blockID)) !== -1; };
             switch (type) {
-                case "image" /* Image */: return this.state.images.getSnapshot(filter)[0];
-                case "tile" /* Tile */: return this.state.tiles.getSnapshot(filter)[0];
-                case "tilemap" /* Tilemap */: return this.state.tilemaps.getSnapshot(filter)[0];
-                case "animation" /* Animation */: return this.state.animations.getSnapshot(filter)[0];
+                case "image" /* AssetType.Image */: return this.state.images.getSnapshot(filter)[0];
+                case "tile" /* AssetType.Tile */: return this.state.tiles.getSnapshot(filter)[0];
+                case "tilemap" /* AssetType.Tilemap */: return this.state.tilemaps.getSnapshot(filter)[0];
+                case "animation" /* AssetType.Animation */: return this.state.animations.getSnapshot(filter)[0];
             }
         }
         updateAsset(asset) {
             this.onChange();
             switch (asset.type) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     return this.state.images.update(asset.id, asset);
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     return this.updateTile(asset);
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     return this.state.tilemaps.update(asset.id, asset);
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     return this.state.animations.update(asset.id, asset);
             }
         }
@@ -116108,17 +116109,17 @@ var pxt;
             const name = displayName || ((_a = clone.meta) === null || _a === void 0 ? void 0 : _a.displayName);
             let newAsset;
             switch (asset.type) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     newAsset = this.createNewProjectImage(clone.bitmap, name);
                     break;
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     newAsset = this.createNewTile(clone.bitmap, null, name);
                     break;
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     const [id, tilemap] = this.createNewTilemapFromData(clone.data, name);
                     newAsset = this.getTilemap(id);
                     break;
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     newAsset = this.createNewAnimationFromData(clone.frames, clone.interval, name);
             }
             return newAsset;
@@ -116126,44 +116127,44 @@ var pxt;
         removeAsset(asset) {
             this.onChange();
             switch (asset.type) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     return this.state.images.removeByID(asset.id);
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     return this.state.tiles.removeByID(asset.id);
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     return this.state.tilemaps.removeByID(asset.id);
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     return this.state.animations.removeByID(asset.id);
             }
         }
         addChangeListener(asset, listener) {
             switch (asset.type) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     this.state.images.addListener(asset.internalID, listener);
                     break;
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     this.state.tiles.addListener(asset.internalID, listener);
                     break;
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     this.state.tilemaps.addListener(asset.internalID, listener);
                     break;
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     this.state.animations.addListener(asset.internalID, listener);
                     break;
             }
         }
         removeChangeListener(type, listener) {
             switch (type) {
-                case "image" /* Image */:
+                case "image" /* AssetType.Image */:
                     this.state.images.removeListener(listener);
                     break;
-                case "tile" /* Tile */:
+                case "tile" /* AssetType.Tile */:
                     this.state.tiles.removeListener(listener);
                     break;
-                case "tilemap" /* Tilemap */:
+                case "tilemap" /* AssetType.Tilemap */:
                     this.state.tilemaps.removeListener(listener);
                     break;
-                case "animation" /* Animation */:
+                case "animation" /* AssetType.Animation */:
                     this.state.animations.removeListener(listener);
                     break;
             }
@@ -116175,7 +116176,7 @@ var pxt;
                 const isProject = dep.id === "this";
                 const images = this.readImages(dep.parseJRes(), isProject);
                 for (const image of images) {
-                    if (image.type === "tile" /* Tile */) {
+                    if (image.type === "tile" /* AssetType.Tile */) {
                         if (isProject) {
                             this.state.tiles.add(image);
                         }
@@ -116183,7 +116184,7 @@ var pxt;
                             this.gallery.tiles.add(image);
                         }
                     }
-                    else if (image.type === "image" /* Image */) {
+                    else if (image.type === "image" /* AssetType.Image */) {
                         if (isProject) {
                             this.state.images.add(image);
                         }
@@ -116204,7 +116205,7 @@ var pxt;
             for (const tm of getTilemaps(pack.parseJRes())) {
                 this.state.tilemaps.add({
                     internalID: this.getNewInternalId(),
-                    type: "tilemap" /* Tilemap */,
+                    type: "tilemap" /* AssetType.Tilemap */,
                     id: tm.id,
                     meta: {
                         // For tilemaps, use the id as the display name for backwards compat
@@ -116219,7 +116220,7 @@ var pxt;
         }
         loadTilemapJRes(jres, skipDuplicates = false) {
             jres = pxt.inflateJRes(jres);
-            const tiles = this.readImages(jres, true).filter(im => im.type === "tile" /* Tile */);
+            const tiles = this.readImages(jres, true).filter(im => im.type === "tile" /* pxt.AssetType.Tile */);
             // If we are loading JRES into an existing project (i.e. in multipart tutorials)
             // we need to correct the tile ids because the user may have created new tiles
             // and taken some of the ids that were used by the tutorial author
@@ -116240,7 +116241,7 @@ var pxt;
             for (const tm of getTilemaps(jres)) {
                 this.state.tilemaps.add({
                     internalID: this.getNewInternalId(),
-                    type: "tilemap" /* Tilemap */,
+                    type: "tilemap" /* AssetType.Tilemap */,
                     id: tm.id,
                     meta: {
                         // For tilemaps, use the id as the display name for backwards compat
@@ -116261,10 +116262,10 @@ var pxt;
             for (const key of Object.keys(jres)) {
                 const entry = jres[key];
                 if (entry.tilemapTile) {
-                    this.state.tiles.add(this.generateImage(entry, "tile" /* Tile */));
+                    this.state.tiles.add(this.generateImage(entry, "tile" /* AssetType.Tile */));
                 }
                 else if (entry.mimeType === pxt.IMAGE_MIME_TYPE) {
-                    this.state.images.add(this.generateImage(entry, "image" /* Image */));
+                    this.state.images.add(this.generateImage(entry, "image" /* AssetType.Image */));
                 }
                 else if (entry.mimeType === pxt.ANIMATION_MIME_TYPE) {
                     const [animation, needsInflation] = this.generateAnimation(entry);
@@ -116325,7 +116326,7 @@ var pxt;
                 }
                 const anim = {
                     internalID: this.getNewInternalId(),
-                    type: "animation" /* Animation */,
+                    type: "animation" /* AssetType.Animation */,
                     meta: {
                         displayName: entry.displayName
                     },
@@ -116359,14 +116360,14 @@ var pxt;
         }
         generateNewID(type) {
             switch (type) {
-                case "animation" /* Animation */:
-                    return this.generateNewIDInternal("animation" /* Animation */, pxt.sprite.ANIMATION_PREFIX, pxt.sprite.ANIMATION_NAMESPACE);
-                case "image" /* Image */:
-                    return this.generateNewIDInternal("image" /* Image */, pxt.sprite.IMAGE_PREFIX, pxt.sprite.IMAGES_NAMESPACE);
-                case "tile" /* Tile */:
-                    return this.generateNewIDInternal("tile" /* Tile */, pxt.sprite.TILE_PREFIX, pxt.sprite.TILE_NAMESPACE);
-                case "tilemap" /* Tilemap */:
-                    return this.generateNewIDInternal("tilemap" /* Tilemap */, lf("level"));
+                case "animation" /* AssetType.Animation */:
+                    return this.generateNewIDInternal("animation" /* AssetType.Animation */, pxt.sprite.ANIMATION_PREFIX, pxt.sprite.ANIMATION_NAMESPACE);
+                case "image" /* AssetType.Image */:
+                    return this.generateNewIDInternal("image" /* AssetType.Image */, pxt.sprite.IMAGE_PREFIX, pxt.sprite.IMAGES_NAMESPACE);
+                case "tile" /* AssetType.Tile */:
+                    return this.generateNewIDInternal("tile" /* AssetType.Tile */, pxt.sprite.TILE_PREFIX, pxt.sprite.TILE_NAMESPACE);
+                case "tilemap" /* AssetType.Tilemap */:
+                    return this.generateNewIDInternal("tilemap" /* AssetType.Tilemap */, lf("level"));
             }
         }
         generateNewIDInternal(type, varPrefix, namespaceString) {
@@ -116388,12 +116389,12 @@ var pxt;
             for (const key of Object.keys(allJRes)) {
                 const entry = allJRes[key];
                 if (entry.tilemapTile) {
-                    const tile = this.generateImage(entry, "tile" /* Tile */);
+                    const tile = this.generateImage(entry, "tile" /* AssetType.Tile */);
                     tile.isProjectTile = isProjectFile;
                     assets.push(tile);
                 }
                 else if (entry.mimeType === pxt.IMAGE_MIME_TYPE) {
-                    assets.push(this.generateImage(entry, "image" /* Image */));
+                    assets.push(this.generateImage(entry, "image" /* AssetType.Image */));
                 }
                 else if (entry.mimeType === pxt.ANIMATION_MIME_TYPE) {
                     const [animation, needsInflation] = this.generateAnimation(entry);
@@ -116442,11 +116443,11 @@ var pxt;
                 // FIXME: we should get the "image.ofBuffer" and blockIdentity from pxtarget probably
                 out += `${indent}//% fixedInstance jres blockIdentity=images._tile\n`;
                 out += `${indent}export const ${key} = image.ofBuffer(hex\`\`);\n`;
-                tileEntries.push({ keys: [entry.displayName, getShortIDCore("tile" /* Tile */, key, true)], expression: key });
+                tileEntries.push({ keys: [entry.displayName, getShortIDCore("tile" /* AssetType.Tile */, key, true)], expression: key });
             }
             if (entry.mimeType === pxt.TILEMAP_MIME_TYPE) {
                 const tm = decodeTilemap(entry);
-                tilemapEntries.push({ keys: [entry.displayName, getShortIDCore("tilemap" /* Tilemap */, entry.id)], expression: pxt.sprite.encodeTilemap(tm, "typescript") });
+                tilemapEntries.push({ keys: [entry.displayName, getShortIDCore("tilemap" /* AssetType.Tilemap */, entry.id)], expression: pxt.sprite.encodeTilemap(tm, "typescript") });
             }
         }
         if (tilemapEntries.length) {
@@ -116470,7 +116471,7 @@ var pxt;
             const entry = jres[key];
             if (typeof entry === "string" || entry.mimeType === pxt.IMAGE_MIME_TYPE) {
                 let expression;
-                let factoryKeys = [getShortIDCore("image" /* Image */, key, true)];
+                let factoryKeys = [getShortIDCore("image" /* AssetType.Image */, key, true)];
                 if (typeof entry === "string") {
                     expression = pxt.sprite.bitmapToImageLiteral(pxt.sprite.getBitmapFromJResURL(entry), "typescript");
                 }
@@ -116486,7 +116487,7 @@ var pxt;
             else if (entry.mimeType === pxt.ANIMATION_MIME_TYPE) {
                 const animation = decodeAnimation(entry);
                 animationEntries.push({
-                    keys: [entry.displayName, getShortIDCore("animation" /* Animation */, key, true)],
+                    keys: [entry.displayName, getShortIDCore("animation" /* AssetType.Animation */, key, true)],
                     expression: `[${animation.frames.map(f => pxt.sprite.bitmapToImageLiteral(pxt.sprite.Bitmap.fromData(f), "typescript")).join(", ")}]`
                 });
             }
@@ -116530,12 +116531,12 @@ var pxt;
     function cloneAsset(asset) {
         asset.meta = Object.assign({}, asset.meta);
         switch (asset.type) {
-            case "tile" /* Tile */:
-            case "image" /* Image */:
+            case "tile" /* AssetType.Tile */:
+            case "image" /* AssetType.Image */:
                 return Object.assign(Object.assign({}, asset), { bitmap: cloneBitmap(asset.bitmap) });
-            case "animation" /* Animation */:
+            case "animation" /* AssetType.Animation */:
                 return Object.assign(Object.assign({}, asset), { frames: asset.frames.map(frame => cloneBitmap(frame)) });
-            case "tilemap" /* Tilemap */:
+            case "tilemap" /* AssetType.Tilemap */:
                 return Object.assign(Object.assign({}, asset), { data: asset.data.cloneData() });
         }
     }
@@ -116544,7 +116545,7 @@ var pxt;
         // Get the last part of the fully qualified name
         const id = asset.id.substr(asset.id.lastIndexOf(".") + 1);
         switch (asset.type) {
-            case "image" /* Image */:
+            case "image" /* AssetType.Image */:
                 allJRes[id] = asset.jresData;
                 if (asset.meta.displayName) {
                     allJRes[id] = {
@@ -116554,7 +116555,7 @@ var pxt;
                     };
                 }
                 break;
-            case "tile" /* Tile */:
+            case "tile" /* AssetType.Tile */:
                 allJRes[id] = {
                     data: asset.jresData,
                     mimeType: pxt.IMAGE_MIME_TYPE,
@@ -116562,12 +116563,12 @@ var pxt;
                     displayName: asset.meta.displayName
                 };
                 break;
-            case "tilemap" /* Tilemap */:
+            case "tilemap" /* AssetType.Tilemap */:
                 // we include the full ID for tilemaps
                 const serialized = serializeTilemap(asset.data, asset.id, asset.meta.displayName);
                 allJRes[serialized.id] = serialized;
                 break;
-            case "animation" /* Animation */:
+            case "animation" /* AssetType.Animation */:
                 allJRes[id] = serializeAnimation(asset);
                 break;
         }
@@ -116581,13 +116582,13 @@ var pxt;
             a.meta.displayName !== b.meta.displayName)
             return false;
         switch (a.type) {
-            case "image" /* Image */:
-            case "tile" /* Tile */:
+            case "image" /* AssetType.Image */:
+            case "tile" /* AssetType.Tile */:
                 return pxt.sprite.bitmapEquals(a.bitmap, b.bitmap);
-            case "animation" /* Animation */:
+            case "animation" /* AssetType.Animation */:
                 const bAnimation = b;
                 return a.interval === bAnimation.interval && pxt.U.arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
-            case "tilemap" /* Tilemap */:
+            case "tilemap" /* AssetType.Tilemap */:
                 return a.data.equals(b.data);
         }
     }
@@ -116611,7 +116612,7 @@ var pxt;
             shortId = getShortIDForAsset(asset);
         }
         if (!shortId) {
-            if (asset.type === "image" /* Image */ || asset.type === "tile" /* Tile */) {
+            if (asset.type === "image" /* pxt.AssetType.Image */ || asset.type === "tile" /* pxt.AssetType.Tile */) {
                 // Use the qualified name
                 return asset.id;
             }
@@ -116620,13 +116621,13 @@ var pxt;
         const leftTick = isPython ? `("""` : "`";
         const rightTick = isPython ? `""")` : "`";
         switch (asset.type) {
-            case "tile" /* Tile */:
+            case "tile" /* AssetType.Tile */:
                 return `assets.tile${leftTick}${shortId}${rightTick}`;
-            case "image" /* Image */:
+            case "image" /* AssetType.Image */:
                 return `assets.image${leftTick}${shortId}${rightTick}`;
-            case "animation" /* Animation */:
+            case "animation" /* AssetType.Animation */:
                 return `assets.animation${leftTick}${shortId}${rightTick}`;
-            case "tilemap" /* Tilemap */:
+            case "tilemap" /* AssetType.Tilemap */:
                 return `tilemap${leftTick}${shortId}${rightTick}`;
         }
     }
@@ -116649,13 +116650,13 @@ var pxt;
             const { type, name } = match;
             switch (type) {
                 case "tile":
-                    return project.lookupAssetByName("tile" /* Tile */, name);
+                    return project.lookupAssetByName("tile" /* AssetType.Tile */, name);
                 case "image":
-                    return project.lookupAssetByName("image" /* Image */, name);
+                    return project.lookupAssetByName("image" /* AssetType.Image */, name);
                 case "tilemap":
-                    return project.lookupAssetByName("tilemap" /* Tilemap */, name) || project.lookupAsset("tilemap" /* Tilemap */, name);
+                    return project.lookupAssetByName("tilemap" /* AssetType.Tilemap */, name) || project.lookupAsset("tilemap" /* AssetType.Tilemap */, name);
                 case "animation":
-                    return project.lookupAssetByName("animation" /* Animation */, name);
+                    return project.lookupAssetByName("animation" /* AssetType.Animation */, name);
             }
         }
         return undefined;
@@ -116663,13 +116664,13 @@ var pxt;
     pxt.lookupProjectAssetByTSReference = lookupProjectAssetByTSReference;
     function getDefaultAssetDisplayName(type) {
         switch (type) {
-            case "image" /* Image */:
+            case "image" /* pxt.AssetType.Image */:
                 return lf("myImage");
-            case "tile" /* Tile */:
+            case "tile" /* pxt.AssetType.Tile */:
                 return lf("myTile");
-            case "tilemap" /* Tilemap */:
+            case "tilemap" /* pxt.AssetType.Tilemap */:
                 return lf("level");
-            case "animation" /* Animation */:
+            case "animation" /* pxt.AssetType.Animation */:
                 return lf("myAnim");
             default:
                 return lf("asset");
@@ -116683,16 +116684,16 @@ var pxt;
     function getShortIDCore(assetType, id, allowNoPrefix = false) {
         let prefix;
         switch (assetType) {
-            case "image" /* Image */:
+            case "image" /* AssetType.Image */:
                 prefix = pxt.sprite.IMAGES_NAMESPACE + ".";
                 break;
-            case "tile" /* Tile */:
+            case "tile" /* AssetType.Tile */:
                 prefix = pxt.sprite.TILE_NAMESPACE + ".";
                 break;
-            case "tilemap" /* Tilemap */:
+            case "tilemap" /* AssetType.Tilemap */:
                 prefix = "";
                 break;
-            case "animation" /* Animation */:
+            case "animation" /* AssetType.Animation */:
                 prefix = pxt.sprite.ANIMATION_NAMESPACE + ".";
                 break;
         }
@@ -116762,7 +116763,7 @@ var pxt;
             id = id.replace(/\.\./g, ".");
         }
         return {
-            type: "animation" /* Animation */,
+            type: "animation" /* AssetType.Animation */,
             internalID: 0,
             id: id,
             interval,
@@ -117695,15 +117696,15 @@ var ts;
             ScriptTarget[ScriptTarget["Latest"] = 2] = "Latest";
         })(ScriptTarget = pxtc.ScriptTarget || (pxtc.ScriptTarget = {}));
         function isIdentifierStart(ch, languageVersion) {
-            return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ ||
-                ch === 36 /* $ */ || ch === 95 /* _ */ ||
-                ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
+            return ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */ || ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */ ||
+                ch === 36 /* CharacterCodes.$ */ || ch === 95 /* CharacterCodes._ */ ||
+                ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
         }
         pxtc.isIdentifierStart = isIdentifierStart;
         function isIdentifierPart(ch, languageVersion) {
-            return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ ||
-                ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ ||
-                ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
+            return ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */ || ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */ ||
+                ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */ || ch === 36 /* CharacterCodes.$ */ || ch === 95 /* CharacterCodes._ */ ||
+                ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
         }
         pxtc.isIdentifierPart = isIdentifierPart;
         pxtc.reservedWords = ["abstract", "any", "as", "break",
@@ -121718,7 +121719,7 @@ var ts;
                             const decl = getDecl(child);
                             if (decl && decl.getSourceFile().fileName !== pxt.MAIN_TS && decl.kind == ts.SyntaxKind.VariableDeclaration) {
                                 const info = pxtc.pxtInfo(child);
-                                info.flags |= 4 /* IsGlobalIdentifier */;
+                                info.flags |= 4 /* PxtNodeFlags.IsGlobalIdentifier */;
                                 if (!info.commentAttrs) {
                                     info.commentAttrs = pxtc.parseComments(decl);
                                 }
@@ -121834,7 +121835,7 @@ var ts;
                         symbol: { isBogusSymbol: true, name: namedNode.name.getText() },
                         name: namedNode.name,
                     };
-                    pxtc.pxtInfo(decl).flags |= 2 /* IsBogusFunction */;
+                    pxtc.pxtInfo(decl).flags |= 2 /* PxtNodeFlags.IsBogusFunction */;
                 }
                 return decl;
             }
@@ -122352,7 +122353,7 @@ ${baseLabel}_nochk:
                 else if (inf.size == 2) {
                     inf.immLimit = 64;
                 }
-                if (b == 1 /* Int8 */ || b == 3 /* Int16 */) {
+                if (b == 1 /* BitSize.Int8 */ || b == 3 /* BitSize.Int16 */) {
                     inf.needsSignExt = true;
                 }
                 return inf;
@@ -123941,7 +123942,7 @@ function ${id}(s) {
                     text = args.length == 2 ? `(${args[0]} ${pxtc.U.lookup(jsOpMap, name)} ${args[1]})` : `(${pxtc.U.lookup(jsOpMap, name)} ${args[0]})`;
                 else
                     text = `${shimToJs(name)}(${args.join(", ")})`;
-                if (topExpr.callingConvention == 0 /* Plain */) {
+                if (topExpr.callingConvention == 0 /* ir.CallingConvention.Plain */) {
                     write(`r0 = ${text};`);
                 }
                 else {
@@ -123950,7 +123951,7 @@ function ${id}(s) {
                     if (name == "String_::stringConv") {
                         write(`if ((${args[0]}) && (${args[0]}).vtable) {`);
                     }
-                    if (topExpr.callingConvention == 2 /* Promise */) {
+                    if (topExpr.callingConvention == 2 /* ir.CallingConvention.Promise */) {
                         write(`(function(cb) { ${text}.then(cb) })(buildResume(s, ${loc}));`);
                     }
                     else {
@@ -124073,13 +124074,13 @@ function ${id}(s) {
             }
             function bitSizeConverter(b) {
                 switch (b) {
-                    case 0 /* None */: return "";
-                    case 1 /* Int8 */: return "pxtrt.toInt8";
-                    case 3 /* Int16 */: return "pxtrt.toInt16";
-                    case 5 /* Int32 */: return "pxtrt.toInt32";
-                    case 2 /* UInt8 */: return "pxtrt.toUInt8";
-                    case 4 /* UInt16 */: return "pxtrt.toUInt16";
-                    case 6 /* UInt32 */: return "pxtrt.toUInt32";
+                    case 0 /* BitSize.None */: return "";
+                    case 1 /* BitSize.Int8 */: return "pxtrt.toInt8";
+                    case 3 /* BitSize.Int16 */: return "pxtrt.toInt16";
+                    case 5 /* BitSize.Int32 */: return "pxtrt.toInt32";
+                    case 2 /* BitSize.UInt8 */: return "pxtrt.toUInt8";
+                    case 4 /* BitSize.UInt16 */: return "pxtrt.toUInt16";
+                    case 6 /* BitSize.UInt32 */: return "pxtrt.toUInt32";
                     default: throw pxtc.oops();
                 }
             }
@@ -125228,7 +125229,7 @@ _start_${name}:
                         emitExpr(src);
                         let cell = trg.data;
                         let instr = "st" + cellref(cell);
-                        if (cell.isGlobal() && (cell.bitSize != 0 /* None */)) {
+                        if (cell.isGlobal() && (cell.bitSize != 0 /* BitSize.None */)) {
                             const enc = pxtc.sizeOfBitSize(cell.bitSize) |
                                 (pxtc.isBitSizeSigned(cell.bitSize) ? 0x10 : 0x00);
                             write("bitconv " + enc);
@@ -125640,7 +125641,7 @@ ${output}</xml>`;
                     }
                     return {
                         paramDefl: {},
-                        callingConvention: 0 /* Plain */
+                        callingConvention: 0 /* ir.CallingConvention.Plain */
                     };
                 }
                 function compInfo(callInfo) {
@@ -128129,7 +128130,7 @@ ${output}</xml>`;
                                 const parentInfo = pxtc.pxtInfo(parent).callInfo;
                                 if (parentInfo && parentInfo.args) {
                                     const api = env.blocks.apis.byQName[parentInfo.qName];
-                                    const instance = api.kind == 1 /* Method */ || api.kind == 2 /* Property */;
+                                    const instance = api.kind == 1 /* pxtc.SymbolKind.Method */ || api.kind == 2 /* pxtc.SymbolKind.Property */;
                                     if (api) {
                                         parentInfo.args.forEach((arg, i) => {
                                             if (arg === child) {
@@ -128246,7 +128247,7 @@ ${output}</xml>`;
                 return node && node.kind === SK.Identifier && node.text === "undefined";
             }
             function isDeclaredElsewhere(node) {
-                return !!(pxtc.pxtInfo(node).flags & 4 /* IsGlobalIdentifier */);
+                return !!(pxtc.pxtInfo(node).flags & 4 /* PxtNodeFlags.IsGlobalIdentifier */);
             }
             function hasStatementInput(info, attributes) {
                 if (attributes.blockId === pxtc.PAUSE_UNTIL_TYPE)
@@ -128619,21 +128620,21 @@ var ts;
                 if (!sym)
                     return undefined;
                 switch (sym.kind) {
-                    case 3 /* Function */:
-                    case 1 /* Method */:
+                    case 3 /* SymbolKind.Function */:
+                    case 1 /* SymbolKind.Method */:
                         return displayStringForFunction(sym, python, apiInfo);
-                    case 6 /* Enum */:
-                    case 7 /* EnumMember */:
+                    case 6 /* SymbolKind.Enum */:
+                    case 7 /* SymbolKind.EnumMember */:
                         return displayStringForEnum(sym, python);
-                    case 5 /* Module */:
+                    case 5 /* SymbolKind.Module */:
                         return displayStringForNamepsace(sym, python);
-                    case 9 /* Interface */:
+                    case 9 /* SymbolKind.Interface */:
                         return displayStringForInterface(sym, python);
-                    case 8 /* Class */:
+                    case 8 /* SymbolKind.Class */:
                         return displayStringForClass(sym, python);
-                    case 4 /* Variable */:
+                    case 4 /* SymbolKind.Variable */:
                         return displayStringForVariable(sym, python, apiInfo);
-                    case 2 /* Property */:
+                    case 2 /* SymbolKind.Property */:
                         return displayStringForProperty(sym, python, apiInfo);
                 }
                 return `**${sym.qName}**`;
@@ -128645,7 +128646,7 @@ var ts;
             service.displayStringForKeyword = displayStringForKeyword;
             function displayStringForFunction(sym, python, apiInfo) {
                 let prefix = "";
-                if (sym.kind === 3 /* Function */) {
+                if (sym.kind === 3 /* SymbolKind.Function */) {
                     prefix += python ? "def " : "function ";
                 }
                 else {
@@ -128664,7 +128665,7 @@ var ts;
             }
             function displayStringForEnum(sym, python) {
                 const qName = python ? sym.pyQName : sym.qName;
-                if (sym.kind === 6 /* Enum */) {
+                if (sym.kind === 6 /* SymbolKind.Enum */) {
                     return codeBlock(`enum ${qName}`, python);
                 }
                 let memberString = `(enum member) ${qName}`;
@@ -129308,7 +129309,7 @@ var ts;
                     this.exprKind = exprKind;
                     this.args = args;
                     this.data = data;
-                    this.callingConvention = 0 /* Plain */;
+                    this.callingConvention = 0 /* CallingConvention.Plain */;
                 }
                 static clone(e) {
                     let copy = new Expr(e.exprKind, e.args ? e.args.slice(0) : null, e.data);
@@ -129516,7 +129517,7 @@ var ts;
                     this._isGlobal = false;
                     this._debugType = "?";
                     this.isUserVariable = false;
-                    this.bitSize = 0 /* None */;
+                    this.bitSize = 0 /* BitSize.None */;
                     if (def) {
                         if (!pxtc.isInPxtModules(def)) {
                             this.isUserVariable = true;
@@ -129557,8 +129558,8 @@ var ts;
                 }
                 load() {
                     let r = this.loadCore();
-                    if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* None */) {
-                        if (this.bitSize == 6 /* UInt32 */)
+                    if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* BitSize.None */) {
+                        if (this.bitSize == 6 /* BitSize.UInt32 */)
                             return rtcall("pxt::fromUInt", [r]);
                         return rtcall("pxt::fromInt", [r]);
                     }
@@ -129577,8 +129578,8 @@ var ts;
                         return rtcall("pxtrt::stlocRef", [this.loadCore(), src]);
                     }
                     else {
-                        if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* None */) {
-                            let cnv = this.bitSize == 6 /* UInt32 */ ? "pxt::toUInt" : "pxt::toInt";
+                        if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* BitSize.None */) {
+                            let cnv = this.bitSize == 6 /* BitSize.UInt32 */ ? "pxt::toUInt" : "pxt::toInt";
                             return this.storeDirect(rtcall(cnv, [src], 1));
                         }
                         return this.storeDirect(src);
@@ -130143,25 +130144,25 @@ var ts;
             constructor(wave, id) {
                 this.wave = wave;
                 this.id = id;
-                this.flags = 0 /* None */;
+                this.flags = 0 /* PxtNodeFlags.None */;
                 this.resetAll();
             }
             refresh() {
                 // clear IsUsed flag
-                this.flags &= ~8 /* IsUsed */;
+                this.flags &= ~8 /* PxtNodeFlags.IsUsed */;
                 // this happens for top-level function expression - we just re-emit them
                 if (this.proc && !this.usedActions && !getEnclosingFunction(this.proc.action))
                     this.resetEmit();
                 else if (this.proc && !this.proc.cachedJS)
                     this.resetEmit();
                 else if (this.usedNodes)
-                    this.flags |= 32 /* FromPreviousCompile */;
+                    this.flags |= 32 /* PxtNodeFlags.FromPreviousCompile */;
                 if (this.classInfo)
                     this.classInfo.reset();
             }
             resetEmit() {
                 // clear IsUsed flag
-                this.flags &= ~(8 /* IsUsed */ | 32 /* FromPreviousCompile */);
+                this.flags &= ~(8 /* PxtNodeFlags.IsUsed */ | 32 /* PxtNodeFlags.FromPreviousCompile */);
                 if (this.proc && this.proc.classInfo && this.proc.classInfo.ctor == this.proc)
                     this.proc.classInfo.ctor = null;
                 this.functionInfo = null;
@@ -130176,7 +130177,7 @@ var ts;
             }
             resetTSC() {
                 // clear all flags except for InPxtModules
-                this.flags &= 16 /* InPxtModules */;
+                this.flags &= 16 /* PxtNodeFlags.InPxtModules */;
                 this.typeCache = null;
                 this.symbolCache = null;
                 this.commentAttrs = null;
@@ -130274,7 +130275,7 @@ var ts;
         let currNodeWave = 1;
         function isInPxtModules(node) {
             if (node.pxt)
-                return !!(node.pxt.flags & 16 /* InPxtModules */);
+                return !!(node.pxt.flags & 16 /* PxtNodeFlags.InPxtModules */);
             const src = ts.getSourceFileOfNode(node);
             return src ? pxtc.isPxtModulesFilename(src.fileName) : false;
         }
@@ -130283,7 +130284,7 @@ var ts;
             if (!n.pxt) {
                 const info = new PxtNode(currNodeWave, ++lastNodeId);
                 if (isInPxtModules(n))
-                    info.flags |= 16 /* InPxtModules */;
+                    info.flags |= 16 /* PxtNodeFlags.InPxtModules */;
                 n.pxt = info;
                 return info;
             }
@@ -130294,7 +130295,7 @@ var ts;
                     if (!pxtc.compileOptions || !pxtc.compileOptions.skipPxtModulesTSC)
                         info.resetAll();
                     else {
-                        if (info.flags & 16 /* InPxtModules */) {
+                        if (info.flags & 16 /* PxtNodeFlags.InPxtModules */) {
                             if (pxtc.compileOptions.skipPxtModulesEmit)
                                 info.refresh();
                             else
@@ -130381,43 +130382,43 @@ var ts;
         }
         function getBitSize(decl) {
             if (!decl || !decl.type)
-                return 0 /* None */;
+                return 0 /* BitSize.None */;
             if (!(isNumberType(typeOf(decl))))
-                return 0 /* None */;
+                return 0 /* BitSize.None */;
             if (decl.type.kind != pxtc.SK.TypeReference)
-                return 0 /* None */;
+                return 0 /* BitSize.None */;
             switch (decl.type.typeName.getText()) {
-                case "int8": return 1 /* Int8 */;
-                case "int16": return 3 /* Int16 */;
-                case "int32": return 5 /* Int32 */;
-                case "uint8": return 2 /* UInt8 */;
-                case "uint16": return 4 /* UInt16 */;
-                case "uint32": return 6 /* UInt32 */;
-                default: return 0 /* None */;
+                case "int8": return 1 /* BitSize.Int8 */;
+                case "int16": return 3 /* BitSize.Int16 */;
+                case "int32": return 5 /* BitSize.Int32 */;
+                case "uint8": return 2 /* BitSize.UInt8 */;
+                case "uint16": return 4 /* BitSize.UInt16 */;
+                case "uint32": return 6 /* BitSize.UInt32 */;
+                default: return 0 /* BitSize.None */;
             }
         }
         function sizeOfBitSize(b) {
             switch (b) {
-                case 0 /* None */: return pxtc.target.shortPointers ? 2 : 4;
-                case 1 /* Int8 */: return 1;
-                case 3 /* Int16 */: return 2;
-                case 5 /* Int32 */: return 4;
-                case 2 /* UInt8 */: return 1;
-                case 4 /* UInt16 */: return 2;
-                case 6 /* UInt32 */: return 4;
+                case 0 /* BitSize.None */: return pxtc.target.shortPointers ? 2 : 4;
+                case 1 /* BitSize.Int8 */: return 1;
+                case 3 /* BitSize.Int16 */: return 2;
+                case 5 /* BitSize.Int32 */: return 4;
+                case 2 /* BitSize.UInt8 */: return 1;
+                case 4 /* BitSize.UInt16 */: return 2;
+                case 6 /* BitSize.UInt32 */: return 4;
                 default: throw pxtc.oops();
             }
         }
         pxtc.sizeOfBitSize = sizeOfBitSize;
         function isBitSizeSigned(b) {
             switch (b) {
-                case 1 /* Int8 */:
-                case 3 /* Int16 */:
-                case 5 /* Int32 */:
+                case 1 /* BitSize.Int8 */:
+                case 3 /* BitSize.Int16 */:
+                case 5 /* BitSize.Int32 */:
                     return true;
-                case 2 /* UInt8 */:
-                case 4 /* UInt16 */:
-                case 6 /* UInt32 */:
+                case 2 /* BitSize.UInt8 */:
+                case 4 /* BitSize.UInt16 */:
+                case 6 /* BitSize.UInt32 */:
                     return false;
                 default: throw pxtc.oops();
             }
@@ -130432,7 +130433,7 @@ var ts;
                     pxtc.oops("void-typed variable, " + l.toString());
                 }
                 l.bitSize = getBitSize(l.def);
-                if (l.bitSize != 0 /* None */) {
+                if (l.bitSize != 0 /* BitSize.None */) {
                     l._debugType = (isBitSizeSigned(l.bitSize) ? "int" : "uint") + (8 * sizeOfBitSize(l.bitSize));
                 }
                 else if (isStringType(tp)) {
@@ -130442,8 +130443,8 @@ var ts;
                     l._debugType = "number";
                 }
             }
-            if (l.isLocal() && l.bitSize != 0 /* None */) {
-                l.bitSize = 0 /* None */;
+            if (l.isLocal() && l.bitSize != 0 /* BitSize.None */) {
+                l.bitSize = 0 /* BitSize.None */;
                 userError(9256, lf("bit sizes are not supported for locals and parameters"));
             }
         }
@@ -130595,7 +130596,7 @@ var ts;
                 this.itable = null;
             }
             get isUsed() {
-                return !!(pxtInfo(this.decl).flags & 8 /* IsUsed */);
+                return !!(pxtInfo(this.decl).flags & 8 /* PxtNodeFlags.IsUsed */);
             }
             allMethods() {
                 const r = [];
@@ -130610,7 +130611,7 @@ var ts;
                 for (let k of Object.keys(this.methods))
                     for (let m of this.methods[k]) {
                         const info = pxtInfo(m);
-                        if (info.flags & 8 /* IsUsed */)
+                        if (info.flags & 8 /* PxtNodeFlags.IsUsed */)
                             r.push(m);
                     }
                 return r;
@@ -130661,7 +130662,7 @@ var ts;
         pxtc.parseCommentsOnSymbol = parseCommentsOnSymbol;
         function parseComments(node) {
             const pinfo = node ? pxtInfo(node) : null;
-            if (!pinfo || pinfo.flags & 2 /* IsBogusFunction */)
+            if (!pinfo || pinfo.flags & 2 /* PxtNodeFlags.IsBogusFunction */)
                 return pxtc.parseCommentString("");
             if (pinfo.commentAttrs)
                 return pinfo.commentAttrs;
@@ -130928,7 +130929,7 @@ var ts;
                 this.capturedVars = [];
             }
             get isUsed() {
-                return !!(pxtInfo(this.decl).flags & 8 /* IsUsed */);
+                return !!(pxtInfo(this.decl).flags & 8 /* PxtNodeFlags.IsUsed */);
             }
         }
         pxtc.FunctionAddInfo = FunctionAddInfo;
@@ -131043,7 +131044,7 @@ var ts;
             };
             _rootFunction = rootFunction;
             const pinfo = pxtInfo(rootFunction);
-            pinfo.flags |= 1 /* IsRootFunction */ | 2 /* IsBogusFunction */;
+            pinfo.flags |= 1 /* PxtNodeFlags.IsRootFunction */ | 2 /* PxtNodeFlags.IsBogusFunction */;
             markUsed(rootFunction);
             usedWorkList = [];
             reset();
@@ -131322,7 +131323,7 @@ var ts;
                     for (let m of ci.allMethods()) {
                         const pinfo = pxtInfo(m);
                         const info = getFunctionInfo(m);
-                        if (pinfo.flags & 8 /* IsUsed */) {
+                        if (pinfo.flags & 8 /* PxtNodeFlags.IsUsed */) {
                             // we need to mark the parent as used, otherwise vtable layout fails, see #3740
                             if (info.virtualParent)
                                 markFunctionUsed(info.virtualParent.decl);
@@ -131460,8 +131461,8 @@ var ts;
                 }
             }
             function needsFullRecompileIfCached(pxtinfo) {
-                if ((pxtinfo.flags & 32 /* FromPreviousCompile */) ||
-                    (pxtinfo.flags & 16 /* InPxtModules */ &&
+                if ((pxtinfo.flags & 32 /* PxtNodeFlags.FromPreviousCompile */) ||
+                    (pxtinfo.flags & 16 /* PxtNodeFlags.InPxtModules */ &&
                         pxtc.compileOptions.skipPxtModulesEmit)) {
                     res.needsFullRecompile = true;
                     throw userError(9200, lf("full recompile required"));
@@ -131513,9 +131514,9 @@ var ts;
                             const pfield = pxtc.U.lookup(prevFields, key);
                             if (pfield) {
                                 const pxtinfo = pxtInfo(pfield);
-                                if (!(pxtinfo.flags & 64 /* IsOverridden */)) {
-                                    pxtinfo.flags |= 64 /* IsOverridden */;
-                                    if (pxtinfo.flags & 8 /* IsUsed */)
+                                if (!(pxtinfo.flags & 64 /* PxtNodeFlags.IsOverridden */)) {
+                                    pxtinfo.flags |= 64 /* PxtNodeFlags.IsOverridden */;
+                                    if (pxtinfo.flags & 8 /* PxtNodeFlags.IsUsed */)
                                         getIfaceMemberId(key, true);
                                     needsFullRecompileIfCached(pxtinfo);
                                 }
@@ -131715,7 +131716,7 @@ ${lbl}: .short 0xffff
                 let expr = emitExpr(e);
                 if (pxtc.target.isNative || isStringLiteral(e))
                     return irToNode(expr, isRef);
-                expr = pxtc.ir.rtcallMask("String_::stringConv", 1, 1 /* Async */, [expr]);
+                expr = pxtc.ir.rtcallMask("String_::stringConv", 1, 1 /* ir.CallingConvention.Async */, [expr]);
                 return irToNode(expr, true);
             }
             function emitTemplateExpression(node) {
@@ -131869,14 +131870,14 @@ ${lbl}: .short 0xffff
             function isSlowField(decl) {
                 if (decl.kind == pxtc.SK.Parameter || decl.kind == pxtc.SK.PropertyDeclaration) {
                     const pinfo = pxtInfo(decl);
-                    return !!pxtc.target.switches.slowFields || !!(pinfo.flags & 64 /* IsOverridden */);
+                    return !!pxtc.target.switches.slowFields || !!(pinfo.flags & 64 /* PxtNodeFlags.IsOverridden */);
                 }
                 return false;
             }
             function emitIndexedAccess(node, assign = null) {
                 let t = typeOf(node.expression);
                 let attrs = {
-                    callingConvention: 0 /* Plain */,
+                    callingConvention: 0 /* ir.CallingConvention.Plain */,
                     paramDefl: {},
                 };
                 let indexer = null;
@@ -131934,7 +131935,7 @@ ${lbl}: .short 0xffff
                     return true;
                 const info = pxtInfo(node);
                 if (bin.finalPass)
-                    return !!(info.flags & 8 /* IsUsed */);
+                    return !!(info.flags & 8 /* PxtNodeFlags.IsUsed */);
                 else
                     return info == currUsingContext;
             }
@@ -131951,8 +131952,8 @@ ${lbl}: .short 0xffff
                 if (isStackMachine() && isClassFunction(decl))
                     getIfaceMemberId(getName(decl), true);
                 recordUsage(decl);
-                if (!(pinfo.flags & 8 /* IsUsed */)) {
-                    pinfo.flags |= 8 /* IsUsed */;
+                if (!(pinfo.flags & 8 /* PxtNodeFlags.IsUsed */)) {
+                    pinfo.flags |= 8 /* PxtNodeFlags.IsUsed */;
                     if (isOnDemandDecl(decl))
                         usedWorkList.push(decl);
                 }
@@ -132004,7 +132005,7 @@ ${lbl}: .short 0xffff
                         symbol: { isBogusSymbol: true, name: namedNode.name.getText() },
                         name: namedNode.name,
                     };
-                    pxtInfo(decl).flags |= 2 /* IsBogusFunction */;
+                    pxtInfo(decl).flags |= 2 /* PxtNodeFlags.IsBogusFunction */;
                 }
                 pinfo.declCache = decl || null;
                 return decl;
@@ -132382,17 +132383,17 @@ ${lbl}: .short 0xffff
                 // smaller immediate range than plain "str" (and same for "ldr")
                 // All the pointers go at the end, for GC
                 globals.forEach((g, i) => g.index = i);
-                const sz = (b) => b == 0 /* None */ ? 10 : sizeOfBitSize(b);
+                const sz = (b) => b == 0 /* BitSize.None */ ? 10 : sizeOfBitSize(b);
                 globals.sort((a, b) => sz(a.bitSize) - sz(b.bitSize) ||
                     a.index - b.index);
                 let currOff = pxtc.numReservedGlobals * 4;
                 let firstPointer = 0;
                 for (let g of globals) {
-                    const bitSize = isStackMachine() ? 0 /* None */ : g.bitSize;
+                    const bitSize = isStackMachine() ? 0 /* BitSize.None */ : g.bitSize;
                     let sz = sizeOfBitSize(bitSize);
                     while (currOff & (sz - 1))
                         currOff++; // align
-                    if (!firstPointer && bitSize == 0 /* None */)
+                    if (!firstPointer && bitSize == 0 /* BitSize.None */)
                         firstPointer = currOff;
                     g.index = currOff;
                     currOff += sz;
@@ -132452,7 +132453,7 @@ ${lbl}: .short 0xffff
                     return;
                 // U.assert(!bin.finalPass)
                 const pinfo = pxtInfo(info.decl);
-                pinfo.flags |= 8 /* IsUsed */;
+                pinfo.flags |= 8 /* PxtNodeFlags.IsUsed */;
                 if (info.baseClassInfo)
                     markVTableUsed(info.baseClassInfo);
                 bin.usedClassInfos.push(info);
@@ -132802,7 +132803,7 @@ ${lbl}: .short 0xffff
                     pxtc.assert(!bin.finalPass, "!bin.finalPass");
                     const pinfo = pxtInfo(node);
                     const myProc = new pxtc.ir.Procedure();
-                    myProc.isRoot = !!(pinfo.flags & 1 /* IsRootFunction */);
+                    myProc.isRoot = !!(pinfo.flags & 1 /* PxtNodeFlags.IsRootFunction */);
                     myProc.action = node;
                     myProc.info = info;
                     pinfo.proc = myProc;
@@ -132933,7 +132934,7 @@ ${lbl}: .short 0xffff
             function emitFunctionDeclaration(node) {
                 if (!shouldEmitNow(node))
                     return undefined;
-                if (pxtInfo(node).flags & 32 /* FromPreviousCompile */)
+                if (pxtInfo(node).flags & 32 /* PxtNodeFlags.FromPreviousCompile */)
                     return undefined;
                 let attrs = parseComments(node);
                 if (attrs.shim != null) {
@@ -133526,7 +133527,7 @@ ${lbl}: .short 0xffff
                 return isNumberLikeType(typeOf(e));
             }
             function rtcallMaskDirect(name, args) {
-                return pxtc.ir.rtcallMask(name, (1 << args.length) - 1, 0 /* Plain */, args);
+                return pxtc.ir.rtcallMask(name, (1 << args.length) - 1, 0 /* ir.CallingConvention.Plain */, args);
             }
             function rtcallMask(name, args, attrs, append = null) {
                 let fmt = [];
@@ -133614,7 +133615,7 @@ ${lbl}: .short 0xffff
                         throw pxtc.U.oops("invalid format specifier: " + f);
                     }
                 });
-                let r = pxtc.ir.rtcallMask(name, mask, attrs ? attrs.callingConvention : 0 /* Plain */, args2);
+                let r = pxtc.ir.rtcallMask(name, mask, attrs ? attrs.callingConvention : 0 /* ir.CallingConvention.Plain */, args2);
                 if (!r.mask)
                     r.mask = { refMask: 0 };
                 r.mask.conversions = convInfos;
@@ -133780,7 +133781,7 @@ ${lbl}: .short 0xffff
                 let shim = (n) => {
                     n = mapIntOpName(n);
                     let args = [node.left, node.right];
-                    return pxtc.ir.rtcallMask(n, getMask(args), 0 /* Plain */, args.map(x => emitExpr(x)));
+                    return pxtc.ir.rtcallMask(n, getMask(args), 0 /* ir.CallingConvention.Plain */, args.map(x => emitExpr(x)));
                 };
                 if (node.operatorToken.kind == pxtc.SK.CommaToken) {
                     if (isNoopExpr(node.left))
@@ -134113,7 +134114,7 @@ ${lbl}: .short 0xffff
                         // we assume the value we're switching over will stay alive
                         // so, the mask only applies to the case expression if needed
                         // switch_eq() will decr(expr) if result is true
-                        let cmpCall = pxtc.ir.rtcallMask(mapIntOpName("pxt::switch_eq"), mask, 0 /* Plain */, [cmpExpr, expr]);
+                        let cmpCall = pxtc.ir.rtcallMask(mapIntOpName("pxt::switch_eq"), mask, 0 /* ir.CallingConvention.Plain */, [cmpExpr, expr]);
                         proc.emitJmp(lbl, cmpCall, pxtc.ir.JmpMode.IfNotZero, expr);
                     }
                     else if (cl.kind == pxtc.SK.DefaultClause) {
@@ -135272,13 +135273,13 @@ var pxt;
                 addFileOff++;
             let mapEnd = 0;
             for (let s of progHeaders) {
-                if (s.type == 1 /* LOAD */)
+                if (s.type == 1 /* PHT.LOAD */)
                     mapEnd = Math.max(mapEnd, s.vaddr + s.memsz);
             }
             let addMemOff = ((mapEnd + pageSize - 1) & ~(pageSize - 1)) + (addFileOff & (pageSize - 1));
             let phOffset = -1;
             for (let s of progHeaders) {
-                if (s.type == 4 /* NOTE */) {
+                if (s.type == 4 /* PHT.NOTE */) {
                     phOffset = s._filepos;
                 }
             }
@@ -135308,13 +135309,13 @@ var pxt;
             pxt.U.memcpy(resBuf, info.imageFileStart, program);
             let ph = {
                 _filepos: info.phOffset,
-                type: 1 /* LOAD */,
+                type: 1 /* PHT.LOAD */,
                 offset: info.imageFileStart,
                 vaddr: info.imageMemStart,
                 paddr: info.imageMemStart,
                 filesz: program.length,
                 memsz: program.length,
-                flags: 4 /* R */ | 1 /* X */,
+                flags: 4 /* PHF.R */ | 1 /* PHF.X */,
                 align: pageSize
             };
             savePH(resBuf, ph);
@@ -137778,10 +137779,10 @@ var ts;
                     // special case for enum members and enum members exported as constants,
                     // which have the return type 'EnumName.MemberName'. we want to match 'EnumName'
                     if (isEnum) {
-                        if (i.symbol.kind == 7 /* EnumMember */) {
+                        if (i.symbol.kind == 7 /* SymbolKind.EnumMember */) {
                             retType = i.symbol.namespace;
                         }
-                        else if (i.symbol.kind == 4 /* Variable */) {
+                        else if (i.symbol.kind == 4 /* SymbolKind.Variable */) {
                             const enumParts = (_b = (_a = i.symbol.attributes) === null || _a === void 0 ? void 0 : _a.enumIdentity) === null || _b === void 0 ? void 0 : _b.split(".");
                             if ((enumParts === null || enumParts === void 0 ? void 0 : enumParts.length) > 1)
                                 retType = enumParts[0];
@@ -137819,20 +137820,20 @@ var ts;
             service.getBasicKindDefault = getBasicKindDefault;
             function tsSymbolToPxtSymbolKind(ts) {
                 if (ts.flags & ts_1.SymbolFlags.Variable)
-                    return 4 /* Variable */;
+                    return 4 /* SymbolKind.Variable */;
                 if (ts.flags & ts_1.SymbolFlags.Class)
-                    return 8 /* Class */;
+                    return 8 /* SymbolKind.Class */;
                 if (ts.flags & ts_1.SymbolFlags.Enum)
-                    return 6 /* Enum */;
+                    return 6 /* SymbolKind.Enum */;
                 if (ts.flags & ts_1.SymbolFlags.EnumMember)
-                    return 7 /* EnumMember */;
+                    return 7 /* SymbolKind.EnumMember */;
                 if (ts.flags & ts_1.SymbolFlags.Method)
-                    return 1 /* Method */;
+                    return 1 /* SymbolKind.Method */;
                 if (ts.flags & ts_1.SymbolFlags.Module)
-                    return 5 /* Module */;
+                    return 5 /* SymbolKind.Module */;
                 if (ts.flags & ts_1.SymbolFlags.Property)
-                    return 2 /* Property */;
-                return 0 /* None */;
+                    return 2 /* SymbolKind.Property */;
+                return 0 /* SymbolKind.None */;
             }
             service.tsSymbolToPxtSymbolKind = tsSymbolToPxtSymbolKind;
             function makePxtSymbolFromKeyword(keyword) {
@@ -137840,14 +137841,14 @@ var ts;
                 //       type than "SymbolInfo" to carry auto completion information.
                 //       Some progress on this exists here: dazuniga/completionitem_refactor
                 let sym = {
-                    kind: 0 /* None */,
+                    kind: 0 /* SymbolKind.None */,
                     name: keyword,
                     pyName: keyword,
                     qName: keyword,
                     pyQName: keyword,
                     namespace: "",
                     attributes: {
-                        callingConvention: 0 /* Plain */,
+                        callingConvention: 0 /* ir.CallingConvention.Plain */,
                         paramDefl: {},
                     },
                     fileName: pxt.MAIN_TS,
@@ -137875,7 +137876,7 @@ var ts;
                     pyQName: qname,
                     namespace: ns,
                     attributes: {
-                        callingConvention: 0 /* Plain */,
+                        callingConvention: 0 /* ir.CallingConvention.Plain */,
                         paramDefl: {},
                     },
                     fileName: pxt.MAIN_TS,
@@ -138257,7 +138258,7 @@ var ts;
                 resultSymbols
                     .map(sym => {
                     // skip for enum member completions (eg "AnimalMob."" should have "Chicken", not "CHICKEN")
-                    if (sym.symbol.attributes.alias && !(isMemberCompletion && sym.symbol.kind === 7 /* EnumMember */)) {
+                    if (sym.symbol.attributes.alias && !(isMemberCompletion && sym.symbol.kind === 7 /* SymbolKind.EnumMember */)) {
                         return completionSymbol(service.lastApiInfo.apis.byQName[sym.symbol.attributes.alias], sym.weight);
                     }
                     else {
@@ -138526,29 +138527,29 @@ var ts;
             switch (node.kind) {
                 case pxtc.SK.MethodDeclaration:
                 case pxtc.SK.MethodSignature:
-                    return 1 /* Method */;
+                    return 1 /* SymbolKind.Method */;
                 case pxtc.SK.PropertyDeclaration:
                 case pxtc.SK.PropertySignature:
                 case pxtc.SK.GetAccessor:
                 case pxtc.SK.SetAccessor:
-                    return 2 /* Property */;
+                    return 2 /* SymbolKind.Property */;
                 case pxtc.SK.Constructor:
                 case pxtc.SK.FunctionDeclaration:
-                    return 3 /* Function */;
+                    return 3 /* SymbolKind.Function */;
                 case pxtc.SK.VariableDeclaration:
-                    return 4 /* Variable */;
+                    return 4 /* SymbolKind.Variable */;
                 case pxtc.SK.ModuleDeclaration:
-                    return 5 /* Module */;
+                    return 5 /* SymbolKind.Module */;
                 case pxtc.SK.EnumDeclaration:
-                    return 6 /* Enum */;
+                    return 6 /* SymbolKind.Enum */;
                 case pxtc.SK.EnumMember:
-                    return 7 /* EnumMember */;
+                    return 7 /* SymbolKind.EnumMember */;
                 case pxtc.SK.ClassDeclaration:
-                    return 8 /* Class */;
+                    return 8 /* SymbolKind.Class */;
                 case pxtc.SK.InterfaceDeclaration:
-                    return 9 /* Interface */;
+                    return 9 /* SymbolKind.Interface */;
                 default:
-                    return 0 /* None */;
+                    return 0 /* SymbolKind.None */;
             }
         }
         function createSymbolInfo(typechecker, qName, stmt) {
@@ -138572,13 +138573,13 @@ var ts;
                 return readableName;
             }
             let kind = getSymbolKind(stmt);
-            if (kind != 0 /* None */) {
+            if (kind != 0 /* SymbolKind.None */) {
                 let decl = stmt;
                 let attributes = pxtc.parseComments(decl);
                 if (attributes.weight < 0)
                     return null;
                 let m = /^(.*)\.(.*)/.exec(qName);
-                let hasParams = kind == 3 /* Function */ || kind == 1 /* Method */;
+                let hasParams = kind == 3 /* SymbolKind.Function */ || kind == 1 /* SymbolKind.Method */;
                 let pkg = null;
                 let pkgs = null;
                 let src = ts.getSourceFileOfNode(stmt);
@@ -138588,7 +138589,7 @@ var ts;
                         pkg = m[1];
                 }
                 let extendsTypes = undefined;
-                if (kind == 8 /* Class */ || kind == 9 /* Interface */) {
+                if (kind == 8 /* SymbolKind.Class */ || kind == 9 /* SymbolKind.Interface */) {
                     let cl = stmt;
                     extendsTypes = [];
                     if (cl.heritageClauses)
@@ -138600,7 +138601,7 @@ var ts;
                             }
                         }
                 }
-                if (kind == 6 /* Enum */ || kind === 7 /* EnumMember */) {
+                if (kind == 6 /* SymbolKind.Enum */ || kind === 7 /* SymbolKind.EnumMember */) {
                     (extendsTypes || (extendsTypes = [])).push("Number");
                 }
                 let r = {
@@ -138614,7 +138615,7 @@ var ts;
                     pkgs,
                     extendsTypes,
                     retType: stmt.kind == ts.SyntaxKind.Constructor ? "void" :
-                        kind == 5 /* Module */ ? "" :
+                        kind == 5 /* SymbolKind.Module */ ? "" :
                             typeOf(decl.type, decl, hasParams),
                     parameters: !hasParams ? null : pxtc.Util.toArray(decl.parameters).map((p, i) => {
                         let n = pxtc.getName(p);
@@ -138681,19 +138682,19 @@ var ts;
                     snippet: ts.isFunctionLike(stmt) ? null : undefined
                 };
                 switch (r.kind) {
-                    case 7 /* EnumMember */:
+                    case 7 /* SymbolKind.EnumMember */:
                         r.pyName = pxtc.U.snakify(r.name).toUpperCase();
                         break;
-                    case 4 /* Variable */:
-                    case 1 /* Method */:
-                    case 2 /* Property */:
-                    case 3 /* Function */:
+                    case 4 /* SymbolKind.Variable */:
+                    case 1 /* SymbolKind.Method */:
+                    case 2 /* SymbolKind.Property */:
+                    case 3 /* SymbolKind.Function */:
                         r.pyName = pxtc.U.snakify(r.name);
                         break;
-                    case 6 /* Enum */:
-                    case 8 /* Class */:
-                    case 9 /* Interface */:
-                    case 5 /* Module */:
+                    case 6 /* SymbolKind.Enum */:
+                    case 8 /* SymbolKind.Class */:
+                    case 9 /* SymbolKind.Interface */:
+                    case 5 /* SymbolKind.Module */:
                     default:
                         r.pyName = r.name;
                         break;
@@ -138711,7 +138712,7 @@ var ts;
             pxt.debug(JSON.stringify(Object.keys(apiInfo.byQName), null, 2));
             const files = {};
             const infos = pxtc.Util.values(apiInfo.byQName);
-            const enumMembers = infos.filter(si => si.kind == 7 /* EnumMember */)
+            const enumMembers = infos.filter(si => si.kind == 7 /* SymbolKind.EnumMember */)
                 .sort(compareSymbols);
             const snippetStrings = {};
             const locStrings = {};
@@ -138724,7 +138725,7 @@ var ts;
                     return; // skip functions starting with __
                 pxt.debug(`loc: ${si.qName}`);
                 // must match blockly loader
-                if (si.kind != 7 /* EnumMember */) {
+                if (si.kind != 7 /* SymbolKind.EnumMember */) {
                     const ns = ts.pxtc.blocksCategory(si);
                     if (ns)
                         locStrings[`{id:category}${ns}`] = ns;
@@ -138750,7 +138751,7 @@ var ts;
                 files[pkg + name + "-strings.json"] = JSON.stringify(locs, null, 2);
             };
             for (const info of infos) {
-                const isNamespace = info.kind == 5 /* Module */;
+                const isNamespace = info.kind == 5 /* SymbolKind.Module */;
                 if (isNamespace) {
                     if (!infos.filter(si => si.namespace == info.name && !!si.attributes.jsDoc)[0])
                         continue; // nothing in namespace
@@ -138808,14 +138809,14 @@ var ts;
             // sort by symbol kind
             if (!symbolKindWeight) {
                 symbolKindWeight = {};
-                symbolKindWeight[4 /* Variable */] = 100;
-                symbolKindWeight[5 /* Module */] = 101;
-                symbolKindWeight[3 /* Function */] = 99;
-                symbolKindWeight[2 /* Property */] = 98;
-                symbolKindWeight[1 /* Method */] = 97;
-                symbolKindWeight[8 /* Class */] = 89;
-                symbolKindWeight[6 /* Enum */] = 81;
-                symbolKindWeight[7 /* EnumMember */] = 80;
+                symbolKindWeight[4 /* SymbolKind.Variable */] = 100;
+                symbolKindWeight[5 /* SymbolKind.Module */] = 101;
+                symbolKindWeight[3 /* SymbolKind.Function */] = 99;
+                symbolKindWeight[2 /* SymbolKind.Property */] = 98;
+                symbolKindWeight[1 /* SymbolKind.Method */] = 97;
+                symbolKindWeight[8 /* SymbolKind.Class */] = 89;
+                symbolKindWeight[6 /* SymbolKind.Enum */] = 81;
+                symbolKindWeight[7 /* SymbolKind.EnumMember */] = 80;
             }
             c = cmpr(s => symbolKindWeight[s.kind] || 0);
             if (c)
@@ -138859,11 +138860,11 @@ var ts;
                         let existing = pxtc.U.lookup(res.byQName, qName);
                         if (existing) {
                             // we can have a function and an interface of the same name
-                            if (existing.kind == 9 /* Interface */ && si.kind != 9 /* Interface */) {
+                            if (existing.kind == 9 /* SymbolKind.Interface */ && si.kind != 9 /* SymbolKind.Interface */) {
                                 // save existing entry
                                 res.byQName[qName + "@type"] = existing;
                             }
-                            else if (existing.kind != 9 /* Interface */ && si.kind == 9 /* Interface */) {
+                            else if (existing.kind != 9 /* SymbolKind.Interface */ && si.kind == 9 /* SymbolKind.Interface */) {
                                 res.byQName[qName + "@type"] = si;
                                 si = existing;
                             }
@@ -138882,7 +138883,7 @@ var ts;
                                 // Check if the colliding symbols are namespace definitions. The same namespace can be
                                 // defined in different packages/extensions, so we want to keep track of that information.
                                 // That way, we can make sure each cached extension has a copy of the namespace
-                                if (existing.kind === 5 /* Module */) {
+                                if (existing.kind === 5 /* SymbolKind.Module */) {
                                     // Reference the existing array of packages where this namespace has been defined
                                     si.pkgs = existing.pkgs || [];
                                     if (existing.pkg !== si.pkg) {
@@ -139782,7 +139783,7 @@ var ts;
                                     .reduce((x, y) => x.concat(y.extendsTypes), []);
                             };
                             // all fixed instances for this namespace
-                            let fixedInstances = instances.filter(value => value.kind === 4 /* Variable */ &&
+                            let fixedInstances = instances.filter(value => value.kind === 4 /* pxtc.SymbolKind.Variable */ &&
                                 value.attributes.fixedInstance);
                             let instanceToUse;
                             // first try to get fixed instances whose retType matches nsInfo.name
@@ -139810,7 +139811,7 @@ var ts;
                                 addNamespace = true;
                             }
                         }
-                        else if (element.kind == 1 /* Method */ || element.kind == 2 /* Property */) {
+                        else if (element.kind == 1 /* pxtc.SymbolKind.Method */ || element.kind == 2 /* pxtc.SymbolKind.Property */) {
                             if (params.thisParameter) {
                                 let varName = undefined;
                                 if (params.thisParameter.definitionName) {
@@ -139823,7 +139824,7 @@ var ts;
                                     snippetPrefix = pxtc.U.snakify(snippetPrefix);
                             }
                         }
-                        else if (nsInfo.kind === 8 /* Class */) {
+                        else if (nsInfo.kind === 8 /* pxtc.SymbolKind.Class */) {
                             return undefined;
                         }
                     }
@@ -139836,7 +139837,7 @@ var ts;
                 }
                 else {
                     snippet = [fnName];
-                    if ((args === null || args === void 0 ? void 0 : args.length) || element.kind == 1 /* Method */ || element.kind == 3 /* Function */ || element.kind == 8 /* Class */) {
+                    if ((args === null || args === void 0 ? void 0 : args.length) || element.kind == 1 /* pxtc.SymbolKind.Method */ || element.kind == 3 /* pxtc.SymbolKind.Function */ || element.kind == 8 /* pxtc.SymbolKind.Class */) {
                         const argsWithCommas = args.reduce((p, n) => [...p, p.length ? ", " : "", n], []);
                         snippet = snippet.concat(["(", ...argsWithCommas, ")"]);
                     }
@@ -140002,7 +140003,7 @@ var ts;
                     return undefined;
                 }
                 function getFixedInstancesOf(type) {
-                    return pxt.Util.values(apis.byQName).filter(sym => sym.kind === 4 /* Variable */
+                    return pxt.Util.values(apis.byQName).filter(sym => sym.kind === 4 /* pxtc.SymbolKind.Variable */
                         && sym.attributes.fixedInstance
                         && isSubtype(apis, sym.retType, type.qName));
                 }
@@ -140762,12 +140763,12 @@ var pxt;
                 error(null, 9501, pxt.U.lf("unknown type '{0}' near '{1}'", tp, currErrorCtx || "???"));
                 return mkType({ primType: tp });
             }
-            if (sym.kind == 7 /* EnumMember */)
+            if (sym.kind == 7 /* SK.EnumMember */)
                 return tpNumber;
             // sym.pyInstanceType might not be initialized yet and we don't want to call symbolType() here to avoid infinite recursion
-            if (sym.kind == 8 /* Class */ || sym.kind == 9 /* Interface */)
+            if (sym.kind == 8 /* SK.Class */ || sym.kind == 9 /* SK.Interface */)
                 return sym.pyInstanceType || mkType({ classType: sym });
-            if (sym.kind == 6 /* Enum */)
+            if (sym.kind == 6 /* SK.Enum */)
                 return tpNumber;
             error(null, 9502, pxt.U.lf("'{0}' is not a type near '{1}'", tp, currErrorCtx || "???"));
             return mkType({ primType: tp });
@@ -140824,7 +140825,7 @@ var pxt;
                 if (prevRetType) {
                     unify(sym.pyAST, prevRetType, sym.pyRetType);
                 }
-                if (sym.kind == 3 /* Function */ || sym.kind == 1 /* Method */) {
+                if (sym.kind == 3 /* SK.Function */ || sym.kind == 1 /* SK.Method */) {
                     let paramTypes = sym.parameters.map(p => p.pyType);
                     if (paramTypes.some(isFalsy)) {
                         error(null, 9526, pxt.U.lf("function symbol is missing parameter types near '{1}'", currErrorCtx || "???"));
@@ -140834,7 +140835,7 @@ var pxt;
                 }
                 else
                     sym.pySymbolType = sym.pyRetType;
-                if (sym.kind == 8 /* Class */ || sym.kind == 9 /* Interface */) {
+                if (sym.kind == 8 /* SK.Class */ || sym.kind == 9 /* SK.Interface */) {
                     sym.pyInstanceType = mkType({ classType: sym });
                 }
                 currErrorCtx = undefined;
@@ -140854,7 +140855,7 @@ var pxt;
             else if (name.indexOf(".") && !name.endsWith(".__constructor")) {
                 const base = name.substring(0, name.lastIndexOf("."));
                 const baseSymbol = lookupGlobalSymbol(base);
-                if ((baseSymbol === null || baseSymbol === void 0 ? void 0 : baseSymbol.kind) === 8 /* Class */ && ((_a = baseSymbol.extendsTypes) === null || _a === void 0 ? void 0 : _a.length)) {
+                if ((baseSymbol === null || baseSymbol === void 0 ? void 0 : baseSymbol.kind) === 8 /* SK.Class */ && ((_a = baseSymbol.extendsTypes) === null || _a === void 0 ? void 0 : _a.length)) {
                     return lookupGlobalSymbol(baseSymbol.extendsTypes[0] + name.substring(base.length));
                 }
             }
@@ -140948,17 +140949,17 @@ var pxt;
                 }
                 let qualifiedName = pref + name;
                 if (scope.kind === "ClassDef") {
-                    varSym = addSymbol(2 /* Property */, qualifiedName);
+                    varSym = addSymbol(2 /* SK.Property */, qualifiedName);
                 }
                 else if (isLocalScope(scope)
                     && (modifier === py_1.VarModifier.Global
                         || modifier === py_1.VarModifier.NonLocal)) {
-                    varSym = addSymbol(4 /* Variable */, name);
+                    varSym = addSymbol(4 /* SK.Variable */, name);
                 }
                 else if (isLocalScope(scope))
-                    varSym = mkSymbol(4 /* Variable */, name);
+                    varSym = mkSymbol(4 /* SK.Variable */, name);
                 else
-                    varSym = addSymbol(4 /* Variable */, qualifiedName);
+                    varSym = addSymbol(4 /* SK.Variable */, qualifiedName);
                 varScopeSym = {
                     symbol: varSym,
                     modifier,
@@ -141211,8 +141212,7 @@ var pxt;
             }
         }
         function isSymbol(c) {
-            var _a;
-            return !!((_a = c) === null || _a === void 0 ? void 0 : _a.name);
+            return !!(c === null || c === void 0 ? void 0 : c.name);
         }
         function isGenericType(t) {
             var _a;
@@ -141277,7 +141277,7 @@ var pxt;
         // TODO optimize ?
         function listClassFields(cd) {
             let qn = cd.symInfo.qName;
-            return pxt.U.values(internalApis).filter(e => e.namespace == qn && e.kind == 2 /* Property */);
+            return pxt.U.values(internalApis).filter(e => e.namespace == qn && e.kind == 2 /* SK.Property */);
         }
         function getClassField(ct, n, isStatic, checkOnly = false, skipBases = false) {
             let qid;
@@ -141308,7 +141308,7 @@ var pxt;
                 }
             }
             if (!checkOnly && ct.pyAST && ct.pyAST.kind == "ClassDef") {
-                let sym = addSymbol(2 /* Property */, qid);
+                let sym = addSymbol(2 /* SK.Property */, qid);
                 sym.isInstance = !isStatic;
                 return sym;
             }
@@ -141444,10 +141444,10 @@ var pxt;
             if (!s)
                 return false;
             switch (s.kind) {
-                case 5 /* Module */:
-                case 9 /* Interface */:
-                case 8 /* Class */:
-                case 6 /* Enum */:
+                case 5 /* SK.Module */:
+                case 9 /* SK.Interface */:
+                case 8 /* SK.Class */:
+                case 6 /* SK.Enum */:
                     return true;
                 default:
                     return false;
@@ -141489,7 +141489,7 @@ var pxt;
                 let sym = lookupApi(tpName + "@type") || lookupApi(tpName);
                 if (sym) {
                     getOrSetSymbolType(sym);
-                    if (sym.kind == 6 /* Enum */)
+                    if (sym.kind == 6 /* SK.Enum */)
                         return tpNumber;
                     if (sym.pyInstanceType)
                         return sym.pyInstanceType;
@@ -141694,7 +141694,7 @@ var pxt;
                 const nested = !!ctx.currFun;
                 setupScope(n);
                 const existing = lookupSymbol(getFullName(n));
-                const sym = addSymbolFor(isMethod ? 1 /* Method */ : 3 /* Function */, n);
+                const sym = addSymbolFor(isMethod ? 1 /* SK.Method */ : 3 /* SK.Function */, n);
                 if (!inline) {
                     if (existing && existing.declared === currIteration) {
                         error(n, 9520, lf("Duplicate function declaration"));
@@ -141799,7 +141799,7 @@ var pxt;
             FunctionDef: (n) => emitFunctionDef(n),
             ClassDef: (n) => guardedScope(n, () => {
                 setupScope(n);
-                const sym = addSymbolFor(8 /* Class */, n);
+                const sym = addSymbolFor(8 /* SK.Class */, n);
                 pxt.U.assert(!ctx.currClass);
                 let topLev = isTopLevel();
                 ctx.currClass = n;
@@ -142248,7 +142248,7 @@ var pxt;
                 const scopeSym = currentScope().vars[nm];
                 const sym = scopeSym === null || scopeSym === void 0 ? void 0 : scopeSym.symbol;
                 // Mark the assignment only if the variable is declared in this scope
-                if (sym && sym.kind === 4 /* Variable */ && scopeSym.modifier === undefined) {
+                if (sym && sym.kind === 4 /* SK.Variable */ && scopeSym.modifier === undefined) {
                     if (scopeSym.firstAssignPos === undefined
                         || scopeSym.firstAssignPos > target.startPos) {
                         scopeSym.firstAssignPos = target.startPos;
@@ -142315,7 +142315,7 @@ var pxt;
             let localScopeVar = currentScope().vars[id];
             let local = localScopeVar === null || localScopeVar === void 0 ? void 0 : localScopeVar.symbol;
             if (n.isdef === undefined) {
-                if (!curr || (curr.kind === 4 /* Variable */ && curr !== local)) {
+                if (!curr || (curr.kind === 4 /* SK.Variable */ && curr !== local)) {
                     if (ctx.currClass && !ctx.currFun) {
                         n.isdef = false; // field
                         currScopeVar = defvar(id, {});
@@ -142593,7 +142593,7 @@ var pxt;
                 n.func.inCalledPosition = true;
                 let nm = tryGetName(n.func);
                 let namedSymbol = lookupSymbol(nm);
-                let isClass = namedSymbol && namedSymbol.kind == 8 /* Class */;
+                let isClass = namedSymbol && namedSymbol.kind == 8 /* SK.Class */;
                 let fun = namedSymbol;
                 let recvTp = undefined;
                 let recv = undefined;
@@ -142601,7 +142601,7 @@ var pxt;
                 if (isClass) {
                     fun = lookupSymbol(namedSymbol.pyQName + ".__constructor");
                     if (!fun) {
-                        fun = addSymbolFor(3 /* Function */, createDummyConstructorSymbol(namedSymbol === null || namedSymbol === void 0 ? void 0 : namedSymbol.pyAST));
+                        fun = addSymbolFor(3 /* SK.Function */, createDummyConstructorSymbol(namedSymbol === null || namedSymbol === void 0 ? void 0 : namedSymbol.pyAST));
                     }
                 }
                 else {
@@ -142669,7 +142669,7 @@ var pxt;
                             recvTp = typeOf(recv);
                             methName = over.n.slice(1);
                             fun = getTypeField(recv, methName);
-                            if (fun && fun.kind == 2 /* Property */)
+                            if (fun && fun.kind == 2 /* SK.Property */)
                                 return B.mkInfix(expr(recv), ".", B.mkText(methName));
                         }
                         else {
@@ -143094,7 +143094,7 @@ var pxt;
             return hoisted;
         }
         function shouldHoist(sym, scope) {
-            let result = sym.symbol.kind === 4 /* Variable */
+            let result = sym.symbol.kind === 4 /* SK.Variable */
                 && !sym.symbol.isParam
                 && sym.modifier === undefined
                 && (sym.lastRefPos > sym.forVariableEndPos
@@ -143251,14 +143251,14 @@ var pxt;
             diagnostics = parseDiags.concat(diagnostics);
             const isGlobalSymbol = (si) => {
                 switch (si.kind) {
-                    case 6 /* Enum */:
-                    case 7 /* EnumMember */:
-                    case 4 /* Variable */:
-                    case 3 /* Function */:
-                    case 5 /* Module */:
+                    case 6 /* SK.Enum */:
+                    case 7 /* SK.EnumMember */:
+                    case 4 /* SK.Variable */:
+                    case 3 /* SK.Function */:
+                    case 5 /* SK.Module */:
                         return true;
-                    case 2 /* Property */:
-                    case 1 /* Method */:
+                    case 2 /* SK.Property */:
+                    case 1 /* SK.Method */:
                         return !si.isInstance;
                     default:
                         return false;
@@ -143495,7 +143495,7 @@ var pxt;
                 },
                 decorator_list: [],
                 vars: {},
-                symInfo: mkSymbol(3 /* Function */, def.symInfo.qName + ".__constructor")
+                symInfo: mkSymbol(3 /* SK.Function */, def.symInfo.qName + ".__constructor")
             };
             result.symInfo.parameters = [];
             result.symInfo.pyRetType = mkType({ classType: def.symInfo });
@@ -153563,13 +153563,13 @@ var pxsim;
             }
         }
         postMessageCore(frame, msg) {
-            var _a, _b, _c, _d;
+            var _a, _b;
             frame.contentWindow.postMessage(msg, frame.dataset['origin']);
-            if (pxsim.U.isLocalHostDev() && ((_b = (_a = pxt) === null || _a === void 0 ? void 0 : _a.appTarget) === null || _b === void 0 ? void 0 : _b.id)) {
+            if (pxsim.U.isLocalHostDev() && ((_a = pxt === null || pxt === void 0 ? void 0 : pxt.appTarget) === null || _a === void 0 ? void 0 : _a.id)) {
                 // If using the production simulator on local serve, the domain might have been
                 // redirected by the CLI server. Also send to the production domain just in case
                 try {
-                    frame.contentWindow.postMessage(msg, `https://trg-${(_d = (_c = pxt) === null || _c === void 0 ? void 0 : _c.appTarget) === null || _d === void 0 ? void 0 : _d.id}.userpxt.io/---simulator`);
+                    frame.contentWindow.postMessage(msg, `https://trg-${(_b = pxt === null || pxt === void 0 ? void 0 : pxt.appTarget) === null || _b === void 0 ? void 0 : _b.id}.userpxt.io/---simulator`);
                 }
                 catch (e) {
                     // Ignore exceptions if the target origin doesn't match
@@ -160322,11 +160322,11 @@ function serveAsync(parsed) {
     }));
 }
 exports.serveAsync = serveAsync;
-const readFileAsync = util_1.promisify(fs.readFile);
-const writeFileAsync = util_1.promisify(fs.writeFile);
-const readDirAsync = util_1.promisify(fs.readdir);
-const statAsync = util_1.promisify(fs.stat);
-const rimrafAsync = util_1.promisify(rimraf);
+const readFileAsync = (0, util_1.promisify)(fs.readFile);
+const writeFileAsync = (0, util_1.promisify)(fs.writeFile);
+const readDirAsync = (0, util_1.promisify)(fs.readdir);
+const statAsync = (0, util_1.promisify)(fs.stat);
+const rimrafAsync = (0, util_1.promisify)(rimraf);
 let commonfiles = {};
 class SnippetHost {
     constructor(name, packageFiles, extraDependencies, includeCommon = false) {