281 lines
8.1 KiB
JavaScript
281 lines
8.1 KiB
JavaScript
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
|
typeof define === 'function' && define.amd ? define(factory) :
|
|
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.markedMfm = factory());
|
|
})(this, (function () { 'use strict';
|
|
|
|
function _wrapRegExp() {
|
|
_wrapRegExp = function (re, groups) {
|
|
return new BabelRegExp(re, void 0, groups);
|
|
};
|
|
|
|
var _super = RegExp.prototype,
|
|
_groups = new WeakMap();
|
|
|
|
function BabelRegExp(re, flags, groups) {
|
|
var _this = new RegExp(re, flags);
|
|
|
|
return _groups.set(_this, groups || _groups.get(re)), _setPrototypeOf(_this, BabelRegExp.prototype);
|
|
}
|
|
|
|
function buildGroups(result, re) {
|
|
var g = _groups.get(re);
|
|
|
|
return Object.keys(g).reduce(function (groups, name) {
|
|
return groups[name] = result[g[name]], groups;
|
|
}, Object.create(null));
|
|
}
|
|
|
|
return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
|
|
var result = _super.exec.call(this, str);
|
|
|
|
return result && (result.groups = buildGroups(result, this)), result;
|
|
}, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
|
|
if ("string" == typeof substitution) {
|
|
var groups = _groups.get(this);
|
|
|
|
return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
|
|
return "$" + groups[name];
|
|
}));
|
|
}
|
|
|
|
if ("function" == typeof substitution) {
|
|
var _this = this;
|
|
|
|
return _super[Symbol.replace].call(this, str, function () {
|
|
var args = arguments;
|
|
return "object" != typeof args[args.length - 1] && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
|
|
});
|
|
}
|
|
|
|
return _super[Symbol.replace].call(this, str, substitution);
|
|
}, _wrapRegExp.apply(this, arguments);
|
|
}
|
|
|
|
function _inherits(subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function");
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
Object.defineProperty(subClass, "prototype", {
|
|
writable: false
|
|
});
|
|
if (superClass) _setPrototypeOf(subClass, superClass);
|
|
}
|
|
|
|
function _setPrototypeOf(o, p) {
|
|
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
|
|
o.__proto__ = p;
|
|
return o;
|
|
};
|
|
return _setPrototypeOf(o, p);
|
|
}
|
|
|
|
var index = {
|
|
extensions: [{
|
|
name: 'mfm',
|
|
level: 'inline',
|
|
start: function start(src) {
|
|
var _src$match;
|
|
|
|
return (_src$match = src.match(/\$\[/)) == null ? void 0 : _src$match.index;
|
|
},
|
|
tokenizer: function tokenizer(src, tokens) {
|
|
// regex doesn't do well finding MFM tags: it's always either too lazy
|
|
// or too greedy.
|
|
var level = 0;
|
|
var walk = 0;
|
|
|
|
while (level > 0 || walk === 0) {
|
|
if (src[walk] + src[walk + 1] === '$[') {
|
|
level++;
|
|
walk++;
|
|
} else if (src[walk] === ']') {
|
|
level--;
|
|
}
|
|
|
|
walk++;
|
|
} // original regex, now definitely on the correct tag
|
|
|
|
|
|
var rule = /*#__PURE__*/_wrapRegExp(/^\$\[([\w\d]+)(?:\.(\S+))? ([\S\s]+)\]/, {
|
|
markup: 1,
|
|
options: 2,
|
|
text: 3
|
|
});
|
|
|
|
var match = rule.exec(src.slice(0, walk));
|
|
|
|
if (match) {
|
|
var token = {
|
|
type: 'mfm',
|
|
raw: match[0],
|
|
markup: match.groups.markup,
|
|
options: match.groups.options,
|
|
text: match.groups.text,
|
|
tokens: []
|
|
};
|
|
this.lexer.inline(token.text, token.tokens);
|
|
return token;
|
|
}
|
|
},
|
|
renderer: function renderer(token) {
|
|
var _this = this;
|
|
|
|
var options = {};
|
|
|
|
if (token.options) {
|
|
options = token.options.split(',').reduce(function (i, opt) {
|
|
i[opt.split('=')[0]] = opt.split('=')[1] || true;
|
|
return i;
|
|
}, {});
|
|
}
|
|
|
|
var el = function el(mfmClass, mfmStyle) {
|
|
if (mfmStyle === void 0) {
|
|
mfmStyle = '';
|
|
}
|
|
|
|
return "<span style=\"display: inline-block;" + mfmStyle + "\" class=\"" + mfmClass + "\">" + _this.parser.parseInline(token.tokens) + "</span>";
|
|
};
|
|
|
|
switch (token.markup) {
|
|
case 'blur':
|
|
{
|
|
return el('_mfm_blur_');
|
|
}
|
|
|
|
case 'bounce':
|
|
{
|
|
return el('_mfm_bounce_');
|
|
}
|
|
|
|
case 'flip':
|
|
{
|
|
var transform = options.x && options.v ? 'scale(-1, -1)' : options.v ? 'scaleY(-1)' : 'scaleX(-1)';
|
|
return el('_mfm_flip_', " transform: " + transform + ";");
|
|
}
|
|
|
|
case 'font':
|
|
{
|
|
var family = options.serif ? 'serif' : options.monospace ? 'monospace' : options.cursive ? 'cursive' : options.fantasy ? 'fantasy' : options.emoji ? 'emoji' : options.math ? 'math' : 'inherit';
|
|
return el('_mfm_font_', " font-family: " + family + ";");
|
|
}
|
|
|
|
case 'jelly':
|
|
{
|
|
var speed = options.speed || '1s';
|
|
return el('_mfm_jelly_', " animation: mfm-rubberBand " + speed + " linear infinite both;");
|
|
}
|
|
|
|
case 'jump':
|
|
{
|
|
return el('_mfm_jump_');
|
|
}
|
|
|
|
case 'rainbow':
|
|
{
|
|
return el('_mfm_rainbow_');
|
|
}
|
|
|
|
case 'rotate':
|
|
{
|
|
var degrees = options.deg || '90';
|
|
return el('_mfm_rotate_', " transform: rotate(" + degrees + "deg); transform-origin: center center;");
|
|
}
|
|
|
|
case 'shake':
|
|
{
|
|
var _speed = options.speed || '0.5s';
|
|
|
|
return el('_mfm_shake_', " animation: mfm-shake " + _speed + " ease infinite;");
|
|
}
|
|
|
|
case 'spin':
|
|
{
|
|
var direction = options.left ? 'reverse' : options.alternate ? 'alternate' : 'normal';
|
|
var anime = options.x ? 'mfm-spinX' : options.y ? 'mfm-spinY' : 'mfm-spin';
|
|
|
|
var _speed2 = options.speed || '1.5s';
|
|
|
|
return el('_mfm_spin_', " animation: " + anime + " " + _speed2 + " linear infinite; animation-direction: " + direction + ";");
|
|
}
|
|
|
|
case 'tada':
|
|
{
|
|
return el('_mfm_tada_');
|
|
}
|
|
|
|
case 'twitch':
|
|
{
|
|
var _speed3 = options.speed || '0.5s';
|
|
|
|
return el('_mfm_twitch_', " animation: mfm-twitch " + _speed3 + " ease infinite;");
|
|
}
|
|
|
|
case 'sparkle':
|
|
{
|
|
return el('_mfm_sparkle_');
|
|
}
|
|
|
|
case 'x2':
|
|
{
|
|
return el('_mfm_x2_');
|
|
}
|
|
|
|
case 'x3':
|
|
{
|
|
return el('_mfm_x3_');
|
|
}
|
|
|
|
case 'x4':
|
|
{
|
|
return el('_mfm_x4_');
|
|
}
|
|
|
|
default:
|
|
{
|
|
return "$[" + token.markup + " " + this.parser.parseInline(token.tokens) + "]";
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
name: 'mfmSearch',
|
|
level: 'block',
|
|
start: function start(src) {
|
|
var _src$match2;
|
|
|
|
return (_src$match2 = src.match(/[^\n]+ search/)) == null ? void 0 : _src$match2.index;
|
|
},
|
|
tokenizer: function tokenizer(src, tokens) {
|
|
var rule = /^([^\n]+) search$/;
|
|
var match = rule.exec(src);
|
|
|
|
if (match) {
|
|
var token = {
|
|
type: 'mfmSearch',
|
|
raw: match[0],
|
|
query: match[1].trim(),
|
|
tokens: []
|
|
};
|
|
this.lexer.inline(token.text, token.tokens);
|
|
return token;
|
|
}
|
|
},
|
|
renderer: function renderer(token) {
|
|
return "<a href=\"https://google.com/search?q=" + token.query + "\" class=\"_mfm_search_\">" + token.raw + "</a>";
|
|
}
|
|
}]
|
|
};
|
|
|
|
return index;
|
|
|
|
}));
|