pxt-core 9.1.1 → 9.1.3

package/built/pxt.js

@@ -97876,6 +97876,7 @@ var pxt;
         const AUTH_LOGIN_STATE_KEY = "login-state"; // stored in local storage.
         const AUTH_USER_STATE_KEY = "user-state"; // stored in local storage.
         const X_PXT_TARGET = "x-pxt-target"; // header passed in auth rest calls.
+        const INTERACTIVE_LOGIN_UNTIL = "interactive-login-until"; // hint whether to prompt user or try SSO first.
         let authDisabled = false;
         auth.DEFAULT_USER_PREFERENCES = () => ({
             highContrast: false,
@@ -97901,19 +97902,29 @@ var pxt;
         // Last known auth token state. This is provided as a convenience for legacy methods that cannot be made async.
         // Preference hasAuthTokenAsync() over taking a dependency on this cached value.
         auth.cachedHasAuthToken = false;
-        async function getAuthTokenAsync() {
-            let token;
+        async function setLocalStorageValueAsync(key, value) {
+            if (!!value)
+                return await pxt.storage.shared.setAsync(AUTH_CONTAINER, key, value);
+            else
+                return await pxt.storage.shared.delAsync(AUTH_CONTAINER, key);
+        }
+        async function getLocalStorageValueAsync(key) {
             try {
-                token = await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+                return await pxt.storage.shared.getAsync(AUTH_CONTAINER, key);
             }
-            catch (_a) { }
+            catch (_a) {
+                return undefined;
+            }
+        }
+        async function getAuthTokenAsync() {
+            const token = await getLocalStorageValueAsync(CSRF_TOKEN_KEY);
             auth.cachedHasAuthToken = !!token;
             return token;
         }
         auth.getAuthTokenAsync = getAuthTokenAsync;
         async function setAuthTokenAsync(token) {
             auth.cachedHasAuthToken = !!token;
-            return await pxt.storage.shared.setAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY, token);
+            return await setLocalStorageValueAsync(CSRF_TOKEN_KEY, token);
         }
         async function hasAuthTokenAsync() {
             return !!(await getAuthTokenAsync());
@@ -97921,7 +97932,7 @@ var pxt;
         auth.hasAuthTokenAsync = hasAuthTokenAsync;
         async function delAuthTokenAsync() {
             auth.cachedHasAuthToken = false;
-            return await pxt.storage.shared.delAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+            return await setLocalStorageValueAsync(CSRF_TOKEN_KEY, undefined);
         }
         async function getUserStateAsync() {
             let userState;
@@ -97984,16 +97995,20 @@ var pxt;
                     idp,
                     persistent
                 };
+                // Should the user be prompted to interactively login, or can we try to silently login?
+                const interactiveUntil = parseInt(await getLocalStorageValueAsync(INTERACTIVE_LOGIN_UNTIL));
+                const interactiveLogin = (interactiveUntil || 0) > Date.now();
                 // Redirect to the login endpoint.
                 const loginUrl = pxt.Util.stringifyQueryString('/api/auth/login', {
                     response_type: "token",
                     provider: idp,
                     persistent,
-                    redirect_uri: `${window.location.origin}${window.location.pathname}?authcallback=1&state=${loginState.key}`
+                    redirect_uri: `${window.location.origin}${window.location.pathname}?authcallback=1&state=${loginState.key}`,
+                    prompt: interactiveLogin ? "select_account" : "silent"
                 });
                 const apiResult = await this.apiAsync(loginUrl);
                 if (apiResult.success) {
-                    loginState.authCodeVerifier = apiResult.resp.authCodeVerifier;
+                    loginState.authCodeVerifier = apiResult.resp.authCodeVerifier; // will be undefined unless configured for the target
                     await pxt.storage.shared.setAsync(AUTH_CONTAINER, AUTH_LOGIN_STATE_KEY, loginState);
                     pxt.tickEvent('auth.login.start', { 'provider': idp });
                     window.location.href = apiResult.resp.loginUrl;
@@ -98012,13 +98027,15 @@ var pxt;
                 if (!hasIdentity()) {
                     return;
                 }
-                // Clear local auth state so we can no longer make authenticated requests.
-                await this.clearAuthStateAsync();
                 await AuthClient.staticLogoutAsync(continuationHash);
                 try {
-                    await this.onSignedOut();
+                    await this.onStateCleared();
                 }
                 catch (_a) { }
+                try {
+                    await this.onSignedOut();
+                }
+                catch (_b) { }
             }
             /**
              * Sign out the user and clear the auth token cookie.
@@ -98028,19 +98045,39 @@ var pxt;
                     return;
                 }
                 pxt.tickEvent('auth.logout');
-                // Tell backend to clear the http-only auth cookie. Ignore errors here, we want to clear local state even if the backend rejects this request.
+                // Indicate that for the next minute, signin should be interactive.
+                // Use case: SSO signed in with the wrong account. User wants to sign in with a different account.
+                await setLocalStorageValueAsync(INTERACTIVE_LOGIN_UNTIL, (Date.now() + 60000).toString());
+                continuationHash = continuationHash ? continuationHash.startsWith('#') ? continuationHash : `#${continuationHash}` : "";
+                const clientRedirect = `${window.location.origin}${window.location.pathname}${window.location.search}${continuationHash}`;
+                // Tell backend to clear the http-only auth cookie.
+                let logoutUri = "";
                 try {
-                    await AuthClient.staticApiAsync('/api/auth/logout');
+                    const uri = pxt.Util.stringifyQueryString('/api/auth/logout', {
+                        redirect_uri: clientRedirect,
+                        authcallback: '1'
+                    });
+                    const apiResult = await AuthClient.staticApiAsync(uri);
+                    if (apiResult.success) {
+                        logoutUri = apiResult.resp.logoutUrl;
+                    }
+                }
+                catch (_a) {
+                    // Ignore errors.
                 }
-                catch (_a) { }
                 // Clear local auth state so we can no longer make authenticated requests.
                 await delAuthTokenAsync();
                 await delUserStateAsync();
-                // Redirect to home screen
                 if (pxt.BrowserUtils.hasWindow()) {
-                    const hash = continuationHash ? continuationHash.startsWith('#') ? continuationHash : `#${continuationHash}` : "";
-                    window.location.href = `${window.location.origin}${window.location.pathname}${window.location.search}${hash}`;
-                    location.reload();
+                    if (logoutUri) {
+                        // Redirect to logout endpoint
+                        window.location.href = logoutUri;
+                    }
+                    else {
+                        // Redirect to home screen
+                        window.location.href = clientRedirect;
+                        location.reload();
+                    }
                 }
             }
             async deleteProfileAsync() {
@@ -98436,6 +98473,8 @@ var pxt;
                 // without its cookie-based counterpart. When "Remember me" is false,
                 // the cookie is not persisted.
                 await setAuthTokenAsync(authToken);
+                // Clear interactive login flag. Next auth request will try silent SSO first.
+                await setLocalStorageValueAsync(INTERACTIVE_LOGIN_UNTIL, undefined);
                 pxt.tickEvent('auth.login.success', { 'provider': loginState.idp });
             } while (false);
             // Clear url parameters and redirect to the callback location.
@@ -102460,10 +102499,6 @@ var pxt;
             return typeof window != "undefined" && !!window.PointerEvent;
         }
         BrowserUtils.hasPointerEvents = hasPointerEvents;
-        function hasSaveAs() {
-            return isEdge() || isIE() || isFirefox();
-        }
-        BrowserUtils.hasSaveAs = hasSaveAs;
         function os() {
             if (isWindows())
                 return "windows";
@@ -155238,6 +155273,13 @@ var pxsim;
         }
     }
     pxsim.Runtime = Runtime;
+    function setParentMuteState(state) {
+        Runtime.postMessage({
+            type: "setmutebuttonstate",
+            state
+        });
+    }
+    pxsim.setParentMuteState = setParentMuteState;
     class PerfCounter {
         constructor(name) {
             this.name = name;
@@ -155898,8 +155940,19 @@ var pxsim;
             this.setFrameState(frame);
             return true;
         }
+        handleDeferredMessages(frame) {
+            var _a, _b, _c;
+            if (frame.dataset["loading"]) {
+                delete frame.dataset["loading"];
+                (_b = (_a = this.deferredMessages) === null || _a === void 0 ? void 0 : _a.filter(defMsg => defMsg[0] === frame)) === null || _b === void 0 ? void 0 : _b.forEach(defMsg => {
+                    const [_, msg] = defMsg;
+                    this.postMessageCore(frame, msg);
+                });
+                this.deferredMessages = (_c = this.deferredMessages) === null || _c === void 0 ? void 0 : _c.filter(defMsg => defMsg[0] !== frame);
+            }
+        }
         handleMessage(msg, source) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             switch (msg.type || '') {
                 case 'ready': {
                     const frameid = msg.frameid;
@@ -155910,12 +155963,7 @@ var pxsim;
                         this.startFrame(frame);
                         if (this.options.revealElement)
                             this.options.revealElement(frame);
-                        delete frame.dataset["loading"];
-                        (_c = (_b = this.deferredMessages) === null || _b === void 0 ? void 0 : _b.filter(defMsg => defMsg[0] === frame)) === null || _c === void 0 ? void 0 : _c.forEach(defMsg => {
-                            const [_, msg] = defMsg;
-                            this.postMessageCore(frame, msg);
-                        });
-                        this.deferredMessages = (_d = this.deferredMessages) === null || _d === void 0 ? void 0 : _d.filter(defMsg => defMsg[0] !== frame);
+                        this.handleDeferredMessages(frame);
                     }
                     if (this.options.onSimulatorReady)
                         this.options.onSimulatorReady();
@@ -155930,6 +155978,7 @@ var pxsim;
                             switch (stmsg.state) {
                                 case "running":
                                     this.setState(SimulatorState.Running);
+                                    this.handleDeferredMessages(frame);
                                     break;
                                 case "killed":
                                     this.setState(SimulatorState.Stopped);
@@ -155966,6 +156015,9 @@ var pxsim;
                     if (this.options.onTopLevelCodeEnd)
                         this.options.onTopLevelCodeEnd();
                     break;
+                case 'setmutebuttonstate':
+                    (_c = (_b = this.options).onMuteButtonStateChange) === null || _c === void 0 ? void 0 : _c.call(_b, msg.state);
+                    break;
                 default:
                     this.postMessage(msg, source);
                     break;
@@ -156370,6 +156422,10 @@ var pxsim;
                 ctx.resume();
         }
         AudioContextManager.mute = mute;
+        function isMuted() {
+            return _mute;
+        }
+        AudioContextManager.isMuted = isMuted;
         function stopTone() {
             setCurrentToneGain(0);
             _frequency = 0;

package/built/pxtblockly.js

@@ -13656,6 +13656,51 @@ var pxtblockly;
             if (value === "CREATE") {
                 promptAndCreateKind(this.sourceBlock_.workspace, this.opts, lf("New {0}:", this.opts.memberName), newName => newName && this.setValue(newName));
             }
+            else if (value === "RENAME") {
+                const ws = this.sourceBlock_.workspace;
+                const toRename = ws.getVariable(this.value_, kindType(this.opts.name));
+                const oldName = toRename.name;
+                if (this.opts.initialMembers.indexOf(oldName) !== -1) {
+                    Blockly.alert(lf("The built-in {0} '{1}' cannot be renamed. Try creating a new kind instead!", this.opts.memberName, oldName));
+                    return;
+                }
+                promptAndRenameKind(ws, Object.assign(Object.assign({}, this.opts), { toRename }), lf("Rename '{0}':", oldName), newName => {
+                    // Update the values of all existing field instances
+                    const allFields = pxtblockly.getAllFields(ws, field => field instanceof FieldKind);
+                    for (const field of allFields) {
+                        if (field.ref.getValue() === oldName) {
+                            field.ref.setValue(newName);
+                        }
+                    }
+                });
+            }
+            else if (value === "DELETE") {
+                const ws = this.sourceBlock_.workspace;
+                const toDelete = ws.getVariable(this.value_, kindType(this.opts.name));
+                const varName = toDelete.name;
+                if (this.opts.initialMembers.indexOf(varName) !== -1) {
+                    Blockly.alert(lf("The built-in {0} '{1}' cannot be deleted.", this.opts.memberName, varName));
+                    return;
+                }
+                const uses = pxtblockly.getAllFields(ws, field => field instanceof FieldKind && field.getValue() === varName);
+                if (uses.length > 1) {
+                    Blockly.confirm(lf("Delete {0} uses of the \"{1}\" {2}?", uses.length, varName, this.opts.memberName), response => {
+                        if (!response)
+                            return;
+                        Blockly.Events.setGroup(true);
+                        for (const use of uses) {
+                            use.block.dispose(true);
+                        }
+                        ws.deleteVariableById(toDelete.getId());
+                        this.setValue(this.opts.initialMembers[0]);
+                        Blockly.Events.setGroup(false);
+                    });
+                }
+                else {
+                    ws.deleteVariableById(toDelete.getId());
+                    this.setValue(this.opts.initialMembers[0]);
+                }
+            }
             else {
                 super.onItemSelected_(menu, menuItem);
             }
@@ -13680,7 +13725,7 @@ var pxtblockly;
                         createVariableForKind(ws, this.opts, memberName);
                     }
                 });
-                if (this.getValue() === "CREATE") {
+                if (this.getValue() === "CREATE" || this.getValue() === "RENAME" || this.getValue() === "DELETE") {
                     if (this.opts.initialMembers.length) {
                         this.setValue(this.opts.initialMembers[0]);
                     }
@@ -13704,10 +13749,13 @@ var pxtblockly;
                 opts.initialMembers.forEach((e) => res.push([e, e]));
             }
             res.push([lf("Add a new {0}...", opts.memberName), "CREATE"]);
+            res.push([undefined, "SEPARATOR"]);
+            res.push([lf("Rename {0}...", opts.memberName), "RENAME"]);
+            res.push([lf("Delete {0}...", opts.memberName), "DELETE"]);
             return res;
         };
     }
-    function promptAndCreateKind(ws, opts, message, cb) {
+    function promptForName(ws, opts, message, cb, prompt) {
         Blockly.prompt(message, null, response => {
             if (response) {
                 let nameIsValid = false;
@@ -13720,28 +13768,41 @@ var pxtblockly;
                     }
                 }
                 if (!nameIsValid) {
-                    Blockly.alert(lf("Names must start with a letter and can only contain letters, numbers, '$', and '_'."), () => promptAndCreateKind(ws, opts, message, cb));
+                    Blockly.alert(lf("Names must start with a letter and can only contain letters, numbers, '$', and '_'."), () => promptForName(ws, opts, message, cb, prompt));
                     return;
                 }
-                if (pxt.blocks.isReservedWord(response)) {
-                    Blockly.alert(lf("'{0}' is a reserved word and cannot be used.", response), () => promptAndCreateKind(ws, opts, message, cb));
+                if (pxt.blocks.isReservedWord(response) || response === "CREATE" || response === "RENAME" || response === "DELETE") {
+                    Blockly.alert(lf("'{0}' is a reserved word and cannot be used.", response), () => promptForName(ws, opts, message, cb, prompt));
                     return;
                 }
                 const existing = getExistingKindMembers(ws, opts.name);
                 for (let i = 0; i < existing.length; i++) {
                     const name = existing[i];
                     if (name === response) {
-                        Blockly.alert(lf("A {0} named '{1}' already exists.", opts.memberName, response), () => promptAndCreateKind(ws, opts, message, cb));
+                        Blockly.alert(lf("A {0} named '{1}' already exists.", opts.memberName, response), () => promptForName(ws, opts, message, cb, prompt));
                         return;
                     }
                 }
                 if (response === opts.createFunctionName) {
-                    Blockly.alert(lf("'{0}' is a reserved name.", opts.createFunctionName), () => promptAndCreateKind(ws, opts, message, cb));
+                    Blockly.alert(lf("'{0}' is a reserved name.", opts.createFunctionName), () => promptForName(ws, opts, message, cb, prompt));
                 }
-                cb(createVariableForKind(ws, opts, response));
+                cb(response);
             }
         }, { placeholder: opts.promptHint });
     }
+    function promptAndCreateKind(ws, opts, message, cb) {
+        const responseHandler = (response) => {
+            cb(createVariableForKind(ws, opts, response));
+        };
+        promptForName(ws, opts, message, responseHandler, promptAndCreateKind);
+    }
+    function promptAndRenameKind(ws, opts, message, cb) {
+        const responseHandler = (response) => {
+            ws.getVariableMap().renameVariable(opts.toRename, response);
+            cb(response);
+        };
+        promptForName(ws, opts, message, responseHandler, promptAndRenameKind);
+    }
     function getExistingKindMembers(ws, kindName) {
         const existing = ws.getVariablesOfType(kindType(kindName));
         if (existing && existing.length) {

package/built/pxtblocks.js

@@ -10094,6 +10094,51 @@ var pxtblockly;
             if (value === "CREATE") {
                 promptAndCreateKind(this.sourceBlock_.workspace, this.opts, lf("New {0}:", this.opts.memberName), newName => newName && this.setValue(newName));
             }
+            else if (value === "RENAME") {
+                const ws = this.sourceBlock_.workspace;
+                const toRename = ws.getVariable(this.value_, kindType(this.opts.name));
+                const oldName = toRename.name;
+                if (this.opts.initialMembers.indexOf(oldName) !== -1) {
+                    Blockly.alert(lf("The built-in {0} '{1}' cannot be renamed. Try creating a new kind instead!", this.opts.memberName, oldName));
+                    return;
+                }
+                promptAndRenameKind(ws, Object.assign(Object.assign({}, this.opts), { toRename }), lf("Rename '{0}':", oldName), newName => {
+                    // Update the values of all existing field instances
+                    const allFields = pxtblockly.getAllFields(ws, field => field instanceof FieldKind);
+                    for (const field of allFields) {
+                        if (field.ref.getValue() === oldName) {
+                            field.ref.setValue(newName);
+                        }
+                    }
+                });
+            }
+            else if (value === "DELETE") {
+                const ws = this.sourceBlock_.workspace;
+                const toDelete = ws.getVariable(this.value_, kindType(this.opts.name));
+                const varName = toDelete.name;
+                if (this.opts.initialMembers.indexOf(varName) !== -1) {
+                    Blockly.alert(lf("The built-in {0} '{1}' cannot be deleted.", this.opts.memberName, varName));
+                    return;
+                }
+                const uses = pxtblockly.getAllFields(ws, field => field instanceof FieldKind && field.getValue() === varName);
+                if (uses.length > 1) {
+                    Blockly.confirm(lf("Delete {0} uses of the \"{1}\" {2}?", uses.length, varName, this.opts.memberName), response => {
+                        if (!response)
+                            return;
+                        Blockly.Events.setGroup(true);
+                        for (const use of uses) {
+                            use.block.dispose(true);
+                        }
+                        ws.deleteVariableById(toDelete.getId());
+                        this.setValue(this.opts.initialMembers[0]);
+                        Blockly.Events.setGroup(false);
+                    });
+                }
+                else {
+                    ws.deleteVariableById(toDelete.getId());
+                    this.setValue(this.opts.initialMembers[0]);
+                }
+            }
             else {
                 super.onItemSelected_(menu, menuItem);
             }
@@ -10118,7 +10163,7 @@ var pxtblockly;
                         createVariableForKind(ws, this.opts, memberName);
                     }
                 });
-                if (this.getValue() === "CREATE") {
+                if (this.getValue() === "CREATE" || this.getValue() === "RENAME" || this.getValue() === "DELETE") {
                     if (this.opts.initialMembers.length) {
                         this.setValue(this.opts.initialMembers[0]);
                     }
@@ -10142,10 +10187,13 @@ var pxtblockly;
                 opts.initialMembers.forEach((e) => res.push([e, e]));
             }
             res.push([lf("Add a new {0}...", opts.memberName), "CREATE"]);
+            res.push([undefined, "SEPARATOR"]);
+            res.push([lf("Rename {0}...", opts.memberName), "RENAME"]);
+            res.push([lf("Delete {0}...", opts.memberName), "DELETE"]);
             return res;
         };
     }
-    function promptAndCreateKind(ws, opts, message, cb) {
+    function promptForName(ws, opts, message, cb, prompt) {
         Blockly.prompt(message, null, response => {
             if (response) {
                 let nameIsValid = false;
@@ -10158,28 +10206,41 @@ var pxtblockly;
                     }
                 }
                 if (!nameIsValid) {
-                    Blockly.alert(lf("Names must start with a letter and can only contain letters, numbers, '$', and '_'."), () => promptAndCreateKind(ws, opts, message, cb));
+                    Blockly.alert(lf("Names must start with a letter and can only contain letters, numbers, '$', and '_'."), () => promptForName(ws, opts, message, cb, prompt));
                     return;
                 }
-                if (pxt.blocks.isReservedWord(response)) {
-                    Blockly.alert(lf("'{0}' is a reserved word and cannot be used.", response), () => promptAndCreateKind(ws, opts, message, cb));
+                if (pxt.blocks.isReservedWord(response) || response === "CREATE" || response === "RENAME" || response === "DELETE") {
+                    Blockly.alert(lf("'{0}' is a reserved word and cannot be used.", response), () => promptForName(ws, opts, message, cb, prompt));
                     return;
                 }
                 const existing = getExistingKindMembers(ws, opts.name);
                 for (let i = 0; i < existing.length; i++) {
                     const name = existing[i];
                     if (name === response) {
-                        Blockly.alert(lf("A {0} named '{1}' already exists.", opts.memberName, response), () => promptAndCreateKind(ws, opts, message, cb));
+                        Blockly.alert(lf("A {0} named '{1}' already exists.", opts.memberName, response), () => promptForName(ws, opts, message, cb, prompt));
                         return;
                     }
                 }
                 if (response === opts.createFunctionName) {
-                    Blockly.alert(lf("'{0}' is a reserved name.", opts.createFunctionName), () => promptAndCreateKind(ws, opts, message, cb));
+                    Blockly.alert(lf("'{0}' is a reserved name.", opts.createFunctionName), () => promptForName(ws, opts, message, cb, prompt));
                 }
-                cb(createVariableForKind(ws, opts, response));
+                cb(response);
             }
         }, { placeholder: opts.promptHint });
     }
+    function promptAndCreateKind(ws, opts, message, cb) {
+        const responseHandler = (response) => {
+            cb(createVariableForKind(ws, opts, response));
+        };
+        promptForName(ws, opts, message, responseHandler, promptAndCreateKind);
+    }
+    function promptAndRenameKind(ws, opts, message, cb) {
+        const responseHandler = (response) => {
+            ws.getVariableMap().renameVariable(opts.toRename, response);
+            cb(response);
+        };
+        promptForName(ws, opts, message, responseHandler, promptAndRenameKind);
+    }
     function getExistingKindMembers(ws, kindName) {
         const existing = ws.getVariablesOfType(kindType(kindName));
         if (existing && existing.length) {

package/built/pxteditor.d.ts

@@ -36,6 +36,11 @@ declare namespace pxt.editor {
         HeaderOnly = "errorListHeader",
         Expanded = "errorListExpanded"
     }
+    enum MuteState {
+        Muted = "muted",
+        Unmuted = "unmuted",
+        Disabled = "disabled"
+    }
     interface IAppProps {
     }
     interface IAppState {
@@ -64,7 +69,7 @@ declare namespace pxt.editor {
         showParts?: boolean;
         fullscreen?: boolean;
         showMiniSim?: boolean;
-        mute?: boolean;
+        mute?: MuteState;
         embedSimView?: boolean;
         editorPosition?: {
             lineNumber: number;
@@ -275,7 +280,7 @@ declare namespace pxt.editor {
         toggleTrace(intervalSpeed?: number): void;
         setTrace(enabled: boolean, intervalSpeed?: number): void;
         toggleMute(): void;
-        setMute(on: boolean): void;
+        setMute(state: MuteState): void;
         openInstructions(): void;
         closeFlyout(): void;
         printCode(): void;

package/built/pxteditor.js

@@ -19,6 +19,12 @@ var pxt;
             ErrorListState["HeaderOnly"] = "errorListHeader";
             ErrorListState["Expanded"] = "errorListExpanded";
         })(ErrorListState = editor.ErrorListState || (editor.ErrorListState = {}));
+        let MuteState;
+        (function (MuteState) {
+            MuteState["Muted"] = "muted";
+            MuteState["Unmuted"] = "unmuted";
+            MuteState["Disabled"] = "disabled";
+        })(MuteState = editor.MuteState || (editor.MuteState = {}));
         let FilterState;
         (function (FilterState) {
             FilterState[FilterState["Hidden"] = 0] = "Hidden";

package/built/pxtlib.d.ts

@@ -727,7 +727,6 @@ declare namespace pxt.BrowserUtils {
     export function noSharedLocalStorage(): boolean;
     export function useOldTutorialLayout(): boolean;
     export function hasPointerEvents(): boolean;
-    export function hasSaveAs(): boolean;
     export function os(): string;
     export function browser(): string;
     export function browserVersion(): string;