matrix-react-sdk
Version:
SDK for matrix.org using React
354 lines (293 loc) • 46.5 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _react = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _filesize = _interopRequireDefault(require("filesize"));
var _languageHandler = require("../../../languageHandler");
var _DecryptFile = require("../../../utils/DecryptFile");
var _Modal = _interopRequireDefault(require("../../../Modal"));
var _AccessibleButton = _interopRequireDefault(require("../elements/AccessibleButton"));
var _replaceableComponent = require("../../../utils/replaceableComponent");
var _Media = require("../../../customisations/Media");
var _ErrorDialog = _interopRequireDefault(require("../dialogs/ErrorDialog"));
var _dec, _class, _class2, _temp;
let downloadIconUrl; // cached copy of the download.svg asset for the sandboxed iframe later on
async function cacheDownloadIcon() {
if (downloadIconUrl) return; // cached already
const svg = await fetch(require("../../../../res/img/download.svg")).then(r => r.text());
downloadIconUrl = "data:image/svg+xml;base64," + window.btoa(svg);
} // Cache the asset immediately
cacheDownloadIcon(); // User supplied content can contain scripts, we have to be careful that
// we don't accidentally run those script within the same origin as the
// client. Otherwise those scripts written by remote users can read
// the access token and end-to-end keys that are in local storage.
//
// For attachments downloaded directly from the homeserver we can use
// Content-Security-Policy headers to disable script execution.
//
// But attachments with end-to-end encryption are more difficult to handle.
// We need to decrypt the attachment on the client and then display it.
// To display the attachment we need to turn the decrypted bytes into a URL.
//
// There are two ways to turn bytes into URLs, data URL and blob URLs.
// Data URLs aren't suitable for downloading a file because Chrome has a
// 2MB limit on the size of URLs that can be viewed in the browser or
// downloaded. This limit does not seem to apply when the url is used as
// the source attribute of an image tag.
//
// Blob URLs are generated using window.URL.createObjectURL and unfortunately
// for our purposes they inherit the origin of the page that created them.
// This means that any scripts that run when the URL is viewed will be able
// to access local storage.
//
// The easiest solution is to host the code that generates the blob URL on
// a different domain to the client.
// Another possibility is to generate the blob URL within a sandboxed iframe.
// The downside of using a second domain is that it complicates hosting,
// the downside of using a sandboxed iframe is that the browers are overly
// restrictive in what you are allowed to do with the generated URL.
/**
* Get the current CSS style for a DOMElement.
* @param {HTMLElement} element The element to get the current style of.
* @return {string} The CSS style encoded as a string.
*/
function computedStyle(element) {
if (!element) {
return "";
}
const style = window.getComputedStyle(element, null);
let cssText = style.cssText; // noinspection EqualityComparisonWithCoercionJS
if (cssText == "") {
// Firefox doesn't implement ".cssText" for computed styles.
// https://bugzilla.mozilla.org/show_bug.cgi?id=137687
for (let i = 0; i < style.length; i++) {
cssText += style[i] + ":";
cssText += style.getPropertyValue(style[i]) + ";";
}
}
return cssText;
}
let MFileBody = (_dec = (0, _replaceableComponent.replaceableComponent)("views.messages.MFileBody"), _dec(_class = (_temp = _class2 = class MFileBody extends _react.default.Component {
constructor(props) {
super(props);
this.state = {
decryptedBlob: this.props.decryptedBlob ? this.props.decryptedBlob : null
};
this._iframe = /*#__PURE__*/(0, _react.createRef)();
this._dummyLink = /*#__PURE__*/(0, _react.createRef)();
}
/**
* Extracts a human readable label for the file attachment to use as
* link text.
*
* @param {Object} content The "content" key of the matrix event.
* @param {boolean} withSize Whether to include size information. Default true.
* @return {string} the human readable link text for the attachment.
*/
presentableTextForFile(content, withSize = true) {
let linkText = (0, _languageHandler._t)("Attachment");
if (content.body && content.body.length > 0) {
// The content body should be the name of the file including a
// file extension.
linkText = content.body;
}
if (content.info && content.info.size && withSize) {
// If we know the size of the file then add it as human readable
// string to the end of the link text so that the user knows how
// big a file they are downloading.
// The content.info also contains a MIME-type but we don't display
// it since it is "ugly", users generally aren't aware what it
// means and the type of the attachment can usually be inferrered
// from the file extension.
linkText += ' (' + (0, _filesize.default)(content.info.size) + ')';
}
return linkText;
}
_getContentUrl() {
const media = (0, _Media.mediaFromContent)(this.props.mxEvent.getContent());
return media.srcHttp;
}
componentDidUpdate(prevProps, prevState) {
if (this.props.onHeightChanged && !prevState.decryptedBlob && this.state.decryptedBlob) {
this.props.onHeightChanged();
}
}
render() {
const content = this.props.mxEvent.getContent();
const text = this.presentableTextForFile(content);
const isEncrypted = content.file !== undefined;
const fileName = content.body && content.body.length > 0 ? content.body : (0, _languageHandler._t)("Attachment");
const contentUrl = this._getContentUrl();
const fileSize = content.info ? content.info.size : null;
const fileType = content.info ? content.info.mimetype : "application/octet-stream";
let placeholder = null;
if (this.props.showGenericPlaceholder) {
placeholder = /*#__PURE__*/_react.default.createElement("div", {
className: "mx_MFileBody_info"
}, /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody_info_icon"
}), /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody_info_filename"
}, this.presentableTextForFile(content, false)));
}
if (isEncrypted) {
if (this.state.decryptedBlob === null) {
// Need to decrypt the attachment
// Wait for the user to click on the link before downloading
// and decrypting the attachment.
let decrypting = false;
const decrypt = e => {
if (decrypting) {
return false;
}
decrypting = true;
(0, _DecryptFile.decryptFile)(content.file).then(blob => {
this.setState({
decryptedBlob: blob
});
}).catch(err => {
console.warn("Unable to decrypt attachment: ", err);
_Modal.default.createTrackedDialog('Error decrypting attachment', '', _ErrorDialog.default, {
title: (0, _languageHandler._t)("Error"),
description: (0, _languageHandler._t)("Error decrypting attachment")
});
}).finally(() => {
decrypting = false;
});
}; // This button should actually Download because usercontent/ will try to click itself
// but it is not guaranteed between various browsers' settings.
return /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody"
}, placeholder, /*#__PURE__*/_react.default.createElement("div", {
className: "mx_MFileBody_download"
}, /*#__PURE__*/_react.default.createElement(_AccessibleButton.default, {
onClick: decrypt
}, (0, _languageHandler._t)("Decrypt %(text)s", {
text: text
}))));
} // When the iframe loads we tell it to render a download link
const onIframeLoad = ev => {
ev.target.contentWindow.postMessage({
imgSrc: downloadIconUrl,
imgStyle: null,
// it handles this internally for us. Useful if a downstream changes the icon.
style: computedStyle(this._dummyLink.current),
blob: this.state.decryptedBlob,
// Set a download attribute for encrypted files so that the file
// will have the correct name when the user tries to download it.
// We can't provide a Content-Disposition header like we would for HTTP.
download: fileName,
textContent: (0, _languageHandler._t)("Download %(text)s", {
text: text
}),
// only auto-download if a user triggered this iframe explicitly
auto: !this.props.decryptedBlob
}, "*");
};
const url = "usercontent/"; // XXX: this path should probably be passed from the skin
// If the attachment is encrypted then put the link inside an iframe.
return /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody"
}, placeholder, /*#__PURE__*/_react.default.createElement("div", {
className: "mx_MFileBody_download"
}, /*#__PURE__*/_react.default.createElement("div", {
style: {
display: "none"
}
}, /*#__PURE__*/_react.default.createElement("a", {
ref: this._dummyLink
})), /*#__PURE__*/_react.default.createElement("iframe", {
src: url,
onLoad: onIframeLoad,
ref: this._iframe,
sandbox: "allow-scripts allow-downloads allow-downloads-without-user-activation"
})));
} else if (contentUrl) {
const downloadProps = {
target: "_blank",
rel: "noreferrer noopener",
// We set the href regardless of whether or not we intercept the download
// because we don't really want to convert the file to a blob eagerly, and
// still want "open in new tab" and "save link as" to work.
href: contentUrl
}; // Blobs can only have up to 500mb, so if the file reports as being too large then
// we won't try and convert it. Likewise, if the file size is unknown then we'll assume
// it is too big. There is the risk of the reported file size and the actual file size
// being different, however the user shouldn't normally run into this problem.
const fileTooBig = typeof fileSize === 'number' ? fileSize > 524288000 : true;
if (["application/pdf"].includes(fileType) && !fileTooBig) {
// We want to force a download on this type, so use an onClick handler.
downloadProps["onClick"] = e => {
console.log(`Downloading ${fileType} as blob (unencrypted)`); // Avoid letting the <a> do its thing
e.preventDefault();
e.stopPropagation(); // Start a fetch for the download
// Based upon https://stackoverflow.com/a/49500465
fetch(contentUrl).then(response => response.blob()).then(blob => {
const blobUrl = URL.createObjectURL(blob); // We have to create an anchor to download the file
const tempAnchor = document.createElement('a');
tempAnchor.download = fileName;
tempAnchor.href = blobUrl;
document.body.appendChild(tempAnchor); // for firefox: https://stackoverflow.com/a/32226068
tempAnchor.click();
tempAnchor.remove();
});
};
} else {
// Else we are hoping the browser will do the right thing
downloadProps["download"] = fileName;
} // If the attachment is not encrypted then we check whether we
// are being displayed in the room timeline or in a list of
// files in the right hand side of the screen.
if (this.props.tileShape === "file_grid") {
return /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody"
}, placeholder, /*#__PURE__*/_react.default.createElement("div", {
className: "mx_MFileBody_download"
}, /*#__PURE__*/_react.default.createElement("a", (0, _extends2.default)({
className: "mx_MFileBody_downloadLink"
}, downloadProps), fileName), /*#__PURE__*/_react.default.createElement("div", {
className: "mx_MImageBody_size"
}, content.info && content.info.size ? (0, _filesize.default)(content.info.size) : "")));
} else {
return /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody"
}, placeholder, /*#__PURE__*/_react.default.createElement("div", {
className: "mx_MFileBody_download"
}, /*#__PURE__*/_react.default.createElement("a", downloadProps, /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody_download_icon"
}), (0, _languageHandler._t)("Download %(text)s", {
text: text
}))));
}
} else {
const extra = text ? ': ' + text : '';
return /*#__PURE__*/_react.default.createElement("span", {
className: "mx_MFileBody"
}, placeholder, (0, _languageHandler._t)("Invalid file%(extra)s", {
extra: extra
}));
}
}
}, (0, _defineProperty2.default)(_class2, "propTypes", {
/* the MatrixEvent to show */
mxEvent: _propTypes.default.object.isRequired,
/* already decrypted blob */
decryptedBlob: _propTypes.default.object,
/* called when the download link iframe is shown */
onHeightChanged: _propTypes.default.func,
/* the shape of the tile, used */
tileShape: _propTypes.default.string,
/* whether or not to show the default placeholder for the file. Defaults to true. */
showGenericPlaceholder: _propTypes.default.bool
}), (0, _defineProperty2.default)(_class2, "defaultProps", {
showGenericPlaceholder: true
}), _temp)) || _class);
exports.default = MFileBody;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/components/views/messages/MFileBody.js"],"names":["downloadIconUrl","cacheDownloadIcon","svg","fetch","require","then","r","text","window","btoa","computedStyle","element","style","getComputedStyle","cssText","i","length","getPropertyValue","MFileBody","React","Component","constructor","props","state","decryptedBlob","_iframe","_dummyLink","presentableTextForFile","content","withSize","linkText","body","info","size","_getContentUrl","media","mxEvent","getContent","srcHttp","componentDidUpdate","prevProps","prevState","onHeightChanged","render","isEncrypted","file","undefined","fileName","contentUrl","fileSize","fileType","mimetype","placeholder","showGenericPlaceholder","decrypting","decrypt","e","blob","setState","catch","err","console","warn","Modal","createTrackedDialog","ErrorDialog","title","description","finally","onIframeLoad","ev","target","contentWindow","postMessage","imgSrc","imgStyle","current","download","textContent","auto","url","display","downloadProps","rel","href","fileTooBig","includes","log","preventDefault","stopPropagation","response","blobUrl","URL","createObjectURL","tempAnchor","document","createElement","appendChild","click","remove","tileShape","extra","PropTypes","object","isRequired","func","string","bool"],"mappings":"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","sourcesContent":["/*\nCopyright 2015, 2016, 2018, 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport React, {createRef} from 'react';\nimport PropTypes from 'prop-types';\nimport filesize from 'filesize';\nimport { _t } from '../../../languageHandler';\nimport {decryptFile} from '../../../utils/DecryptFile';\nimport Modal from '../../../Modal';\nimport AccessibleButton from \"../elements/AccessibleButton\";\nimport {replaceableComponent} from \"../../../utils/replaceableComponent\";\nimport {mediaFromContent} from \"../../../customisations/Media\";\nimport ErrorDialog from \"../dialogs/ErrorDialog\";\n\nlet downloadIconUrl; // cached copy of the download.svg asset for the sandboxed iframe later on\n\nasync function cacheDownloadIcon() {\n    if (downloadIconUrl) return; // cached already\n    const svg = await fetch(require(\"../../../../res/img/download.svg\")).then(r => r.text());\n    downloadIconUrl = \"data:image/svg+xml;base64,\" + window.btoa(svg);\n}\n\n// Cache the asset immediately\ncacheDownloadIcon();\n\n// User supplied content can contain scripts, we have to be careful that\n// we don't accidentally run those script within the same origin as the\n// client. Otherwise those scripts written by remote users can read\n// the access token and end-to-end keys that are in local storage.\n//\n// For attachments downloaded directly from the homeserver we can use\n// Content-Security-Policy headers to disable script execution.\n//\n// But attachments with end-to-end encryption are more difficult to handle.\n// We need to decrypt the attachment on the client and then display it.\n// To display the attachment we need to turn the decrypted bytes into a URL.\n//\n// There are two ways to turn bytes into URLs, data URL and blob URLs.\n// Data URLs aren't suitable for downloading a file because Chrome has a\n// 2MB limit on the size of URLs that can be viewed in the browser or\n// downloaded. This limit does not seem to apply when the url is used as\n// the source attribute of an image tag.\n//\n// Blob URLs are generated using window.URL.createObjectURL and unfortunately\n// for our purposes they inherit the origin of the page that created them.\n// This means that any scripts that run when the URL is viewed will be able\n// to access local storage.\n//\n// The easiest solution is to host the code that generates the blob URL on\n// a different domain to the client.\n// Another possibility is to generate the blob URL within a sandboxed iframe.\n// The downside of using a second domain is that it complicates hosting,\n// the downside of using a sandboxed iframe is that the browers are overly\n// restrictive in what you are allowed to do with the generated URL.\n\n/**\n * Get the current CSS style for a DOMElement.\n * @param {HTMLElement} element The element to get the current style of.\n * @return {string} The CSS style encoded as a string.\n */\nfunction computedStyle(element) {\n    if (!element) {\n        return \"\";\n    }\n    const style = window.getComputedStyle(element, null);\n    let cssText = style.cssText;\n    // noinspection EqualityComparisonWithCoercionJS\n    if (cssText == \"\") {\n        // Firefox doesn't implement \".cssText\" for computed styles.\n        // https://bugzilla.mozilla.org/show_bug.cgi?id=137687\n        for (let i = 0; i < style.length; i++) {\n            cssText += style[i] + \":\";\n            cssText += style.getPropertyValue(style[i]) + \";\";\n        }\n    }\n    return cssText;\n}\n\n@replaceableComponent(\"views.messages.MFileBody\")\nexport default class MFileBody extends React.Component {\n    static propTypes = {\n        /* the MatrixEvent to show */\n        mxEvent: PropTypes.object.isRequired,\n        /* already decrypted blob */\n        decryptedBlob: PropTypes.object,\n        /* called when the download link iframe is shown */\n        onHeightChanged: PropTypes.func,\n        /* the shape of the tile, used */\n        tileShape: PropTypes.string,\n        /* whether or not to show the default placeholder for the file. Defaults to true. */\n        showGenericPlaceholder: PropTypes.bool,\n    };\n\n    static defaultProps = {\n        showGenericPlaceholder: true,\n    };\n\n    constructor(props) {\n        super(props);\n\n        this.state = {\n            decryptedBlob: (this.props.decryptedBlob ? this.props.decryptedBlob : null),\n        };\n\n        this._iframe = createRef();\n        this._dummyLink = createRef();\n    }\n\n    /**\n     * Extracts a human readable label for the file attachment to use as\n     * link text.\n     *\n     * @param {Object} content The \"content\" key of the matrix event.\n     * @param {boolean} withSize Whether to include size information. Default true.\n     * @return {string} the human readable link text for the attachment.\n     */\n    presentableTextForFile(content, withSize = true) {\n        let linkText = _t(\"Attachment\");\n        if (content.body && content.body.length > 0) {\n            // The content body should be the name of the file including a\n            // file extension.\n            linkText = content.body;\n        }\n\n        if (content.info && content.info.size && withSize) {\n            // If we know the size of the file then add it as human readable\n            // string to the end of the link text so that the user knows how\n            // big a file they are downloading.\n            // The content.info also contains a MIME-type but we don't display\n            // it since it is \"ugly\", users generally aren't aware what it\n            // means and the type of the attachment can usually be inferrered\n            // from the file extension.\n            linkText += ' (' + filesize(content.info.size) + ')';\n        }\n        return linkText;\n    }\n\n    _getContentUrl() {\n        const media = mediaFromContent(this.props.mxEvent.getContent());\n        return media.srcHttp;\n    }\n\n    componentDidUpdate(prevProps, prevState) {\n        if (this.props.onHeightChanged && !prevState.decryptedBlob && this.state.decryptedBlob) {\n            this.props.onHeightChanged();\n        }\n    }\n\n    render() {\n        const content = this.props.mxEvent.getContent();\n        const text = this.presentableTextForFile(content);\n        const isEncrypted = content.file !== undefined;\n        const fileName = content.body && content.body.length > 0 ? content.body : _t(\"Attachment\");\n        const contentUrl = this._getContentUrl();\n        const fileSize = content.info ? content.info.size : null;\n        const fileType = content.info ? content.info.mimetype : \"application/octet-stream\";\n\n        let placeholder = null;\n        if (this.props.showGenericPlaceholder) {\n            placeholder = (\n                <div className=\"mx_MFileBody_info\">\n                    <span className=\"mx_MFileBody_info_icon\" />\n                    <span className=\"mx_MFileBody_info_filename\">{this.presentableTextForFile(content, false)}</span>\n                </div>\n            );\n        }\n\n        if (isEncrypted) {\n            if (this.state.decryptedBlob === null) {\n                // Need to decrypt the attachment\n                // Wait for the user to click on the link before downloading\n                // and decrypting the attachment.\n                let decrypting = false;\n                const decrypt = (e) => {\n                    if (decrypting) {\n                        return false;\n                    }\n                    decrypting = true;\n                    decryptFile(content.file).then((blob) => {\n                        this.setState({\n                            decryptedBlob: blob,\n                        });\n                    }).catch((err) => {\n                        console.warn(\"Unable to decrypt attachment: \", err);\n                        Modal.createTrackedDialog('Error decrypting attachment', '', ErrorDialog, {\n                            title: _t(\"Error\"),\n                            description: _t(\"Error decrypting attachment\"),\n                        });\n                    }).finally(() => {\n                        decrypting = false;\n                    });\n                };\n\n                // This button should actually Download because usercontent/ will try to click itself\n                // but it is not guaranteed between various browsers' settings.\n                return (\n                    <span className=\"mx_MFileBody\">\n                        {placeholder}\n                        <div className=\"mx_MFileBody_download\">\n                            <AccessibleButton onClick={decrypt}>\n                                { _t(\"Decrypt %(text)s\", { text: text }) }\n                            </AccessibleButton>\n                        </div>\n                    </span>\n                );\n            }\n\n            // When the iframe loads we tell it to render a download link\n            const onIframeLoad = (ev) => {\n                ev.target.contentWindow.postMessage({\n                    imgSrc: downloadIconUrl,\n                    imgStyle: null, // it handles this internally for us. Useful if a downstream changes the icon.\n                    style: computedStyle(this._dummyLink.current),\n                    blob: this.state.decryptedBlob,\n                    // Set a download attribute for encrypted files so that the file\n                    // will have the correct name when the user tries to download it.\n                    // We can't provide a Content-Disposition header like we would for HTTP.\n                    download: fileName,\n                    textContent: _t(\"Download %(text)s\", { text: text }),\n                    // only auto-download if a user triggered this iframe explicitly\n                    auto: !this.props.decryptedBlob,\n                }, \"*\");\n            };\n\n            const url = \"usercontent/\"; // XXX: this path should probably be passed from the skin\n\n            // If the attachment is encrypted then put the link inside an iframe.\n            return (\n                <span className=\"mx_MFileBody\">\n                    {placeholder}\n                    <div className=\"mx_MFileBody_download\">\n                        <div style={{display: \"none\"}}>\n                            { /*\n                              * Add dummy copy of the \"a\" tag\n                              * We'll use it to learn how the download link\n                              * would have been styled if it was rendered inline.\n                              */ }\n                            <a ref={this._dummyLink} />\n                        </div>\n                        <iframe\n                            src={url}\n                            onLoad={onIframeLoad}\n                            ref={this._iframe}\n                            sandbox=\"allow-scripts allow-downloads allow-downloads-without-user-activation\" />\n                    </div>\n                </span>\n            );\n        } else if (contentUrl) {\n            const downloadProps = {\n                target: \"_blank\",\n                rel: \"noreferrer noopener\",\n\n                // We set the href regardless of whether or not we intercept the download\n                // because we don't really want to convert the file to a blob eagerly, and\n                // still want \"open in new tab\" and \"save link as\" to work.\n                href: contentUrl,\n            };\n\n            // Blobs can only have up to 500mb, so if the file reports as being too large then\n            // we won't try and convert it. Likewise, if the file size is unknown then we'll assume\n            // it is too big. There is the risk of the reported file size and the actual file size\n            // being different, however the user shouldn't normally run into this problem.\n            const fileTooBig = typeof(fileSize) === 'number' ? fileSize > 524288000 : true;\n\n            if ([\"application/pdf\"].includes(fileType) && !fileTooBig) {\n                // We want to force a download on this type, so use an onClick handler.\n                downloadProps[\"onClick\"] = (e) => {\n                    console.log(`Downloading ${fileType} as blob (unencrypted)`);\n\n                    // Avoid letting the <a> do its thing\n                    e.preventDefault();\n                    e.stopPropagation();\n\n                    // Start a fetch for the download\n                    // Based upon https://stackoverflow.com/a/49500465\n                    fetch(contentUrl).then((response) => response.blob()).then((blob) => {\n                        const blobUrl = URL.createObjectURL(blob);\n\n                        // We have to create an anchor to download the file\n                        const tempAnchor = document.createElement('a');\n                        tempAnchor.download = fileName;\n                        tempAnchor.href = blobUrl;\n                        document.body.appendChild(tempAnchor); // for firefox: https://stackoverflow.com/a/32226068\n                        tempAnchor.click();\n                        tempAnchor.remove();\n                    });\n                };\n            } else {\n                // Else we are hoping the browser will do the right thing\n                downloadProps[\"download\"] = fileName;\n            }\n\n            // If the attachment is not encrypted then we check whether we\n            // are being displayed in the room timeline or in a list of\n            // files in the right hand side of the screen.\n            if (this.props.tileShape === \"file_grid\") {\n                return (\n                    <span className=\"mx_MFileBody\">\n                        {placeholder}\n                        <div className=\"mx_MFileBody_download\">\n                            <a className=\"mx_MFileBody_downloadLink\" {...downloadProps}>\n                                { fileName }\n                            </a>\n                            <div className=\"mx_MImageBody_size\">\n                                { content.info && content.info.size ? filesize(content.info.size) : \"\" }\n                            </div>\n                        </div>\n                    </span>\n                );\n            } else {\n                return (\n                    <span className=\"mx_MFileBody\">\n                        {placeholder}\n                        <div className=\"mx_MFileBody_download\">\n                            <a {...downloadProps}>\n                                <span className=\"mx_MFileBody_download_icon\" />\n                                { _t(\"Download %(text)s\", { text: text }) }\n                            </a>\n                        </div>\n                    </span>\n                );\n            }\n        } else {\n            const extra = text ? (': ' + text) : '';\n            return <span className=\"mx_MFileBody\">\n                {placeholder}\n                { _t(\"Invalid file%(extra)s\", { extra: extra }) }\n            </span>;\n        }\n    }\n}\n"]}