pxt-core 7.4.6 → 7.4.10

package/built/pxtblocks.d.ts

@@ -471,7 +471,7 @@ declare namespace pxtblockly {
         protected animateRef: any;
         protected asset: pxt.Animation;
         protected initInterval: number;
-        init(): void;
+        initView(): void;
         showEditor_(): void;
         render_(): void;
         protected getAssetType(): pxt.AssetType;
@@ -508,7 +508,7 @@ declare namespace pxtblockly {
         CURSOR: string;
         private type_;
         constructor(state: string, params: Blockly.FieldCustomOptions, opt_validator?: Function);
-        init(): void;
+        initView(): void;
         updateSize_(): void;
         /**
          * Return 'TRUE' if the toggle is ON, 'FALSE' otherwise.
@@ -1243,7 +1243,7 @@ declare namespace pxtblockly {
         protected blocksInfo: pxtc.BlocksInfo;
         protected transparent: TilesetDropdownOption;
         constructor(text: string, options: FieldImageDropdownOptions, validator?: Function);
-        init(): void;
+        initView(): void;
         getValue(): any;
         getText(): string;
         render_(): void;
@@ -1265,7 +1265,7 @@ declare namespace pxtblockly {
         CURSOR: string;
         private type_;
         constructor(state: string, params: Blockly.FieldCustomOptions, opt_validator?: Function);
-        init(): void;
+        initView(): void;
         getDisplayText_(): string;
         getTrueText(): string;
         getFalseText(): string;

package/built/pxtblocks.js

@@ -1497,7 +1497,7 @@ var pxt;
         function compileBlockAsync(b, blockInfo) {
             const w = b.workspace;
             const e = mkEnv(w, blockInfo);
-            infer(w && w.getAllBlocks(), e, w);
+            infer(w && w.getAllBlocks(false), e, w);
             const compiled = compileStatementBlock(e, b);
             removeAllPlaceholders();
             return tdASTtoTS(e, compiled);
@@ -1518,7 +1518,7 @@ var pxt;
         function compileWorkspace(e, w, blockInfo) {
             try {
                 // all compiled top level blocks are events
-                let allBlocks = w.getAllBlocks();
+                let allBlocks = w.getAllBlocks(false);
                 if (pxt.react.getTilemapProject) {
                     pxt.react.getTilemapProject().removeInactiveBlockAssets(allBlocks.map(b => b.id));
                 }
@@ -1788,13 +1788,11 @@ var pxt;
             });
         }
         function maybeAddComment(b, comments) {
-            if (b.comment) {
-                if ((typeof b.comment) === "string") {
-                    comments.push(b.comment);
-                }
-                else {
-                    comments.push(b.comment.getText());
-                }
+            var _a;
+            // Check if getCommentText exists, block may be placeholder
+            const text = (_a = b.getCommentText) === null || _a === void 0 ? void 0 : _a.call(b);
+            if (text) {
+                comments.push(text);
             }
         }
         function addCommentNodes(comments, r) {
@@ -2457,9 +2455,9 @@ var pxt;
                 }
             });
             // we'll ignore disabled blocks in the final output
-            const oldBlocks = oldWs.getAllBlocks().filter(b => b.isEnabled());
+            const oldBlocks = oldWs.getAllBlocks(false).filter(b => b.isEnabled());
             const oldTopBlocks = oldWs.getTopBlocks(false).filter(b => b.isEnabled());
-            const newBlocks = newWs.getAllBlocks().filter(b => b.isEnabled());
+            const newBlocks = newWs.getAllBlocks(false).filter(b => b.isEnabled());
             log(`blocks`, newBlocks.map(b => b.toDevString()));
             log(newBlocks);
             if (oldBlocks.length == 0 && newBlocks.length == 0) {
@@ -2481,11 +2479,11 @@ var pxt;
             const newXml = pxt.blocks.saveWorkspaceXml(newWs, true);
             pxt.blocks.domToWorkspaceNoEvents(Blockly.Xml.textToDom(newXml), ws);
             // delete disabled blocks from final workspace
-            ws.getAllBlocks().filter(b => !b.isEnabled()).forEach(b => {
+            ws.getAllBlocks(false).filter(b => !b.isEnabled()).forEach(b => {
                 log('disabled ', b.toDevString());
                 b.dispose(false);
             });
-            const todoBlocks = pxt.Util.toDictionary(ws.getAllBlocks(), b => b.id);
+            const todoBlocks = pxt.Util.toDictionary(ws.getAllBlocks(false), b => b.id);
             log(`todo blocks`, todoBlocks);
             logTodo('start');
             // 1. deleted top blocks
@@ -2495,7 +2493,7 @@ var pxt;
                     done(b);
                     const b2 = cloneIntoDiff(b);
                     done(b2);
-                    b2.setDisabled(true);
+                    b2.setEnabled(false);
                 });
                 logTodo('deleted top');
             }
@@ -2560,7 +2558,7 @@ var pxt;
             });
             logTodo('unmodified');
             // if nothing is left in the workspace, we "missed" change
-            if (!ws.getAllBlocks().length) {
+            if (!ws.getAllBlocks(false).length) {
                 pxt.tickEvent("blocks.diff", { missed: 1 });
                 return {
                     ws,
@@ -2593,7 +2591,7 @@ var pxt;
             function stitch(b) {
                 log(`stitching ${b.toDevString()}->${dids[b.id]}`);
                 const wb = ws.getBlockById(dids[b.id]);
-                wb.setDisabled(true);
+                wb.setEnabled(false);
                 markUsed(wb);
                 done(wb);
                 // connect previous connection to delted or existing block
@@ -2855,10 +2853,10 @@ var pxt;
         function applyMetaComments(workspace) {
             // process meta comments
             // @highlight -> highlight block
-            workspace.getAllBlocks()
-                .filter(b => !!b.comment && b.comment instanceof Blockly.Comment)
+            workspace.getAllBlocks(false)
+                .filter(b => !!b.getCommentText())
                 .forEach(b => {
-                const c = b.comment.getText();
+                const c = b.getCommentText();
                 if (/@highlight/.test(c)) {
                     const cc = c.replace(/@highlight/g, '').trim();
                     b.setCommentText(cc || null);
@@ -4343,7 +4341,7 @@ var pxt;
                                 }
                                 else if (pr.type == "number" && pr.shadowBlockId && pr.shadowBlockId == "value") {
                                     inputName = undefined;
-                                    fields.push(namedField(new Blockly.FieldTextInput("0", Blockly.FieldTextInput.numberValidator), defName));
+                                    fields.push(namedField(new Blockly.FieldNumber("0"), defName));
                                 }
                                 else if (pr.type == "string" && pr.shadowOptions && pr.shadowOptions.toString) {
                                     inputCheck = null;
@@ -5445,11 +5443,6 @@ var pxt;
                         let blockText = '<xml>' +
                             '<block type="variables_change" gap="' + gap + '">' +
                             Blockly.Variables.generateVariableFieldXmlString(mostRecentVariable) +
-                            '<value name="DELTA">' +
-                            '<shadow type="math_number">' +
-                            '<field name="NUM">1</field>' +
-                            '</shadow>' +
-                            '</value>' +
                             '</block>' +
                             '</xml>';
                         let block = Blockly.Xml.textToDom(blockText).firstChild;
@@ -7622,19 +7615,8 @@ var pxtblockly;
                 this.valueText = text;
         }
         init() {
-            if (this.isInitialized())
-                return;
-            // Build the DOM.
-            this.fieldGroup_ = Blockly.utils.dom.createSvgElement('g', {}, null);
-            if (!this.visible_) {
-                this.fieldGroup_.style.display = 'none';
-            }
+            super.init();
             this.onInit();
-            this.updateEditable();
-            this.sourceBlock_.getSvgRoot().appendChild(this.fieldGroup_);
-            // Force a render.
-            this.render_();
-            this.mouseDownWrapper_ = Blockly.bindEventWithChecks_(this.getClickTarget_(), "mousedown", this, this.onMouseDown_);
         }
         dispose() {
             this.onDispose();
@@ -7787,9 +7769,11 @@ var pxtblockly;
         }
         getDisplayText_() {
             // This is only used when isGreyBlock is true
-            const text = pxt.Util.htmlUnescape(this.valueText);
-            return text.substr(0, text.indexOf("(")) + "(...)";
-            ;
+            if (this.isGreyBlock) {
+                const text = pxt.Util.htmlUnescape(this.valueText);
+                return text.substr(0, text.indexOf("(")) + "(...)";
+            }
+            return "";
         }
         updateEditable() {
             if (this.isGreyBlock && this.fieldGroup_) {
@@ -8046,12 +8030,7 @@ var pxtblockly;
                 }
             };
         }
-        init() {
-            if (this.fieldGroup_) {
-                // Field has already been initialized once.
-                return;
-            }
-            super.init();
+        initView() {
             // Register mouseover events for animating preview
             this.sourceBlock_.getSvgRoot().addEventListener("mouseenter", this.onMouseEnter);
             this.sourceBlock_.getSvgRoot().addEventListener("mouseleave", this.onMouseLeave);
@@ -8257,16 +8236,10 @@ var pxtblockly;
             this.addArgType('toggle');
             this.type_ = params.type;
         }
-        init() {
-            if (this.fieldGroup_) {
-                // Field has already been initialized once.
+        initView() {
+            if (!this.fieldGroup_) {
                 return;
             }
-            // Build the DOM.
-            this.fieldGroup_ = Blockly.utils.dom.createSvgElement('g', {}, null);
-            if (!this.visible_) {
-                this.fieldGroup_.style.display = 'none';
-            }
             // Add an attribute to cassify the type of field.
             if (this.getArgTypes() !== null) {
                 if (this.sourceBlock_.isShadow()) {
@@ -8295,15 +8268,10 @@ var pxtblockly;
                 'dy': '0.6ex',
                 'y': size.height / 2
             }, this.fieldGroup_);
-            this.updateEditable();
-            this.sourceBlock_.getSvgRoot().appendChild(this.fieldGroup_);
             this.switchToggle(this.state_);
             this.setValue(this.getValue());
             // Force a render.
-            this.render_();
-            this.size_.width = 0;
-            this.mouseDownWrapper_ =
-                Blockly.bindEventWithChecks_(this.getClickTarget_(), 'mousedown', this, this.onMouseDown_);
+            this.markDirty();
         }
         updateSize_() {
             this.size_.width = 30;
@@ -9773,7 +9741,7 @@ var pxtblockly;
         }
         render_() {
             if (!this.visible_) {
-                this.size_.width = 0;
+                this.markDirty();
                 return;
             }
             if (!this.elt) {
@@ -11277,7 +11245,7 @@ var pxtblockly;
         dropdownCreate() {
             let functionList = [];
             if (this.sourceBlock_ && this.sourceBlock_.workspace) {
-                let blocks = this.sourceBlock_.workspace.getAllBlocks();
+                let blocks = this.sourceBlock_.workspace.getAllBlocks(false);
                 // Iterate through every block and check the name.
                 for (let i = 0; i < blocks.length; i++) {
                     if (blocks[i].getProcedureDef) {
@@ -11306,10 +11274,6 @@ var pxtblockly;
         }
         onItemSelected(menu, menuItem) {
             let itemText = menuItem.getValue();
-            if (this.sourceBlock_) {
-                // Call any validation function, and allow it to override.
-                itemText = this.callValidator(itemText);
-            }
             if (itemText !== null) {
                 this.setValue(itemText);
             }
@@ -11804,8 +11768,8 @@ var pxtblockly;
             }
             return FieldTileset.referencedTiles;
         }
-        init() {
-            super.init();
+        initView() {
+            super.initView();
             if (this.sourceBlock_ && this.sourceBlock_.isInFlyout) {
                 this.setValue(this.getOptions()[0][1]);
             }
@@ -11954,16 +11918,10 @@ var pxtblockly;
             this.addArgType('toggle');
             this.type_ = params.type;
         }
-        init() {
-            if (this.fieldGroup_) {
-                // Field has already been initialized once.
+        initView() {
+            if (!this.fieldGroup_) {
                 return;
             }
-            // Build the DOM.
-            this.fieldGroup_ = Blockly.utils.dom.createSvgElement('g', {}, null);
-            if (!this.visible_) {
-                this.fieldGroup_.style.display = 'none';
-            }
             // Add an attribute to cassify the type of field.
             if (this.getArgTypes() !== null) {
                 if (this.sourceBlock_.isShadow()) {
@@ -12035,10 +11993,7 @@ var pxtblockly;
             this.switchToggle(this.state_);
             this.setValue(this.getValue());
             // Force a render.
-            this.render_();
-            this.size_.width = 0;
-            this.mouseDownWrapper_ =
-                Blockly.bindEventWithChecks_(this.getClickTarget_(), 'mousedown', this, this.onMouseDown_);
+            this.markDirty();
         }
         getDisplayText_() {
             return this.state_ ? this.getTrueText() : this.getFalseText();

package/built/pxteditor.d.ts

@@ -543,7 +543,7 @@ declare namespace pxt.editor {
         message?: string;
         data?: Map<string | number>;
     }
-    type EditorMessageTutorialEventRequest = EditorMessageTutorialProgressEventRequest | EditorMessageTutorialCompletedEventRequest | EditorMessageTutorialLoadedEventRequest;
+    type EditorMessageTutorialEventRequest = EditorMessageTutorialProgressEventRequest | EditorMessageTutorialCompletedEventRequest | EditorMessageTutorialLoadedEventRequest | EditorMessageTutorialExitEventRequest;
     interface EditorMessageTutorialProgressEventRequest extends EditorMessageRequest {
         action: "tutorialevent";
         tutorialEvent: "progress";

package/built/pxtlib.d.ts

@@ -57,6 +57,10 @@ declare namespace pxt.auth {
     type UserBadgeState = {
         badges: Badge[];
     };
+    type SetPrefResult = {
+        success: boolean;
+        res: UserPreferences;
+    };
     /**
      * User preference state that should be synced with the cloud.
      */
@@ -66,6 +70,7 @@ declare namespace pxt.auth {
         reader?: string;
         skillmap?: UserSkillmapState;
         badges?: UserBadgeState;
+        email?: boolean;
     };
     const DEFAULT_USER_PREFERENCES: () => UserPreferences;
     /**
@@ -124,7 +129,11 @@ declare namespace pxt.auth {
             username?: string;
             avatarUrl?: string;
         }): Promise<boolean>;
-        patchUserPreferencesAsync(ops: ts.pxtc.jsonPatch.PatchOperation | ts.pxtc.jsonPatch.PatchOperation[]): Promise<void>;
+        private patchQueue;
+        patchUserPreferencesAsync(patchOps: ts.pxtc.jsonPatch.PatchOperation | ts.pxtc.jsonPatch.PatchOperation[], opts?: {
+            immediate?: boolean;
+            filter?: (op: ts.pxtc.jsonPatch.PatchOperation) => boolean;
+        }): Promise<SetPrefResult>;
         hasUserId(): boolean;
         private fetchUserAsync;
         private setUserProfileAsync;
@@ -269,6 +278,7 @@ declare namespace ts.pxtc.Util {
     export function listsEqual<T>(a: T[], b: T[]): boolean;
     export function oops(msg?: string): Error;
     export function reversed<T>(arr: T[]): T[];
+    export function arrayEquals<U>(a: U[], b: U[], compare?: (c: U, d: U) => boolean): boolean;
     export function iterMap<T>(m: pxt.Map<T>, f: (k: string, v: T) => void): void;
     export function mapMap<T, S>(m: pxt.Map<T>, f: (k: string, v: T) => S): pxt.Map<S>;
     export function values<T>(m: pxt.Map<T>): T[];
@@ -295,6 +305,7 @@ declare namespace ts.pxtc.Util {
     export function groupBy<T>(arr: T[], f: (t: T) => string): pxt.Map<T[]>;
     export function toDictionary<T>(arr: T[], f: (t: T) => string): pxt.Map<T>;
     export function toSet<T>(arr: T[], f: (t: T) => string): pxt.Map<boolean>;
+    export function deepCopy(src: any): any;
     export interface ArrayLike<T> {
         [index: number]: T;
         length: number;
@@ -464,6 +475,7 @@ declare namespace ts.pxtc.jsonPatch {
      * Applies a set of JSON Patch operations to the object.
      */
     function patchInPlace(obj: any, ops: PatchOperation[]): void;
+    function opsAreEqual(a: PatchOperation, b: PatchOperation): boolean;
 }
 declare namespace ts.pxtc.jsonPatch.tests {
     function diffTests(): void;

package/built/pxtlib.js

@@ -185,19 +185,21 @@ var pxt;
             highContrast: false,
             language: pxt.appTarget.appTheme.defaultLocale,
             reader: "",
-            skillmap: { mapProgress: {}, completedTags: {} }
+            skillmap: { mapProgress: {}, completedTags: {} },
+            email: false
         });
         let _client;
         function client() { return _client; }
         auth.client = client;
-        const PREFERENCES_DEBOUNCE_MS = 5 * 1000;
-        const PREFERENCES_DEBOUNCE_MAX_MS = 30 * 1000;
+        const PREFERENCES_DEBOUNCE_MS = 1 * 1000;
+        const PREFERENCES_DEBOUNCE_MAX_MS = 10 * 1000;
         let debouncePreferencesChangedTimeout = 0;
         let debouncePreferencesChangedStarted = 0;
         class AuthClient {
             constructor() {
                 this.initialUserPreferences_ = undefined;
                 this.initialAuthCheck_ = undefined;
+                this.patchQueue = [];
                 pxt.Util.assert(!_client);
                 // Set global instance.
                 _client = this;
@@ -387,40 +389,87 @@ var pxt;
                 }
                 return result.success;
             }
-            async patchUserPreferencesAsync(ops) {
-                ops = Array.isArray(ops) ? ops : [ops];
-                if (!ops.length) {
-                    return;
-                }
+            async patchUserPreferencesAsync(patchOps, opts = {}) {
+                const defaultSuccessAsync = async () => ({ success: true, res: await this.userPreferencesAsync() });
+                patchOps = Array.isArray(patchOps) ? patchOps : [patchOps];
+                patchOps = patchOps.filter(op => !!op);
+                if (!patchOps.length) {
+                    return await defaultSuccessAsync();
+                }
+                const patchDiff = (pSrc, ops, filter) => {
+                    // Apply patches to pDst and return the diff as a set of new patch ops.
+                    const pDst = pxt.U.deepCopy(pSrc);
+                    ts.pxtc.jsonPatch.patchInPlace(pDst, ops);
+                    let diff = ts.pxtc.jsonPatch.diff(pSrc, pDst);
+                    // Run caller-provided filter
+                    if (diff.length && filter) {
+                        diff = diff.filter(filter);
+                    }
+                    return diff;
+                };
+                // Process incoming patch operations to produce a more fine-grained set of diffs. Incoming patches may be overly destructive
+                // Apply the patch in isolation and get the diff from original
                 const curPref = await this.userPreferencesAsync();
-                ts.pxtc.jsonPatch.patchInPlace(curPref, ops);
+                const diff = patchDiff(curPref, patchOps, opts.filter);
+                if (!diff.length) {
+                    return await defaultSuccessAsync();
+                }
+                // Apply the new diff to the current state
+                ts.pxtc.jsonPatch.patchInPlace(curPref, diff);
                 await this.setUserPreferencesAsync(curPref);
-                // If we're not logged in, non-persistent local state is all we'll use
+                // If the user is not logged in, non-persistent local state is all we'll use (no sync to cloud)
                 if (!await this.loggedInAsync()) {
-                    return;
+                    return await defaultSuccessAsync();
                 }
-                // If the user is logged in, save to cloud, but debounce the api call as this can be called frequently from skillmaps
+                // If the user is logged in, sync to cloud, but debounce the api call as this can be called frequently from skillmaps
+                // Queue the patch for sync with backend
+                this.patchQueue.push({ ops: patchOps, filter: opts.filter });
                 clearTimeout(debouncePreferencesChangedTimeout);
-                const savePrefs = async () => {
+                const syncPrefs = async () => {
                     debouncePreferencesChangedStarted = 0;
-                    const result = await this.apiAsync('/api/user/preferences', ops, 'PATCH');
-                    if (result.success) {
-                        pxt.debug("Updating local user preferences w/ cloud data after result of POST");
-                        // Set user profile from returned value so we stay in-sync
-                        this.setUserPreferencesAsync(result.resp);
+                    if (!this.patchQueue.length) {
+                        return await defaultSuccessAsync();
+                    }
+                    // Fetch latest prefs from remote
+                    const getResult = await this.apiAsync('/api/user/preferences');
+                    if (!getResult.success) {
+                        pxt.reportError("identity", "failed to fetch preferences for patch", getResult);
+                        return { success: false, res: undefined };
+                    }
+                    // Apply queued patches to the remote state in isolation and develop a final diff to send to the backend
+                    const remotePrefs = pxt.U.deepCopy(getResult.resp);
+                    const patchQueue = this.patchQueue;
+                    this.patchQueue = []; // Reset the queue
+                    patchQueue.forEach(patch => {
+                        const diff = patchDiff(remotePrefs, patch.ops, patch.filter);
+                        ts.pxtc.jsonPatch.patchInPlace(remotePrefs, diff);
+                    });
+                    // Diff the original and patched remote states to get a final set of patch operations
+                    const finalOps = pxtc.jsonPatch.diff(getResult.resp, remotePrefs);
+                    const patchResult = await this.apiAsync('/api/user/preferences', finalOps, 'PATCH');
+                    if (patchResult.success) {
+                        // Set user profile from returned value so we stay in sync
+                        this.setUserPreferencesAsync(patchResult.resp);
                     }
                     else {
-                        pxt.reportError("identity", "update preferences failed", result);
+                        pxt.reportError("identity", "failed to patch preferences", patchResult);
                     }
+                    return { success: patchResult.success, res: patchResult.resp };
                 };
-                if (!debouncePreferencesChangedStarted) {
-                    debouncePreferencesChangedStarted = pxt.U.now();
-                }
-                if (PREFERENCES_DEBOUNCE_MAX_MS < pxt.U.now() - debouncePreferencesChangedStarted) {
-                    await savePrefs();
+                if (opts.immediate) {
+                    return await syncPrefs();
                 }
                 else {
-                    debouncePreferencesChangedTimeout = setTimeout(savePrefs, PREFERENCES_DEBOUNCE_MS);
+                    if (!debouncePreferencesChangedStarted) {
+                        debouncePreferencesChangedStarted = pxt.U.now();
+                    }
+                    if (PREFERENCES_DEBOUNCE_MAX_MS < pxt.U.now() - debouncePreferencesChangedStarted) {
+                        return await syncPrefs();
+                    }
+                    else {
+                        debouncePreferencesChangedTimeout = setTimeout(syncPrefs, PREFERENCES_DEBOUNCE_MS);
+                        return { success: false, res: undefined }; // This needs to be implemented correctly to return a promise with the debouncer
+                    }
                 }
             }
             /*protected*/ hasUserId() {
@@ -1214,6 +1263,18 @@ var ts;
                 return arr;
             }
             Util.reversed = reversed;
+            function arrayEquals(a, b, compare = (c, d) => c === d) {
+                if (a == b)
+                    return true;
+                if (!a && b || !b && a || a.length !== b.length)
+                    return false;
+                for (let i = 0; i < a.length; i++) {
+                    if (!compare(a[i], b[i]))
+                        return false;
+                }
+                return true;
+            }
+            Util.arrayEquals = arrayEquals;
             function iterMap(m, f) {
                 Object.keys(m).forEach(k => f(k, m[k]));
             }
@@ -1489,6 +1550,18 @@ var ts;
                 return r;
             }
             Util.toSet = toSet;
+            function deepCopy(src) {
+                if (typeof src !== "object" || src === null) {
+                    return src;
+                }
+                const dst = Array.isArray(src) ? [] : {};
+                for (const key in src) {
+                    const value = src[key];
+                    dst[key] = deepCopy(value);
+                }
+                return dst;
+            }
+            Util.deepCopy = deepCopy;
             function toArray(a) {
                 if (Array.isArray(a)) {
                     return a;
@@ -3037,6 +3110,10 @@ var ts;
                 }
             }
             jsonPatch.patchInPlace = patchInPlace;
+            function opsAreEqual(a, b) {
+                return (a.op === b.op && pxtc.U.arrayEquals(a.path, b.path));
+            }
+            jsonPatch.opsAreEqual = opsAreEqual;
         })(jsonPatch = pxtc.jsonPatch || (pxtc.jsonPatch = {}));
     })(pxtc = ts.pxtc || (ts.pxtc = {}));
 })(ts || (ts = {}));
@@ -18505,8 +18582,8 @@ var pxt;
         if (a == b)
             return true;
         if (a.id !== b.id || a.type !== b.type ||
-            !arrayEquals(a.meta.tags, b.meta.tags) ||
-            !arrayEquals(a.meta.blockIDs, b.meta.blockIDs) ||
+            !pxt.U.arrayEquals(a.meta.tags, b.meta.tags) ||
+            !pxt.U.arrayEquals(a.meta.blockIDs, b.meta.blockIDs) ||
             a.meta.displayName !== b.meta.displayName)
             return false;
         switch (a.type) {
@@ -18515,7 +18592,7 @@ var pxt;
                 return pxt.sprite.bitmapEquals(a.bitmap, b.bitmap);
             case "animation" /* Animation */:
                 const bAnimation = b;
-                return a.interval === bAnimation.interval && arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
+                return a.interval === bAnimation.interval && pxt.U.arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
             case "tilemap" /* Tilemap */:
                 return a.data.equals(b.data);
         }
@@ -18637,17 +18714,6 @@ var pxt;
         }
         return id;
     }
-    function arrayEquals(a, b, compare = (c, d) => c === d) {
-        if (a == b)
-            return true;
-        if (!a && b || !b && a || a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!compare(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
     function serializeTilemap(tilemap, id, name) {
         const tm = tilemap.tilemap.data();
         const data = new Uint8ClampedArray(5 + tm.data.length + tilemap.layers.data.length);