mirror of
https://github.com/element-hq/element-web.git
synced 2024-12-05 05:38:41 +03:00
128 lines
4.6 KiB
JavaScript
128 lines
4.6 KiB
JavaScript
/*
|
|
Copyright 2016 OpenMarket Ltd
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
import marked from 'marked';
|
|
|
|
// marked only applies the default options on the high
|
|
// level marked() interface, so we do it here.
|
|
const marked_options = Object.assign({}, marked.defaults, {
|
|
gfm: true,
|
|
tables: true,
|
|
breaks: true,
|
|
pedantic: false,
|
|
sanitize: true,
|
|
smartLists: true,
|
|
smartypants: false,
|
|
xhtml: true, // return self closing tags (ie. <br /> not <br>)
|
|
});
|
|
|
|
/**
|
|
* Class that wraps marked, adding the ability to see whether
|
|
* a given message actually uses any markdown syntax or whether
|
|
* it's plain text.
|
|
*/
|
|
export default class Markdown {
|
|
constructor(input) {
|
|
const lexer = new marked.Lexer(marked_options);
|
|
this.tokens = lexer.lex(input);
|
|
}
|
|
|
|
_copyTokens() {
|
|
// copy tokens (the parser modifies its input arg)
|
|
const tokens_copy = this.tokens.slice();
|
|
// it also has a 'links' property, because this is javascript
|
|
// and why wouldn't you have an array that also has properties?
|
|
return Object.assign(tokens_copy, this.tokens);
|
|
}
|
|
|
|
isPlainText() {
|
|
// we determine if the message requires markdown by
|
|
// running the parser on the tokens with a dummy
|
|
// rendered and seeing if any of the renderer's
|
|
// functions are called other than those noted below.
|
|
// In case you were wondering, no we can't just examine
|
|
// the tokens because the tokens we have are only the
|
|
// output of the *first* tokenizer: any line-based
|
|
// markdown is processed by marked within Parser by
|
|
// the 'inline lexer'...
|
|
let is_plain = true;
|
|
|
|
function setNotPlain() {
|
|
is_plain = false;
|
|
}
|
|
|
|
const dummy_renderer = {};
|
|
for (const k of Object.keys(marked.Renderer.prototype)) {
|
|
dummy_renderer[k] = setNotPlain;
|
|
}
|
|
// text and paragraph are just text
|
|
dummy_renderer.text = function(t){return t;}
|
|
dummy_renderer.paragraph = function(t){return t;}
|
|
|
|
// ignore links where text is just the url:
|
|
// this ignores plain URLs that markdown has
|
|
// detected whilst preserving markdown syntax links
|
|
dummy_renderer.link = function(href, title, text) {
|
|
if (text != href) {
|
|
is_plain = false;
|
|
}
|
|
}
|
|
|
|
const dummy_options = Object.assign({}, marked_options, {
|
|
renderer: dummy_renderer,
|
|
});
|
|
const dummy_parser = new marked.Parser(dummy_options);
|
|
dummy_parser.parse(this._copyTokens());
|
|
|
|
return is_plain;
|
|
}
|
|
|
|
toHTML() {
|
|
const real_renderer = new marked.Renderer();
|
|
real_renderer.link = function(href, title, text) {
|
|
// prevent marked from turning plain URLs
|
|
// into links, because its algorithm is fairly
|
|
// poor. Let's send plain URLs rather than
|
|
// badly linkified ones (the linkifier Vector
|
|
// uses on message display is way better, eg.
|
|
// handles URLs with closing parens at the end).
|
|
if (text == href) {
|
|
return href;
|
|
}
|
|
return marked.Renderer.prototype.link.apply(this, arguments);
|
|
}
|
|
|
|
real_renderer.paragraph = (text) => {
|
|
// The tokens at the top level are the 'blocks', so if we
|
|
// have more than one, there are multiple 'paragraphs'.
|
|
// If there is only one top level token, just return the
|
|
// bare text: it's a single line of text and so should be
|
|
// 'inline', rather than necessarily wrapped in its own
|
|
// p tag. If, however, we have multiple tokens, each gets
|
|
// its own p tag to keep them as separate paragraphs.
|
|
if (this.tokens.length == 1) {
|
|
return text;
|
|
}
|
|
return '<p>' + text + '</p>';
|
|
}
|
|
|
|
const real_options = Object.assign({}, marked_options, {
|
|
renderer: real_renderer,
|
|
});
|
|
const real_parser = new marked.Parser(real_options);
|
|
return real_parser.parse(this._copyTokens());
|
|
}
|
|
}
|