matrix-react-sdk/lib/HtmlUtils.js

SDK for matrix.org using React

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.unicodeToShortcode = unicodeToShortcode;
exports.shortcodeToUnicode = shortcodeToUnicode;
exports.processHtmlForSending = processHtmlForSending;
exports.sanitizedHtmlNode = sanitizedHtmlNode;
exports.getHtmlText = getHtmlText;
exports.isUrlPermitted = isUrlPermitted;
exports.bodyToHtml = bodyToHtml;
exports.linkifyString = linkifyString;
exports.linkifyElement = linkifyElement;
exports.linkifyAndSanitizeHtml = linkifyAndSanitizeHtml;
exports.checkBlockNode = checkBlockNode;
exports.PERMITTED_URL_SCHEMES = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _react = _interopRequireDefault(require("react"));

var _sanitizeHtml = _interopRequireDefault(require("sanitize-html"));

var linkify = _interopRequireWildcard(require("linkifyjs"));

var _linkifyMatrix = _interopRequireDefault(require("./linkify-matrix"));

var _element = _interopRequireDefault(require("linkifyjs/element"));

var _string = _interopRequireDefault(require("linkifyjs/string"));

var _classnames = _interopRequireDefault(require("classnames"));

var _emojibaseRegex = _interopRequireDefault(require("emojibase-regex"));

var _url = _interopRequireDefault(require("url"));

var _katex = _interopRequireDefault(require("katex"));

var _htmlEntities = require("html-entities");

var _SettingsStore = _interopRequireDefault(require("./settings/SettingsStore"));

var _cheerio = _interopRequireDefault(require("cheerio"));

var _Permalinks = require("./utils/permalinks/Permalinks");

var _emoji = require("./emoji");

var _ReplyThread = _interopRequireDefault(require("./components/views/elements/ReplyThread"));

var _Media = require("./customisations/Media");

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

(0, _linkifyMatrix.default)(linkify); // Anything outside the basic multilingual plane will be a surrogate pair

const SURROGATE_PAIR_PATTERN = /([\ud800-\udbff])([\udc00-\udfff])/; // And there a bunch more symbol characters that emojibase has within the
// BMP, so this includes the ranges from 'letterlike symbols' to
// 'miscellaneous symbols and arrows' which should catch all of them
// (with plenty of false positives, but that's OK)

const SYMBOL_PATTERN = /([\u2100-\u2bff])/; // Regex pattern for Zero-Width joiner unicode characters

const ZWJ_REGEX = new RegExp("\u200D|\u2003", "g"); // Regex pattern for whitespace characters

const WHITESPACE_REGEX = new RegExp("\\s", "g");
const BIGEMOJI_REGEX = new RegExp(`^(${_emojibaseRegex.default.source})+$`, 'i');
const COLOR_REGEX = /^#[0-9a-fA-F]{6}$/;
const PERMITTED_URL_SCHEMES = ['http', 'https', 'ftp', 'mailto', 'magnet'];
/*
 * Return true if the given string contains emoji
 * Uses a much, much simpler regex than emojibase's so will give false
 * positives, but useful for fast-path testing strings to see if they
 * need emojification.
 * unicodeToImage uses this function.
 */

exports.PERMITTED_URL_SCHEMES = PERMITTED_URL_SCHEMES;

function mightContainEmoji(str
/*: string*/
) {
  return SURROGATE_PAIR_PATTERN.test(str) || SYMBOL_PATTERN.test(str);
}
/**
 * Returns the shortcode for an emoji character.
 *
 * @param {String} char The emoji character
 * @return {String} The shortcode (such as :thumbup:)
 */


function unicodeToShortcode(char
/*: string*/
) {
  const data = (0, _emoji.getEmojiFromUnicode)(char);
  return data && data.shortcodes ? `:${data.shortcodes[0]}:` : '';
}
/**
 * Returns the unicode character for an emoji shortcode
 *
 * @param {String} shortcode The shortcode (such as :thumbup:)
 * @return {String} The emoji character; null if none exists
 */


function shortcodeToUnicode(shortcode
/*: string*/
) {
  shortcode = shortcode.slice(1, shortcode.length - 1);

  const data = _emoji.SHORTCODE_TO_EMOJI.get(shortcode);

  return data ? data.unicode : null;
}

function processHtmlForSending(html
/*: string*/
)
/*: string*/
{
  const contentDiv = document.createElement('div');
  contentDiv.innerHTML = html;

  if (contentDiv.children.length === 0) {
    return contentDiv.innerHTML;
  }

  let contentHTML = "";

  for (let i = 0; i < contentDiv.children.length; i++) {
    const element = contentDiv.children[i];

    if (element.tagName.toLowerCase() === 'p') {
      contentHTML += element.innerHTML; // Don't add a <br /> for the last <p>

      if (i !== contentDiv.children.length - 1) {
        contentHTML += '<br />';
      }
    } else {
      const temp = document.createElement('div');
      temp.appendChild(element.cloneNode(true));
      contentHTML += temp.innerHTML;
    }
  }

  return contentHTML;
}
/*
 * Given an untrusted HTML string, return a React node with an sanitized version
 * of that HTML.
 */


function sanitizedHtmlNode(insaneHtml
/*: string*/
) {
  const saneHtml = (0, _sanitizeHtml.default)(insaneHtml, sanitizeHtmlParams);
  return /*#__PURE__*/_react.default.createElement("div", {
    dangerouslySetInnerHTML: {
      __html: saneHtml
    },
    dir: "auto"
  });
}

function getHtmlText(insaneHtml
/*: string*/
) {
  return (0, _sanitizeHtml.default)(insaneHtml, {
    allowedTags: [],
    allowedAttributes: {},
    selfClosing: [],
    allowedSchemes: [],
    disallowedTagsMode: 'discard'
  });
}
/**
 * Tests if a URL from an untrusted source may be safely put into the DOM
 * The biggest threat here is javascript: URIs.
 * Note that the HTML sanitiser library has its own internal logic for
 * doing this, to which we pass the same list of schemes. This is used in
 * other places we need to sanitise URLs.
 * @return true if permitted, otherwise false
 */


function isUrlPermitted(inputUrl
/*: string*/
) {
  try {
    const parsed = _url.default.parse(inputUrl);

    if (!parsed.protocol) return false; // URL parser protocol includes the trailing colon

    return PERMITTED_URL_SCHEMES.includes(parsed.protocol.slice(0, -1));
  } catch (e) {
    return false;
  }
}

const transformTags
/*: IExtendedSanitizeOptions["transformTags"]*/
= {
  // custom to matrix
  // add blank targets to all hyperlinks except vector URLs
  'a': function (tagName
  /*: string*/
  , attribs
  /*: sanitizeHtml.Attributes*/
  ) {
    if (attribs.href) {
      attribs.target = '_blank'; // by default

      const transformed = (0, _Permalinks.tryTransformPermalinkToLocalHref)(attribs.href);

      if (transformed !== attribs.href || attribs.href.match(_linkifyMatrix.default.ELEMENT_URL_PATTERN)) {
        attribs.href = transformed;
        delete attribs.target;
      }
    }

    attribs.rel = 'noreferrer noopener'; // https://mathiasbynens.github.io/rel-noopener/

    return {
      tagName,
      attribs
    };
  },
  'img': function (tagName
  /*: string*/
  , attribs
  /*: sanitizeHtml.Attributes*/
  ) {
    // Strip out imgs that aren't `mxc` here instead of using allowedSchemesByTag
    // because transformTags is used _before_ we filter by allowedSchemesByTag and
    // we don't want to allow images with `https?` `src`s.
    // We also drop inline images (as if they were not present at all) when the "show
    // images" preference is disabled. Future work might expose some UI to reveal them
    // like standalone image events have.
    if (!attribs.src || !attribs.src.startsWith('mxc://') || !_SettingsStore.default.getValue("showImages")) {
      return {
        tagName,
        attribs: {}
      };
    }

    const width = Number(attribs.width) || 800;
    const height = Number(attribs.height) || 600;
    attribs.src = (0, _Media.mediaFromMxc)(attribs.src).getThumbnailOfSourceHttp(width, height);
    return {
      tagName,
      attribs
    };
  },
  'code': function (tagName
  /*: string*/
  , attribs
  /*: sanitizeHtml.Attributes*/
  ) {
    if (typeof attribs.class !== 'undefined') {
      // Filter out all classes other than ones starting with language- for syntax highlighting.
      const classes = attribs.class.split(/\s/).filter(function (cl) {
        return cl.startsWith('language-') && !cl.startsWith('language-_');
      });
      attribs.class = classes.join(' ');
    }

    return {
      tagName,
      attribs
    };
  },
  '*': function (tagName
  /*: string*/
  , attribs
  /*: sanitizeHtml.Attributes*/
  ) {
    // Delete any style previously assigned, style is an allowedTag for font and span
    // because attributes are stripped after transforming
    delete attribs.style; // Sanitise and transform data-mx-color and data-mx-bg-color to their CSS
    // equivalents

    const customCSSMapper = {
      'data-mx-color': 'color',
      'data-mx-bg-color': 'background-color' // $customAttributeKey: $cssAttributeKey

    };
    let style = "";
    Object.keys(customCSSMapper).forEach(customAttributeKey => {
      const cssAttributeKey = customCSSMapper[customAttributeKey];
      const customAttributeValue = attribs[customAttributeKey];

      if (customAttributeValue && typeof customAttributeValue === 'string' && COLOR_REGEX.test(customAttributeValue)) {
        style += cssAttributeKey + ":" + customAttributeValue + ";";
        delete attribs[customAttributeKey];
      }
    });

    if (style) {
      attribs.style = style;
    }

    return {
      tagName,
      attribs
    };
  }
};
const sanitizeHtmlParams
/*: IExtendedSanitizeOptions*/
= {
  allowedTags: ['font', // custom to matrix for IRC-style font coloring
  'del', // for markdown
  'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'p', 'a', 'ul', 'ol', 'sup', 'sub', 'nl', 'li', 'b', 'i', 'u', 'strong', 'em', 'strike', 'code', 'hr', 'br', 'div', 'table', 'thead', 'caption', 'tbody', 'tr', 'th', 'td', 'pre', 'span', 'img', 'details', 'summary'],
  allowedAttributes: {
    // custom ones first:
    font: ['color', 'data-mx-bg-color', 'data-mx-color', 'style'],
    // custom to matrix
    span: ['data-mx-maths', 'data-mx-bg-color', 'data-mx-color', 'data-mx-spoiler', 'style'],
    // custom to matrix
    div: ['data-mx-maths'],
    a: ['href', 'name', 'target', 'rel'],
    // remote target: custom to matrix
    img: ['src', 'width', 'height', 'alt', 'title'],
    ol: ['start'],
    code: ['class'] // We don't actually allow all classes, we filter them in transformTags

  },
  // Lots of these won't come up by default because we don't allow them
  selfClosing: ['img', 'br', 'hr', 'area', 'base', 'basefont', 'input', 'link', 'meta'],
  // URL schemes we permit
  allowedSchemes: PERMITTED_URL_SCHEMES,
  allowProtocolRelative: false,
  transformTags,
  // 50 levels deep "should be enough for anyone"
  nestingLimit: 50
}; // this is the same as the above except with less rewriting

const composerSanitizeHtmlParams
/*: IExtendedSanitizeOptions*/
= _objectSpread(_objectSpread({}, sanitizeHtmlParams), {}, {
  transformTags: {
    'code': transformTags['code'],
    '*': transformTags['*']
  }
});

class BaseHighlighter
/*:: <T extends React.ReactNode>*/
{
  constructor(highlightClass
  /*: string*/
  , highlightLink
  /*: string*/
  ) {
    this.highlightClass
    /*:: */
    = highlightClass
    /*:: */
    ;
    this.highlightLink
    /*:: */
    = highlightLink
    /*:: */
    ;
  }
  /**
   * apply the highlights to a section of text
   *
   * @param {string} safeSnippet The snippet of text to apply the highlights
   *     to.
   * @param {string[]} safeHighlights A list of substrings to highlight,
   *     sorted by descending length.
   *
   * returns a list of results (strings for HtmlHighligher, react nodes for
   * TextHighlighter).
   */


  applyHighlights(safeSnippet
  /*: string*/
  , safeHighlights
  /*: string[]*/
  )
  /*: T[]*/
  {
    let lastOffset = 0;
    let offset;
    let nodes
    /*: T[]*/
    = [];
    const safeHighlight = safeHighlights[0];

    while ((offset = safeSnippet.toLowerCase().indexOf(safeHighlight.toLowerCase(), lastOffset)) >= 0) {
      // handle preamble
      if (offset > lastOffset) {
        const subSnippet = safeSnippet.substring(lastOffset, offset);
        nodes = nodes.concat(this.applySubHighlights(subSnippet, safeHighlights));
      } // do highlight. use the original string rather than safeHighlight
      // to preserve the original casing.


      const endOffset = offset + safeHighlight.length;
      nodes.push(this.processSnippet(safeSnippet.substring(offset, endOffset), true));
      lastOffset = endOffset;
    } // handle postamble


    if (lastOffset !== safeSnippet.length) {
      const subSnippet = safeSnippet.substring(lastOffset, undefined);
      nodes = nodes.concat(this.applySubHighlights(subSnippet, safeHighlights));
    }

    return nodes;
  }

  applySubHighlights(safeSnippet
  /*: string*/
  , safeHighlights
  /*: string[]*/
  )
  /*: T[]*/
  {
    if (safeHighlights[1]) {
      // recurse into this range to check for the next set of highlight matches
      return this.applyHighlights(safeSnippet, safeHighlights.slice(1));
    } else {
      // no more highlights to be found, just return the unhighlighted string
      return [this.processSnippet(safeSnippet, false)];
    }
  }

}

class HtmlHighlighter extends BaseHighlighter
/*:: <string>*/
{
  /* highlight the given snippet if required
   *
   * snippet: content of the span; must have been sanitised
   * highlight: true to highlight as a search match
   *
   * returns an HTML string
   */
  processSnippet(snippet
  /*: string*/
  , highlight
  /*: boolean*/
  )
  /*: string*/
  {
    if (!highlight) {
      // nothing required here
      return snippet;
    }

    let span = `<span class="${this.highlightClass}">${snippet}</span>`;

    if (this.highlightLink) {
      span = `<a href="${encodeURI(this.highlightLink)}">${span}</a>`;
    }

    return span;
  }

}

/* turn a matrix event body into html
 *
 * content: 'content' of the MatrixEvent
 *
 * highlights: optional list of words to highlight, ordered by longest word first
 *
 * opts.highlightLink: optional href to add to highlighted words
 * opts.disableBigEmoji: optional argument to disable the big emoji class.
 * opts.stripReplyFallback: optional argument specifying the event is a reply and so fallback needs removing
 * opts.returnString: return an HTML string rather than JSX elements
 * opts.forComposerQuote: optional param to lessen the url rewriting done by sanitization, for quoting into composer
 * opts.ref: React ref to attach to any React components returned (not compatible with opts.returnString)
 */
function bodyToHtml(content
/*: IContent*/
, highlights
/*: string[]*/
, opts
/*: IOpts*/
= {}) {
  const isHtmlMessage = content.format === "org.matrix.custom.html" && content.formatted_body;
  let bodyHasEmoji = false;
  let sanitizeParams = sanitizeHtmlParams;

  if (opts.forComposerQuote) {
    sanitizeParams = composerSanitizeHtmlParams;
  }

  let strippedBody
  /*: string*/
  ;
  let safeBody
  /*: string*/
  ;
  let isDisplayedWithHtml
  /*: boolean*/
  ; // XXX: We sanitize the HTML whilst also highlighting its text nodes, to avoid accidentally trying
  // to highlight HTML tags themselves.  However, this does mean that we don't highlight textnodes which
  // are interrupted by HTML tags (not that we did before) - e.g. foo<span/>bar won't get highlighted
  // by an attempt to search for 'foobar'.  Then again, the search query probably wouldn't work either

  try {
    if (highlights && highlights.length > 0) {
      const highlighter = new HtmlHighlighter("mx_EventTile_searchHighlight", opts.highlightLink);
      const safeHighlights = highlights.map(function (highlight) {
        return (0, _sanitizeHtml.default)(highlight, sanitizeParams);
      }); // XXX: hacky bodge to temporarily apply a textFilter to the sanitizeParams structure.

      sanitizeParams.textFilter = function (safeText) {
        return highlighter.applyHighlights(safeText, safeHighlights).join('');
      };
    }

    let formattedBody = typeof content.formatted_body === 'string' ? content.formatted_body : null;
    const plainBody = typeof content.body === 'string' ? content.body : "";
    if (opts.stripReplyFallback && formattedBody) formattedBody = _ReplyThread.default.stripHTMLReply(formattedBody);
    strippedBody = opts.stripReplyFallback ? _ReplyThread.default.stripPlainReply(plainBody) : plainBody;
    bodyHasEmoji = mightContainEmoji(isHtmlMessage ? formattedBody : plainBody); // Only generate safeBody if the message was sent as org.matrix.custom.html

    if (isHtmlMessage) {
      isDisplayedWithHtml = true;
      safeBody = (0, _sanitizeHtml.default)(formattedBody, sanitizeParams);

      if (_SettingsStore.default.getValue("feature_latex_maths")) {
        const phtml = _cheerio.default.load(safeBody, {
          // @ts-ignore: The `_useHtmlParser2` internal option is the
          // simplest way to both parse and render using `htmlparser2`.
          _useHtmlParser2: true,
          decodeEntities: false
        }); // @ts-ignore - The types for `replaceWith` wrongly expect
        // Cheerio instance to be returned.


        phtml('div, span[data-mx-maths!=""]').replaceWith(function (i, e) {
          return _katex.default.renderToString(_htmlEntities.AllHtmlEntities.decode(phtml(e).attr('data-mx-maths')), {
            throwOnError: false,
            // @ts-ignore - `e` can be an Element, not just a Node
            displayMode: e.name == 'div',
            output: "htmlAndMathml"
          });
        });
        safeBody = phtml.html();
      }
    }
  } finally {
    delete sanitizeParams.textFilter;
  }

  const contentBody = isDisplayedWithHtml ? safeBody : strippedBody;

  if (opts.returnString) {
    return contentBody;
  }

  let emojiBody = false;

  if (!opts.disableBigEmoji && bodyHasEmoji) {
    let contentBodyTrimmed = contentBody !== undefined ? contentBody.trim() : ''; // Ignore spaces in body text. Emojis with spaces in between should
    // still be counted as purely emoji messages.

    contentBodyTrimmed = contentBodyTrimmed.replace(WHITESPACE_REGEX, ''); // Remove zero width joiner characters from emoji messages. This ensures
    // that emojis that are made up of multiple unicode characters are still
    // presented as large.

    contentBodyTrimmed = contentBodyTrimmed.replace(ZWJ_REGEX, '');
    const match = BIGEMOJI_REGEX.exec(contentBodyTrimmed);
    emojiBody = match && match[0] && match[0].length === contentBodyTrimmed.length && ( // Prevent user pills expanding for users with only emoji in
    // their username. Permalinks (links in pills) can be any URL
    // now, so we just check for an HTTP-looking thing.
    strippedBody === safeBody || // replies have the html fallbacks, account for that here
    content.formatted_body === undefined || !content.formatted_body.includes("http:") && !content.formatted_body.includes("https:"));
  }

  const className = (0, _classnames.default)({
    'mx_EventTile_body': true,
    'mx_EventTile_bigEmoji': emojiBody,
    'markdown-body': isHtmlMessage && !emojiBody
  });
  return isDisplayedWithHtml ? /*#__PURE__*/_react.default.createElement("span", {
    key: "body",
    ref: opts.ref,
    className: className,
    dangerouslySetInnerHTML: {
      __html: safeBody
    },
    dir: "auto"
  }) : /*#__PURE__*/_react.default.createElement("span", {
    key: "body",
    ref: opts.ref,
    className: className,
    dir: "auto"
  }, strippedBody);
}
/**
 * Linkifies the given string. This is a wrapper around 'linkifyjs/string'.
 *
 * @param {string} str string to linkify
 * @param {object} [options] Options for linkifyString. Default: linkifyMatrix.options
 * @returns {string} Linkified string
 */


function linkifyString(str
/*: string*/
, options = _linkifyMatrix.default.options) {
  return (0, _string.default)(str, options);
}
/**
 * Linkifies the given DOM element. This is a wrapper around 'linkifyjs/element'.
 *
 * @param {object} element DOM element to linkify
 * @param {object} [options] Options for linkifyElement. Default: linkifyMatrix.options
 * @returns {object}
 */


function linkifyElement(element
/*: HTMLElement*/
, options = _linkifyMatrix.default.options) {
  return (0, _element.default)(element, options);
}
/**
 * Linkify the given string and sanitize the HTML afterwards.
 *
 * @param {string} dirtyHtml The HTML string to sanitize and linkify
 * @param {object} [options] Options for linkifyString. Default: linkifyMatrix.options
 * @returns {string}
 */


function linkifyAndSanitizeHtml(dirtyHtml
/*: string*/
, options = _linkifyMatrix.default.options) {
  return (0, _sanitizeHtml.default)(linkifyString(dirtyHtml, options), sanitizeHtmlParams);
}
/**
 * Returns if a node is a block element or not.
 * Only takes html nodes into account that are allowed in matrix messages.
 *
 * @param {Node} node
 * @returns {bool}
 */


function checkBlockNode(node
/*: Node*/
) {
  switch (node.nodeName) {
    case "H1":
    case "H2":
    case "H3":
    case "H4":
    case "H5":
    case "H6":
    case "PRE":
    case "BLOCKQUOTE":
    case "P":
    case "UL":
    case "OL":
    case "LI":
    case "HR":
    case "TABLE":
    case "THEAD":
    case "TBODY":
    case "TR":
    case "TH":
    case "TD":
      return true;

    case "DIV":
      // don't treat math nodes as block nodes for deserializing
      return !node.hasAttribute("data-mx-maths");

    default:
      return false;
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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