pxt-core 8.2.13 → 8.2.14

package/built/pxtlib.js

@@ -3802,7 +3802,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);
@@ -4461,6 +4461,7 @@ var pxt;
         }
     })(blocks = pxt.blocks || (pxt.blocks = {}));
 })(pxt || (pxt = {}));
+/// <reference path="../localtypings/dom.d.ts" />
 var pxt;
 (function (pxt) {
     var BrowserUtils;
@@ -12999,7 +13000,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));
         }
@@ -15515,7 +15516,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
@@ -15527,7 +15528,7 @@ var ts;
                         fileName: s.fileName,
                         qName: `${mkey}.${tp}`,
                         pkg: s.pkg,
-                        kind: 2 /* Property */,
+                        kind: 2 /* SymbolKind.Property */,
                         parameters: [
                             {
                                 name: "property",
@@ -15641,15 +15642,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 : [];
@@ -15703,7 +15704,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);
@@ -15886,7 +15887,7 @@ var ts;
         function parseCommentString(cmt) {
             let res = {
                 paramDefl: {},
-                callingConvention: 0 /* Plain */,
+                callingConvention: 0 /* ir.CallingConvention.Plain */,
                 _source: cmt
             };
             let didSomething = true;
@@ -16018,9 +16019,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) {
@@ -16102,11 +16103,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;
@@ -16116,21 +16117,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;
                             }
                         }
@@ -16151,12 +16152,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);
                 }
@@ -16168,7 +16169,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 = [];
@@ -16178,7 +16179,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) {
@@ -16200,35 +16201,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" });
                 }
             }
@@ -16297,9 +16298,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 });
                     }
@@ -16784,7 +16785,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, {
@@ -16794,7 +16795,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, {
@@ -17953,12 +17954,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)
@@ -17966,12 +17967,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: {},
@@ -17979,11 +17980,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 },
@@ -18016,13 +18017,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: {
@@ -18036,8 +18037,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
@@ -18052,7 +18053,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);
@@ -18115,7 +18116,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];
@@ -18132,7 +18133,7 @@ var pxt;
                 tile = {
                     internalID: this.getNewInternalId(),
                     id,
-                    type: "tile" /* Tile */,
+                    type: "tile" /* AssetType.Tile */,
                     bitmap: bitmap,
                     jresData: pxt.sprite.base64EncodeBitmap(bitmap),
                     meta: {},
@@ -18144,11 +18145,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
                 },
@@ -18235,13 +18236,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);
                 }
             };
@@ -18279,8 +18280,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;
                     }
@@ -18294,15 +18295,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}\``;
@@ -18316,15 +18317,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}"""\)`;
@@ -18355,63 +18356,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);
             }
         }
@@ -18422,17 +18423,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;
@@ -18440,44 +18441,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;
             }
@@ -18489,7 +18490,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);
                         }
@@ -18497,7 +18498,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);
                         }
@@ -18518,7 +18519,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
@@ -18533,7 +18534,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
@@ -18554,7 +18555,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
@@ -18575,10 +18576,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);
@@ -18639,7 +18640,7 @@ var pxt;
                 }
                 const anim = {
                     internalID: this.getNewInternalId(),
-                    type: "animation" /* Animation */,
+                    type: "animation" /* AssetType.Animation */,
                     meta: {
                         displayName: entry.displayName
                     },
@@ -18673,14 +18674,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) {
@@ -18702,12 +18703,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);
@@ -18756,11 +18757,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) {
@@ -18784,7 +18785,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");
                 }
@@ -18800,7 +18801,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(", ")}]`
                 });
             }
@@ -18844,12 +18845,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() });
         }
     }
@@ -18858,7 +18859,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] = {
@@ -18868,7 +18869,7 @@ var pxt;
                     };
                 }
                 break;
-            case "tile" /* Tile */:
+            case "tile" /* AssetType.Tile */:
                 allJRes[id] = {
                     data: asset.jresData,
                     mimeType: pxt.IMAGE_MIME_TYPE,
@@ -18876,12 +18877,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;
         }
@@ -18895,13 +18896,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);
         }
     }
@@ -18925,7 +18926,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;
             }
@@ -18934,13 +18935,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}`;
         }
     }
@@ -18963,13 +18964,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;
@@ -18977,13 +18978,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");
@@ -18997,16 +18998,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;
         }
@@ -19076,7 +19077,7 @@ var pxt;
             id = id.replace(/\.\./g, ".");
         }
         return {
-            type: "animation" /* Animation */,
+            type: "animation" /* AssetType.Animation */,
             internalID: 0,
             id: id,
             interval,
@@ -20009,15 +20010,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",