/*! remarkable 1.7.4 https://github.com/jonschlinkert/remarkable @license MIT */(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Remarkable = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i`\x00-\x20]+/; var single_quoted = /'[^']*'/; var double_quoted = /"[^"]*"/; /*eslint no-spaced-func:0*/ var attr_value = replace(/(?:unquoted|single_quoted|double_quoted)/) ('unquoted', unquoted) ('single_quoted', single_quoted) ('double_quoted', double_quoted) (); var attribute = replace(/(?:\s+attr_name(?:\s*=\s*attr_value)?)/) ('attr_name', attr_name) ('attr_value', attr_value) (); var open_tag = replace(/<[A-Za-z][A-Za-z0-9]*attribute*\s*\/?>/) ('attribute', attribute) (); var close_tag = /<\/[A-Za-z][A-Za-z0-9]*\s*>/; var comment = /|/; var processing = /<[?].*?[?]>/; var declaration = /]*>/; var cdata = //; var HTML_TAG_RE = replace(/^(?:open_tag|close_tag|comment|processing|declaration|cdata)/) ('open_tag', open_tag) ('close_tag', close_tag) ('comment', comment) ('processing', processing) ('declaration', declaration) ('cdata', cdata) (); module.exports.HTML_TAG_RE = HTML_TAG_RE; },{}],4:[function(require,module,exports){ // List of valid url schemas, accorting to commonmark spec // http://jgm.github.io/CommonMark/spec.html#autolinks 'use strict'; module.exports = [ 'coap', 'doi', 'javascript', 'aaa', 'aaas', 'about', 'acap', 'cap', 'cid', 'crid', 'data', 'dav', 'dict', 'dns', 'file', 'ftp', 'geo', 'go', 'gopher', 'h323', 'http', 'https', 'iax', 'icap', 'im', 'imap', 'info', 'ipp', 'iris', 'iris.beep', 'iris.xpc', 'iris.xpcs', 'iris.lwz', 'ldap', 'mailto', 'mid', 'msrp', 'msrps', 'mtqp', 'mupdate', 'news', 'nfs', 'ni', 'nih', 'nntp', 'opaquelocktoken', 'pop', 'pres', 'rtsp', 'service', 'session', 'shttp', 'sieve', 'sip', 'sips', 'sms', 'snmp', 'soap.beep', 'soap.beeps', 'tag', 'tel', 'telnet', 'tftp', 'thismessage', 'tn3270', 'tip', 'tv', 'urn', 'vemmi', 'ws', 'wss', 'xcon', 'xcon-userid', 'xmlrpc.beep', 'xmlrpc.beeps', 'xmpp', 'z39.50r', 'z39.50s', 'adiumxtra', 'afp', 'afs', 'aim', 'apt', 'attachment', 'aw', 'beshare', 'bitcoin', 'bolo', 'callto', 'chrome', 'chrome-extension', 'com-eventbrite-attendee', 'content', 'cvs', 'dlna-playsingle', 'dlna-playcontainer', 'dtn', 'dvb', 'ed2k', 'facetime', 'feed', 'finger', 'fish', 'gg', 'git', 'gizmoproject', 'gtalk', 'hcp', 'icon', 'ipn', 'irc', 'irc6', 'ircs', 'itms', 'jar', 'jms', 'keyparc', 'lastfm', 'ldaps', 'magnet', 'maps', 'market', 'message', 'mms', 'ms-help', 'msnim', 'mumble', 'mvn', 'notes', 'oid', 'palm', 'paparazzi', 'platform', 'proxy', 'psyc', 'query', 'res', 'resource', 'rmi', 'rsync', 'rtmp', 'secondlife', 'sftp', 'sgn', 'skype', 'smb', 'soldat', 'spotify', 'ssh', 'steam', 'svn', 'teamspeak', 'things', 'udp', 'unreal', 'ut2004', 'ventrilo', 'view-source', 'webcal', 'wtai', 'wyciwyg', 'xfire', 'xri', 'ymsgr' ]; },{}],5:[function(require,module,exports){ 'use strict'; /** * Utility functions */ function typeOf(obj) { return Object.prototype.toString.call(obj); } function isString(obj) { return typeOf(obj) === '[object String]'; } var hasOwn = Object.prototype.hasOwnProperty; function has(object, key) { return object ? hasOwn.call(object, key) : false; } // Extend objects // function assign(obj /*from1, from2, from3, ...*/) { var sources = [].slice.call(arguments, 1); sources.forEach(function (source) { if (!source) { return; } if (typeof source !== 'object') { throw new TypeError(source + 'must be object'); } Object.keys(source).forEach(function (key) { obj[key] = source[key]; }); }); return obj; } //////////////////////////////////////////////////////////////////////////////// var UNESCAPE_MD_RE = /\\([\\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g; function unescapeMd(str) { if (str.indexOf('\\') < 0) { return str; } return str.replace(UNESCAPE_MD_RE, '$1'); } //////////////////////////////////////////////////////////////////////////////// function isValidEntityCode(c) { /*eslint no-bitwise:0*/ // broken sequence if (c >= 0xD800 && c <= 0xDFFF) { return false; } // never used if (c >= 0xFDD0 && c <= 0xFDEF) { return false; } if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false; } // control codes if (c >= 0x00 && c <= 0x08) { return false; } if (c === 0x0B) { return false; } if (c >= 0x0E && c <= 0x1F) { return false; } if (c >= 0x7F && c <= 0x9F) { return false; } // out of range if (c > 0x10FFFF) { return false; } return true; } function fromCodePoint(c) { /*eslint no-bitwise:0*/ if (c > 0xffff) { c -= 0x10000; var surrogate1 = 0xd800 + (c >> 10), surrogate2 = 0xdc00 + (c & 0x3ff); return String.fromCharCode(surrogate1, surrogate2); } return String.fromCharCode(c); } var NAMED_ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi; var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i; var entities = require('./entities'); function replaceEntityPattern(match, name) { var code = 0; if (has(entities, name)) { return entities[name]; } else if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) { code = name[1].toLowerCase() === 'x' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10); if (isValidEntityCode(code)) { return fromCodePoint(code); } } return match; } function replaceEntities(str) { if (str.indexOf('&') < 0) { return str; } return str.replace(NAMED_ENTITY_RE, replaceEntityPattern); } //////////////////////////////////////////////////////////////////////////////// var HTML_ESCAPE_TEST_RE = /[&<>"]/; var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g; var HTML_REPLACEMENTS = { '&': '&', '<': '<', '>': '>', '"': '"' }; function replaceUnsafeChar(ch) { return HTML_REPLACEMENTS[ch]; } function escapeHtml(str) { if (HTML_ESCAPE_TEST_RE.test(str)) { return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar); } return str; } //////////////////////////////////////////////////////////////////////////////// exports.assign = assign; exports.isString = isString; exports.has = has; exports.unescapeMd = unescapeMd; exports.isValidEntityCode = isValidEntityCode; exports.fromCodePoint = fromCodePoint; exports.replaceEntities = replaceEntities; exports.escapeHtml = escapeHtml; },{"./entities":1}],6:[function(require,module,exports){ // Commonmark default options 'use strict'; module.exports = { options: { html: true, // Enable HTML tags in source xhtmlOut: true, // Use '/' to close single tags (
) breaks: false, // Convert '\n' in paragraphs into
langPrefix: 'language-', // CSS language prefix for fenced blocks linkify: false, // autoconvert URL-like texts to links linkTarget: '', // set target to open link in // Enable some language-neutral replacements + quotes beautification typographer: false, // Double + single quotes replacement pairs, when typographer enabled, // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German. quotes: '“”‘’', // Highlighter function. Should return escaped HTML, // or '' if input not changed // // function (/*str, lang*/) { return ''; } // highlight: null, maxNesting: 20 // Internal protection, recursion limit }, components: { core: { rules: [ 'block', 'inline', 'references', 'abbr2' ] }, block: { rules: [ 'blockquote', 'code', 'fences', 'heading', 'hr', 'htmlblock', 'lheading', 'list', 'paragraph' ] }, inline: { rules: [ 'autolink', 'backticks', 'emphasis', 'entity', 'escape', 'htmltag', 'links', 'newline', 'text' ] } } }; },{}],7:[function(require,module,exports){ // Remarkable default options 'use strict'; module.exports = { options: { html: false, // Enable HTML tags in source xhtmlOut: false, // Use '/' to close single tags (
) breaks: false, // Convert '\n' in paragraphs into
langPrefix: 'language-', // CSS language prefix for fenced blocks linkify: false, // autoconvert URL-like texts to links linkTarget: '', // set target to open link in // Enable some language-neutral replacements + quotes beautification typographer: false, // Double + single quotes replacement pairs, when typographer enabled, // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German. quotes: '“”‘’', // Highlighter function. Should return escaped HTML, // or '' if input not changed // // function (/*str, lang*/) { return ''; } // highlight: null, maxNesting: 20 // Internal protection, recursion limit }, components: { core: { rules: [ 'block', 'inline', 'references', 'replacements', 'linkify', 'smartquotes', 'references', 'abbr2', 'footnote_tail' ] }, block: { rules: [ 'blockquote', 'code', 'fences', 'footnote', 'heading', 'hr', 'htmlblock', 'lheading', 'list', 'paragraph', 'table' ] }, inline: { rules: [ 'autolink', 'backticks', 'del', 'emphasis', 'entity', 'escape', 'footnote_ref', 'htmltag', 'links', 'newline', 'text' ] } } }; },{}],8:[function(require,module,exports){ // Remarkable default options 'use strict'; module.exports = { options: { html: false, // Enable HTML tags in source xhtmlOut: false, // Use '/' to close single tags (
) breaks: false, // Convert '\n' in paragraphs into
langPrefix: 'language-', // CSS language prefix for fenced blocks linkify: false, // autoconvert URL-like texts to links linkTarget: '', // set target to open link in // Enable some language-neutral replacements + quotes beautification typographer: false, // Double + single quotes replacement pairs, when typographer enabled, // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German. quotes: '“”‘’', // Highlighter function. Should return escaped HTML, // or '' if input not changed // // function (/*str, lang*/) { return ''; } // highlight: null, maxNesting: 20 // Internal protection, recursion limit }, components: { // Don't restrict core/block/inline rules core: {}, block: {}, inline: {} } }; },{}],9:[function(require,module,exports){ 'use strict'; var replaceEntities = require('../common/utils').replaceEntities; module.exports = function normalizeLink(url) { var normalized = replaceEntities(url); // We shouldn't care about the result of malformed URIs, // and should not throw an exception. try { normalized = decodeURI(normalized); } catch (err) {} return encodeURI(normalized); }; },{"../common/utils":5}],10:[function(require,module,exports){ 'use strict'; module.exports = function normalizeReference(str) { // use .toUpperCase() instead of .toLowerCase() // here to avoid a conflict with Object.prototype // members (most notably, `__proto__`) return str.trim().replace(/\s+/g, ' ').toUpperCase(); }; },{}],11:[function(require,module,exports){ 'use strict'; var normalizeLink = require('./normalize_link'); var unescapeMd = require('../common/utils').unescapeMd; /** * Parse link destination * * - on success it returns a string and updates state.pos; * - on failure it returns null * * @param {Object} state * @param {Number} pos * @api private */ module.exports = function parseLinkDestination(state, pos) { var code, level, link, start = pos, max = state.posMax; if (state.src.charCodeAt(pos) === 0x3C /* < */) { pos++; while (pos < max) { code = state.src.charCodeAt(pos); if (code === 0x0A /* \n */) { return false; } if (code === 0x3E /* > */) { link = normalizeLink(unescapeMd(state.src.slice(start + 1, pos))); if (!state.parser.validateLink(link)) { return false; } state.pos = pos + 1; state.linkContent = link; return true; } if (code === 0x5C /* \ */ && pos + 1 < max) { pos += 2; continue; } pos++; } // no closing '>' return false; } // this should be ... } else { ... branch level = 0; while (pos < max) { code = state.src.charCodeAt(pos); if (code === 0x20) { break; } // ascii control chars if (code < 0x20 || code === 0x7F) { break; } if (code === 0x5C /* \ */ && pos + 1 < max) { pos += 2; continue; } if (code === 0x28 /* ( */) { level++; if (level > 1) { break; } } if (code === 0x29 /* ) */) { level--; if (level < 0) { break; } } pos++; } if (start === pos) { return false; } link = unescapeMd(state.src.slice(start, pos)); if (!state.parser.validateLink(link)) { return false; } state.linkContent = link; state.pos = pos; return true; }; },{"../common/utils":5,"./normalize_link":9}],12:[function(require,module,exports){ 'use strict'; /** * Parse link labels * * This function assumes that first character (`[`) already matches; * returns the end of the label. * * @param {Object} state * @param {Number} start * @api private */ module.exports = function parseLinkLabel(state, start) { var level, found, marker, labelEnd = -1, max = state.posMax, oldPos = state.pos, oldFlag = state.isInLabel; if (state.isInLabel) { return -1; } if (state.labelUnmatchedScopes) { state.labelUnmatchedScopes--; return -1; } state.pos = start + 1; state.isInLabel = true; level = 1; while (state.pos < max) { marker = state.src.charCodeAt(state.pos); if (marker === 0x5B /* [ */) { level++; } else if (marker === 0x5D /* ] */) { level--; if (level === 0) { found = true; break; } } state.parser.skipToken(state); } if (found) { labelEnd = state.pos; state.labelUnmatchedScopes = 0; } else { state.labelUnmatchedScopes = level - 1; } // restore old state state.pos = oldPos; state.isInLabel = oldFlag; return labelEnd; }; },{}],13:[function(require,module,exports){ 'use strict'; var unescapeMd = require('../common/utils').unescapeMd; /** * Parse link title * * - on success it returns a string and updates state.pos; * - on failure it returns null * * @param {Object} state * @param {Number} pos * @api private */ module.exports = function parseLinkTitle(state, pos) { var code, start = pos, max = state.posMax, marker = state.src.charCodeAt(pos); if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return false; } pos++; // if opening marker is "(", switch it to closing marker ")" if (marker === 0x28) { marker = 0x29; } while (pos < max) { code = state.src.charCodeAt(pos); if (code === marker) { state.pos = pos + 1; state.linkContent = unescapeMd(state.src.slice(start + 1, pos)); return true; } if (code === 0x5C /* \ */ && pos + 1 < max) { pos += 2; continue; } pos++; } return false; }; },{"../common/utils":5}],14:[function(require,module,exports){ 'use strict'; /** * Local dependencies */ var assign = require('./common/utils').assign; var Renderer = require('./renderer'); var ParserCore = require('./parser_core'); var ParserBlock = require('./parser_block'); var ParserInline = require('./parser_inline'); var Ruler = require('./ruler'); /** * Preset configs */ var config = { 'default': require('./configs/default'), 'full': require('./configs/full'), 'commonmark': require('./configs/commonmark') }; /** * The `StateCore` class manages state. * * @param {Object} `instance` Remarkable instance * @param {String} `str` Markdown string * @param {Object} `env` */ function StateCore(instance, str, env) { this.src = str; this.env = env; this.options = instance.options; this.tokens = []; this.inlineMode = false; this.inline = instance.inline; this.block = instance.block; this.renderer = instance.renderer; this.typographer = instance.typographer; } /** * The main `Remarkable` class. Create an instance of * `Remarkable` with a `preset` and/or `options`. * * @param {String} `preset` If no preset is given, `default` is used. * @param {Object} `options` */ function Remarkable(preset, options) { if (typeof preset !== 'string') { options = preset; preset = 'default'; } this.inline = new ParserInline(); this.block = new ParserBlock(); this.core = new ParserCore(); this.renderer = new Renderer(); this.ruler = new Ruler(); this.options = {}; this.configure(config[preset]); this.set(options || {}); } /** * Set options as an alternative to passing them * to the constructor. * * ```js * md.set({typographer: true}); * ``` * @param {Object} `options` * @api public */ Remarkable.prototype.set = function (options) { assign(this.options, options); }; /** * Batch loader for components rules states, and options * * @param {Object} `presets` */ Remarkable.prototype.configure = function (presets) { var self = this; if (!presets) { throw new Error('Wrong `remarkable` preset, check name/content'); } if (presets.options) { self.set(presets.options); } if (presets.components) { Object.keys(presets.components).forEach(function (name) { if (presets.components[name].rules) { self[name].ruler.enable(presets.components[name].rules, true); } }); } }; /** * Use a plugin. * * ```js * var md = new Remarkable(); * * md.use(plugin1) * .use(plugin2, opts) * .use(plugin3); * ``` * * @param {Function} `plugin` * @param {Object} `options` * @return {Object} `Remarkable` for chaining */ Remarkable.prototype.use = function (plugin, options) { plugin(this, options); return this; }; /** * Parse the input `string` and return a tokens array. * Modifies `env` with definitions data. * * @param {String} `string` * @param {Object} `env` * @return {Array} Array of tokens */ Remarkable.prototype.parse = function (str, env) { var state = new StateCore(this, str, env); this.core.process(state); return state.tokens; }; /** * The main `.render()` method that does all the magic :) * * @param {String} `string` * @param {Object} `env` * @return {String} Rendered HTML. */ Remarkable.prototype.render = function (str, env) { env = env || {}; return this.renderer.render(this.parse(str, env), this.options, env); }; /** * Parse the given content `string` as a single string. * * @param {String} `string` * @param {Object} `env` * @return {Array} Array of tokens */ Remarkable.prototype.parseInline = function (str, env) { var state = new StateCore(this, str, env); state.inlineMode = true; this.core.process(state); return state.tokens; }; /** * Render a single content `string`, without wrapping it * to paragraphs * * @param {String} `str` * @param {Object} `env` * @return {String} */ Remarkable.prototype.renderInline = function (str, env) { env = env || {}; return this.renderer.render(this.parseInline(str, env), this.options, env); }; /** * Expose `Remarkable` */ module.exports = Remarkable; /** * Expose `utils`, Useful helper functions for custom * rendering. */ module.exports.utils = require('./common/utils'); },{"./common/utils":5,"./configs/commonmark":6,"./configs/default":7,"./configs/full":8,"./parser_block":15,"./parser_core":16,"./parser_inline":17,"./renderer":18,"./ruler":19}],15:[function(require,module,exports){ 'use strict'; /** * Local dependencies */ var Ruler = require('./ruler'); var StateBlock = require('./rules_block/state_block'); /** * Parser rules */ var _rules = [ [ 'code', require('./rules_block/code') ], [ 'fences', require('./rules_block/fences'), [ 'paragraph', 'blockquote', 'list' ] ], [ 'blockquote', require('./rules_block/blockquote'), [ 'paragraph', 'blockquote', 'list' ] ], [ 'hr', require('./rules_block/hr'), [ 'paragraph', 'blockquote', 'list' ] ], [ 'list', require('./rules_block/list'), [ 'paragraph', 'blockquote' ] ], [ 'footnote', require('./rules_block/footnote'), [ 'paragraph' ] ], [ 'heading', require('./rules_block/heading'), [ 'paragraph', 'blockquote' ] ], [ 'lheading', require('./rules_block/lheading') ], [ 'htmlblock', require('./rules_block/htmlblock'), [ 'paragraph', 'blockquote' ] ], [ 'table', require('./rules_block/table'), [ 'paragraph' ] ], [ 'deflist', require('./rules_block/deflist'), [ 'paragraph' ] ], [ 'paragraph', require('./rules_block/paragraph') ] ]; /** * Block Parser class * * @api private */ function ParserBlock() { this.ruler = new Ruler(); for (var i = 0; i < _rules.length; i++) { this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() }); } } /** * Generate tokens for the given input range. * * @param {Object} `state` Has properties like `src`, `parser`, `options` etc * @param {Number} `startLine` * @param {Number} `endLine` * @api private */ ParserBlock.prototype.tokenize = function (state, startLine, endLine) { var rules = this.ruler.getRules(''); var len = rules.length; var line = startLine; var hasEmptyLines = false; var ok, i; while (line < endLine) { state.line = line = state.skipEmptyLines(line); if (line >= endLine) { break; } // Termination condition for nested calls. // Nested calls currently used for blockquotes & lists if (state.tShift[line] < state.blkIndent) { break; } // Try all possible rules. // On success, rule should: // // - update `state.line` // - update `state.tokens` // - return true for (i = 0; i < len; i++) { ok = rules[i](state, line, endLine, false); if (ok) { break; } } // set state.tight iff we had an empty line before current tag // i.e. latest empty line should not count state.tight = !hasEmptyLines; // paragraph might "eat" one newline after it in nested lists if (state.isEmpty(state.line - 1)) { hasEmptyLines = true; } line = state.line; if (line < endLine && state.isEmpty(line)) { hasEmptyLines = true; line++; // two empty lines should stop the parser in list mode if (line < endLine && state.parentType === 'list' && state.isEmpty(line)) { break; } state.line = line; } } }; var TABS_SCAN_RE = /[\n\t]/g; var NEWLINES_RE = /\r[\n\u0085]|[\u2424\u2028\u0085]/g; var SPACES_RE = /\u00a0/g; /** * Tokenize the given `str`. * * @param {String} `str` Source string * @param {Object} `options` * @param {Object} `env` * @param {Array} `outTokens` * @api private */ ParserBlock.prototype.parse = function (str, options, env, outTokens) { var state, lineStart = 0, lastTabPos = 0; if (!str) { return []; } // Normalize spaces str = str.replace(SPACES_RE, ' '); // Normalize newlines str = str.replace(NEWLINES_RE, '\n'); // Replace tabs with proper number of spaces (1..4) if (str.indexOf('\t') >= 0) { str = str.replace(TABS_SCAN_RE, function (match, offset) { var result; if (str.charCodeAt(offset) === 0x0A) { lineStart = offset + 1; lastTabPos = 0; return match; } result = ' '.slice((offset - lineStart - lastTabPos) % 4); lastTabPos = offset - lineStart + 1; return result; }); } state = new StateBlock(str, this, options, env, outTokens); this.tokenize(state, state.line, state.lineMax); }; /** * Expose `ParserBlock` */ module.exports = ParserBlock; },{"./ruler":19,"./rules_block/blockquote":21,"./rules_block/code":22,"./rules_block/deflist":23,"./rules_block/fences":24,"./rules_block/footnote":25,"./rules_block/heading":26,"./rules_block/hr":27,"./rules_block/htmlblock":28,"./rules_block/lheading":29,"./rules_block/list":30,"./rules_block/paragraph":31,"./rules_block/state_block":32,"./rules_block/table":33}],16:[function(require,module,exports){ 'use strict'; /** * Local dependencies */ var Ruler = require('./ruler'); /** * Core parser `rules` */ var _rules = [ [ 'block', require('./rules_core/block') ], [ 'abbr', require('./rules_core/abbr') ], [ 'references', require('./rules_core/references') ], [ 'inline', require('./rules_core/inline') ], [ 'footnote_tail', require('./rules_core/footnote_tail') ], [ 'abbr2', require('./rules_core/abbr2') ], [ 'replacements', require('./rules_core/replacements') ], [ 'smartquotes', require('./rules_core/smartquotes') ], [ 'linkify', require('./rules_core/linkify') ] ]; /** * Class for top level (`core`) parser rules * * @api private */ function Core() { this.options = {}; this.ruler = new Ruler(); for (var i = 0; i < _rules.length; i++) { this.ruler.push(_rules[i][0], _rules[i][1]); } } /** * Process rules with the given `state` * * @param {Object} `state` * @api private */ Core.prototype.process = function (state) { var i, l, rules; rules = this.ruler.getRules(''); for (i = 0, l = rules.length; i < l; i++) { rules[i](state); } }; /** * Expose `Core` */ module.exports = Core; },{"./ruler":19,"./rules_core/abbr":34,"./rules_core/abbr2":35,"./rules_core/block":36,"./rules_core/footnote_tail":37,"./rules_core/inline":38,"./rules_core/linkify":39,"./rules_core/references":40,"./rules_core/replacements":41,"./rules_core/smartquotes":42}],17:[function(require,module,exports){ 'use strict'; /** * Local dependencies */ var Ruler = require('./ruler'); var StateInline = require('./rules_inline/state_inline'); var utils = require('./common/utils'); /** * Inline Parser `rules` */ var _rules = [ [ 'text', require('./rules_inline/text') ], [ 'newline', require('./rules_inline/newline') ], [ 'escape', require('./rules_inline/escape') ], [ 'backticks', require('./rules_inline/backticks') ], [ 'del', require('./rules_inline/del') ], [ 'ins', require('./rules_inline/ins') ], [ 'mark', require('./rules_inline/mark') ], [ 'emphasis', require('./rules_inline/emphasis') ], [ 'sub', require('./rules_inline/sub') ], [ 'sup', require('./rules_inline/sup') ], [ 'links', require('./rules_inline/links') ], [ 'footnote_inline', require('./rules_inline/footnote_inline') ], [ 'footnote_ref', require('./rules_inline/footnote_ref') ], [ 'autolink', require('./rules_inline/autolink') ], [ 'htmltag', require('./rules_inline/htmltag') ], [ 'entity', require('./rules_inline/entity') ] ]; /** * Inline Parser class. Note that link validation is stricter * in Remarkable than what is specified by CommonMark. If you * want to change this you can use a custom validator. * * @api private */ function ParserInline() { this.ruler = new Ruler(); for (var i = 0; i < _rules.length; i++) { this.ruler.push(_rules[i][0], _rules[i][1]); } // Can be overridden with a custom validator this.validateLink = validateLink; } /** * Skip a single token by running all rules in validation mode. * Returns `true` if any rule reports success. * * @param {Object} `state` * @api privage */ ParserInline.prototype.skipToken = function (state) { var rules = this.ruler.getRules(''); var len = rules.length; var pos = state.pos; var i, cached_pos; if ((cached_pos = state.cacheGet(pos)) > 0) { state.pos = cached_pos; return; } for (i = 0; i < len; i++) { if (rules[i](state, true)) { state.cacheSet(pos, state.pos); return; } } state.pos++; state.cacheSet(pos, state.pos); }; /** * Generate tokens for the given input range. * * @param {Object} `state` * @api private */ ParserInline.prototype.tokenize = function (state) { var rules = this.ruler.getRules(''); var len = rules.length; var end = state.posMax; var ok, i; while (state.pos < end) { // Try all possible rules. // On success, the rule should: // // - update `state.pos` // - update `state.tokens` // - return true for (i = 0; i < len; i++) { ok = rules[i](state, false); if (ok) { break; } } if (ok) { if (state.pos >= end) { break; } continue; } state.pending += state.src[state.pos++]; } if (state.pending) { state.pushPending(); } }; /** * Parse the given input string. * * @param {String} `str` * @param {Object} `options` * @param {Object} `env` * @param {Array} `outTokens` * @api private */ ParserInline.prototype.parse = function (str, options, env, outTokens) { var state = new StateInline(str, this, options, env, outTokens); this.tokenize(state); }; /** * Validate the given `url` by checking for bad protocols. * * @param {String} `url` * @return {Boolean} */ function validateLink(url) { var BAD_PROTOCOLS = [ 'vbscript', 'javascript', 'file', 'data' ]; var str = url.trim().toLowerCase(); // Care about digital entities "javascript:alert(1)" str = utils.replaceEntities(str); if (str.indexOf(':') !== -1 && BAD_PROTOCOLS.indexOf(str.split(':')[0]) !== -1) { return false; } return true; } /** * Expose `ParserInline` */ module.exports = ParserInline; },{"./common/utils":5,"./ruler":19,"./rules_inline/autolink":43,"./rules_inline/backticks":44,"./rules_inline/del":45,"./rules_inline/emphasis":46,"./rules_inline/entity":47,"./rules_inline/escape":48,"./rules_inline/footnote_inline":49,"./rules_inline/footnote_ref":50,"./rules_inline/htmltag":51,"./rules_inline/ins":52,"./rules_inline/links":53,"./rules_inline/mark":54,"./rules_inline/newline":55,"./rules_inline/state_inline":56,"./rules_inline/sub":57,"./rules_inline/sup":58,"./rules_inline/text":59}],18:[function(require,module,exports){ 'use strict'; /** * Local dependencies */ var utils = require('./common/utils'); var rules = require('./rules'); /** * Expose `Renderer` */ module.exports = Renderer; /** * Renderer class. Renders HTML and exposes `rules` to allow * local modifications. */ function Renderer() { this.rules = utils.assign({}, rules); // exported helper, for custom rules only this.getBreak = rules.getBreak; } /** * Render a string of inline HTML with the given `tokens` and * `options`. * * @param {Array} `tokens` * @param {Object} `options` * @param {Object} `env` * @return {String} * @api public */ Renderer.prototype.renderInline = function (tokens, options, env) { var _rules = this.rules; var len = tokens.length, i = 0; var result = ''; while (len--) { result += _rules[tokens[i].type](tokens, i++, options, env, this); } return result; }; /** * Render a string of HTML with the given `tokens` and * `options`. * * @param {Array} `tokens` * @param {Object} `options` * @param {Object} `env` * @return {String} * @api public */ Renderer.prototype.render = function (tokens, options, env) { var _rules = this.rules; var len = tokens.length, i = -1; var result = ''; while (++i < len) { if (tokens[i].type === 'inline') { result += this.renderInline(tokens[i].children, options, env); } else { result += _rules[tokens[i].type](tokens, i, options, env, this); } } return result; }; },{"./common/utils":5,"./rules":20}],19:[function(require,module,exports){ 'use strict'; /** * Ruler is a helper class for building responsibility chains from * parse rules. It allows: * * - easy stack rules chains * - getting main chain and named chains content (as arrays of functions) * * Helper methods, should not be used directly. * @api private */ function Ruler() { // List of added rules. Each element is: // // { name: XXX, // enabled: Boolean, // fn: Function(), // alt: [ name2, name3 ] } // this.__rules__ = []; // Cached rule chains. // // First level - chain name, '' for default. // Second level - digital anchor for fast filtering by charcodes. // this.__cache__ = null; } /** * Find the index of a rule by `name`. * * @param {String} `name` * @return {Number} Index of the given `name` * @api private */ Ruler.prototype.__find__ = function (name) { var len = this.__rules__.length; var i = -1; while (len--) { if (this.__rules__[++i].name === name) { return i; } } return -1; }; /** * Build the rules lookup cache * * @api private */ Ruler.prototype.__compile__ = function () { var self = this; var chains = [ '' ]; // collect unique names self.__rules__.forEach(function (rule) { if (!rule.enabled) { return; } rule.alt.forEach(function (altName) { if (chains.indexOf(altName) < 0) { chains.push(altName); } }); }); self.__cache__ = {}; chains.forEach(function (chain) { self.__cache__[chain] = []; self.__rules__.forEach(function (rule) { if (!rule.enabled) { return; } if (chain && rule.alt.indexOf(chain) < 0) { return; } self.__cache__[chain].push(rule.fn); }); }); }; /** * Ruler public methods * ------------------------------------------------ */ /** * Replace rule function * * @param {String} `name` Rule name * @param {Function `fn` * @param {Object} `options` * @api private */ Ruler.prototype.at = function (name, fn, options) { var idx = this.__find__(name); var opt = options || {}; if (idx === -1) { throw new Error('Parser rule not found: ' + name); } this.__rules__[idx].fn = fn; this.__rules__[idx].alt = opt.alt || []; this.__cache__ = null; }; /** * Add a rule to the chain before given the `ruleName`. * * @param {String} `beforeName` * @param {String} `ruleName` * @param {Function} `fn` * @param {Object} `options` * @api private */ Ruler.prototype.before = function (beforeName, ruleName, fn, options) { var idx = this.__find__(beforeName); var opt = options || {}; if (idx === -1) { throw new Error('Parser rule not found: ' + beforeName); } this.__rules__.splice(idx, 0, { name: ruleName, enabled: true, fn: fn, alt: opt.alt || [] }); this.__cache__ = null; }; /** * Add a rule to the chain after the given `ruleName`. * * @param {String} `afterName` * @param {String} `ruleName` * @param {Function} `fn` * @param {Object} `options` * @api private */ Ruler.prototype.after = function (afterName, ruleName, fn, options) { var idx = this.__find__(afterName); var opt = options || {}; if (idx === -1) { throw new Error('Parser rule not found: ' + afterName); } this.__rules__.splice(idx + 1, 0, { name: ruleName, enabled: true, fn: fn, alt: opt.alt || [] }); this.__cache__ = null; }; /** * Add a rule to the end of chain. * * @param {String} `ruleName` * @param {Function} `fn` * @param {Object} `options` * @return {String} */ Ruler.prototype.push = function (ruleName, fn, options) { var opt = options || {}; this.__rules__.push({ name: ruleName, enabled: true, fn: fn, alt: opt.alt || [] }); this.__cache__ = null; }; /** * Enable a rule or list of rules. * * @param {String|Array} `list` Name or array of rule names to enable * @param {Boolean} `strict` If `true`, all non listed rules will be disabled. * @api private */ Ruler.prototype.enable = function (list, strict) { list = !Array.isArray(list) ? [ list ] : list; // In strict mode disable all existing rules first if (strict) { this.__rules__.forEach(function (rule) { rule.enabled = false; }); } // Search by name and enable list.forEach(function (name) { var idx = this.__find__(name); if (idx < 0) { throw new Error('Rules manager: invalid rule name ' + name); } this.__rules__[idx].enabled = true; }, this); this.__cache__ = null; }; /** * Disable a rule or list of rules. * * @param {String|Array} `list` Name or array of rule names to disable * @api private */ Ruler.prototype.disable = function (list) { list = !Array.isArray(list) ? [ list ] : list; // Search by name and disable list.forEach(function (name) { var idx = this.__find__(name); if (idx < 0) { throw new Error('Rules manager: invalid rule name ' + name); } this.__rules__[idx].enabled = false; }, this); this.__cache__ = null; }; /** * Get a rules list as an array of functions. * * @param {String} `chainName` * @return {Object} * @api private */ Ruler.prototype.getRules = function (chainName) { if (this.__cache__ === null) { this.__compile__(); } return this.__cache__[chainName] || []; }; /** * Expose `Ruler` */ module.exports = Ruler; },{}],20:[function(require,module,exports){ 'use strict'; /** * Local dependencies */ var has = require('./common/utils').has; var unescapeMd = require('./common/utils').unescapeMd; var replaceEntities = require('./common/utils').replaceEntities; var escapeHtml = require('./common/utils').escapeHtml; /** * Renderer rules cache */ var rules = {}; /** * Blockquotes */ rules.blockquote_open = function(/* tokens, idx, options, env */) { return '
\n'; }; rules.blockquote_close = function(tokens, idx /*, options, env */) { return '
' + getBreak(tokens, idx); }; /** * Code */ rules.code = function(tokens, idx /*, options, env */) { if (tokens[idx].block) { return '
' + escapeHtml(tokens[idx].content) + '
' + getBreak(tokens, idx); } return '' + escapeHtml(tokens[idx].content) + ''; }; /** * Fenced code blocks */ rules.fence = function(tokens, idx, options, env, instance) { var token = tokens[idx]; var langClass = ''; var langPrefix = options.langPrefix; var langName = '', fences, fenceName; var highlighted; if (token.params) { // // ```foo bar // // Try custom renderer "foo" first. That will simplify overwrite // for diagrams, latex, and any other fenced block with custom look // fences = token.params.split(/\s+/g); fenceName = fences.join(' '); if (has(instance.rules.fence_custom, fences[0])) { return instance.rules.fence_custom[fences[0]](tokens, idx, options, env, instance); } langName = escapeHtml(replaceEntities(unescapeMd(fenceName))); langClass = ' class="' + langPrefix + langName + '"'; } if (options.highlight) { highlighted = options.highlight.apply(options.highlight, [ token.content ].concat(fences)) || escapeHtml(token.content); } else { highlighted = escapeHtml(token.content); } return '
'
        + highlighted
        + '
' + getBreak(tokens, idx); }; rules.fence_custom = {}; /** * Headings */ rules.heading_open = function(tokens, idx /*, options, env */) { return ''; }; rules.heading_close = function(tokens, idx /*, options, env */) { return '\n'; }; /** * Horizontal rules */ rules.hr = function(tokens, idx, options /*, env */) { return (options.xhtmlOut ? '
' : '
') + getBreak(tokens, idx); }; /** * Bullets */ rules.bullet_list_open = function(/* tokens, idx, options, env */) { return '' + getBreak(tokens, idx); }; /** * List items */ rules.list_item_open = function(/* tokens, idx, options, env */) { return '
  • '; }; rules.list_item_close = function(/* tokens, idx, options, env */) { return '
    • \n'; }; /** * Ordered list items */ rules.ordered_list_open = function(tokens, idx /*, options, env */) { var token = tokens[idx]; var order = token.order > 1 ? ' start="' + token.order + '"' : ''; return '\n'; }; rules.ordered_list_close = function(tokens, idx /*, options, env */) { return '' + getBreak(tokens, idx); }; /** * Paragraphs */ rules.paragraph_open = function(tokens, idx /*, options, env */) { return tokens[idx].tight ? '' : '

    '; }; rules.paragraph_close = function(tokens, idx /*, options, env */) { var addBreak = !(tokens[idx].tight && idx && tokens[idx - 1].type === 'inline' && !tokens[idx - 1].content); return (tokens[idx].tight ? '' : '

    ') + (addBreak ? getBreak(tokens, idx) : ''); }; /** * Links */ rules.link_open = function(tokens, idx, options /* env */) { var title = tokens[idx].title ? (' title="' + escapeHtml(replaceEntities(tokens[idx].title)) + '"') : ''; var target = options.linkTarget ? (' target="' + options.linkTarget + '"') : ''; return ''; }; rules.link_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Images */ rules.image = function(tokens, idx, options /*, env */) { var src = ' src="' + escapeHtml(tokens[idx].src) + '"'; var title = tokens[idx].title ? (' title="' + escapeHtml(replaceEntities(tokens[idx].title)) + '"') : ''; var alt = ' alt="' + (tokens[idx].alt ? escapeHtml(replaceEntities(unescapeMd(tokens[idx].alt))) : '') + '"'; var suffix = options.xhtmlOut ? ' /' : ''; return ''; }; /** * Tables */ rules.table_open = function(/* tokens, idx, options, env */) { return '\n'; }; rules.table_close = function(/* tokens, idx, options, env */) { return '
    \n'; }; rules.thead_open = function(/* tokens, idx, options, env */) { return '\n'; }; rules.thead_close = function(/* tokens, idx, options, env */) { return '\n'; }; rules.tbody_open = function(/* tokens, idx, options, env */) { return '\n'; }; rules.tbody_close = function(/* tokens, idx, options, env */) { return '\n'; }; rules.tr_open = function(/* tokens, idx, options, env */) { return ''; }; rules.tr_close = function(/* tokens, idx, options, env */) { return '\n'; }; rules.th_open = function(tokens, idx /*, options, env */) { var token = tokens[idx]; return ''; }; rules.th_close = function(/* tokens, idx, options, env */) { return ''; }; rules.td_open = function(tokens, idx /*, options, env */) { var token = tokens[idx]; return ''; }; rules.td_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Bold */ rules.strong_open = function(/* tokens, idx, options, env */) { return ''; }; rules.strong_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Italicize */ rules.em_open = function(/* tokens, idx, options, env */) { return ''; }; rules.em_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Strikethrough */ rules.del_open = function(/* tokens, idx, options, env */) { return ''; }; rules.del_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Insert */ rules.ins_open = function(/* tokens, idx, options, env */) { return ''; }; rules.ins_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Highlight */ rules.mark_open = function(/* tokens, idx, options, env */) { return ''; }; rules.mark_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Super- and sub-script */ rules.sub = function(tokens, idx /*, options, env */) { return '' + escapeHtml(tokens[idx].content) + ''; }; rules.sup = function(tokens, idx /*, options, env */) { return '' + escapeHtml(tokens[idx].content) + ''; }; /** * Breaks */ rules.hardbreak = function(tokens, idx, options /*, env */) { return options.xhtmlOut ? '
    \n' : '
    \n'; }; rules.softbreak = function(tokens, idx, options /*, env */) { return options.breaks ? (options.xhtmlOut ? '
    \n' : '
    \n') : '\n'; }; /** * Text */ rules.text = function(tokens, idx /*, options, env */) { return escapeHtml(tokens[idx].content); }; /** * Content */ rules.htmlblock = function(tokens, idx /*, options, env */) { return tokens[idx].content; }; rules.htmltag = function(tokens, idx /*, options, env */) { return tokens[idx].content; }; /** * Abbreviations, initialism */ rules.abbr_open = function(tokens, idx /*, options, env */) { return ''; }; rules.abbr_close = function(/* tokens, idx, options, env */) { return ''; }; /** * Footnotes */ rules.footnote_ref = function(tokens, idx) { var n = Number(tokens[idx].id + 1).toString(); var id = 'fnref' + n; if (tokens[idx].subId > 0) { id += ':' + tokens[idx].subId; } return '[' + n + ']'; }; rules.footnote_block_open = function(tokens, idx, options) { var hr = options.xhtmlOut ? '
    \n' : '
    \n'; return hr + '
    \n
      \n'; }; rules.footnote_block_close = function() { return '
    \n
    \n'; }; rules.footnote_open = function(tokens, idx) { var id = Number(tokens[idx].id + 1).toString(); return '
  • '; }; rules.footnote_close = function() { return '
    • \n'; }; rules.footnote_anchor = function(tokens, idx) { var n = Number(tokens[idx].id + 1).toString(); var id = 'fnref' + n; if (tokens[idx].subId > 0) { id += ':' + tokens[idx].subId; } return ' ↩'; }; /** * Definition lists */ rules.dl_open = function() { return '
    \n'; }; rules.dt_open = function() { return '
    '; }; rules.dd_open = function() { return '
    '; }; rules.dl_close = function() { return '
    \n'; }; rules.dt_close = function() { return '\n'; }; rules.dd_close = function() { return '\n'; }; /** * Helper functions */ function nextToken(tokens, idx) { if (++idx >= tokens.length - 2) { return idx; } if ((tokens[idx].type === 'paragraph_open' && tokens[idx].tight) && (tokens[idx + 1].type === 'inline' && tokens[idx + 1].content.length === 0) && (tokens[idx + 2].type === 'paragraph_close' && tokens[idx + 2].tight)) { return nextToken(tokens, idx + 2); } return idx; } /** * Check to see if `\n` is needed before the next token. * * @param {Array} `tokens` * @param {Number} `idx` * @return {String} Empty string or newline * @api private */ var getBreak = rules.getBreak = function getBreak(tokens, idx) { idx = nextToken(tokens, idx); if (idx < tokens.length && tokens[idx].type === 'list_item_close') { return ''; } return '\n'; }; /** * Expose `rules` */ module.exports = rules; },{"./common/utils":5}],21:[function(require,module,exports){ // Block quotes 'use strict'; module.exports = function blockquote(state, startLine, endLine, silent) { var nextLine, lastLineEmpty, oldTShift, oldBMarks, oldIndent, oldParentType, lines, terminatorRules, i, l, terminate, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine]; if (pos > max) { return false; } // check the block quote marker if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { return false; } if (state.level >= state.options.maxNesting) { return false; } // we know that it's going to be a valid blockquote, // so no point trying to find the end of it in silent mode if (silent) { return true; } // skip one optional space after '>' if (state.src.charCodeAt(pos) === 0x20) { pos++; } oldIndent = state.blkIndent; state.blkIndent = 0; oldBMarks = [ state.bMarks[startLine] ]; state.bMarks[startLine] = pos; // check if we have an empty blockquote pos = pos < max ? state.skipSpaces(pos) : pos; lastLineEmpty = pos >= max; oldTShift = [ state.tShift[startLine] ]; state.tShift[startLine] = pos - state.bMarks[startLine]; terminatorRules = state.parser.ruler.getRules('blockquote'); // Search the end of the block // // Block ends with either: // 1. an empty line outside: // ``` // > test // // ``` // 2. an empty line inside: // ``` // > // test // ``` // 3. another tag // ``` // > test // - - - // ``` for (nextLine = startLine + 1; nextLine < endLine; nextLine++) { pos = state.bMarks[nextLine] + state.tShift[nextLine]; max = state.eMarks[nextLine]; if (pos >= max) { // Case 1: line is not inside the blockquote, and this line is empty. break; } if (state.src.charCodeAt(pos++) === 0x3E/* > */) { // This line is inside the blockquote. // skip one optional space after '>' if (state.src.charCodeAt(pos) === 0x20) { pos++; } oldBMarks.push(state.bMarks[nextLine]); state.bMarks[nextLine] = pos; pos = pos < max ? state.skipSpaces(pos) : pos; lastLineEmpty = pos >= max; oldTShift.push(state.tShift[nextLine]); state.tShift[nextLine] = pos - state.bMarks[nextLine]; continue; } // Case 2: line is not inside the blockquote, and the last line was empty. if (lastLineEmpty) { break; } // Case 3: another tag found. terminate = false; for (i = 0, l = terminatorRules.length; i < l; i++) { if (terminatorRules[i](state, nextLine, endLine, true)) { terminate = true; break; } } if (terminate) { break; } oldBMarks.push(state.bMarks[nextLine]); oldTShift.push(state.tShift[nextLine]); // A negative number means that this is a paragraph continuation; // // Any negative number will do the job here, but it's better for it // to be large enough to make any bugs obvious. state.tShift[nextLine] = -1337; } oldParentType = state.parentType; state.parentType = 'blockquote'; state.tokens.push({ type: 'blockquote_open', lines: lines = [ startLine, 0 ], level: state.level++ }); state.parser.tokenize(state, startLine, nextLine); state.tokens.push({ type: 'blockquote_close', level: --state.level }); state.parentType = oldParentType; lines[1] = state.line; // Restore original tShift; this might not be necessary since the parser // has already been here, but just to make sure we can do that. for (i = 0; i < oldTShift.length; i++) { state.bMarks[i + startLine] = oldBMarks[i]; state.tShift[i + startLine] = oldTShift[i]; } state.blkIndent = oldIndent; return true; }; },{}],22:[function(require,module,exports){ // Code block (4 spaces padded) 'use strict'; module.exports = function code(state, startLine, endLine/*, silent*/) { var nextLine, last; if (state.tShift[startLine] - state.blkIndent < 4) { return false; } last = nextLine = startLine + 1; while (nextLine < endLine) { if (state.isEmpty(nextLine)) { nextLine++; continue; } if (state.tShift[nextLine] - state.blkIndent >= 4) { nextLine++; last = nextLine; continue; } break; } state.line = nextLine; state.tokens.push({ type: 'code', content: state.getLines(startLine, last, 4 + state.blkIndent, true), block: true, lines: [ startLine, state.line ], level: state.level }); return true; }; },{}],23:[function(require,module,exports){ // Definition lists 'use strict'; // Search `[:~][\n ]`, returns next pos after marker on success // or -1 on fail. function skipMarker(state, line) { var pos, marker, start = state.bMarks[line] + state.tShift[line], max = state.eMarks[line]; if (start >= max) { return -1; } // Check bullet marker = state.src.charCodeAt(start++); if (marker !== 0x7E/* ~ */ && marker !== 0x3A/* : */) { return -1; } pos = state.skipSpaces(start); // require space after ":" if (start === pos) { return -1; } // no empty definitions, e.g. " : " if (pos >= max) { return -1; } return pos; } function markTightParagraphs(state, idx) { var i, l, level = state.level + 2; for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) { if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') { state.tokens[i + 2].tight = true; state.tokens[i].tight = true; i += 2; } } } module.exports = function deflist(state, startLine, endLine, silent) { var contentStart, ddLine, dtLine, itemLines, listLines, listTokIdx, nextLine, oldIndent, oldDDIndent, oldParentType, oldTShift, oldTight, prevEmptyEnd, tight; if (silent) { // quirk: validation mode validates a dd block only, not a whole deflist if (state.ddIndent < 0) { return false; } return skipMarker(state, startLine) >= 0; } nextLine = startLine + 1; if (state.isEmpty(nextLine)) { if (++nextLine > endLine) { return false; } } if (state.tShift[nextLine] < state.blkIndent) { return false; } contentStart = skipMarker(state, nextLine); if (contentStart < 0) { return false; } if (state.level >= state.options.maxNesting) { return false; } // Start list listTokIdx = state.tokens.length; state.tokens.push({ type: 'dl_open', lines: listLines = [ startLine, 0 ], level: state.level++ }); // // Iterate list items // dtLine = startLine; ddLine = nextLine; // One definition list can contain multiple DTs, // and one DT can be followed by multiple DDs. // // Thus, there is two loops here, and label is // needed to break out of the second one // /*eslint no-labels:0,block-scoped-var:0*/ OUTER: for (;;) { tight = true; prevEmptyEnd = false; state.tokens.push({ type: 'dt_open', lines: [ dtLine, dtLine ], level: state.level++ }); state.tokens.push({ type: 'inline', content: state.getLines(dtLine, dtLine + 1, state.blkIndent, false).trim(), level: state.level + 1, lines: [ dtLine, dtLine ], children: [] }); state.tokens.push({ type: 'dt_close', level: --state.level }); for (;;) { state.tokens.push({ type: 'dd_open', lines: itemLines = [ nextLine, 0 ], level: state.level++ }); oldTight = state.tight; oldDDIndent = state.ddIndent; oldIndent = state.blkIndent; oldTShift = state.tShift[ddLine]; oldParentType = state.parentType; state.blkIndent = state.ddIndent = state.tShift[ddLine] + 2; state.tShift[ddLine] = contentStart - state.bMarks[ddLine]; state.tight = true; state.parentType = 'deflist'; state.parser.tokenize(state, ddLine, endLine, true); // If any of list item is tight, mark list as tight if (!state.tight || prevEmptyEnd) { tight = false; } // Item become loose if finish with empty line, // but we should filter last element, because it means list finish prevEmptyEnd = (state.line - ddLine) > 1 && state.isEmpty(state.line - 1); state.tShift[ddLine] = oldTShift; state.tight = oldTight; state.parentType = oldParentType; state.blkIndent = oldIndent; state.ddIndent = oldDDIndent; state.tokens.push({ type: 'dd_close', level: --state.level }); itemLines[1] = nextLine = state.line; if (nextLine >= endLine) { break OUTER; } if (state.tShift[nextLine] < state.blkIndent) { break OUTER; } contentStart = skipMarker(state, nextLine); if (contentStart < 0) { break; } ddLine = nextLine; // go to the next loop iteration: // insert DD tag and repeat checking } if (nextLine >= endLine) { break; } dtLine = nextLine; if (state.isEmpty(dtLine)) { break; } if (state.tShift[dtLine] < state.blkIndent) { break; } ddLine = dtLine + 1; if (ddLine >= endLine) { break; } if (state.isEmpty(ddLine)) { ddLine++; } if (ddLine >= endLine) { break; } if (state.tShift[ddLine] < state.blkIndent) { break; } contentStart = skipMarker(state, ddLine); if (contentStart < 0) { break; } // go to the next loop iteration: // insert DT and DD tags and repeat checking } // Finilize list state.tokens.push({ type: 'dl_close', level: --state.level }); listLines[1] = nextLine; state.line = nextLine; // mark paragraphs tight if needed if (tight) { markTightParagraphs(state, listTokIdx); } return true; }; },{}],24:[function(require,module,exports){ // fences (``` lang, ~~~ lang) 'use strict'; module.exports = function fences(state, startLine, endLine, silent) { var marker, len, params, nextLine, mem, haveEndMarker = false, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine]; if (pos + 3 > max) { return false; } marker = state.src.charCodeAt(pos); if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) { return false; } // scan marker length mem = pos; pos = state.skipChars(pos, marker); len = pos - mem; if (len < 3) { return false; } params = state.src.slice(pos, max).trim(); if (params.indexOf('`') >= 0) { return false; } // Since start is found, we can report success here in validation mode if (silent) { return true; } // search end of block nextLine = startLine; for (;;) { nextLine++; if (nextLine >= endLine) { // unclosed block should be autoclosed by end of document. // also block seems to be autoclosed by end of parent break; } pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]; max = state.eMarks[nextLine]; if (pos < max && state.tShift[nextLine] < state.blkIndent) { // non-empty line with negative indent should stop the list: // - ``` // test break; } if (state.src.charCodeAt(pos) !== marker) { continue; } if (state.tShift[nextLine] - state.blkIndent >= 4) { // closing fence should be indented less than 4 spaces continue; } pos = state.skipChars(pos, marker); // closing code fence must be at least as long as the opening one if (pos - mem < len) { continue; } // make sure tail has spaces only pos = state.skipSpaces(pos); if (pos < max) { continue; } haveEndMarker = true; // found! break; } // If a fence has heading spaces, they should be removed from its inner block len = state.tShift[startLine]; state.line = nextLine + (haveEndMarker ? 1 : 0); state.tokens.push({ type: 'fence', params: params, content: state.getLines(startLine + 1, nextLine, len, true), lines: [ startLine, state.line ], level: state.level }); return true; }; },{}],25:[function(require,module,exports){ // Process footnote reference list 'use strict'; module.exports = function footnote(state, startLine, endLine, silent) { var oldBMark, oldTShift, oldParentType, pos, label, start = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine]; // line should be at least 5 chars - "[^x]:" if (start + 4 > max) { return false; } if (state.src.charCodeAt(start) !== 0x5B/* [ */) { return false; } if (state.src.charCodeAt(start + 1) !== 0x5E/* ^ */) { return false; } if (state.level >= state.options.maxNesting) { return false; } for (pos = start + 2; pos < max; pos++) { if (state.src.charCodeAt(pos) === 0x20) { return false; } if (state.src.charCodeAt(pos) === 0x5D /* ] */) { break; } } if (pos === start + 2) { return false; } // no empty footnote labels if (pos + 1 >= max || state.src.charCodeAt(++pos) !== 0x3A /* : */) { return false; } if (silent) { return true; } pos++; if (!state.env.footnotes) { state.env.footnotes = {}; } if (!state.env.footnotes.refs) { state.env.footnotes.refs = {}; } label = state.src.slice(start + 2, pos - 2); state.env.footnotes.refs[':' + label] = -1; state.tokens.push({ type: 'footnote_reference_open', label: label, level: state.level++ }); oldBMark = state.bMarks[startLine]; oldTShift = state.tShift[startLine]; oldParentType = state.parentType; state.tShift[startLine] = state.skipSpaces(pos) - pos; state.bMarks[startLine] = pos; state.blkIndent += 4; state.parentType = 'footnote'; if (state.tShift[startLine] < state.blkIndent) { state.tShift[startLine] += state.blkIndent; state.bMarks[startLine] -= state.blkIndent; } state.parser.tokenize(state, startLine, endLine, true); state.parentType = oldParentType; state.blkIndent -= 4; state.tShift[startLine] = oldTShift; state.bMarks[startLine] = oldBMark; state.tokens.push({ type: 'footnote_reference_close', level: --state.level }); return true; }; },{}],26:[function(require,module,exports){ // heading (#, ##, ...) 'use strict'; module.exports = function heading(state, startLine, endLine, silent) { var ch, level, tmp, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine]; if (pos >= max) { return false; } ch = state.src.charCodeAt(pos); if (ch !== 0x23/* # */ || pos >= max) { return false; } // count heading level level = 1; ch = state.src.charCodeAt(++pos); while (ch === 0x23/* # */ && pos < max && level <= 6) { level++; ch = state.src.charCodeAt(++pos); } if (level > 6 || (pos < max && ch !== 0x20/* space */)) { return false; } if (silent) { return true; } // Let's cut tails like ' ### ' from the end of string max = state.skipCharsBack(max, 0x20, pos); // space tmp = state.skipCharsBack(max, 0x23, pos); // # if (tmp > pos && state.src.charCodeAt(tmp - 1) === 0x20/* space */) { max = tmp; } state.line = startLine + 1; state.tokens.push({ type: 'heading_open', hLevel: level, lines: [ startLine, state.line ], level: state.level }); // only if header is not empty if (pos < max) { state.tokens.push({ type: 'inline', content: state.src.slice(pos, max).trim(), level: state.level + 1, lines: [ startLine, state.line ], children: [] }); } state.tokens.push({ type: 'heading_close', hLevel: level, level: state.level }); return true; }; },{}],27:[function(require,module,exports){ // Horizontal rule 'use strict'; module.exports = function hr(state, startLine, endLine, silent) { var marker, cnt, ch, pos = state.bMarks[startLine], max = state.eMarks[startLine]; pos += state.tShift[startLine]; if (pos > max) { return false; } marker = state.src.charCodeAt(pos++); // Check hr marker if (marker !== 0x2A/* * */ && marker !== 0x2D/* - */ && marker !== 0x5F/* _ */) { return false; } // markers can be mixed with spaces, but there should be at least 3 one cnt = 1; while (pos < max) { ch = state.src.charCodeAt(pos++); if (ch !== marker && ch !== 0x20/* space */) { return false; } if (ch === marker) { cnt++; } } if (cnt < 3) { return false; } if (silent) { return true; } state.line = startLine + 1; state.tokens.push({ type: 'hr', lines: [ startLine, state.line ], level: state.level }); return true; }; },{}],28:[function(require,module,exports){ // HTML block 'use strict'; var block_names = require('../common/html_blocks'); var HTML_TAG_OPEN_RE = /^<([a-zA-Z]{1,15})[\s\/>]/; var HTML_TAG_CLOSE_RE = /^<\/([a-zA-Z]{1,15})[\s>]/; function isLetter(ch) { /*eslint no-bitwise:0*/ var lc = ch | 0x20; // to lower case return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */); } module.exports = function htmlblock(state, startLine, endLine, silent) { var ch, match, nextLine, pos = state.bMarks[startLine], max = state.eMarks[startLine], shift = state.tShift[startLine]; pos += shift; if (!state.options.html) { return false; } if (shift > 3 || pos + 2 >= max) { return false; } if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; } ch = state.src.charCodeAt(pos + 1); if (ch === 0x21/* ! */ || ch === 0x3F/* ? */) { // Directive start / comment start / processing instruction start if (silent) { return true; } } else if (ch === 0x2F/* / */ || isLetter(ch)) { // Probably start or end of tag if (ch === 0x2F/* \ */) { // closing tag match = state.src.slice(pos, max).match(HTML_TAG_CLOSE_RE); if (!match) { return false; } } else { // opening tag match = state.src.slice(pos, max).match(HTML_TAG_OPEN_RE); if (!match) { return false; } } // Make sure tag name is valid if (block_names[match[1].toLowerCase()] !== true) { return false; } if (silent) { return true; } } else { return false; } // If we are here - we detected HTML block. // Let's roll down till empty line (block end). nextLine = startLine + 1; while (nextLine < state.lineMax && !state.isEmpty(nextLine)) { nextLine++; } state.line = nextLine; state.tokens.push({ type: 'htmlblock', level: state.level, lines: [ startLine, state.line ], content: state.getLines(startLine, nextLine, 0, true) }); return true; }; },{"../common/html_blocks":2}],29:[function(require,module,exports){ // lheading (---, ===) 'use strict'; module.exports = function lheading(state, startLine, endLine/*, silent*/) { var marker, pos, max, next = startLine + 1; if (next >= endLine) { return false; } if (state.tShift[next] < state.blkIndent) { return false; } // Scan next line if (state.tShift[next] - state.blkIndent > 3) { return false; } pos = state.bMarks[next] + state.tShift[next]; max = state.eMarks[next]; if (pos >= max) { return false; } marker = state.src.charCodeAt(pos); if (marker !== 0x2D/* - */ && marker !== 0x3D/* = */) { return false; } pos = state.skipChars(pos, marker); pos = state.skipSpaces(pos); if (pos < max) { return false; } pos = state.bMarks[startLine] + state.tShift[startLine]; state.line = next + 1; state.tokens.push({ type: 'heading_open', hLevel: marker === 0x3D/* = */ ? 1 : 2, lines: [ startLine, state.line ], level: state.level }); state.tokens.push({ type: 'inline', content: state.src.slice(pos, state.eMarks[startLine]).trim(), level: state.level + 1, lines: [ startLine, state.line - 1 ], children: [] }); state.tokens.push({ type: 'heading_close', hLevel: marker === 0x3D/* = */ ? 1 : 2, level: state.level }); return true; }; },{}],30:[function(require,module,exports){ // Lists 'use strict'; // Search `[-+*][\n ]`, returns next pos arter marker on success // or -1 on fail. function skipBulletListMarker(state, startLine) { var marker, pos, max; pos = state.bMarks[startLine] + state.tShift[startLine]; max = state.eMarks[startLine]; if (pos >= max) { return -1; } marker = state.src.charCodeAt(pos++); // Check bullet if (marker !== 0x2A/* * */ && marker !== 0x2D/* - */ && marker !== 0x2B/* + */) { return -1; } if (pos < max && state.src.charCodeAt(pos) !== 0x20) { // " 1.test " - is not a list item return -1; } return pos; } // Search `\d+[.)][\n ]`, returns next pos arter marker on success // or -1 on fail. function skipOrderedListMarker(state, startLine) { var ch, pos = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine]; if (pos + 1 >= max) { return -1; } ch = state.src.charCodeAt(pos++); if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1; } for (;;) { // EOL -> fail if (pos >= max) { return -1; } ch = state.src.charCodeAt(pos++); if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) { continue; } // found valid marker if (ch === 0x29/* ) */ || ch === 0x2e/* . */) { break; } return -1; } if (pos < max && state.src.charCodeAt(pos) !== 0x20/* space */) { // " 1.test " - is not a list item return -1; } return pos; } function markTightParagraphs(state, idx) { var i, l, level = state.level + 2; for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) { if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') { state.tokens[i + 2].tight = true; state.tokens[i].tight = true; i += 2; } } } module.exports = function list(state, startLine, endLine, silent) { var nextLine, indent, oldTShift, oldIndent, oldTight, oldParentType, start, posAfterMarker, max, indentAfterMarker, markerValue, markerCharCode, isOrdered, contentStart, listTokIdx, prevEmptyEnd, listLines, itemLines, tight = true, terminatorRules, i, l, terminate; // Detect list type and position after marker if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) { isOrdered = true; } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) { isOrdered = false; } else { return false; } if (state.level >= state.options.maxNesting) { return false; } // We should terminate list on style change. Remember first one to compare. markerCharCode = state.src.charCodeAt(posAfterMarker - 1); // For validation mode we can terminate immediately if (silent) { return true; } // Start list listTokIdx = state.tokens.length; if (isOrdered) { start = state.bMarks[startLine] + state.tShift[startLine]; markerValue = Number(state.src.substr(start, posAfterMarker - start - 1)); state.tokens.push({ type: 'ordered_list_open', order: markerValue, lines: listLines = [ startLine, 0 ], level: state.level++ }); } else { state.tokens.push({ type: 'bullet_list_open', lines: listLines = [ startLine, 0 ], level: state.level++ }); } // // Iterate list items // nextLine = startLine; prevEmptyEnd = false; terminatorRules = state.parser.ruler.getRules('list'); while (nextLine < endLine) { contentStart = state.skipSpaces(posAfterMarker); max = state.eMarks[nextLine]; if (contentStart >= max) { // trimming space in "- \n 3" case, indent is 1 here indentAfterMarker = 1; } else { indentAfterMarker = contentStart - posAfterMarker; } // If we have more than 4 spaces, the indent is 1 // (the rest is just indented code block) if (indentAfterMarker > 4) { indentAfterMarker = 1; } // If indent is less than 1, assume that it's one, example: // "-\n test" if (indentAfterMarker < 1) { indentAfterMarker = 1; } // " - test" // ^^^^^ - calculating total length of this thing indent = (posAfterMarker - state.bMarks[nextLine]) + indentAfterMarker; // Run subparser & write tokens state.tokens.push({ type: 'list_item_open', lines: itemLines = [ startLine, 0 ], level: state.level++ }); oldIndent = state.blkIndent; oldTight = state.tight; oldTShift = state.tShift[startLine]; oldParentType = state.parentType; state.tShift[startLine] = contentStart - state.bMarks[startLine]; state.blkIndent = indent; state.tight = true; state.parentType = 'list'; state.parser.tokenize(state, startLine, endLine, true); // If any of list item is tight, mark list as tight if (!state.tight || prevEmptyEnd) { tight = false; } // Item become loose if finish with empty line, // but we should filter last element, because it means list finish prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1); state.blkIndent = oldIndent; state.tShift[startLine] = oldTShift; state.tight = oldTight; state.parentType = oldParentType; state.tokens.push({ type: 'list_item_close', level: --state.level }); nextLine = startLine = state.line; itemLines[1] = nextLine; contentStart = state.bMarks[startLine]; if (nextLine >= endLine) { break; } if (state.isEmpty(nextLine)) { break; } // // Try to check if list is terminated or continued. // if (state.tShift[nextLine] < state.blkIndent) { break; } // fail if terminating block found terminate = false; for (i = 0, l = terminatorRules.length; i < l; i++) { if (terminatorRules[i](state, nextLine, endLine, true)) { terminate = true; break; } } if (terminate) { break; } // fail if list has another type if (isOrdered) { posAfterMarker = skipOrderedListMarker(state, nextLine); if (posAfterMarker < 0) { break; } } else { posAfterMarker = skipBulletListMarker(state, nextLine); if (posAfterMarker < 0) { break; } } if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break; } } // Finilize list state.tokens.push({ type: isOrdered ? 'ordered_list_close' : 'bullet_list_close', level: --state.level }); listLines[1] = nextLine; state.line = nextLine; // mark paragraphs tight if needed if (tight) { markTightParagraphs(state, listTokIdx); } return true; }; },{}],31:[function(require,module,exports){ // Paragraph 'use strict'; module.exports = function paragraph(state, startLine/*, endLine*/) { var endLine, content, terminate, i, l, nextLine = startLine + 1, terminatorRules; endLine = state.lineMax; // jump line-by-line until empty one or EOF if (nextLine < endLine && !state.isEmpty(nextLine)) { terminatorRules = state.parser.ruler.getRules('paragraph'); for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) { // this would be a code block normally, but after paragraph // it's considered a lazy continuation regardless of what's there if (state.tShift[nextLine] - state.blkIndent > 3) { continue; } // Some tags can terminate paragraph without empty line. terminate = false; for (i = 0, l = terminatorRules.length; i < l; i++) { if (terminatorRules[i](state, nextLine, endLine, true)) { terminate = true; break; } } if (terminate) { break; } } } content = state.getLines(startLine, nextLine, state.blkIndent, false).trim(); state.line = nextLine; if (content.length) { state.tokens.push({ type: 'paragraph_open', tight: false, lines: [ startLine, state.line ], level: state.level }); state.tokens.push({ type: 'inline', content: content, level: state.level + 1, lines: [ startLine, state.line ], children: [] }); state.tokens.push({ type: 'paragraph_close', tight: false, level: state.level }); } return true; }; },{}],32:[function(require,module,exports){ // Parser state class 'use strict'; function StateBlock(src, parser, options, env, tokens) { var ch, s, start, pos, len, indent, indent_found; this.src = src; // Shortcuts to simplify nested calls this.parser = parser; this.options = options; this.env = env; // // Internal state vartiables // this.tokens = tokens; this.bMarks = []; // line begin offsets for fast jumps this.eMarks = []; // line end offsets for fast jumps this.tShift = []; // indent for each line // block parser variables this.blkIndent = 0; // required block content indent // (for example, if we are in list) this.line = 0; // line index in src this.lineMax = 0; // lines count this.tight = false; // loose/tight mode for lists this.parentType = 'root'; // if `list`, block parser stops on two newlines this.ddIndent = -1; // indent of the current dd block (-1 if there isn't any) this.level = 0; // renderer this.result = ''; // Create caches // Generate markers. s = this.src; indent = 0; indent_found = false; for (start = pos = indent = 0, len = s.length; pos < len; pos++) { ch = s.charCodeAt(pos); if (!indent_found) { if (ch === 0x20/* space */) { indent++; continue; } else { indent_found = true; } } if (ch === 0x0A || pos === len - 1) { if (ch !== 0x0A) { pos++; } this.bMarks.push(start); this.eMarks.push(pos); this.tShift.push(indent); indent_found = false; indent = 0; start = pos + 1; } } // Push fake entry to simplify cache bounds checks this.bMarks.push(s.length); this.eMarks.push(s.length); this.tShift.push(0); this.lineMax = this.bMarks.length - 1; // don't count last fake line } StateBlock.prototype.isEmpty = function isEmpty(line) { return this.bMarks[line] + this.tShift[line] >= this.eMarks[line]; }; StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) { for (var max = this.lineMax; from < max; from++) { if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) { break; } } return from; }; // Skip spaces from given position. StateBlock.prototype.skipSpaces = function skipSpaces(pos) { for (var max = this.src.length; pos < max; pos++) { if (this.src.charCodeAt(pos) !== 0x20/* space */) { break; } } return pos; }; // Skip char codes from given position StateBlock.prototype.skipChars = function skipChars(pos, code) { for (var max = this.src.length; pos < max; pos++) { if (this.src.charCodeAt(pos) !== code) { break; } } return pos; }; // Skip char codes reverse from given position - 1 StateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) { if (pos <= min) { return pos; } while (pos > min) { if (code !== this.src.charCodeAt(--pos)) { return pos + 1; } } return pos; }; // cut lines range from source. StateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) { var i, first, last, queue, shift, line = begin; if (begin >= end) { return ''; } // Opt: don't use push queue for single line; if (line + 1 === end) { first = this.bMarks[line] + Math.min(this.tShift[line], indent); last = keepLastLF ? this.eMarks[line] + 1 : this.eMarks[line]; return this.src.slice(first, last); } queue = new Array(end - begin); for (i = 0; line < end; line++, i++) { shift = this.tShift[line]; if (shift > indent) { shift = indent; } if (shift < 0) { shift = 0; } first = this.bMarks[line] + shift; if (line + 1 < end || keepLastLF) { // No need for bounds check because we have fake entry on tail. last = this.eMarks[line] + 1; } else { last = this.eMarks[line]; } queue[i] = this.src.slice(first, last); } return queue.join(''); }; module.exports = StateBlock; },{}],33:[function(require,module,exports){ // GFM table, non-standard 'use strict'; function getLine(state, line) { var pos = state.bMarks[line] + state.blkIndent, max = state.eMarks[line]; return state.src.substr(pos, max - pos); } module.exports = function table(state, startLine, endLine, silent) { var ch, lineText, pos, i, nextLine, rows, cell, aligns, t, tableLines, tbodyLines; // should have at least three lines if (startLine + 2 > endLine) { return false; } nextLine = startLine + 1; if (state.tShift[nextLine] < state.blkIndent) { return false; } // first character of the second line should be '|' or '-' pos = state.bMarks[nextLine] + state.tShift[nextLine]; if (pos >= state.eMarks[nextLine]) { return false; } ch = state.src.charCodeAt(pos); if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */) { return false; } lineText = getLine(state, startLine + 1); if (!/^[-:| ]+$/.test(lineText)) { return false; } rows = lineText.split('|'); if (rows <= 2) { return false; } aligns = []; for (i = 0; i < rows.length; i++) { t = rows[i].trim(); if (!t) { // allow empty columns before and after table, but not in between columns; // e.g. allow ` |---| `, disallow ` ---||--- ` if (i === 0 || i === rows.length - 1) { continue; } else { return false; } } if (!/^:?-+:?$/.test(t)) { return false; } if (t.charCodeAt(t.length - 1) === 0x3A/* : */) { aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right'); } else if (t.charCodeAt(0) === 0x3A/* : */) { aligns.push('left'); } else { aligns.push(''); } } lineText = getLine(state, startLine).trim(); if (lineText.indexOf('|') === -1) { return false; } rows = lineText.replace(/^\||\|$/g, '').split('|'); if (aligns.length !== rows.length) { return false; } if (silent) { return true; } state.tokens.push({ type: 'table_open', lines: tableLines = [ startLine, 0 ], level: state.level++ }); state.tokens.push({ type: 'thead_open', lines: [ startLine, startLine + 1 ], level: state.level++ }); state.tokens.push({ type: 'tr_open', lines: [ startLine, startLine + 1 ], level: state.level++ }); for (i = 0; i < rows.length; i++) { state.tokens.push({ type: 'th_open', align: aligns[i], lines: [ startLine, startLine + 1 ], level: state.level++ }); state.tokens.push({ type: 'inline', content: rows[i].trim(), lines: [ startLine, startLine + 1 ], level: state.level, children: [] }); state.tokens.push({ type: 'th_close', level: --state.level }); } state.tokens.push({ type: 'tr_close', level: --state.level }); state.tokens.push({ type: 'thead_close', level: --state.level }); state.tokens.push({ type: 'tbody_open', lines: tbodyLines = [ startLine + 2, 0 ], level: state.level++ }); for (nextLine = startLine + 2; nextLine < endLine; nextLine++) { if (state.tShift[nextLine] < state.blkIndent) { break; } lineText = getLine(state, nextLine).trim(); if (lineText.indexOf('|') === -1) { break; } rows = lineText.replace(/^\||\|$/g, '').split('|'); state.tokens.push({ type: 'tr_open', level: state.level++ }); for (i = 0; i < rows.length; i++) { state.tokens.push({ type: 'td_open', align: aligns[i], level: state.level++ }); // 0x7c === '|' cell = rows[i].substring( rows[i].charCodeAt(0) === 0x7c ? 1 : 0, rows[i].charCodeAt(rows[i].length - 1) === 0x7c ? rows[i].length - 1 : rows[i].length ).trim(); state.tokens.push({ type: 'inline', content: cell, level: state.level, children: [] }); state.tokens.push({ type: 'td_close', level: --state.level }); } state.tokens.push({ type: 'tr_close', level: --state.level }); } state.tokens.push({ type: 'tbody_close', level: --state.level }); state.tokens.push({ type: 'table_close', level: --state.level }); tableLines[1] = tbodyLines[1] = nextLine; state.line = nextLine; return true; }; },{}],34:[function(require,module,exports){ // Parse abbreviation definitions, i.e. `*[abbr]: description` // 'use strict'; var StateInline = require('../rules_inline/state_inline'); var parseLinkLabel = require('../helpers/parse_link_label'); function parseAbbr(str, parserInline, options, env) { var state, labelEnd, pos, max, label, title; if (str.charCodeAt(0) !== 0x2A/* * */) { return -1; } if (str.charCodeAt(1) !== 0x5B/* [ */) { return -1; } if (str.indexOf(']:') === -1) { return -1; } state = new StateInline(str, parserInline, options, env, []); labelEnd = parseLinkLabel(state, 1); if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return -1; } max = state.posMax; // abbr title is always one line, so looking for ending "\n" here for (pos = labelEnd + 2; pos < max; pos++) { if (state.src.charCodeAt(pos) === 0x0A) { break; } } label = str.slice(2, labelEnd); title = str.slice(labelEnd + 2, pos).trim(); if (title.length === 0) { return -1; } if (!env.abbreviations) { env.abbreviations = {}; } // prepend ':' to avoid conflict with Object.prototype members if (typeof env.abbreviations[':' + label] === 'undefined') { env.abbreviations[':' + label] = title; } return pos; } module.exports = function abbr(state) { var tokens = state.tokens, i, l, content, pos; if (state.inlineMode) { return; } // Parse inlines for (i = 1, l = tokens.length - 1; i < l; i++) { if (tokens[i - 1].type === 'paragraph_open' && tokens[i].type === 'inline' && tokens[i + 1].type === 'paragraph_close') { content = tokens[i].content; while (content.length) { pos = parseAbbr(content, state.inline, state.options, state.env); if (pos < 0) { break; } content = content.slice(pos).trim(); } tokens[i].content = content; if (!content.length) { tokens[i - 1].tight = true; tokens[i + 1].tight = true; } } } }; },{"../helpers/parse_link_label":12,"../rules_inline/state_inline":56}],35:[function(require,module,exports){ // Enclose abbreviations in tags // 'use strict'; var PUNCT_CHARS = ' \n()[]\'".,!?-'; // from Google closure library // http://closure-library.googlecode.com/git-history/docs/local_closure_goog_string_string.js.source.html#line1021 function regEscape(s) { return s.replace(/([-()\[\]{}+?*.$\^|,:#= 0; i--) { token = tokens[i]; if (token.type !== 'text') { continue; } pos = 0; text = token.content; reg.lastIndex = 0; level = token.level; nodes = []; while ((m = reg.exec(text))) { if (reg.lastIndex > pos) { nodes.push({ type: 'text', content: text.slice(pos, m.index + m[1].length), level: level }); } nodes.push({ type: 'abbr_open', title: state.env.abbreviations[':' + m[2]], level: level++ }); nodes.push({ type: 'text', content: m[2], level: level }); nodes.push({ type: 'abbr_close', level: --level }); pos = reg.lastIndex - m[3].length; } if (!nodes.length) { continue; } if (pos < text.length) { nodes.push({ type: 'text', content: text.slice(pos), level: level }); } // replace current node blockTokens[j].children = tokens = [].concat(tokens.slice(0, i), nodes, tokens.slice(i + 1)); } } }; },{}],36:[function(require,module,exports){ 'use strict'; module.exports = function block(state) { if (state.inlineMode) { state.tokens.push({ type: 'inline', content: state.src.replace(/\n/g, ' ').trim(), level: 0, lines: [ 0, 1 ], children: [] }); } else { state.block.parse(state.src, state.options, state.env, state.tokens); } }; },{}],37:[function(require,module,exports){ 'use strict'; module.exports = function footnote_block(state) { var i, l, j, t, lastParagraph, list, tokens, current, currentLabel, level = 0, insideRef = false, refTokens = {}; if (!state.env.footnotes) { return; } state.tokens = state.tokens.filter(function(tok) { if (tok.type === 'footnote_reference_open') { insideRef = true; current = []; currentLabel = tok.label; return false; } if (tok.type === 'footnote_reference_close') { insideRef = false; // prepend ':' to avoid conflict with Object.prototype members refTokens[':' + currentLabel] = current; return false; } if (insideRef) { current.push(tok); } return !insideRef; }); if (!state.env.footnotes.list) { return; } list = state.env.footnotes.list; state.tokens.push({ type: 'footnote_block_open', level: level++ }); for (i = 0, l = list.length; i < l; i++) { state.tokens.push({ type: 'footnote_open', id: i, level: level++ }); if (list[i].tokens) { tokens = []; tokens.push({ type: 'paragraph_open', tight: false, level: level++ }); tokens.push({ type: 'inline', content: '', level: level, children: list[i].tokens }); tokens.push({ type: 'paragraph_close', tight: false, level: --level }); } else if (list[i].label) { tokens = refTokens[':' + list[i].label]; } state.tokens = state.tokens.concat(tokens); if (state.tokens[state.tokens.length - 1].type === 'paragraph_close') { lastParagraph = state.tokens.pop(); } else { lastParagraph = null; } t = list[i].count > 0 ? list[i].count : 1; for (j = 0; j < t; j++) { state.tokens.push({ type: 'footnote_anchor', id: i, subId: j, level: level }); } if (lastParagraph) { state.tokens.push(lastParagraph); } state.tokens.push({ type: 'footnote_close', level: --level }); } state.tokens.push({ type: 'footnote_block_close', level: --level }); }; },{}],38:[function(require,module,exports){ 'use strict'; module.exports = function inline(state) { var tokens = state.tokens, tok, i, l; // Parse inlines for (i = 0, l = tokens.length; i < l; i++) { tok = tokens[i]; if (tok.type === 'inline') { state.inline.parse(tok.content, state.options, state.env, tok.children); } } }; },{}],39:[function(require,module,exports){ // Replace link-like texts with link nodes. // // Currently restricted by `inline.validateLink()` to http/https/ftp // 'use strict'; var Autolinker = require('autolinker'); var LINK_SCAN_RE = /www|@|\:\/\//; function isLinkOpen(str) { return /^\s]/i.test(str); } function isLinkClose(str) { return /^<\/a\s*>/i.test(str); } // Stupid fabric to avoid singletons, for thread safety. // Required for engines like Nashorn. // function createLinkifier() { var links = []; var autolinker = new Autolinker({ stripPrefix: false, url: true, email: true, twitter: false, replaceFn: function (linker, match) { // Only collect matched strings but don't change anything. switch (match.getType()) { /*eslint default-case:0*/ case 'url': links.push({ text: match.matchedText, url: match.getUrl() }); break; case 'email': links.push({ text: match.matchedText, // normalize email protocol url: 'mailto:' + match.getEmail().replace(/^mailto:/i, '') }); break; } return false; } }); return { links: links, autolinker: autolinker }; } module.exports = function linkify(state) { var i, j, l, tokens, token, text, nodes, ln, pos, level, htmlLinkLevel, blockTokens = state.tokens, linkifier = null, links, autolinker; if (!state.options.linkify) { return; } for (j = 0, l = blockTokens.length; j < l; j++) { if (blockTokens[j].type !== 'inline') { continue; } tokens = blockTokens[j].children; htmlLinkLevel = 0; // We scan from the end, to keep position when new tags added. // Use reversed logic in links start/end match for (i = tokens.length - 1; i >= 0; i--) { token = tokens[i]; // Skip content of markdown links if (token.type === 'link_close') { i--; while (tokens[i].level !== token.level && tokens[i].type !== 'link_open') { i--; } continue; } // Skip content of html tag links if (token.type === 'htmltag') { if (isLinkOpen(token.content) && htmlLinkLevel > 0) { htmlLinkLevel--; } if (isLinkClose(token.content)) { htmlLinkLevel++; } } if (htmlLinkLevel > 0) { continue; } if (token.type === 'text' && LINK_SCAN_RE.test(token.content)) { // Init linkifier in lazy manner, only if required. if (!linkifier) { linkifier = createLinkifier(); links = linkifier.links; autolinker = linkifier.autolinker; } text = token.content; links.length = 0; autolinker.link(text); if (!links.length) { continue; } // Now split string to nodes nodes = []; level = token.level; for (ln = 0; ln < links.length; ln++) { if (!state.inline.validateLink(links[ln].url)) { continue; } pos = text.indexOf(links[ln].text); if (pos) { level = level; nodes.push({ type: 'text', content: text.slice(0, pos), level: level }); } nodes.push({ type: 'link_open', href: links[ln].url, title: '', level: level++ }); nodes.push({ type: 'text', content: links[ln].text, level: level }); nodes.push({ type: 'link_close', level: --level }); text = text.slice(pos + links[ln].text.length); } if (text.length) { nodes.push({ type: 'text', content: text, level: level }); } // replace current node blockTokens[j].children = tokens = [].concat(tokens.slice(0, i), nodes, tokens.slice(i + 1)); } } } }; },{"autolinker":60}],40:[function(require,module,exports){ 'use strict'; var StateInline = require('../rules_inline/state_inline'); var parseLinkLabel = require('../helpers/parse_link_label'); var parseLinkDestination = require('../helpers/parse_link_destination'); var parseLinkTitle = require('../helpers/parse_link_title'); var normalizeReference = require('../helpers/normalize_reference'); function parseReference(str, parser, options, env) { var state, labelEnd, pos, max, code, start, href, title, label; if (str.charCodeAt(0) !== 0x5B/* [ */) { return -1; } if (str.indexOf(']:') === -1) { return -1; } state = new StateInline(str, parser, options, env, []); labelEnd = parseLinkLabel(state, 0); if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return -1; } max = state.posMax; // [label]: destination 'title' // ^^^ skip optional whitespace here for (pos = labelEnd + 2; pos < max; pos++) { code = state.src.charCodeAt(pos); if (code !== 0x20 && code !== 0x0A) { break; } } // [label]: destination 'title' // ^^^^^^^^^^^ parse this if (!parseLinkDestination(state, pos)) { return -1; } href = state.linkContent; pos = state.pos; // [label]: destination 'title' // ^^^ skipping those spaces start = pos; for (pos = pos + 1; pos < max; pos++) { code = state.src.charCodeAt(pos); if (code !== 0x20 && code !== 0x0A) { break; } } // [label]: destination 'title' // ^^^^^^^ parse this if (pos < max && start !== pos && parseLinkTitle(state, pos)) { title = state.linkContent; pos = state.pos; } else { title = ''; pos = start; } // ensure that the end of the line is empty while (pos < max && state.src.charCodeAt(pos) === 0x20/* space */) { pos++; } if (pos < max && state.src.charCodeAt(pos) !== 0x0A) { return -1; } label = normalizeReference(str.slice(1, labelEnd)); if (typeof env.references[label] === 'undefined') { env.references[label] = { title: title, href: href }; } return pos; } module.exports = function references(state) { var tokens = state.tokens, i, l, content, pos; state.env.references = state.env.references || {}; if (state.inlineMode) { return; } // Scan definitions in paragraph inlines for (i = 1, l = tokens.length - 1; i < l; i++) { if (tokens[i].type === 'inline' && tokens[i - 1].type === 'paragraph_open' && tokens[i + 1].type === 'paragraph_close') { content = tokens[i].content; while (content.length) { pos = parseReference(content, state.inline, state.options, state.env); if (pos < 0) { break; } content = content.slice(pos).trim(); } tokens[i].content = content; if (!content.length) { tokens[i - 1].tight = true; tokens[i + 1].tight = true; } } } }; },{"../helpers/normalize_reference":10,"../helpers/parse_link_destination":11,"../helpers/parse_link_label":12,"../helpers/parse_link_title":13,"../rules_inline/state_inline":56}],41:[function(require,module,exports){ // Simple typographical replacements // 'use strict'; // TODO: // - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾ // - miltiplication 2 x 4 -> 2 × 4 var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/; var SCOPED_ABBR_RE = /\((c|tm|r|p)\)/ig; var SCOPED_ABBR = { 'c': '©', 'r': '®', 'p': '§', 'tm': '™' }; function replaceScopedAbbr(str) { if (str.indexOf('(') < 0) { return str; } return str.replace(SCOPED_ABBR_RE, function(match, name) { return SCOPED_ABBR[name.toLowerCase()]; }); } module.exports = function replace(state) { var i, token, text, inlineTokens, blkIdx; if (!state.options.typographer) { return; } for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) { if (state.tokens[blkIdx].type !== 'inline') { continue; } inlineTokens = state.tokens[blkIdx].children; for (i = inlineTokens.length - 1; i >= 0; i--) { token = inlineTokens[i]; if (token.type === 'text') { text = token.content; text = replaceScopedAbbr(text); if (RARE_RE.test(text)) { text = text .replace(/\+-/g, '±') // .., ..., ....... -> … // but ?..... & !..... -> ?.. & !.. .replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..') .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',') // em-dash .replace(/(^|[^-])---([^-]|$)/mg, '$1\u2014$2') // en-dash .replace(/(^|\s)--(\s|$)/mg, '$1\u2013$2') .replace(/(^|[^-\s])--([^-\s]|$)/mg, '$1\u2013$2'); } token.content = text; } } } }; },{}],42:[function(require,module,exports){ // Convert straight quotation marks to typographic ones // 'use strict'; var QUOTE_TEST_RE = /['"]/; var QUOTE_RE = /['"]/g; var PUNCT_RE = /[-\s()\[\]]/; var APOSTROPHE = '’'; // This function returns true if the character at `pos` // could be inside a word. function isLetter(str, pos) { if (pos < 0 || pos >= str.length) { return false; } return !PUNCT_RE.test(str[pos]); } function replaceAt(str, index, ch) { return str.substr(0, index) + ch + str.substr(index + 1); } module.exports = function smartquotes(state) { /*eslint max-depth:0*/ var i, token, text, t, pos, max, thisLevel, lastSpace, nextSpace, item, canOpen, canClose, j, isSingle, blkIdx, tokens, stack; if (!state.options.typographer) { return; } stack = []; for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) { if (state.tokens[blkIdx].type !== 'inline') { continue; } tokens = state.tokens[blkIdx].children; stack.length = 0; for (i = 0; i < tokens.length; i++) { token = tokens[i]; if (token.type !== 'text' || QUOTE_TEST_RE.test(token.text)) { continue; } thisLevel = tokens[i].level; for (j = stack.length - 1; j >= 0; j--) { if (stack[j].level <= thisLevel) { break; } } stack.length = j + 1; text = token.content; pos = 0; max = text.length; /*eslint no-labels:0,block-scoped-var:0*/ OUTER: while (pos < max) { QUOTE_RE.lastIndex = pos; t = QUOTE_RE.exec(text); if (!t) { break; } lastSpace = !isLetter(text, t.index - 1); pos = t.index + 1; isSingle = (t[0] === "'"); nextSpace = !isLetter(text, pos); if (!nextSpace && !lastSpace) { // middle of word if (isSingle) { token.content = replaceAt(token.content, t.index, APOSTROPHE); } continue; } canOpen = !nextSpace; canClose = !lastSpace; if (canClose) { // this could be a closing quote, rewind the stack to get a match for (j = stack.length - 1; j >= 0; j--) { item = stack[j]; if (stack[j].level < thisLevel) { break; } if (item.single === isSingle && stack[j].level === thisLevel) { item = stack[j]; if (isSingle) { tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[2]); token.content = replaceAt(token.content, t.index, state.options.quotes[3]); } else { tokens[item.token].content = replaceAt(tokens[item.token].content, item.pos, state.options.quotes[0]); token.content = replaceAt(token.content, t.index, state.options.quotes[1]); } stack.length = j; continue OUTER; } } } if (canOpen) { stack.push({ token: i, pos: t.index, single: isSingle, level: thisLevel }); } else if (canClose && isSingle) { token.content = replaceAt(token.content, t.index, APOSTROPHE); } } } } }; },{}],43:[function(require,module,exports){ // Process autolinks '' 'use strict'; var url_schemas = require('../common/url_schemas'); var normalizeLink = require('../helpers/normalize_link'); /*eslint max-len:0*/ var EMAIL_RE = /^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/; var AUTOLINK_RE = /^<([a-zA-Z.\-]{1,25}):([^<>\x00-\x20]*)>/; module.exports = function autolink(state, silent) { var tail, linkMatch, emailMatch, url, fullUrl, pos = state.pos; if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; } tail = state.src.slice(pos); if (tail.indexOf('>') < 0) { return false; } linkMatch = tail.match(AUTOLINK_RE); if (linkMatch) { if (url_schemas.indexOf(linkMatch[1].toLowerCase()) < 0) { return false; } url = linkMatch[0].slice(1, -1); fullUrl = normalizeLink(url); if (!state.parser.validateLink(url)) { return false; } if (!silent) { state.push({ type: 'link_open', href: fullUrl, level: state.level }); state.push({ type: 'text', content: url, level: state.level + 1 }); state.push({ type: 'link_close', level: state.level }); } state.pos += linkMatch[0].length; return true; } emailMatch = tail.match(EMAIL_RE); if (emailMatch) { url = emailMatch[0].slice(1, -1); fullUrl = normalizeLink('mailto:' + url); if (!state.parser.validateLink(fullUrl)) { return false; } if (!silent) { state.push({ type: 'link_open', href: fullUrl, level: state.level }); state.push({ type: 'text', content: url, level: state.level + 1 }); state.push({ type: 'link_close', level: state.level }); } state.pos += emailMatch[0].length; return true; } return false; }; },{"../common/url_schemas":4,"../helpers/normalize_link":9}],44:[function(require,module,exports){ // Parse backticks 'use strict'; module.exports = function backticks(state, silent) { var start, max, marker, matchStart, matchEnd, pos = state.pos, ch = state.src.charCodeAt(pos); if (ch !== 0x60/* ` */) { return false; } start = pos; pos++; max = state.posMax; while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; } marker = state.src.slice(start, pos); matchStart = matchEnd = pos; while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) { matchEnd = matchStart + 1; while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; } if (matchEnd - matchStart === marker.length) { if (!silent) { state.push({ type: 'code', content: state.src.slice(pos, matchStart) .replace(/[ \n]+/g, ' ') .trim(), block: false, level: state.level }); } state.pos = matchEnd; return true; } } if (!silent) { state.pending += marker; } state.pos += marker.length; return true; }; },{}],45:[function(require,module,exports){ // Process ~~deleted text~~ 'use strict'; module.exports = function del(state, silent) { var found, pos, stack, max = state.posMax, start = state.pos, lastChar, nextChar; if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; } if (silent) { return false; } // don't run any pairs in validation mode if (start + 4 >= max) { return false; } if (state.src.charCodeAt(start + 1) !== 0x7E/* ~ */) { return false; } if (state.level >= state.options.maxNesting) { return false; } lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1; nextChar = state.src.charCodeAt(start + 2); if (lastChar === 0x7E/* ~ */) { return false; } if (nextChar === 0x7E/* ~ */) { return false; } if (nextChar === 0x20 || nextChar === 0x0A) { return false; } pos = start + 2; while (pos < max && state.src.charCodeAt(pos) === 0x7E/* ~ */) { pos++; } if (pos > start + 3) { // sequence of 4+ markers taking as literal, same as in a emphasis state.pos += pos - start; if (!silent) { state.pending += state.src.slice(start, pos); } return true; } state.pos = start + 2; stack = 1; while (state.pos + 1 < max) { if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) { if (state.src.charCodeAt(state.pos + 1) === 0x7E/* ~ */) { lastChar = state.src.charCodeAt(state.pos - 1); nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1; if (nextChar !== 0x7E/* ~ */ && lastChar !== 0x7E/* ~ */) { if (lastChar !== 0x20 && lastChar !== 0x0A) { // closing '~~' stack--; } else if (nextChar !== 0x20 && nextChar !== 0x0A) { // opening '~~' stack++; } // else { // // standalone ' ~~ ' indented with spaces // } if (stack <= 0) { found = true; break; } } } } state.parser.skipToken(state); } if (!found) { // parser failed to find ending tag, so it's not valid emphasis state.pos = start; return false; } // found! state.posMax = state.pos; state.pos = start + 2; if (!silent) { state.push({ type: 'del_open', level: state.level++ }); state.parser.tokenize(state); state.push({ type: 'del_close', level: --state.level }); } state.pos = state.posMax + 2; state.posMax = max; return true; }; },{}],46:[function(require,module,exports){ // Process *this* and _that_ 'use strict'; function isAlphaNum(code) { return (code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) || (code >= 0x41 /* A */ && code <= 0x5A /* Z */) || (code >= 0x61 /* a */ && code <= 0x7A /* z */); } // parse sequence of emphasis markers, // "start" should point at a valid marker function scanDelims(state, start) { var pos = start, lastChar, nextChar, count, can_open = true, can_close = true, max = state.posMax, marker = state.src.charCodeAt(start); lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1; while (pos < max && state.src.charCodeAt(pos) === marker) { pos++; } if (pos >= max) { can_open = false; } count = pos - start; if (count >= 4) { // sequence of four or more unescaped markers can't start/end an emphasis can_open = can_close = false; } else { nextChar = pos < max ? state.src.charCodeAt(pos) : -1; // check whitespace conditions if (nextChar === 0x20 || nextChar === 0x0A) { can_open = false; } if (lastChar === 0x20 || lastChar === 0x0A) { can_close = false; } if (marker === 0x5F /* _ */) { // check if we aren't inside the word if (isAlphaNum(lastChar)) { can_open = false; } if (isAlphaNum(nextChar)) { can_close = false; } } } return { can_open: can_open, can_close: can_close, delims: count }; } module.exports = function emphasis(state, silent) { var startCount, count, found, oldCount, newCount, stack, res, max = state.posMax, start = state.pos, marker = state.src.charCodeAt(start); if (marker !== 0x5F/* _ */ && marker !== 0x2A /* * */) { return false; } if (silent) { return false; } // don't run any pairs in validation mode res = scanDelims(state, start); startCount = res.delims; if (!res.can_open) { state.pos += startCount; if (!silent) { state.pending += state.src.slice(start, state.pos); } return true; } if (state.level >= state.options.maxNesting) { return false; } state.pos = start + startCount; stack = [ startCount ]; while (state.pos < max) { if (state.src.charCodeAt(state.pos) === marker) { res = scanDelims(state, state.pos); count = res.delims; if (res.can_close) { oldCount = stack.pop(); newCount = count; while (oldCount !== newCount) { if (newCount < oldCount) { stack.push(oldCount - newCount); break; } // assert(newCount > oldCount) newCount -= oldCount; if (stack.length === 0) { break; } state.pos += oldCount; oldCount = stack.pop(); } if (stack.length === 0) { startCount = oldCount; found = true; break; } state.pos += count; continue; } if (res.can_open) { stack.push(count); } state.pos += count; continue; } state.parser.skipToken(state); } if (!found) { // parser failed to find ending tag, so it's not valid emphasis state.pos = start; return false; } // found! state.posMax = state.pos; state.pos = start + startCount; if (!silent) { if (startCount === 2 || startCount === 3) { state.push({ type: 'strong_open', level: state.level++ }); } if (startCount === 1 || startCount === 3) { state.push({ type: 'em_open', level: state.level++ }); } state.parser.tokenize(state); if (startCount === 1 || startCount === 3) { state.push({ type: 'em_close', level: --state.level }); } if (startCount === 2 || startCount === 3) { state.push({ type: 'strong_close', level: --state.level }); } } state.pos = state.posMax + startCount; state.posMax = max; return true; }; },{}],47:[function(require,module,exports){ // Process html entity - {, ¯, ", ... 'use strict'; var entities = require('../common/entities'); var has = require('../common/utils').has; var isValidEntityCode = require('../common/utils').isValidEntityCode; var fromCodePoint = require('../common/utils').fromCodePoint; var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i; var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i; module.exports = function entity(state, silent) { var ch, code, match, pos = state.pos, max = state.posMax; if (state.src.charCodeAt(pos) !== 0x26/* & */) { return false; } if (pos + 1 < max) { ch = state.src.charCodeAt(pos + 1); if (ch === 0x23 /* # */) { match = state.src.slice(pos).match(DIGITAL_RE); if (match) { if (!silent) { code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10); state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD); } state.pos += match[0].length; return true; } } else { match = state.src.slice(pos).match(NAMED_RE); if (match) { if (has(entities, match[1])) { if (!silent) { state.pending += entities[match[1]]; } state.pos += match[0].length; return true; } } } } if (!silent) { state.pending += '&'; } state.pos++; return true; }; },{"../common/entities":1,"../common/utils":5}],48:[function(require,module,exports){ // Proceess escaped chars and hardbreaks 'use strict'; var ESCAPED = []; for (var i = 0; i < 256; i++) { ESCAPED.push(0); } '\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-' .split('').forEach(function(ch) { ESCAPED[ch.charCodeAt(0)] = 1; }); module.exports = function escape(state, silent) { var ch, pos = state.pos, max = state.posMax; if (state.src.charCodeAt(pos) !== 0x5C/* \ */) { return false; } pos++; if (pos < max) { ch = state.src.charCodeAt(pos); if (ch < 256 && ESCAPED[ch] !== 0) { if (!silent) { state.pending += state.src[pos]; } state.pos += 2; return true; } if (ch === 0x0A) { if (!silent) { state.push({ type: 'hardbreak', level: state.level }); } pos++; // skip leading whitespaces from next line while (pos < max && state.src.charCodeAt(pos) === 0x20) { pos++; } state.pos = pos; return true; } } if (!silent) { state.pending += '\\'; } state.pos++; return true; }; },{}],49:[function(require,module,exports){ // Process inline footnotes (^[...]) 'use strict'; var parseLinkLabel = require('../helpers/parse_link_label'); module.exports = function footnote_inline(state, silent) { var labelStart, labelEnd, footnoteId, oldLength, max = state.posMax, start = state.pos; if (start + 2 >= max) { return false; } if (state.src.charCodeAt(start) !== 0x5E/* ^ */) { return false; } if (state.src.charCodeAt(start + 1) !== 0x5B/* [ */) { return false; } if (state.level >= state.options.maxNesting) { return false; } labelStart = start + 2; labelEnd = parseLinkLabel(state, start + 1); // parser failed to find ']', so it's not a valid note if (labelEnd < 0) { return false; } // We found the end of the link, and know for a fact it's a valid link; // so all that's left to do is to call tokenizer. // if (!silent) { if (!state.env.footnotes) { state.env.footnotes = {}; } if (!state.env.footnotes.list) { state.env.footnotes.list = []; } footnoteId = state.env.footnotes.list.length; state.pos = labelStart; state.posMax = labelEnd; state.push({ type: 'footnote_ref', id: footnoteId, level: state.level }); state.linkLevel++; oldLength = state.tokens.length; state.parser.tokenize(state); state.env.footnotes.list[footnoteId] = { tokens: state.tokens.splice(oldLength) }; state.linkLevel--; } state.pos = labelEnd + 1; state.posMax = max; return true; }; },{"../helpers/parse_link_label":12}],50:[function(require,module,exports){ // Process footnote references ([^...]) 'use strict'; module.exports = function footnote_ref(state, silent) { var label, pos, footnoteId, footnoteSubId, max = state.posMax, start = state.pos; // should be at least 4 chars - "[^x]" if (start + 3 > max) { return false; } if (!state.env.footnotes || !state.env.footnotes.refs) { return false; } if (state.src.charCodeAt(start) !== 0x5B/* [ */) { return false; } if (state.src.charCodeAt(start + 1) !== 0x5E/* ^ */) { return false; } if (state.level >= state.options.maxNesting) { return false; } for (pos = start + 2; pos < max; pos++) { if (state.src.charCodeAt(pos) === 0x20) { return false; } if (state.src.charCodeAt(pos) === 0x0A) { return false; } if (state.src.charCodeAt(pos) === 0x5D /* ] */) { break; } } if (pos === start + 2) { return false; } // no empty footnote labels if (pos >= max) { return false; } pos++; label = state.src.slice(start + 2, pos - 1); if (typeof state.env.footnotes.refs[':' + label] === 'undefined') { return false; } if (!silent) { if (!state.env.footnotes.list) { state.env.footnotes.list = []; } if (state.env.footnotes.refs[':' + label] < 0) { footnoteId = state.env.footnotes.list.length; state.env.footnotes.list[footnoteId] = { label: label, count: 0 }; state.env.footnotes.refs[':' + label] = footnoteId; } else { footnoteId = state.env.footnotes.refs[':' + label]; } footnoteSubId = state.env.footnotes.list[footnoteId].count; state.env.footnotes.list[footnoteId].count++; state.push({ type: 'footnote_ref', id: footnoteId, subId: footnoteSubId, level: state.level }); } state.pos = pos; state.posMax = max; return true; }; },{}],51:[function(require,module,exports){ // Process html tags 'use strict'; var HTML_TAG_RE = require('../common/html_re').HTML_TAG_RE; function isLetter(ch) { /*eslint no-bitwise:0*/ var lc = ch | 0x20; // to lower case return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */); } module.exports = function htmltag(state, silent) { var ch, match, max, pos = state.pos; if (!state.options.html) { return false; } // Check start max = state.posMax; if (state.src.charCodeAt(pos) !== 0x3C/* < */ || pos + 2 >= max) { return false; } // Quick fail on second char ch = state.src.charCodeAt(pos + 1); if (ch !== 0x21/* ! */ && ch !== 0x3F/* ? */ && ch !== 0x2F/* / */ && !isLetter(ch)) { return false; } match = state.src.slice(pos).match(HTML_TAG_RE); if (!match) { return false; } if (!silent) { state.push({ type: 'htmltag', content: state.src.slice(pos, pos + match[0].length), level: state.level }); } state.pos += match[0].length; return true; }; },{"../common/html_re":3}],52:[function(require,module,exports){ // Process ++inserted text++ 'use strict'; module.exports = function ins(state, silent) { var found, pos, stack, max = state.posMax, start = state.pos, lastChar, nextChar; if (state.src.charCodeAt(start) !== 0x2B/* + */) { return false; } if (silent) { return false; } // don't run any pairs in validation mode if (start + 4 >= max) { return false; } if (state.src.charCodeAt(start + 1) !== 0x2B/* + */) { return false; } if (state.level >= state.options.maxNesting) { return false; } lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1; nextChar = state.src.charCodeAt(start + 2); if (lastChar === 0x2B/* + */) { return false; } if (nextChar === 0x2B/* + */) { return false; } if (nextChar === 0x20 || nextChar === 0x0A) { return false; } pos = start + 2; while (pos < max && state.src.charCodeAt(pos) === 0x2B/* + */) { pos++; } if (pos !== start + 2) { // sequence of 3+ markers taking as literal, same as in a emphasis state.pos += pos - start; if (!silent) { state.pending += state.src.slice(start, pos); } return true; } state.pos = start + 2; stack = 1; while (state.pos + 1 < max) { if (state.src.charCodeAt(state.pos) === 0x2B/* + */) { if (state.src.charCodeAt(state.pos + 1) === 0x2B/* + */) { lastChar = state.src.charCodeAt(state.pos - 1); nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1; if (nextChar !== 0x2B/* + */ && lastChar !== 0x2B/* + */) { if (lastChar !== 0x20 && lastChar !== 0x0A) { // closing '++' stack--; } else if (nextChar !== 0x20 && nextChar !== 0x0A) { // opening '++' stack++; } // else { // // standalone ' ++ ' indented with spaces // } if (stack <= 0) { found = true; break; } } } } state.parser.skipToken(state); } if (!found) { // parser failed to find ending tag, so it's not valid emphasis state.pos = start; return false; } // found! state.posMax = state.pos; state.pos = start + 2; if (!silent) { state.push({ type: 'ins_open', level: state.level++ }); state.parser.tokenize(state); state.push({ type: 'ins_close', level: --state.level }); } state.pos = state.posMax + 2; state.posMax = max; return true; }; },{}],53:[function(require,module,exports){ // Process [links]( "stuff") 'use strict'; var parseLinkLabel = require('../helpers/parse_link_label'); var parseLinkDestination = require('../helpers/parse_link_destination'); var parseLinkTitle = require('../helpers/parse_link_title'); var normalizeReference = require('../helpers/normalize_reference'); module.exports = function links(state, silent) { var labelStart, labelEnd, label, href, title, pos, ref, code, isImage = false, oldPos = state.pos, max = state.posMax, start = state.pos, marker = state.src.charCodeAt(start); if (marker === 0x21/* ! */) { isImage = true; marker = state.src.charCodeAt(++start); } if (marker !== 0x5B/* [ */) { return false; } if (state.level >= state.options.maxNesting) { return false; } labelStart = start + 1; labelEnd = parseLinkLabel(state, start); // parser failed to find ']', so it's not a valid link if (labelEnd < 0) { return false; } pos = labelEnd + 1; if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) { // // Inline link // // [link]( "title" ) // ^^ skipping these spaces pos++; for (; pos < max; pos++) { code = state.src.charCodeAt(pos); if (code !== 0x20 && code !== 0x0A) { break; } } if (pos >= max) { return false; } // [link]( "title" ) // ^^^^^^ parsing link destination start = pos; if (parseLinkDestination(state, pos)) { href = state.linkContent; pos = state.pos; } else { href = ''; } // [link]( "title" ) // ^^ skipping these spaces start = pos; for (; pos < max; pos++) { code = state.src.charCodeAt(pos); if (code !== 0x20 && code !== 0x0A) { break; } } // [link]( "title" ) // ^^^^^^^ parsing link title if (pos < max && start !== pos && parseLinkTitle(state, pos)) { title = state.linkContent; pos = state.pos; // [link]( "title" ) // ^^ skipping these spaces for (; pos < max; pos++) { code = state.src.charCodeAt(pos); if (code !== 0x20 && code !== 0x0A) { break; } } } else { title = ''; } if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) { state.pos = oldPos; return false; } pos++; } else { // // Link reference // // do not allow nested reference links if (state.linkLevel > 0) { return false; } // [foo] [bar] // ^^ optional whitespace (can include newlines) for (; pos < max; pos++) { code = state.src.charCodeAt(pos); if (code !== 0x20 && code !== 0x0A) { break; } } if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) { start = pos + 1; pos = parseLinkLabel(state, pos); if (pos >= 0) { label = state.src.slice(start, pos++); } else { pos = start - 1; } } // covers label === '' and label === undefined // (collapsed reference link and shortcut reference link respectively) if (!label) { if (typeof label === 'undefined') { pos = labelEnd + 1; } label = state.src.slice(labelStart, labelEnd); } ref = state.env.references[normalizeReference(label)]; if (!ref) { state.pos = oldPos; return false; } href = ref.href; title = ref.title; } // // We found the end of the link, and know for a fact it's a valid link; // so all that's left to do is to call tokenizer. // if (!silent) { state.pos = labelStart; state.posMax = labelEnd; if (isImage) { state.push({ type: 'image', src: href, title: title, alt: state.src.substr(labelStart, labelEnd - labelStart), level: state.level }); } else { state.push({ type: 'link_open', href: href, title: title, level: state.level++ }); state.linkLevel++; state.parser.tokenize(state); state.linkLevel--; state.push({ type: 'link_close', level: --state.level }); } } state.pos = pos; state.posMax = max; return true; }; },{"../helpers/normalize_reference":10,"../helpers/parse_link_destination":11,"../helpers/parse_link_label":12,"../helpers/parse_link_title":13}],54:[function(require,module,exports){ // Process ==highlighted text== 'use strict'; module.exports = function del(state, silent) { var found, pos, stack, max = state.posMax, start = state.pos, lastChar, nextChar; if (state.src.charCodeAt(start) !== 0x3D/* = */) { return false; } if (silent) { return false; } // don't run any pairs in validation mode if (start + 4 >= max) { return false; } if (state.src.charCodeAt(start + 1) !== 0x3D/* = */) { return false; } if (state.level >= state.options.maxNesting) { return false; } lastChar = start > 0 ? state.src.charCodeAt(start - 1) : -1; nextChar = state.src.charCodeAt(start + 2); if (lastChar === 0x3D/* = */) { return false; } if (nextChar === 0x3D/* = */) { return false; } if (nextChar === 0x20 || nextChar === 0x0A) { return false; } pos = start + 2; while (pos < max && state.src.charCodeAt(pos) === 0x3D/* = */) { pos++; } if (pos !== start + 2) { // sequence of 3+ markers taking as literal, same as in a emphasis state.pos += pos - start; if (!silent) { state.pending += state.src.slice(start, pos); } return true; } state.pos = start + 2; stack = 1; while (state.pos + 1 < max) { if (state.src.charCodeAt(state.pos) === 0x3D/* = */) { if (state.src.charCodeAt(state.pos + 1) === 0x3D/* = */) { lastChar = state.src.charCodeAt(state.pos - 1); nextChar = state.pos + 2 < max ? state.src.charCodeAt(state.pos + 2) : -1; if (nextChar !== 0x3D/* = */ && lastChar !== 0x3D/* = */) { if (lastChar !== 0x20 && lastChar !== 0x0A) { // closing '==' stack--; } else if (nextChar !== 0x20 && nextChar !== 0x0A) { // opening '==' stack++; } // else { // // standalone ' == ' indented with spaces // } if (stack <= 0) { found = true; break; } } } } state.parser.skipToken(state); } if (!found) { // parser failed to find ending tag, so it's not valid emphasis state.pos = start; return false; } // found! state.posMax = state.pos; state.pos = start + 2; if (!silent) { state.push({ type: 'mark_open', level: state.level++ }); state.parser.tokenize(state); state.push({ type: 'mark_close', level: --state.level }); } state.pos = state.posMax + 2; state.posMax = max; return true; }; },{}],55:[function(require,module,exports){ // Proceess '\n' 'use strict'; module.exports = function newline(state, silent) { var pmax, max, pos = state.pos; if (state.src.charCodeAt(pos) !== 0x0A/* \n */) { return false; } pmax = state.pending.length - 1; max = state.posMax; // ' \n' -> hardbreak // Lookup in pending chars is bad practice! Don't copy to other rules! // Pending string is stored in concat mode, indexed lookups will cause // convertion to flat mode. if (!silent) { if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) { if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) { // Strip out all trailing spaces on this line. for (var i = pmax - 2; i >= 0; i--) { if (state.pending.charCodeAt(i) !== 0x20) { state.pending = state.pending.substring(0, i + 1); break; } } state.push({ type: 'hardbreak', level: state.level }); } else { state.pending = state.pending.slice(0, -1); state.push({ type: 'softbreak', level: state.level }); } } else { state.push({ type: 'softbreak', level: state.level }); } } pos++; // skip heading spaces for next line while (pos < max && state.src.charCodeAt(pos) === 0x20) { pos++; } state.pos = pos; return true; }; },{}],56:[function(require,module,exports){ // Inline parser state 'use strict'; function StateInline(src, parserInline, options, env, outTokens) { this.src = src; this.env = env; this.options = options; this.parser = parserInline; this.tokens = outTokens; this.pos = 0; this.posMax = this.src.length; this.level = 0; this.pending = ''; this.pendingLevel = 0; this.cache = []; // Stores { start: end } pairs. Useful for backtrack // optimization of pairs parse (emphasis, strikes). // Link parser state vars this.isInLabel = false; // Set true when seek link label - we should disable // "paired" rules (emphasis, strikes) to not skip // tailing `]` this.linkLevel = 0; // Increment for each nesting link. Used to prevent // nesting in definitions this.linkContent = ''; // Temporary storage for link url this.labelUnmatchedScopes = 0; // Track unpaired `[` for link labels // (backtrack optimization) } // Flush pending text // StateInline.prototype.pushPending = function () { this.tokens.push({ type: 'text', content: this.pending, level: this.pendingLevel }); this.pending = ''; }; // Push new token to "stream". // If pending text exists - flush it as text token // StateInline.prototype.push = function (token) { if (this.pending) { this.pushPending(); } this.tokens.push(token); this.pendingLevel = this.level; }; // Store value to cache. // !!! Implementation has parser-specific optimizations // !!! keys MUST be integer, >= 0; values MUST be integer, > 0 // StateInline.prototype.cacheSet = function (key, val) { for (var i = this.cache.length; i <= key; i++) { this.cache.push(0); } this.cache[key] = val; }; // Get cache value // StateInline.prototype.cacheGet = function (key) { return key < this.cache.length ? this.cache[key] : 0; }; module.exports = StateInline; },{}],57:[function(require,module,exports){ // Process ~subscript~ 'use strict'; // same as UNESCAPE_MD_RE plus a space var UNESCAPE_RE = /\\([ \\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g; module.exports = function sub(state, silent) { var found, content, max = state.posMax, start = state.pos; if (state.src.charCodeAt(start) !== 0x7E/* ~ */) { return false; } if (silent) { return false; } // don't run any pairs in validation mode if (start + 2 >= max) { return false; } if (state.level >= state.options.maxNesting) { return false; } state.pos = start + 1; while (state.pos < max) { if (state.src.charCodeAt(state.pos) === 0x7E/* ~ */) { found = true; break; } state.parser.skipToken(state); } if (!found || start + 1 === state.pos) { state.pos = start; return false; } content = state.src.slice(start + 1, state.pos); // don't allow unescaped spaces/newlines inside if (content.match(/(^|[^\\])(\\\\)*\s/)) { state.pos = start; return false; } // found! state.posMax = state.pos; state.pos = start + 1; if (!silent) { state.push({ type: 'sub', level: state.level, content: content.replace(UNESCAPE_RE, '$1') }); } state.pos = state.posMax + 1; state.posMax = max; return true; }; },{}],58:[function(require,module,exports){ // Process ^superscript^ 'use strict'; // same as UNESCAPE_MD_RE plus a space var UNESCAPE_RE = /\\([ \\!"#$%&'()*+,.\/:;<=>?@[\]^_`{|}~-])/g; module.exports = function sup(state, silent) { var found, content, max = state.posMax, start = state.pos; if (state.src.charCodeAt(start) !== 0x5E/* ^ */) { return false; } if (silent) { return false; } // don't run any pairs in validation mode if (start + 2 >= max) { return false; } if (state.level >= state.options.maxNesting) { return false; } state.pos = start + 1; while (state.pos < max) { if (state.src.charCodeAt(state.pos) === 0x5E/* ^ */) { found = true; break; } state.parser.skipToken(state); } if (!found || start + 1 === state.pos) { state.pos = start; return false; } content = state.src.slice(start + 1, state.pos); // don't allow unescaped spaces/newlines inside if (content.match(/(^|[^\\])(\\\\)*\s/)) { state.pos = start; return false; } // found! state.posMax = state.pos; state.pos = start + 1; if (!silent) { state.push({ type: 'sup', level: state.level, content: content.replace(UNESCAPE_RE, '$1') }); } state.pos = state.posMax + 1; state.posMax = max; return true; }; },{}],59:[function(require,module,exports){ // Skip text characters for text token, place those to pending buffer // and increment current pos 'use strict'; // Rule to skip pure text // '{}$%@~+=:' reserved for extentions function isTerminatorChar(ch) { switch (ch) { case 0x0A/* \n */: case 0x5C/* \ */: case 0x60/* ` */: case 0x2A/* * */: case 0x5F/* _ */: case 0x5E/* ^ */: case 0x5B/* [ */: case 0x5D/* ] */: case 0x21/* ! */: case 0x26/* & */: case 0x3C/* < */: case 0x3E/* > */: case 0x7B/* { */: case 0x7D/* } */: case 0x24/* $ */: case 0x25/* % */: case 0x40/* @ */: case 0x7E/* ~ */: case 0x2B/* + */: case 0x3D/* = */: case 0x3A/* : */: return true; default: return false; } } module.exports = function text(state, silent) { var pos = state.pos; while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) { pos++; } if (pos === state.pos) { return false; } if (!silent) { state.pending += state.src.slice(state.pos, pos); } state.pos = pos; return true; }; },{}],60:[function(require,module,exports){ /*! * Autolinker.js * 0.28.1 * * Copyright(c) 2016 Gregory Jacobs * MIT License * * https://github.com/gregjacobs/Autolinker.js */ ;(function(root, factory) { if (typeof define === 'function' && define.amd) { define([], factory); } else if (typeof exports === 'object') { module.exports = factory(); } else { root.Autolinker = factory(); } }(this, function() { /** * @class Autolinker * @extends Object * * Utility class used to process a given string of text, and wrap the matches in * the appropriate anchor (<a>) tags to turn them into links. * * Any of the configuration options may be provided in an Object (map) provided * to the Autolinker constructor, which will configure how the {@link #link link()} * method will process the links. * * For example: * * var autolinker = new Autolinker( { * newWindow : false, * truncate : 30 * } ); * * var html = autolinker.link( "Joe went to www.yahoo.com" ); * // produces: 'Joe went to yahoo.com' * * * The {@link #static-link static link()} method may also be used to inline * options into a single call, which may be more convenient for one-off uses. * For example: * * var html = Autolinker.link( "Joe went to www.yahoo.com", { * newWindow : false, * truncate : 30 * } ); * // produces: 'Joe went to yahoo.com' * * * ## Custom Replacements of Links * * If the configuration options do not provide enough flexibility, a {@link #replaceFn} * may be provided to fully customize the output of Autolinker. This function is * called once for each URL/Email/Phone#/Twitter Handle/Hashtag match that is * encountered. * * For example: * * var input = "..."; // string with URLs, Email Addresses, Phone #s, Twitter Handles, and Hashtags * * var linkedText = Autolinker.link( input, { * replaceFn : function( autolinker, match ) { * console.log( "href = ", match.getAnchorHref() ); * console.log( "text = ", match.getAnchorText() ); * * switch( match.getType() ) { * case 'url' : * console.log( "url: ", match.getUrl() ); * * if( match.getUrl().indexOf( 'mysite.com' ) === -1 ) { * var tag = autolinker.getTagBuilder().build( match ); // returns an `Autolinker.HtmlTag` instance, which provides mutator methods for easy changes * tag.setAttr( 'rel', 'nofollow' ); * tag.addClass( 'external-link' ); * * return tag; * * } else { * return true; // let Autolinker perform its normal anchor tag replacement * } * * case 'email' : * var email = match.getEmail(); * console.log( "email: ", email ); * * if( email === "my@own.address" ) { * return false; // don't auto-link this particular email address; leave as-is * } else { * return; // no return value will have Autolinker perform its normal anchor tag replacement (same as returning `true`) * } * * case 'phone' : * var phoneNumber = match.getPhoneNumber(); * console.log( phoneNumber ); * * return '' + phoneNumber + ''; * * case 'twitter' : * var twitterHandle = match.getTwitterHandle(); * console.log( twitterHandle ); * * return '' + twitterHandle + ''; * * case 'hashtag' : * var hashtag = match.getHashtag(); * console.log( hashtag ); * * return '' + hashtag + ''; * } * } * } ); * * * The function may return the following values: * * - `true` (Boolean): Allow Autolinker to replace the match as it normally * would. * - `false` (Boolean): Do not replace the current match at all - leave as-is. * - Any String: If a string is returned from the function, the string will be * used directly as the replacement HTML for the match. * - An {@link Autolinker.HtmlTag} instance, which can be used to build/modify * an HTML tag before writing out its HTML text. * * @constructor * @param {Object} [cfg] The configuration options for the Autolinker instance, * specified in an Object (map). */ var Autolinker = function( cfg ) { cfg = cfg || {}; this.version = Autolinker.version; this.urls = this.normalizeUrlsCfg( cfg.urls ); this.email = typeof cfg.email === 'boolean' ? cfg.email : true; this.twitter = typeof cfg.twitter === 'boolean' ? cfg.twitter : true; this.phone = typeof cfg.phone === 'boolean' ? cfg.phone : true; this.hashtag = cfg.hashtag || false; this.newWindow = typeof cfg.newWindow === 'boolean' ? cfg.newWindow : true; this.stripPrefix = typeof cfg.stripPrefix === 'boolean' ? cfg.stripPrefix : true; // Validate the value of the `hashtag` cfg. var hashtag = this.hashtag; if( hashtag !== false && hashtag !== 'twitter' && hashtag !== 'facebook' && hashtag !== 'instagram' ) { throw new Error( "invalid `hashtag` cfg - see docs" ); } this.truncate = this.normalizeTruncateCfg( cfg.truncate ); this.className = cfg.className || ''; this.replaceFn = cfg.replaceFn || null; this.htmlParser = null; this.matchers = null; this.tagBuilder = null; }; /** * Automatically links URLs, Email addresses, Phone Numbers, Twitter handles, * and Hashtags found in the given chunk of HTML. Does not link URLs found * within HTML tags. * * For instance, if given the text: `You should go to http://www.yahoo.com`, * then the result will be `You should go to <a href="http://www.yahoo.com">http://www.yahoo.com</a>` * * Example: * * var linkedText = Autolinker.link( "Go to google.com", { newWindow: false } ); * // Produces: "Go to google.com" * * @static * @param {String} textOrHtml The HTML or text to find matches within (depending * on if the {@link #urls}, {@link #email}, {@link #phone}, {@link #twitter}, * and {@link #hashtag} options are enabled). * @param {Object} [options] Any of the configuration options for the Autolinker * class, specified in an Object (map). See the class description for an * example call. * @return {String} The HTML text, with matches automatically linked. */ Autolinker.link = function( textOrHtml, options ) { var autolinker = new Autolinker( options ); return autolinker.link( textOrHtml ); }; /** * @static * @property {String} version (readonly) * * The Autolinker version number in the form major.minor.patch * * Ex: 0.25.1 */ Autolinker.version = '0.28.1'; Autolinker.prototype = { constructor : Autolinker, // fix constructor property /** * @cfg {Boolean/Object} [urls=true] * * `true` if URLs should be automatically linked, `false` if they should not * be. * * This option also accepts an Object form with 3 properties, to allow for * more customization of what exactly gets linked. All default to `true`: * * @param {Boolean} schemeMatches `true` to match URLs found prefixed with a * scheme, i.e. `http://google.com`, or `other+scheme://google.com`, * `false` to prevent these types of matches. * @param {Boolean} wwwMatches `true` to match urls found prefixed with * `'www.'`, i.e. `www.google.com`. `false` to prevent these types of * matches. Note that if the URL had a prefixed scheme, and * `schemeMatches` is true, it will still be linked. * @param {Boolean} tldMatches `true` to match URLs with known top level * domains (.com, .net, etc.) that are not prefixed with a scheme or * `'www.'`. This option attempts to match anything that looks like a URL * in the given text. Ex: `google.com`, `asdf.org/?page=1`, etc. `false` * to prevent these types of matches. */ /** * @cfg {Boolean} [email=true] * * `true` if email addresses should be automatically linked, `false` if they * should not be. */ /** * @cfg {Boolean} [twitter=true] * * `true` if Twitter handles ("@example") should be automatically linked, * `false` if they should not be. */ /** * @cfg {Boolean} [phone=true] * * `true` if Phone numbers ("(555)555-5555") should be automatically linked, * `false` if they should not be. */ /** * @cfg {Boolean/String} [hashtag=false] * * A string for the service name to have hashtags (ex: "#myHashtag") * auto-linked to. The currently-supported values are: * * - 'twitter' * - 'facebook' * - 'instagram' * * Pass `false` to skip auto-linking of hashtags. */ /** * @cfg {Boolean} [newWindow=true] * * `true` if the links should open in a new window, `false` otherwise. */ /** * @cfg {Boolean} [stripPrefix=true] * * `true` if 'http://' or 'https://' and/or the 'www.' should be stripped * from the beginning of URL links' text, `false` otherwise. */ /** * @cfg {Number/Object} [truncate=0] * * ## Number Form * * A number for how many characters matched text should be truncated to * inside the text of a link. If the matched text is over this number of * characters, it will be truncated to this length by adding a two period * ellipsis ('..') to the end of the string. * * For example: A url like 'http://www.yahoo.com/some/long/path/to/a/file' * truncated to 25 characters might look something like this: * 'yahoo.com/some/long/pat..' * * Example Usage: * * truncate: 25 * * * Defaults to `0` for "no truncation." * * * ## Object Form * * An Object may also be provided with two properties: `length` (Number) and * `location` (String). `location` may be one of the following: 'end' * (default), 'middle', or 'smart'. * * Example Usage: * * truncate: { length: 25, location: 'middle' } * * @cfg {Number} [truncate.length=0] How many characters to allow before * truncation will occur. Defaults to `0` for "no truncation." * @cfg {"end"/"middle"/"smart"} [truncate.location="end"] * * - 'end' (default): will truncate up to the number of characters, and then * add an ellipsis at the end. Ex: 'yahoo.com/some/long/pat..' * - 'middle': will truncate and add the ellipsis in the middle. Ex: * 'yahoo.com/s..th/to/a/file' * - 'smart': for URLs where the algorithm attempts to strip out unnecessary * parts first (such as the 'www.', then URL scheme, hash, etc.), * attempting to make the URL human-readable before looking for a good * point to insert the ellipsis if it is still too long. Ex: * 'yahoo.com/some..to/a/file'. For more details, see * {@link Autolinker.truncate.TruncateSmart}. */ /** * @cfg {String} className * * A CSS class name to add to the generated links. This class will be added * to all links, as well as this class plus match suffixes for styling * url/email/phone/twitter/hashtag links differently. * * For example, if this config is provided as "myLink", then: * * - URL links will have the CSS classes: "myLink myLink-url" * - Email links will have the CSS classes: "myLink myLink-email", and * - Twitter links will have the CSS classes: "myLink myLink-twitter" * - Phone links will have the CSS classes: "myLink myLink-phone" * - Hashtag links will have the CSS classes: "myLink myLink-hashtag" */ /** * @cfg {Function} replaceFn * * A function to individually process each match found in the input string. * * See the class's description for usage. * * This function is called with the following parameters: * * @cfg {Autolinker} replaceFn.autolinker The Autolinker instance, which may * be used to retrieve child objects from (such as the instance's * {@link #getTagBuilder tag builder}). * @cfg {Autolinker.match.Match} replaceFn.match The Match instance which * can be used to retrieve information about the match that the `replaceFn` * is currently processing. See {@link Autolinker.match.Match} subclasses * for details. */ /** * @property {String} version (readonly) * * The Autolinker version number in the form major.minor.patch * * Ex: 0.25.1 */ /** * @private * @property {Autolinker.htmlParser.HtmlParser} htmlParser * * The HtmlParser instance used to skip over HTML tags, while finding text * nodes to process. This is lazily instantiated in the {@link #getHtmlParser} * method. */ /** * @private * @property {Autolinker.matcher.Matcher[]} matchers * * The {@link Autolinker.matcher.Matcher} instances for this Autolinker * instance. * * This is lazily created in {@link #getMatchers}. */ /** * @private * @property {Autolinker.AnchorTagBuilder} tagBuilder * * The AnchorTagBuilder instance used to build match replacement anchor tags. * Note: this is lazily instantiated in the {@link #getTagBuilder} method. */ /** * Normalizes the {@link #urls} config into an Object with 3 properties: * `schemeMatches`, `wwwMatches`, and `tldMatches`, all Booleans. * * See {@link #urls} config for details. * * @private * @param {Boolean/Object} urls * @return {Object} */ normalizeUrlsCfg : function( urls ) { if( urls == null ) urls = true; // default to `true` if( typeof urls === 'boolean' ) { return { schemeMatches: urls, wwwMatches: urls, tldMatches: urls }; } else { // object form return { schemeMatches : typeof urls.schemeMatches === 'boolean' ? urls.schemeMatches : true, wwwMatches : typeof urls.wwwMatches === 'boolean' ? urls.wwwMatches : true, tldMatches : typeof urls.tldMatches === 'boolean' ? urls.tldMatches : true }; } }, /** * Normalizes the {@link #truncate} config into an Object with 2 properties: * `length` (Number), and `location` (String). * * See {@link #truncate} config for details. * * @private * @param {Number/Object} truncate * @return {Object} */ normalizeTruncateCfg : function( truncate ) { if( typeof truncate === 'number' ) { return { length: truncate, location: 'end' }; } else { // object, or undefined/null return Autolinker.Util.defaults( truncate || {}, { length : Number.POSITIVE_INFINITY, location : 'end' } ); } }, /** * Parses the input `textOrHtml` looking for URLs, email addresses, phone * numbers, username handles, and hashtags (depending on the configuration * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match} * objects describing those matches. * * This method is used by the {@link #link} method, but can also be used to * simply do parsing of the input in order to discover what kinds of links * there are and how many. * * @param {String} textOrHtml The HTML or text to find matches within * (depending on if the {@link #urls}, {@link #email}, {@link #phone}, * {@link #twitter}, and {@link #hashtag} options are enabled). * @return {Autolinker.match.Match[]} The array of Matches found in the * given input `textOrHtml`. */ parse : function( textOrHtml ) { var htmlParser = this.getHtmlParser(), htmlNodes = htmlParser.parse( textOrHtml ), anchorTagStackCount = 0, // used to only process text around anchor tags, and any inner text/html they may have; matches = []; // Find all matches within the `textOrHtml` (but not matches that are // already nested within tags) for( var i = 0, len = htmlNodes.length; i < len; i++ ) { var node = htmlNodes[ i ], nodeType = node.getType(); if( nodeType === 'element' && node.getTagName() === 'a' ) { // Process HTML anchor element nodes in the input `textOrHtml` to find out when we're within an tag if( !node.isClosing() ) { // it's the start tag anchorTagStackCount++; } else { // it's the end tag anchorTagStackCount = Math.max( anchorTagStackCount - 1, 0 ); // attempt to handle extraneous tags by making sure the stack count never goes below 0 } } else if( nodeType === 'text' && anchorTagStackCount === 0 ) { // Process text nodes that are not within an tag var textNodeMatches = this.parseText( node.getText(), node.getOffset() ); matches.push.apply( matches, textNodeMatches ); } } // After we have found all matches, remove subsequent matches that // overlap with a previous match. This can happen for instance with URLs, // where the url 'google.com/#link' would match '#link' as a hashtag. matches = this.compactMatches( matches ); // And finally, remove matches for match types that have been turned // off. We needed to have all match types turned on initially so that // things like hashtags could be filtered out if they were really just // part of a URL match (for instance, as a named anchor). matches = this.removeUnwantedMatches( matches ); return matches; }, /** * After we have found all matches, we need to remove subsequent matches * that overlap with a previous match. This can happen for instance with * URLs, where the url 'google.com/#link' would match '#link' as a hashtag. * * @private * @param {Autolinker.match.Match[]} matches * @return {Autolinker.match.Match[]} */ compactMatches : function( matches ) { // First, the matches need to be sorted in order of offset matches.sort( function( a, b ) { return a.getOffset() - b.getOffset(); } ); for( var i = 0; i < matches.length - 1; i++ ) { var match = matches[ i ], endIdx = match.getOffset() + match.getMatchedText().length; // Remove subsequent matches that overlap with the current match while( i + 1 < matches.length && matches[ i + 1 ].getOffset() <= endIdx ) { matches.splice( i + 1, 1 ); } } return matches; }, /** * Removes matches for matchers that were turned off in the options. For * example, if {@link #hashtag hashtags} were not to be matched, we'll * remove them from the `matches` array here. * * @private * @param {Autolinker.match.Match[]} matches The array of matches to remove * the unwanted matches from. Note: this array is mutated for the * removals. * @return {Autolinker.match.Match[]} The mutated input `matches` array. */ removeUnwantedMatches : function( matches ) { var remove = Autolinker.Util.remove; if( !this.hashtag ) remove( matches, function( match ) { return match.getType() === 'hashtag'; } ); if( !this.email ) remove( matches, function( match ) { return match.getType() === 'email'; } ); if( !this.phone ) remove( matches, function( match ) { return match.getType() === 'phone'; } ); if( !this.twitter ) remove( matches, function( match ) { return match.getType() === 'twitter'; } ); if( !this.urls.schemeMatches ) { remove( matches, function( m ) { return m.getType() === 'url' && m.getUrlMatchType() === 'scheme'; } ); } if( !this.urls.wwwMatches ) { remove( matches, function( m ) { return m.getType() === 'url' && m.getUrlMatchType() === 'www'; } ); } if( !this.urls.tldMatches ) { remove( matches, function( m ) { return m.getType() === 'url' && m.getUrlMatchType() === 'tld'; } ); } return matches; }, /** * Parses the input `text` looking for URLs, email addresses, phone * numbers, username handles, and hashtags (depending on the configuration * of the Autolinker instance), and returns an array of {@link Autolinker.match.Match} * objects describing those matches. * * This method processes a **non-HTML string**, and is used to parse and * match within the text nodes of an HTML string. This method is used * internally by {@link #parse}. * * @private * @param {String} text The text to find matches within (depending on if the * {@link #urls}, {@link #email}, {@link #phone}, {@link #twitter}, and * {@link #hashtag} options are enabled). This must be a non-HTML string. * @param {Number} [offset=0] The offset of the text node within the * original string. This is used when parsing with the {@link #parse} * method to generate correct offsets within the {@link Autolinker.match.Match} * instances, but may be omitted if calling this method publicly. * @return {Autolinker.match.Match[]} The array of Matches found in the * given input `text`. */ parseText : function( text, offset ) { offset = offset || 0; var matchers = this.getMatchers(), matches = []; for( var i = 0, numMatchers = matchers.length; i < numMatchers; i++ ) { var textMatches = matchers[ i ].parseMatches( text ); // Correct the offset of each of the matches. They are originally // the offset of the match within the provided text node, but we // need to correct them to be relative to the original HTML input // string (i.e. the one provided to #parse). for( var j = 0, numTextMatches = textMatches.length; j < numTextMatches; j++ ) { textMatches[ j ].setOffset( offset + textMatches[ j ].getOffset() ); } matches.push.apply( matches, textMatches ); } return matches; }, /** * Automatically links URLs, Email addresses, Phone numbers, Twitter * handles, and Hashtags found in the given chunk of HTML. Does not link * URLs found within HTML tags. * * For instance, if given the text: `You should go to http://www.yahoo.com`, * then the result will be `You should go to * <a href="http://www.yahoo.com">http://www.yahoo.com</a>` * * This method finds the text around any HTML elements in the input * `textOrHtml`, which will be the text that is processed. Any original HTML * elements will be left as-is, as well as the text that is already wrapped * in anchor (<a>) tags. * * @param {String} textOrHtml The HTML or text to autolink matches within * (depending on if the {@link #urls}, {@link #email}, {@link #phone}, * {@link #twitter}, and {@link #hashtag} options are enabled). * @return {String} The HTML, with matches automatically linked. */ link : function( textOrHtml ) { if( !textOrHtml ) { return ""; } // handle `null` and `undefined` var matches = this.parse( textOrHtml ), newHtml = [], lastIndex = 0; for( var i = 0, len = matches.length; i < len; i++ ) { var match = matches[ i ]; newHtml.push( textOrHtml.substring( lastIndex, match.getOffset() ) ); newHtml.push( this.createMatchReturnVal( match ) ); lastIndex = match.getOffset() + match.getMatchedText().length; } newHtml.push( textOrHtml.substring( lastIndex ) ); // handle the text after the last match return newHtml.join( '' ); }, /** * Creates the return string value for a given match in the input string. * * This method handles the {@link #replaceFn}, if one was provided. * * @private * @param {Autolinker.match.Match} match The Match object that represents * the match. * @return {String} The string that the `match` should be replaced with. * This is usually the anchor tag string, but may be the `matchStr` itself * if the match is not to be replaced. */ createMatchReturnVal : function( match ) { // Handle a custom `replaceFn` being provided var replaceFnResult; if( this.replaceFn ) { replaceFnResult = this.replaceFn.call( this, this, match ); // Autolinker instance is the context, and the first arg } if( typeof replaceFnResult === 'string' ) { return replaceFnResult; // `replaceFn` returned a string, use that } else if( replaceFnResult === false ) { return match.getMatchedText(); // no replacement for the match } else if( replaceFnResult instanceof Autolinker.HtmlTag ) { return replaceFnResult.toAnchorString(); } else { // replaceFnResult === true, or no/unknown return value from function // Perform Autolinker's default anchor tag generation var anchorTag = match.buildTag(); // returns an Autolinker.HtmlTag instance return anchorTag.toAnchorString(); } }, /** * Lazily instantiates and returns the {@link #htmlParser} instance for this * Autolinker instance. * * @protected * @return {Autolinker.htmlParser.HtmlParser} */ getHtmlParser : function() { var htmlParser = this.htmlParser; if( !htmlParser ) { htmlParser = this.htmlParser = new Autolinker.htmlParser.HtmlParser(); } return htmlParser; }, /** * Lazily instantiates and returns the {@link Autolinker.matcher.Matcher} * instances for this Autolinker instance. * * @protected * @return {Autolinker.matcher.Matcher[]} */ getMatchers : function() { if( !this.matchers ) { var matchersNs = Autolinker.matcher, tagBuilder = this.getTagBuilder(); var matchers = [ new matchersNs.Hashtag( { tagBuilder: tagBuilder, serviceName: this.hashtag } ), new matchersNs.Email( { tagBuilder: tagBuilder } ), new matchersNs.Phone( { tagBuilder: tagBuilder } ), new matchersNs.Twitter( { tagBuilder: tagBuilder } ), new matchersNs.Url( { tagBuilder: tagBuilder, stripPrefix: this.stripPrefix } ) ]; return ( this.matchers = matchers ); } else { return this.matchers; } }, /** * Returns the {@link #tagBuilder} instance for this Autolinker instance, lazily instantiating it * if it does not yet exist. * * This method may be used in a {@link #replaceFn} to generate the {@link Autolinker.HtmlTag HtmlTag} instance that * Autolinker would normally generate, and then allow for modifications before returning it. For example: * * var html = Autolinker.link( "Test google.com", { * replaceFn : function( autolinker, match ) { * var tag = autolinker.getTagBuilder().build( match ); // returns an {@link Autolinker.HtmlTag} instance * tag.setAttr( 'rel', 'nofollow' ); * * return tag; * } * } ); * * // generated html: * // Test google.com * * @return {Autolinker.AnchorTagBuilder} */ getTagBuilder : function() { var tagBuilder = this.tagBuilder; if( !tagBuilder ) { tagBuilder = this.tagBuilder = new Autolinker.AnchorTagBuilder( { newWindow : this.newWindow, truncate : this.truncate, className : this.className } ); } return tagBuilder; } }; // Autolinker Namespaces Autolinker.match = {}; Autolinker.matcher = {}; Autolinker.htmlParser = {}; Autolinker.truncate = {}; /*global Autolinker */ /*jshint eqnull:true, boss:true */ /** * @class Autolinker.Util * @singleton * * A few utility methods for Autolinker. */ Autolinker.Util = { /** * @property {Function} abstractMethod * * A function object which represents an abstract method. */ abstractMethod : function() { throw "abstract"; }, /** * @private * @property {RegExp} trimRegex * * The regular expression used to trim the leading and trailing whitespace * from a string. */ trimRegex : /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, /** * Assigns (shallow copies) the properties of `src` onto `dest`. * * @param {Object} dest The destination object. * @param {Object} src The source object. * @return {Object} The destination object (`dest`) */ assign : function( dest, src ) { for( var prop in src ) { if( src.hasOwnProperty( prop ) ) { dest[ prop ] = src[ prop ]; } } return dest; }, /** * Assigns (shallow copies) the properties of `src` onto `dest`, if the * corresponding property on `dest` === `undefined`. * * @param {Object} dest The destination object. * @param {Object} src The source object. * @return {Object} The destination object (`dest`) */ defaults : function( dest, src ) { for( var prop in src ) { if( src.hasOwnProperty( prop ) && dest[ prop ] === undefined ) { dest[ prop ] = src[ prop ]; } } return dest; }, /** * Extends `superclass` to create a new subclass, adding the `protoProps` to the new subclass's prototype. * * @param {Function} superclass The constructor function for the superclass. * @param {Object} protoProps The methods/properties to add to the subclass's prototype. This may contain the * special property `constructor`, which will be used as the new subclass's constructor function. * @return {Function} The new subclass function. */ extend : function( superclass, protoProps ) { var superclassProto = superclass.prototype; var F = function() {}; F.prototype = superclassProto; var subclass; if( protoProps.hasOwnProperty( 'constructor' ) ) { subclass = protoProps.constructor; } else { subclass = function() { superclassProto.constructor.apply( this, arguments ); }; } var subclassProto = subclass.prototype = new F(); // set up prototype chain subclassProto.constructor = subclass; // fix constructor property subclassProto.superclass = superclassProto; delete protoProps.constructor; // don't re-assign constructor property to the prototype, since a new function may have been created (`subclass`), which is now already there Autolinker.Util.assign( subclassProto, protoProps ); return subclass; }, /** * Truncates the `str` at `len - ellipsisChars.length`, and adds the `ellipsisChars` to the * end of the string (by default, two periods: '..'). If the `str` length does not exceed * `len`, the string will be returned unchanged. * * @param {String} str The string to truncate and add an ellipsis to. * @param {Number} truncateLen The length to truncate the string at. * @param {String} [ellipsisChars=..] The ellipsis character(s) to add to the end of `str` * when truncated. Defaults to '..' */ ellipsis : function( str, truncateLen, ellipsisChars ) { if( str.length > truncateLen ) { ellipsisChars = ( ellipsisChars == null ) ? '..' : ellipsisChars; str = str.substring( 0, truncateLen - ellipsisChars.length ) + ellipsisChars; } return str; }, /** * Supports `Array.prototype.indexOf()` functionality for old IE (IE8 and below). * * @param {Array} arr The array to find an element of. * @param {*} element The element to find in the array, and return the index of. * @return {Number} The index of the `element`, or -1 if it was not found. */ indexOf : function( arr, element ) { if( Array.prototype.indexOf ) { return arr.indexOf( element ); } else { for( var i = 0, len = arr.length; i < len; i++ ) { if( arr[ i ] === element ) return i; } return -1; } }, /** * Removes array elements based on a filtering function. Mutates the input * array. * * Using this instead of the ES5 Array.prototype.filter() function, to allow * Autolinker compatibility with IE8, and also to prevent creating many new * arrays in memory for filtering. * * @param {Array} arr The array to remove elements from. This array is * mutated. * @param {Function} fn A function which should return `true` to * remove an element. * @return {Array} The mutated input `arr`. */ remove : function( arr, fn ) { for( var i = arr.length - 1; i >= 0; i-- ) { if( fn( arr[ i ] ) === true ) { arr.splice( i, 1 ); } } }, /** * Performs the functionality of what modern browsers do when `String.prototype.split()` is called * with a regular expression that contains capturing parenthesis. * * For example: * * // Modern browsers: * "a,b,c".split( /(,)/ ); // --> [ 'a', ',', 'b', ',', 'c' ] * * // Old IE (including IE8): * "a,b,c".split( /(,)/ ); // --> [ 'a', 'b', 'c' ] * * This method emulates the functionality of modern browsers for the old IE case. * * @param {String} str The string to split. * @param {RegExp} splitRegex The regular expression to split the input `str` on. The splitting * character(s) will be spliced into the array, as in the "modern browsers" example in the * description of this method. * Note #1: the supplied regular expression **must** have the 'g' flag specified. * Note #2: for simplicity's sake, the regular expression does not need * to contain capturing parenthesis - it will be assumed that any match has them. * @return {String[]} The split array of strings, with the splitting character(s) included. */ splitAndCapture : function( str, splitRegex ) { if( !splitRegex.global ) throw new Error( "`splitRegex` must have the 'g' flag set" ); var result = [], lastIdx = 0, match; while( match = splitRegex.exec( str ) ) { result.push( str.substring( lastIdx, match.index ) ); result.push( match[ 0 ] ); // push the splitting char(s) lastIdx = match.index + match[ 0 ].length; } result.push( str.substring( lastIdx ) ); return result; }, /** * Trims the leading and trailing whitespace from a string. * * @param {String} str The string to trim. * @return {String} */ trim : function( str ) { return str.replace( this.trimRegex, '' ); } }; /*global Autolinker */ /*jshint boss:true */ /** * @class Autolinker.HtmlTag * @extends Object * * Represents an HTML tag, which can be used to easily build/modify HTML tags programmatically. * * Autolinker uses this abstraction to create HTML tags, and then write them out as strings. You may also use * this class in your code, especially within a {@link Autolinker#replaceFn replaceFn}. * * ## Examples * * Example instantiation: * * var tag = new Autolinker.HtmlTag( { * tagName : 'a', * attrs : { 'href': 'http://google.com', 'class': 'external-link' }, * innerHtml : 'Google' * } ); * * tag.toAnchorString(); // Google * * // Individual accessor methods * tag.getTagName(); // 'a' * tag.getAttr( 'href' ); // 'http://google.com' * tag.hasClass( 'external-link' ); // true * * * Using mutator methods (which may be used in combination with instantiation config properties): * * var tag = new Autolinker.HtmlTag(); * tag.setTagName( 'a' ); * tag.setAttr( 'href', 'http://google.com' ); * tag.addClass( 'external-link' ); * tag.setInnerHtml( 'Google' ); * * tag.getTagName(); // 'a' * tag.getAttr( 'href' ); // 'http://google.com' * tag.hasClass( 'external-link' ); // true * * tag.toAnchorString(); // Google * * * ## Example use within a {@link Autolinker#replaceFn replaceFn} * * var html = Autolinker.link( "Test google.com", { * replaceFn : function( autolinker, match ) { * var tag = match.buildTag(); // returns an {@link Autolinker.HtmlTag} instance, configured with the Match's href and anchor text * tag.setAttr( 'rel', 'nofollow' ); * * return tag; * } * } ); * * // generated html: * // Test google.com * * * ## Example use with a new tag for the replacement * * var html = Autolinker.link( "Test google.com", { * replaceFn : function( autolinker, match ) { * var tag = new Autolinker.HtmlTag( { * tagName : 'button', * attrs : { 'title': 'Load URL: ' + match.getAnchorHref() }, * innerHtml : 'Load URL: ' + match.getAnchorText() * } ); * * return tag; * } * } ); * * // generated html: * // Test */ Autolinker.HtmlTag = Autolinker.Util.extend( Object, { /** * @cfg {String} tagName * * The tag name. Ex: 'a', 'button', etc. * * Not required at instantiation time, but should be set using {@link #setTagName} before {@link #toAnchorString} * is executed. */ /** * @cfg {Object.} attrs * * An key/value Object (map) of attributes to create the tag with. The keys are the attribute names, and the * values are the attribute values. */ /** * @cfg {String} innerHtml * * The inner HTML for the tag. * * Note the camel case name on `innerHtml`. Acronyms are camelCased in this utility (such as not to run into the acronym * naming inconsistency that the DOM developers created with `XMLHttpRequest`). You may alternatively use {@link #innerHTML} * if you prefer, but this one is recommended. */ /** * @cfg {String} innerHTML * * Alias of {@link #innerHtml}, accepted for consistency with the browser DOM api, but prefer the camelCased version * for acronym names. */ /** * @protected * @property {RegExp} whitespaceRegex * * Regular expression used to match whitespace in a string of CSS classes. */ whitespaceRegex : /\s+/, /** * @constructor * @param {Object} [cfg] The configuration properties for this class, in an Object (map) */ constructor : function( cfg ) { Autolinker.Util.assign( this, cfg ); this.innerHtml = this.innerHtml || this.innerHTML; // accept either the camelCased form or the fully capitalized acronym }, /** * Sets the tag name that will be used to generate the tag with. * * @param {String} tagName * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ setTagName : function( tagName ) { this.tagName = tagName; return this; }, /** * Retrieves the tag name. * * @return {String} */ getTagName : function() { return this.tagName || ""; }, /** * Sets an attribute on the HtmlTag. * * @param {String} attrName The attribute name to set. * @param {String} attrValue The attribute value to set. * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ setAttr : function( attrName, attrValue ) { var tagAttrs = this.getAttrs(); tagAttrs[ attrName ] = attrValue; return this; }, /** * Retrieves an attribute from the HtmlTag. If the attribute does not exist, returns `undefined`. * * @param {String} attrName The attribute name to retrieve. * @return {String} The attribute's value, or `undefined` if it does not exist on the HtmlTag. */ getAttr : function( attrName ) { return this.getAttrs()[ attrName ]; }, /** * Sets one or more attributes on the HtmlTag. * * @param {Object.} attrs A key/value Object (map) of the attributes to set. * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ setAttrs : function( attrs ) { var tagAttrs = this.getAttrs(); Autolinker.Util.assign( tagAttrs, attrs ); return this; }, /** * Retrieves the attributes Object (map) for the HtmlTag. * * @return {Object.} A key/value object of the attributes for the HtmlTag. */ getAttrs : function() { return this.attrs || ( this.attrs = {} ); }, /** * Sets the provided `cssClass`, overwriting any current CSS classes on the HtmlTag. * * @param {String} cssClass One or more space-separated CSS classes to set (overwrite). * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ setClass : function( cssClass ) { return this.setAttr( 'class', cssClass ); }, /** * Convenience method to add one or more CSS classes to the HtmlTag. Will not add duplicate CSS classes. * * @param {String} cssClass One or more space-separated CSS classes to add. * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ addClass : function( cssClass ) { var classAttr = this.getClass(), whitespaceRegex = this.whitespaceRegex, indexOf = Autolinker.Util.indexOf, // to support IE8 and below classes = ( !classAttr ) ? [] : classAttr.split( whitespaceRegex ), newClasses = cssClass.split( whitespaceRegex ), newClass; while( newClass = newClasses.shift() ) { if( indexOf( classes, newClass ) === -1 ) { classes.push( newClass ); } } this.getAttrs()[ 'class' ] = classes.join( " " ); return this; }, /** * Convenience method to remove one or more CSS classes from the HtmlTag. * * @param {String} cssClass One or more space-separated CSS classes to remove. * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ removeClass : function( cssClass ) { var classAttr = this.getClass(), whitespaceRegex = this.whitespaceRegex, indexOf = Autolinker.Util.indexOf, // to support IE8 and below classes = ( !classAttr ) ? [] : classAttr.split( whitespaceRegex ), removeClasses = cssClass.split( whitespaceRegex ), removeClass; while( classes.length && ( removeClass = removeClasses.shift() ) ) { var idx = indexOf( classes, removeClass ); if( idx !== -1 ) { classes.splice( idx, 1 ); } } this.getAttrs()[ 'class' ] = classes.join( " " ); return this; }, /** * Convenience method to retrieve the CSS class(es) for the HtmlTag, which will each be separated by spaces when * there are multiple. * * @return {String} */ getClass : function() { return this.getAttrs()[ 'class' ] || ""; }, /** * Convenience method to check if the tag has a CSS class or not. * * @param {String} cssClass The CSS class to check for. * @return {Boolean} `true` if the HtmlTag has the CSS class, `false` otherwise. */ hasClass : function( cssClass ) { return ( ' ' + this.getClass() + ' ' ).indexOf( ' ' + cssClass + ' ' ) !== -1; }, /** * Sets the inner HTML for the tag. * * @param {String} html The inner HTML to set. * @return {Autolinker.HtmlTag} This HtmlTag instance, so that method calls may be chained. */ setInnerHtml : function( html ) { this.innerHtml = html; return this; }, /** * Retrieves the inner HTML for the tag. * * @return {String} */ getInnerHtml : function() { return this.innerHtml || ""; }, /** * Override of superclass method used to generate the HTML string for the tag. * * @return {String} */ toAnchorString : function() { var tagName = this.getTagName(), attrsStr = this.buildAttrsStr(); attrsStr = ( attrsStr ) ? ' ' + attrsStr : ''; // prepend a space if there are actually attributes return [ '<', tagName, attrsStr, '>', this.getInnerHtml(), '' ].join( "" ); }, /** * Support method for {@link #toAnchorString}, returns the string space-separated key="value" pairs, used to populate * the stringified HtmlTag. * * @protected * @return {String} Example return: `attr1="value1" attr2="value2"` */ buildAttrsStr : function() { if( !this.attrs ) return ""; // no `attrs` Object (map) has been set, return empty string var attrs = this.getAttrs(), attrsArr = []; for( var prop in attrs ) { if( attrs.hasOwnProperty( prop ) ) { attrsArr.push( prop + '="' + attrs[ prop ] + '"' ); } } return attrsArr.join( " " ); } } ); /*global Autolinker */ /** * @class Autolinker.RegexLib * @singleton * * Builds and stores a library of the common regular expressions used by the * Autolinker utility. * * Other regular expressions may exist ad-hoc, but these are generally the * regular expressions that are shared between source files. */ Autolinker.RegexLib = (function() { /** * The string form of a regular expression that would match all of the * alphabetic ("letter") chars in the unicode character set when placed in a * RegExp character class (`[]`). This includes all international alphabetic * characters. * * These would be the characters matched by unicode regex engines `\p{L}` * escape ("all letters"). * * Taken from the XRegExp library: http://xregexp.com/ * Specifically: http://xregexp.com/v/3.0.0/unicode-categories.js * * @private * @type {String} */ var alphaCharsStr = 'A-Za-z\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC'; /** * The string form of a regular expression that would match all of the * decimal number chars in the unicode character set when placed in a RegExp * character class (`[]`). * * These would be the characters matched by unicode regex engines `\p{Nd}` * escape ("all decimal numbers") * * Taken from the XRegExp library: http://xregexp.com/ * Specifically: http://xregexp.com/v/3.0.0/unicode-categories.js * * @private * @type {String} */ var decimalNumbersStr = '0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19'; // See documentation below var alphaNumericCharsStr = alphaCharsStr + decimalNumbersStr; // See documentation below var domainNameRegex = new RegExp( '[' + alphaNumericCharsStr + '.\\-]*[' + alphaNumericCharsStr + '\\-]' ); // See documentation below var tldRegex = /(?:travelersinsurance|sandvikcoromant|kerryproperties|cancerresearch|weatherchannel|kerrylogistics|spreadbetting|international|wolterskluwer|lifeinsurance|construction|pamperedchef|scholarships|versicherung|bridgestone|creditunion|kerryhotels|investments|productions|blackfriday|enterprises|lamborghini|photography|motorcycles|williamhill|playstation|contractors|barclaycard|accountants|redumbrella|engineering|management|telefonica|protection|consulting|tatamotors|creditcard|vlaanderen|schaeffler|associates|properties|foundation|republican|bnpparibas|boehringer|eurovision|extraspace|industries|immobilien|university|technology|volkswagen|healthcare|restaurant|cuisinella|vistaprint|apartments|accountant|travelers|homedepot|institute|vacations|furniture|fresenius|insurance|christmas|bloomberg|solutions|barcelona|firestone|financial|kuokgroup|fairwinds|community|passagens|goldpoint|equipment|lifestyle|yodobashi|aquarelle|marketing|analytics|education|amsterdam|statefarm|melbourne|allfinanz|directory|microsoft|stockholm|montblanc|accenture|lancaster|landrover|everbank|istanbul|graphics|grainger|ipiranga|softbank|attorney|pharmacy|saarland|catering|airforce|yokohama|mortgage|frontier|mutuelle|stcgroup|memorial|pictures|football|symantec|cipriani|ventures|telecity|cityeats|verisign|flsmidth|boutique|cleaning|firmdale|clinique|clothing|redstone|infiniti|deloitte|feedback|services|broadway|plumbing|commbank|training|barclays|exchange|computer|brussels|software|delivery|barefoot|builders|business|bargains|engineer|holdings|download|security|helsinki|lighting|movistar|discount|hdfcbank|supplies|marriott|property|diamonds|capetown|partners|democrat|jpmorgan|bradesco|budapest|rexroth|zuerich|shriram|academy|science|support|youtube|singles|surgery|alibaba|statoil|dentist|schwarz|android|cruises|cricket|digital|markets|starhub|systems|courses|coupons|netbank|country|domains|corsica|network|neustar|realtor|lincoln|limited|schmidt|yamaxun|cooking|contact|auction|spiegel|liaison|leclerc|latrobe|lasalle|abogado|compare|lanxess|exposed|express|company|cologne|college|avianca|lacaixa|fashion|recipes|ferrero|komatsu|storage|wanggou|clubmed|sandvik|fishing|fitness|bauhaus|kitchen|flights|florist|flowers|watches|weather|temasek|samsung|bentley|forsale|channel|theater|frogans|theatre|okinawa|website|tickets|jewelry|gallery|tiffany|iselect|shiksha|brother|organic|wedding|genting|toshiba|origins|philips|hyundai|hotmail|hoteles|hosting|rentals|windows|cartier|bugatti|holiday|careers|whoswho|hitachi|panerai|caravan|reviews|guitars|capital|trading|hamburg|hangout|finance|stream|family|abbott|health|review|travel|report|hermes|hiphop|gratis|career|toyota|hockey|dating|repair|google|social|soccer|reisen|global|otsuka|giving|unicom|casino|photos|center|broker|rocher|orange|bostik|garden|insure|ryukyu|bharti|safety|physio|sakura|oracle|online|jaguar|gallup|piaget|tienda|futbol|pictet|joburg|webcam|berlin|office|juegos|kaufen|chanel|chrome|xihuan|church|tennis|circle|kinder|flickr|bayern|claims|clinic|viajes|nowruz|xperia|norton|yachts|studio|coffee|camera|sanofi|nissan|author|expert|events|comsec|lawyer|tattoo|viking|estate|villas|condos|realty|yandex|energy|emerck|virgin|vision|durban|living|school|coupon|london|taobao|natura|taipei|nagoya|luxury|walter|aramco|sydney|madrid|credit|maison|makeup|schule|market|anquan|direct|design|swatch|suzuki|alsace|vuelos|dental|alipay|voyage|shouji|voting|airtel|mutual|degree|supply|agency|museum|mobily|dealer|monash|select|mormon|active|moscow|racing|datsun|quebec|nissay|rodeo|email|gifts|works|photo|chloe|edeka|cheap|earth|vista|tushu|koeln|glass|shoes|globo|tunes|gmail|nokia|space|kyoto|black|ricoh|seven|lamer|sener|epson|cisco|praxi|trust|citic|crown|shell|lease|green|legal|lexus|ninja|tatar|gripe|nikon|group|video|wales|autos|gucci|party|nexus|guide|linde|adult|parts|amica|lixil|boats|azure|loans|locus|cymru|lotte|lotto|stada|click|poker|quest|dabur|lupin|nadex|paris|faith|dance|canon|place|gives|trade|skype|rocks|mango|cloud|boots|smile|final|swiss|homes|honda|media|horse|cards|deals|watch|bosch|house|pizza|miami|osaka|tours|total|xerox|coach|sucks|style|delta|toray|iinet|tools|money|codes|beats|tokyo|salon|archi|movie|baidu|study|actor|yahoo|store|apple|world|forex|today|bible|tmall|tirol|irish|tires|forum|reise|vegas|vodka|sharp|omega|weber|jetzt|audio|promo|build|bingo|chase|gallo|drive|dubai|rehab|press|solar|sale|beer|bbva|bank|band|auto|sapo|sarl|saxo|audi|asia|arte|arpa|army|yoga|ally|zara|scor|scot|sexy|seat|zero|seek|aero|adac|zone|aarp|maif|meet|meme|menu|surf|mini|mobi|mtpc|porn|desi|star|ltda|name|talk|navy|love|loan|live|link|news|limo|like|spot|life|nico|lidl|lgbt|land|taxi|team|tech|kred|kpmg|sony|song|kiwi|kddi|jprs|jobs|sohu|java|itau|tips|info|immo|icbc|hsbc|town|host|page|toys|here|help|pars|haus|guru|guge|tube|goog|golf|gold|sncf|gmbh|gift|ggee|gent|gbiz|game|vana|pics|fund|ford|ping|pink|fish|film|fast|farm|play|fans|fail|plus|skin|pohl|fage|moda|post|erni|dvag|prod|doha|prof|docs|viva|diet|luxe|site|dell|sina|dclk|show|qpon|date|vote|cyou|voto|read|coop|cool|wang|club|city|chat|cern|cash|reit|rent|casa|cars|care|camp|rest|call|cafe|weir|wien|rich|wiki|buzz|wine|book|bond|room|work|rsvp|shia|ruhr|blue|bing|shaw|bike|safe|xbox|best|pwc|mtn|lds|aig|boo|fyi|nra|nrw|ntt|car|gal|obi|zip|aeg|vin|how|one|ong|onl|dad|ooo|bet|esq|org|htc|bar|uol|ibm|ovh|gdn|ice|icu|uno|gea|ifm|bot|top|wtf|lol|day|pet|eus|wtc|ubs|tvs|aco|ing|ltd|ink|tab|abb|afl|cat|int|pid|pin|bid|cba|gle|com|cbn|ads|man|wed|ceb|gmo|sky|ist|gmx|tui|mba|fan|ski|iwc|app|pro|med|ceo|jcb|jcp|goo|dev|men|aaa|meo|pub|jlc|bom|jll|gop|jmp|mil|got|gov|win|jot|mma|joy|trv|red|cfa|cfd|bio|moe|moi|mom|ren|biz|aws|xin|bbc|dnp|buy|kfh|mov|thd|xyz|fit|kia|rio|rip|kim|dog|vet|nyc|bcg|mtr|bcn|bms|bmw|run|bzh|rwe|tel|stc|axa|kpn|fly|krd|cab|bnl|foo|crs|eat|tci|sap|srl|nec|sas|net|cal|sbs|sfr|sca|scb|csc|edu|new|xxx|hiv|fox|wme|ngo|nhk|vip|sex|frl|lat|yun|law|you|tax|soy|sew|om|ac|hu|se|sc|sg|sh|sb|sa|rw|ru|rs|ro|re|qa|py|si|pw|pt|ps|sj|sk|pr|pn|pm|pl|sl|sm|pk|sn|ph|so|pg|pf|pe|pa|zw|nz|nu|nr|np|no|nl|ni|ng|nf|sr|ne|st|nc|na|mz|my|mx|mw|mv|mu|mt|ms|mr|mq|mp|mo|su|mn|mm|ml|mk|mh|mg|me|sv|md|mc|sx|sy|ma|ly|lv|sz|lu|lt|ls|lr|lk|li|lc|lb|la|tc|kz|td|ky|kw|kr|kp|kn|km|ki|kh|tf|tg|th|kg|ke|jp|jo|jm|je|it|is|ir|tj|tk|tl|tm|iq|tn|to|io|in|im|il|ie|ad|sd|ht|hr|hn|hm|tr|hk|gy|gw|gu|gt|gs|gr|gq|tt|gp|gn|gm|gl|tv|gi|tw|tz|ua|gh|ug|uk|gg|gf|ge|gd|us|uy|uz|va|gb|ga|vc|ve|fr|fo|fm|fk|fj|vg|vi|fi|eu|et|es|er|eg|ee|ec|dz|do|dm|dk|vn|dj|de|cz|cy|cx|cw|vu|cv|cu|cr|co|cn|cm|cl|ck|ci|ch|cg|cf|cd|cc|ca|wf|bz|by|bw|bv|bt|bs|br|bo|bn|bm|bj|bi|ws|bh|bg|bf|be|bd|bb|ba|az|ax|aw|au|at|as|ye|ar|aq|ao|am|al|yt|ai|za|ag|af|ae|zm|id)\b/; return { /** * The string form of a regular expression that would match all of the * letters and decimal number chars in the unicode character set when placed * in a RegExp character class (`[]`). * * These would be the characters matched by unicode regex engines `[\p{L}\p{Nd}]` * escape ("all letters and decimal numbers") * * @property {String} alphaNumericCharsStr */ alphaNumericCharsStr : alphaNumericCharsStr, /** * A regular expression to match domain names of a URL or email address. * Ex: 'google', 'yahoo', 'some-other-company', etc. * * @property {RegExp} domainNameRegex */ domainNameRegex : domainNameRegex, /** * A regular expression to match top level domains (TLDs) for a URL or * email address. Ex: 'com', 'org', 'net', etc. * * @property {RegExp} tldRegex */ tldRegex : tldRegex }; }() ); /*global Autolinker */ /*jshint sub:true */ /** * @protected * @class Autolinker.AnchorTagBuilder * @extends Object * * Builds anchor (<a>) tags for the Autolinker utility when a match is * found. * * Normally this class is instantiated, configured, and used internally by an * {@link Autolinker} instance, but may actually be retrieved in a {@link Autolinker#replaceFn replaceFn} * to create {@link Autolinker.HtmlTag HtmlTag} instances which may be modified * before returning from the {@link Autolinker#replaceFn replaceFn}. For * example: * * var html = Autolinker.link( "Test google.com", { * replaceFn : function( autolinker, match ) { * var tag = autolinker.getTagBuilder().build( match ); // returns an {@link Autolinker.HtmlTag} instance * tag.setAttr( 'rel', 'nofollow' ); * * return tag; * } * } ); * * // generated html: * // Test google.com */ Autolinker.AnchorTagBuilder = Autolinker.Util.extend( Object, { /** * @cfg {Boolean} newWindow * @inheritdoc Autolinker#newWindow */ /** * @cfg {Object} truncate * @inheritdoc Autolinker#truncate */ /** * @cfg {String} className * @inheritdoc Autolinker#className */ /** * @constructor * @param {Object} [cfg] The configuration options for the AnchorTagBuilder instance, specified in an Object (map). */ constructor : function( cfg ) { Autolinker.Util.assign( this, cfg ); }, /** * Generates the actual anchor (<a>) tag to use in place of the * matched text, via its `match` object. * * @param {Autolinker.match.Match} match The Match instance to generate an * anchor tag from. * @return {Autolinker.HtmlTag} The HtmlTag instance for the anchor tag. */ build : function( match ) { return new Autolinker.HtmlTag( { tagName : 'a', attrs : this.createAttrs( match.getType(), match.getAnchorHref() ), innerHtml : this.processAnchorText( match.getAnchorText() ) } ); }, /** * Creates the Object (map) of the HTML attributes for the anchor (<a>) * tag being generated. * * @protected * @param {"url"/"email"/"phone"/"twitter"/"hashtag"} matchType The type of * match that an anchor tag is being generated for. * @param {String} anchorHref The href for the anchor tag. * @return {Object} A key/value Object (map) of the anchor tag's attributes. */ createAttrs : function( matchType, anchorHref ) { var attrs = { 'href' : anchorHref // we'll always have the `href` attribute }; var cssClass = this.createCssClass( matchType ); if( cssClass ) { attrs[ 'class' ] = cssClass; } if( this.newWindow ) { attrs[ 'target' ] = "_blank"; attrs[ 'rel' ] = "noopener noreferrer"; } return attrs; }, /** * Creates the CSS class that will be used for a given anchor tag, based on * the `matchType` and the {@link #className} config. * * @private * @param {"url"/"email"/"phone"/"twitter"/"hashtag"} matchType The type of * match that an anchor tag is being generated for. * @return {String} The CSS class string for the link. Example return: * "myLink myLink-url". If no {@link #className} was configured, returns * an empty string. */ createCssClass : function( matchType ) { var className = this.className; if( !className ) return ""; else return className + " " + className + "-" + matchType; // ex: "myLink myLink-url", "myLink myLink-email", "myLink myLink-phone", "myLink myLink-twitter", or "myLink myLink-hashtag" }, /** * Processes the `anchorText` by truncating the text according to the * {@link #truncate} config. * * @private * @param {String} anchorText The anchor tag's text (i.e. what will be * displayed). * @return {String} The processed `anchorText`. */ processAnchorText : function( anchorText ) { anchorText = this.doTruncate( anchorText ); return anchorText; }, /** * Performs the truncation of the `anchorText` based on the {@link #truncate} * option. If the `anchorText` is longer than the length specified by the * {@link #truncate} option, the truncation is performed based on the * `location` property. See {@link #truncate} for details. * * @private * @param {String} anchorText The anchor tag's text (i.e. what will be * displayed). * @return {String} The truncated anchor text. */ doTruncate : function( anchorText ) { var truncate = this.truncate; if( !truncate || !truncate.length ) return anchorText; var truncateLength = truncate.length, truncateLocation = truncate.location; if( truncateLocation === 'smart' ) { return Autolinker.truncate.TruncateSmart( anchorText, truncateLength, '..' ); } else if( truncateLocation === 'middle' ) { return Autolinker.truncate.TruncateMiddle( anchorText, truncateLength, '..' ); } else { return Autolinker.truncate.TruncateEnd( anchorText, truncateLength, '..' ); } } } ); /*global Autolinker */ /** * @class Autolinker.htmlParser.HtmlParser * @extends Object * * An HTML parser implementation which simply walks an HTML string and returns an array of * {@link Autolinker.htmlParser.HtmlNode HtmlNodes} that represent the basic HTML structure of the input string. * * Autolinker uses this to only link URLs/emails/Twitter handles within text nodes, effectively ignoring / "walking * around" HTML tags. */ Autolinker.htmlParser.HtmlParser = Autolinker.Util.extend( Object, { /** * @private * @property {RegExp} htmlRegex * * The regular expression used to pull out HTML tags from a string. Handles namespaced HTML tags and * attribute names, as specified by http://www.w3.org/TR/html-markup/syntax.html. * * Capturing groups: * * 1. The "!DOCTYPE" tag name, if a tag is a <!DOCTYPE> tag. * 2. If it is an end tag, this group will have the '/'. * 3. If it is a comment tag, this group will hold the comment text (i.e. * the text inside the `<!--` and `-->`. * 4. The tag name for all tags (other than the <!DOCTYPE> tag) */ htmlRegex : (function() { var commentTagRegex = /!--([\s\S]+?)--/, tagNameRegex = /[0-9a-zA-Z][0-9a-zA-Z:]*/, attrNameRegex = /[^\s"'>\/=\x00-\x1F\x7F]+/, // the unicode range accounts for excluding control chars, and the delete char attrValueRegex = /(?:"[^"]*?"|'[^']*?'|[^'"=<>`\s]+)/, // double quoted, single quoted, or unquoted attribute values nameEqualsValueRegex = attrNameRegex.source + '(?:\\s*=\\s*' + attrValueRegex.source + ')?'; // optional '=[value]' return new RegExp( [ // for tag. Ex: ) '(?:', '<(!DOCTYPE)', // *** Capturing Group 1 - If it's a doctype tag // Zero or more attributes following the tag name '(?:', '\\s+', // one or more whitespace chars before an attribute // Either: // A. attr="value", or // B. "value" alone (To cover example doctype tag: ) '(?:', nameEqualsValueRegex, '|', attrValueRegex.source + ')', ')*', '>', ')', '|', // All other HTML tags (i.e. tags that are not ) '(?:', '<(/)?', // Beginning of a tag or comment. Either '<' for a start tag, or '' ')', ')', '>', ')' ].join( "" ), 'gi' ); } )(), /** * @private * @property {RegExp} htmlCharacterEntitiesRegex * * The regular expression that matches common HTML character entities. * * Ignoring & as it could be part of a query string -- handling it separately. */ htmlCharacterEntitiesRegex: /( | |<|<|>|>|"|"|')/gi, /** * Parses an HTML string and returns a simple array of {@link Autolinker.htmlParser.HtmlNode HtmlNodes} * to represent the HTML structure of the input string. * * @param {String} html The HTML to parse. * @return {Autolinker.htmlParser.HtmlNode[]} */ parse : function( html ) { var htmlRegex = this.htmlRegex, currentResult, lastIndex = 0, textAndEntityNodes, nodes = []; // will be the result of the method while( ( currentResult = htmlRegex.exec( html ) ) !== null ) { var tagText = currentResult[ 0 ], commentText = currentResult[ 3 ], // if we've matched a comment tagName = currentResult[ 1 ] || currentResult[ 4 ], // The tag (ex: "!DOCTYPE"), or another tag (ex: "a" or "img") isClosingTag = !!currentResult[ 2 ], offset = currentResult.index, inBetweenTagsText = html.substring( lastIndex, offset ); // Push TextNodes and EntityNodes for any text found between tags if( inBetweenTagsText ) { textAndEntityNodes = this.parseTextAndEntityNodes( lastIndex, inBetweenTagsText ); nodes.push.apply( nodes, textAndEntityNodes ); } // Push the CommentNode or ElementNode if( commentText ) { nodes.push( this.createCommentNode( offset, tagText, commentText ) ); } else { nodes.push( this.createElementNode( offset, tagText, tagName, isClosingTag ) ); } lastIndex = offset + tagText.length; } // Process any remaining text after the last HTML element. Will process all of the text if there were no HTML elements. if( lastIndex < html.length ) { var text = html.substring( lastIndex ); // Push TextNodes and EntityNodes for any text found between tags if( text ) { textAndEntityNodes = this.parseTextAndEntityNodes( lastIndex, text ); nodes.push.apply( nodes, textAndEntityNodes ); } } return nodes; }, /** * Parses text and HTML entity nodes from a given string. The input string * should not have any HTML tags (elements) within it. * * @private * @param {Number} offset The offset of the text node match within the * original HTML string. * @param {String} text The string of text to parse. This is from an HTML * text node. * @return {Autolinker.htmlParser.HtmlNode[]} An array of HtmlNodes to * represent the {@link Autolinker.htmlParser.TextNode TextNodes} and * {@link Autolinker.htmlParser.EntityNode EntityNodes} found. */ parseTextAndEntityNodes : function( offset, text ) { var nodes = [], textAndEntityTokens = Autolinker.Util.splitAndCapture( text, this.htmlCharacterEntitiesRegex ); // split at HTML entities, but include the HTML entities in the results array // Every even numbered token is a TextNode, and every odd numbered token is an EntityNode // For example: an input `text` of "Test "this" today" would turn into the // `textAndEntityTokens`: [ 'Test ', '"', 'this', '"', ' today' ] for( var i = 0, len = textAndEntityTokens.length; i < len; i += 2 ) { var textToken = textAndEntityTokens[ i ], entityToken = textAndEntityTokens[ i + 1 ]; if( textToken ) { nodes.push( this.createTextNode( offset, textToken ) ); offset += textToken.length; } if( entityToken ) { nodes.push( this.createEntityNode( offset, entityToken ) ); offset += entityToken.length; } } return nodes; }, /** * Factory method to create an {@link Autolinker.htmlParser.CommentNode CommentNode}. * * @private * @param {Number} offset The offset of the match within the original HTML * string. * @param {String} tagText The full text of the tag (comment) that was * matched, including its <!-- and -->. * @param {String} commentText The full text of the comment that was matched. */ createCommentNode : function( offset, tagText, commentText ) { return new Autolinker.htmlParser.CommentNode( { offset : offset, text : tagText, comment: Autolinker.Util.trim( commentText ) } ); }, /** * Factory method to create an {@link Autolinker.htmlParser.ElementNode ElementNode}. * * @private * @param {Number} offset The offset of the match within the original HTML * string. * @param {String} tagText The full text of the tag (element) that was * matched, including its attributes. * @param {String} tagName The name of the tag. Ex: An <img> tag would * be passed to this method as "img". * @param {Boolean} isClosingTag `true` if it's a closing tag, false * otherwise. * @return {Autolinker.htmlParser.ElementNode} */ createElementNode : function( offset, tagText, tagName, isClosingTag ) { return new Autolinker.htmlParser.ElementNode( { offset : offset, text : tagText, tagName : tagName.toLowerCase(), closing : isClosingTag } ); }, /** * Factory method to create a {@link Autolinker.htmlParser.EntityNode EntityNode}. * * @private * @param {Number} offset The offset of the match within the original HTML * string. * @param {String} text The text that was matched for the HTML entity (such * as '&nbsp;'). * @return {Autolinker.htmlParser.EntityNode} */ createEntityNode : function( offset, text ) { return new Autolinker.htmlParser.EntityNode( { offset: offset, text: text } ); }, /** * Factory method to create a {@link Autolinker.htmlParser.TextNode TextNode}. * * @private * @param {Number} offset The offset of the match within the original HTML * string. * @param {String} text The text that was matched. * @return {Autolinker.htmlParser.TextNode} */ createTextNode : function( offset, text ) { return new Autolinker.htmlParser.TextNode( { offset: offset, text: text } ); } } ); /*global Autolinker */ /** * @abstract * @class Autolinker.htmlParser.HtmlNode * * Represents an HTML node found in an input string. An HTML node is one of the * following: * * 1. An {@link Autolinker.htmlParser.ElementNode ElementNode}, which represents * HTML tags. * 2. A {@link Autolinker.htmlParser.CommentNode CommentNode}, which represents * HTML comments. * 3. A {@link Autolinker.htmlParser.TextNode TextNode}, which represents text * outside or within HTML tags. * 4. A {@link Autolinker.htmlParser.EntityNode EntityNode}, which represents * one of the known HTML entities that Autolinker looks for. This includes * common ones such as &quot; and &nbsp; */ Autolinker.htmlParser.HtmlNode = Autolinker.Util.extend( Object, { /** * @cfg {Number} offset (required) * * The offset of the HTML node in the original text that was parsed. */ offset : undefined, /** * @cfg {String} text (required) * * The text that was matched for the HtmlNode. * * - In the case of an {@link Autolinker.htmlParser.ElementNode ElementNode}, * this will be the tag's text. * - In the case of an {@link Autolinker.htmlParser.CommentNode CommentNode}, * this will be the comment's text. * - In the case of a {@link Autolinker.htmlParser.TextNode TextNode}, this * will be the text itself. * - In the case of a {@link Autolinker.htmlParser.EntityNode EntityNode}, * this will be the text of the HTML entity. */ text : undefined, /** * @constructor * @param {Object} cfg The configuration properties for the Match instance, * specified in an Object (map). */ constructor : function( cfg ) { Autolinker.Util.assign( this, cfg ); if( this.offset == null ) throw new Error( '`offset` cfg required' ); if( this.text == null ) throw new Error( '`text` cfg required' ); }, /** * Returns a string name for the type of node that this class represents. * * @abstract * @return {String} */ getType : Autolinker.Util.abstractMethod, /** * Retrieves the {@link #offset} of the HtmlNode. This is the offset of the * HTML node in the original string that was parsed. * * @return {Number} */ getOffset : function() { return this.offset; }, /** * Retrieves the {@link #text} for the HtmlNode. * * @return {String} */ getText : function() { return this.text; } } ); /*global Autolinker */ /** * @class Autolinker.htmlParser.CommentNode * @extends Autolinker.htmlParser.HtmlNode * * Represents an HTML comment node that has been parsed by the * {@link Autolinker.htmlParser.HtmlParser}. * * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more * details. */ Autolinker.htmlParser.CommentNode = Autolinker.Util.extend( Autolinker.htmlParser.HtmlNode, { /** * @cfg {String} comment (required) * * The text inside the comment tag. This text is stripped of any leading or * trailing whitespace. */ comment : '', /** * Returns a string name for the type of node that this class represents. * * @return {String} */ getType : function() { return 'comment'; }, /** * Returns the comment inside the comment tag. * * @return {String} */ getComment : function() { return this.comment; } } ); /*global Autolinker */ /** * @class Autolinker.htmlParser.ElementNode * @extends Autolinker.htmlParser.HtmlNode * * Represents an HTML element node that has been parsed by the {@link Autolinker.htmlParser.HtmlParser}. * * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more * details. */ Autolinker.htmlParser.ElementNode = Autolinker.Util.extend( Autolinker.htmlParser.HtmlNode, { /** * @cfg {String} tagName (required) * * The name of the tag that was matched. */ tagName : '', /** * @cfg {Boolean} closing (required) * * `true` if the element (tag) is a closing tag, `false` if its an opening * tag. */ closing : false, /** * Returns a string name for the type of node that this class represents. * * @return {String} */ getType : function() { return 'element'; }, /** * Returns the HTML element's (tag's) name. Ex: for an <img> tag, * returns "img". * * @return {String} */ getTagName : function() { return this.tagName; }, /** * Determines if the HTML element (tag) is a closing tag. Ex: <div> * returns `false`, while </div> returns `true`. * * @return {Boolean} */ isClosing : function() { return this.closing; } } ); /*global Autolinker */ /** * @class Autolinker.htmlParser.EntityNode * @extends Autolinker.htmlParser.HtmlNode * * Represents a known HTML entity node that has been parsed by the {@link Autolinker.htmlParser.HtmlParser}. * Ex: '&nbsp;', or '&#160;' (which will be retrievable from the {@link #getText} * method. * * Note that this class will only be returned from the HtmlParser for the set of * checked HTML entity nodes defined by the {@link Autolinker.htmlParser.HtmlParser#htmlCharacterEntitiesRegex}. * * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more * details. */ Autolinker.htmlParser.EntityNode = Autolinker.Util.extend( Autolinker.htmlParser.HtmlNode, { /** * Returns a string name for the type of node that this class represents. * * @return {String} */ getType : function() { return 'entity'; } } ); /*global Autolinker */ /** * @class Autolinker.htmlParser.TextNode * @extends Autolinker.htmlParser.HtmlNode * * Represents a text node that has been parsed by the {@link Autolinker.htmlParser.HtmlParser}. * * See this class's superclass ({@link Autolinker.htmlParser.HtmlNode}) for more * details. */ Autolinker.htmlParser.TextNode = Autolinker.Util.extend( Autolinker.htmlParser.HtmlNode, { /** * Returns a string name for the type of node that this class represents. * * @return {String} */ getType : function() { return 'text'; } } ); /*global Autolinker */ /** * @abstract * @class Autolinker.match.Match * * Represents a match found in an input string which should be Autolinked. A Match object is what is provided in a * {@link Autolinker#replaceFn replaceFn}, and may be used to query for details about the match. * * For example: * * var input = "..."; // string with URLs, Email Addresses, and Twitter Handles * * var linkedText = Autolinker.link( input, { * replaceFn : function( autolinker, match ) { * console.log( "href = ", match.getAnchorHref() ); * console.log( "text = ", match.getAnchorText() ); * * switch( match.getType() ) { * case 'url' : * console.log( "url: ", match.getUrl() ); * * case 'email' : * console.log( "email: ", match.getEmail() ); * * case 'twitter' : * console.log( "twitter: ", match.getTwitterHandle() ); * } * } * } ); * * See the {@link Autolinker} class for more details on using the {@link Autolinker#replaceFn replaceFn}. */ Autolinker.match.Match = Autolinker.Util.extend( Object, { /** * @cfg {Autolinker.AnchorTagBuilder} tagBuilder (required) * * Reference to the AnchorTagBuilder instance to use to generate an anchor * tag for the Match. */ /** * @cfg {String} matchedText (required) * * The original text that was matched by the {@link Autolinker.matcher.Matcher}. */ /** * @cfg {Number} offset (required) * * The offset of where the match was made in the input string. */ /** * @constructor * @param {Object} cfg The configuration properties for the Match * instance, specified in an Object (map). */ constructor : function( cfg ) { if( cfg.tagBuilder == null ) throw new Error( '`tagBuilder` cfg required' ); if( cfg.matchedText == null ) throw new Error( '`matchedText` cfg required' ); if( cfg.offset == null ) throw new Error( '`offset` cfg required' ); this.tagBuilder = cfg.tagBuilder; this.matchedText = cfg.matchedText; this.offset = cfg.offset; }, /** * Returns a string name for the type of match that this class represents. * * @abstract * @return {String} */ getType : Autolinker.Util.abstractMethod, /** * Returns the original text that was matched. * * @return {String} */ getMatchedText : function() { return this.matchedText; }, /** * Sets the {@link #offset} of where the match was made in the input string. * * A {@link Autolinker.matcher.Matcher} will be fed only HTML text nodes, * and will therefore set an original offset that is relative to the HTML * text node itself. However, we want this offset to be relative to the full * HTML input string, and thus if using {@link Autolinker#parse} (rather * than calling a {@link Autolinker.matcher.Matcher} directly), then this * offset is corrected after the Matcher itself has done its job. * * @param {Number} offset */ setOffset : function( offset ) { this.offset = offset; }, /** * Returns the offset of where the match was made in the input string. This * is the 0-based index of the match. * * @return {Number} */ getOffset : function() { return this.offset; }, /** * Returns the anchor href that should be generated for the match. * * @abstract * @return {String} */ getAnchorHref : Autolinker.Util.abstractMethod, /** * Returns the anchor text that should be generated for the match. * * @abstract * @return {String} */ getAnchorText : Autolinker.Util.abstractMethod, /** * Builds and returns an {@link Autolinker.HtmlTag} instance based on the * Match. * * This can be used to easily generate anchor tags from matches, and either * return their HTML string, or modify them before doing so. * * Example Usage: * * var tag = match.buildTag(); * tag.addClass( 'cordova-link' ); * tag.setAttr( 'target', '_system' ); * * tag.toAnchorString(); // Google */ buildTag : function() { return this.tagBuilder.build( this ); } } ); /*global Autolinker */ /** * @class Autolinker.match.Email * @extends Autolinker.match.Match * * Represents a Email match found in an input string which should be Autolinked. * * See this class's superclass ({@link Autolinker.match.Match}) for more details. */ Autolinker.match.Email = Autolinker.Util.extend( Autolinker.match.Match, { /** * @cfg {String} email (required) * * The email address that was matched. */ /** * @constructor * @param {Object} cfg The configuration properties for the Match * instance, specified in an Object (map). */ constructor : function( cfg ) { Autolinker.match.Match.prototype.constructor.call( this, cfg ); if( !cfg.email ) throw new Error( '`email` cfg required' ); this.email = cfg.email; }, /** * Returns a string name for the type of match that this class represents. * * @return {String} */ getType : function() { return 'email'; }, /** * Returns the email address that was matched. * * @return {String} */ getEmail : function() { return this.email; }, /** * Returns the anchor href that should be generated for the match. * * @return {String} */ getAnchorHref : function() { return 'mailto:' + this.email; }, /** * Returns the anchor text that should be generated for the match. * * @return {String} */ getAnchorText : function() { return this.email; } } ); /*global Autolinker */ /** * @class Autolinker.match.Hashtag * @extends Autolinker.match.Match * * Represents a Hashtag match found in an input string which should be * Autolinked. * * See this class's superclass ({@link Autolinker.match.Match}) for more * details. */ Autolinker.match.Hashtag = Autolinker.Util.extend( Autolinker.match.Match, { /** * @cfg {String} serviceName * * The service to point hashtag matches to. See {@link Autolinker#hashtag} * for available values. */ /** * @cfg {String} hashtag (required) * * The Hashtag that was matched, without the '#'. */ /** * @constructor * @param {Object} cfg The configuration properties for the Match * instance, specified in an Object (map). */ constructor : function( cfg ) { Autolinker.match.Match.prototype.constructor.call( this, cfg ); // TODO: if( !serviceName ) throw new Error( '`serviceName` cfg required' ); if( !cfg.hashtag ) throw new Error( '`hashtag` cfg required' ); this.serviceName = cfg.serviceName; this.hashtag = cfg.hashtag; }, /** * Returns the type of match that this class represents. * * @return {String} */ getType : function() { return 'hashtag'; }, /** * Returns the configured {@link #serviceName} to point the Hashtag to. * Ex: 'facebook', 'twitter'. * * @return {String} */ getServiceName : function() { return this.serviceName; }, /** * Returns the matched hashtag, without the '#' character. * * @return {String} */ getHashtag : function() { return this.hashtag; }, /** * Returns the anchor href that should be generated for the match. * * @return {String} */ getAnchorHref : function() { var serviceName = this.serviceName, hashtag = this.hashtag; switch( serviceName ) { case 'twitter' : return 'https://twitter.com/hashtag/' + hashtag; case 'facebook' : return 'https://www.facebook.com/hashtag/' + hashtag; case 'instagram' : return 'https://instagram.com/explore/tags/' + hashtag; default : // Shouldn't happen because Autolinker's constructor should block any invalid values, but just in case. throw new Error( 'Unknown service name to point hashtag to: ', serviceName ); } }, /** * Returns the anchor text that should be generated for the match. * * @return {String} */ getAnchorText : function() { return '#' + this.hashtag; } } ); /*global Autolinker */ /** * @class Autolinker.match.Phone * @extends Autolinker.match.Match * * Represents a Phone number match found in an input string which should be * Autolinked. * * See this class's superclass ({@link Autolinker.match.Match}) for more * details. */ Autolinker.match.Phone = Autolinker.Util.extend( Autolinker.match.Match, { /** * @protected * @property {String} number (required) * * The phone number that was matched, without any delimiter characters. * * Note: This is a string to allow for prefixed 0's. */ /** * @protected * @property {Boolean} plusSign (required) * * `true` if the matched phone number started with a '+' sign. We'll include * it in the `tel:` URL if so, as this is needed for international numbers. * * Ex: '+1 (123) 456 7879' */ /** * @constructor * @param {Object} cfg The configuration properties for the Match * instance, specified in an Object (map). */ constructor : function( cfg ) { Autolinker.match.Match.prototype.constructor.call( this, cfg ); if( !cfg.number ) throw new Error( '`number` cfg required' ); if( cfg.plusSign == null ) throw new Error( '`plusSign` cfg required' ); this.number = cfg.number; this.plusSign = cfg.plusSign; }, /** * Returns a string name for the type of match that this class represents. * * @return {String} */ getType : function() { return 'phone'; }, /** * Returns the phone number that was matched as a string, without any * delimiter characters. * * Note: This is a string to allow for prefixed 0's. * * @return {String} */ getNumber: function() { return this.number; }, /** * Returns the anchor href that should be generated for the match. * * @return {String} */ getAnchorHref : function() { return 'tel:' + ( this.plusSign ? '+' : '' ) + this.number; }, /** * Returns the anchor text that should be generated for the match. * * @return {String} */ getAnchorText : function() { return this.matchedText; } } ); /*global Autolinker */ /** * @class Autolinker.match.Twitter * @extends Autolinker.match.Match * * Represents a Twitter match found in an input string which should be Autolinked. * * See this class's superclass ({@link Autolinker.match.Match}) for more details. */ Autolinker.match.Twitter = Autolinker.Util.extend( Autolinker.match.Match, { /** * @cfg {String} twitterHandle (required) * * The Twitter handle that was matched, without the '@' character. */ /** * @constructor * @param {Object} cfg The configuration properties for the Match * instance, specified in an Object (map). */ constructor : function( cfg) { Autolinker.match.Match.prototype.constructor.call( this, cfg ); if( !cfg.twitterHandle ) throw new Error( '`twitterHandle` cfg required' ); this.twitterHandle = cfg.twitterHandle; }, /** * Returns the type of match that this class represents. * * @return {String} */ getType : function() { return 'twitter'; }, /** * Returns the twitter handle, without the '@' character. * * @return {String} */ getTwitterHandle : function() { return this.twitterHandle; }, /** * Returns the anchor href that should be generated for the match. * * @return {String} */ getAnchorHref : function() { return 'https://twitter.com/' + this.twitterHandle; }, /** * Returns the anchor text that should be generated for the match. * * @return {String} */ getAnchorText : function() { return '@' + this.twitterHandle; } } ); /*global Autolinker */ /** * @class Autolinker.match.Url * @extends Autolinker.match.Match * * Represents a Url match found in an input string which should be Autolinked. * * See this class's superclass ({@link Autolinker.match.Match}) for more details. */ Autolinker.match.Url = Autolinker.Util.extend( Autolinker.match.Match, { /** * @cfg {String} url (required) * * The url that was matched. */ /** * @cfg {"scheme"/"www"/"tld"} urlMatchType (required) * * The type of URL match that this class represents. This helps to determine * if the match was made in the original text with a prefixed scheme (ex: * 'http://www.google.com'), a prefixed 'www' (ex: 'www.google.com'), or * was matched by a known top-level domain (ex: 'google.com'). */ /** * @cfg {Boolean} protocolUrlMatch (required) * * `true` if the URL is a match which already has a protocol (i.e. * 'http://'), `false` if the match was from a 'www' or known TLD match. */ /** * @cfg {Boolean} protocolRelativeMatch (required) * * `true` if the URL is a protocol-relative match. A protocol-relative match * is a URL that starts with '//', and will be either http:// or https:// * based on the protocol that the site is loaded under. */ /** * @cfg {Boolean} stripPrefix (required) * @inheritdoc Autolinker#cfg-stripPrefix */ /** * @constructor * @param {Object} cfg The configuration properties for the Match * instance, specified in an Object (map). */ constructor : function( cfg ) { Autolinker.match.Match.prototype.constructor.call( this, cfg ); if( cfg.urlMatchType !== 'scheme' && cfg.urlMatchType !== 'www' && cfg.urlMatchType !== 'tld' ) throw new Error( '`urlMatchType` cfg must be one of: "scheme", "www", or "tld"' ); if( !cfg.url ) throw new Error( '`url` cfg required' ); if( cfg.protocolUrlMatch == null ) throw new Error( '`protocolUrlMatch` cfg required' ); if( cfg.protocolRelativeMatch == null ) throw new Error( '`protocolRelativeMatch` cfg required' ); if( cfg.stripPrefix == null ) throw new Error( '`stripPrefix` cfg required' ); this.urlMatchType = cfg.urlMatchType; this.url = cfg.url; this.protocolUrlMatch = cfg.protocolUrlMatch; this.protocolRelativeMatch = cfg.protocolRelativeMatch; this.stripPrefix = cfg.stripPrefix; }, /** * @private * @property {RegExp} urlPrefixRegex * * A regular expression used to remove the 'http://' or 'https://' and/or the 'www.' from URLs. */ urlPrefixRegex: /^(https?:\/\/)?(www\.)?/i, /** * @private * @property {RegExp} protocolRelativeRegex * * The regular expression used to remove the protocol-relative '//' from the {@link #url} string, for purposes * of {@link #getAnchorText}. A protocol-relative URL is, for example, "//yahoo.com" */ protocolRelativeRegex : /^\/\//, /** * @private * @property {Boolean} protocolPrepended * * Will be set to `true` if the 'http://' protocol has been prepended to the {@link #url} (because the * {@link #url} did not have a protocol) */ protocolPrepended : false, /** * Returns a string name for the type of match that this class represents. * * @return {String} */ getType : function() { return 'url'; }, /** * Returns a string name for the type of URL match that this class * represents. * * This helps to determine if the match was made in the original text with a * prefixed scheme (ex: 'http://www.google.com'), a prefixed 'www' (ex: * 'www.google.com'), or was matched by a known top-level domain (ex: * 'google.com'). * * @return {"scheme"/"www"/"tld"} */ getUrlMatchType : function() { return this.urlMatchType; }, /** * Returns the url that was matched, assuming the protocol to be 'http://' if the original * match was missing a protocol. * * @return {String} */ getUrl : function() { var url = this.url; // if the url string doesn't begin with a protocol, assume 'http://' if( !this.protocolRelativeMatch && !this.protocolUrlMatch && !this.protocolPrepended ) { url = this.url = 'http://' + url; this.protocolPrepended = true; } return url; }, /** * Returns the anchor href that should be generated for the match. * * @return {String} */ getAnchorHref : function() { var url = this.getUrl(); return url.replace( /&/g, '&' ); // any &'s in the URL should be converted back to '&' if they were displayed as & in the source html }, /** * Returns the anchor text that should be generated for the match. * * @return {String} */ getAnchorText : function() { var anchorText = this.getMatchedText(); if( this.protocolRelativeMatch ) { // Strip off any protocol-relative '//' from the anchor text anchorText = this.stripProtocolRelativePrefix( anchorText ); } if( this.stripPrefix ) { anchorText = this.stripUrlPrefix( anchorText ); } anchorText = this.removeTrailingSlash( anchorText ); // remove trailing slash, if there is one return anchorText; }, // --------------------------------------- // Utility Functionality /** * Strips the URL prefix (such as "http://" or "https://") from the given text. * * @private * @param {String} text The text of the anchor that is being generated, for which to strip off the * url prefix (such as stripping off "http://") * @return {String} The `anchorText`, with the prefix stripped. */ stripUrlPrefix : function( text ) { return text.replace( this.urlPrefixRegex, '' ); }, /** * Strips any protocol-relative '//' from the anchor text. * * @private * @param {String} text The text of the anchor that is being generated, for which to strip off the * protocol-relative prefix (such as stripping off "//") * @return {String} The `anchorText`, with the protocol-relative prefix stripped. */ stripProtocolRelativePrefix : function( text ) { return text.replace( this.protocolRelativeRegex, '' ); }, /** * Removes any trailing slash from the given `anchorText`, in preparation for the text to be displayed. * * @private * @param {String} anchorText The text of the anchor that is being generated, for which to remove any trailing * slash ('/') that may exist. * @return {String} The `anchorText`, with the trailing slash removed. */ removeTrailingSlash : function( anchorText ) { if( anchorText.charAt( anchorText.length - 1 ) === '/' ) { anchorText = anchorText.slice( 0, -1 ); } return anchorText; } } ); /*global Autolinker */ /** * @abstract * @class Autolinker.matcher.Matcher * * An abstract class and interface for individual matchers to find matches in * an input string with linkified versions of them. * * Note that Matchers do not take HTML into account - they must be fed the text * nodes of any HTML string, which is handled by {@link Autolinker#parse}. */ Autolinker.matcher.Matcher = Autolinker.Util.extend( Object, { /** * @cfg {Autolinker.AnchorTagBuilder} tagBuilder (required) * * Reference to the AnchorTagBuilder instance to use to generate HTML tags * for {@link Autolinker.match.Match Matches}. */ /** * @constructor * @param {Object} cfg The configuration properties for the Matcher * instance, specified in an Object (map). */ constructor : function( cfg ) { if( !cfg.tagBuilder ) throw new Error( '`tagBuilder` cfg required' ); this.tagBuilder = cfg.tagBuilder; }, /** * Parses the input `text` and returns the array of {@link Autolinker.match.Match Matches} * for the matcher. * * @abstract * @param {String} text The text to scan and replace matches in. * @return {Autolinker.match.Match[]} */ parseMatches : Autolinker.Util.abstractMethod } ); /*global Autolinker */ /** * @class Autolinker.matcher.Email * @extends Autolinker.matcher.Matcher * * Matcher to find email matches in an input string. * * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more details. */ Autolinker.matcher.Email = Autolinker.Util.extend( Autolinker.matcher.Matcher, { /** * The regular expression to match email addresses. Example match: * * person@place.com * * @private * @property {RegExp} matcherRegex */ matcherRegex : (function() { var alphaNumericChars = Autolinker.RegexLib.alphaNumericCharsStr, emailRegex = new RegExp( '[' + alphaNumericChars + '\\-_\';:&=+$.,]+@' ), // something@ for email addresses (a.k.a. local-part) domainNameRegex = Autolinker.RegexLib.domainNameRegex, tldRegex = Autolinker.RegexLib.tldRegex; // match our known top level domains (TLDs) return new RegExp( [ emailRegex.source, domainNameRegex.source, '\\.', tldRegex.source // '.com', '.net', etc ].join( "" ), 'gi' ); } )(), /** * @inheritdoc */ parseMatches : function( text ) { var matcherRegex = this.matcherRegex, tagBuilder = this.tagBuilder, matches = [], match; while( ( match = matcherRegex.exec( text ) ) !== null ) { var matchedText = match[ 0 ]; matches.push( new Autolinker.match.Email( { tagBuilder : tagBuilder, matchedText : matchedText, offset : match.index, email : matchedText } ) ); } return matches; } } ); /*global Autolinker */ /** * @class Autolinker.matcher.Hashtag * @extends Autolinker.matcher.Matcher * * Matcher to find Hashtag matches in an input string. */ Autolinker.matcher.Hashtag = Autolinker.Util.extend( Autolinker.matcher.Matcher, { /** * @cfg {String} serviceName * * The service to point hashtag matches to. See {@link Autolinker#hashtag} * for available values. */ /** * The regular expression to match Hashtags. Example match: * * #asdf * * @private * @property {RegExp} matcherRegex */ matcherRegex : new RegExp( '#[_' + Autolinker.RegexLib.alphaNumericCharsStr + ']{1,139}', 'g' ), /** * The regular expression to use to check the character before a username match to * make sure we didn't accidentally match an email address. * * For example, the string "asdf@asdf.com" should not match "@asdf" as a username. * * @private * @property {RegExp} nonWordCharRegex */ nonWordCharRegex : new RegExp( '[^' + Autolinker.RegexLib.alphaNumericCharsStr + ']' ), /** * @constructor * @param {Object} cfg The configuration properties for the Match instance, * specified in an Object (map). */ constructor : function( cfg ) { Autolinker.matcher.Matcher.prototype.constructor.call( this, cfg ); this.serviceName = cfg.serviceName; }, /** * @inheritdoc */ parseMatches : function( text ) { var matcherRegex = this.matcherRegex, nonWordCharRegex = this.nonWordCharRegex, serviceName = this.serviceName, tagBuilder = this.tagBuilder, matches = [], match; while( ( match = matcherRegex.exec( text ) ) !== null ) { var offset = match.index, prevChar = text.charAt( offset - 1 ); // If we found the match at the beginning of the string, or we found the match // and there is a whitespace char in front of it (meaning it is not a '#' char // in the middle of a word), then it is a hashtag match. if( offset === 0 || nonWordCharRegex.test( prevChar ) ) { var matchedText = match[ 0 ], hashtag = match[ 0 ].slice( 1 ); // strip off the '#' character at the beginning matches.push( new Autolinker.match.Hashtag( { tagBuilder : tagBuilder, matchedText : matchedText, offset : offset, serviceName : serviceName, hashtag : hashtag } ) ); } } return matches; } } ); /*global Autolinker */ /** * @class Autolinker.matcher.Phone * @extends Autolinker.matcher.Matcher * * Matcher to find Phone number matches in an input string. * * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more * details. */ Autolinker.matcher.Phone = Autolinker.Util.extend( Autolinker.matcher.Matcher, { /** * The regular expression to match Phone numbers. Example match: * * (123) 456-7890 * * This regular expression has the following capturing groups: * * 1. The prefixed '+' sign, if there is one. * * @private * @property {RegExp} matcherRegex */ matcherRegex : /(?:(\+)?\d{1,3}[-\040.])?\(?\d{3}\)?[-\040.]?\d{3}[-\040.]\d{4}/g, // ex: (123) 456-7890, 123 456 7890, 123-456-7890, etc. /** * @inheritdoc */ parseMatches : function( text ) { var matcherRegex = this.matcherRegex, tagBuilder = this.tagBuilder, matches = [], match; while( ( match = matcherRegex.exec( text ) ) !== null ) { // Remove non-numeric values from phone number string var matchedText = match[ 0 ], cleanNumber = matchedText.replace( /\D/g, '' ), // strip out non-digit characters plusSign = !!match[ 1 ]; // match[ 1 ] is the prefixed plus sign, if there is one matches.push( new Autolinker.match.Phone( { tagBuilder : tagBuilder, matchedText : matchedText, offset : match.index, number : cleanNumber, plusSign : plusSign } ) ); } return matches; } } ); /*global Autolinker */ /** * @class Autolinker.matcher.Twitter * @extends Autolinker.matcher.Matcher * * Matcher to find/replace username matches in an input string. */ Autolinker.matcher.Twitter = Autolinker.Util.extend( Autolinker.matcher.Matcher, { /** * The regular expression to match username handles. Example match: * * @asdf * * @private * @property {RegExp} matcherRegex */ matcherRegex : new RegExp( '@[_' + Autolinker.RegexLib.alphaNumericCharsStr + ']{1,20}', 'g' ), /** * The regular expression to use to check the character before a username match to * make sure we didn't accidentally match an email address. * * For example, the string "asdf@asdf.com" should not match "@asdf" as a username. * * @private * @property {RegExp} nonWordCharRegex */ nonWordCharRegex : new RegExp( '[^' + Autolinker.RegexLib.alphaNumericCharsStr + ']' ), /** * @inheritdoc */ parseMatches : function( text ) { var matcherRegex = this.matcherRegex, nonWordCharRegex = this.nonWordCharRegex, tagBuilder = this.tagBuilder, matches = [], match; while( ( match = matcherRegex.exec( text ) ) !== null ) { var offset = match.index, prevChar = text.charAt( offset - 1 ); // If we found the match at the beginning of the string, or we found the match // and there is a whitespace char in front of it (meaning it is not an email // address), then it is a username match. if( offset === 0 || nonWordCharRegex.test( prevChar ) ) { var matchedText = match[ 0 ], twitterHandle = match[ 0 ].slice( 1 ); // strip off the '@' character at the beginning matches.push( new Autolinker.match.Twitter( { tagBuilder : tagBuilder, matchedText : matchedText, offset : offset, twitterHandle : twitterHandle } ) ); } } return matches; } } ); /*global Autolinker */ /** * @class Autolinker.matcher.Url * @extends Autolinker.matcher.Matcher * * Matcher to find URL matches in an input string. * * See this class's superclass ({@link Autolinker.matcher.Matcher}) for more details. */ Autolinker.matcher.Url = Autolinker.Util.extend( Autolinker.matcher.Matcher, { /** * @cfg {Boolean} stripPrefix (required) * @inheritdoc Autolinker#stripPrefix */ /** * @private * @property {RegExp} matcherRegex * * The regular expression to match URLs with an optional scheme, port * number, path, query string, and hash anchor. * * Example matches: * * http://google.com * www.google.com * google.com/path/to/file?q1=1&q2=2#myAnchor * * * This regular expression will have the following capturing groups: * * 1. Group that matches a scheme-prefixed URL (i.e. 'http://google.com'). * This is used to match scheme URLs with just a single word, such as * 'http://localhost', where we won't double check that the domain name * has at least one dot ('.') in it. * 2. Group that matches a 'www.' prefixed URL. This is only matched if the * 'www.' text was not prefixed by a scheme (i.e.: not prefixed by * 'http://', 'ftp:', etc.) * 3. A protocol-relative ('//') match for the case of a 'www.' prefixed * URL. Will be an empty string if it is not a protocol-relative match. * We need to know the character before the '//' in order to determine * if it is a valid match or the // was in a string we don't want to * auto-link. * 4. Group that matches a known TLD (top level domain), when a scheme * or 'www.'-prefixed domain is not matched. * 5. A protocol-relative ('//') match for the case of a known TLD prefixed * URL. Will be an empty string if it is not a protocol-relative match. * See #3 for more info. */ matcherRegex : (function() { var schemeRegex = /(?:[A-Za-z][-.+A-Za-z0-9]*:(?![A-Za-z][-.+A-Za-z0-9]*:\/\/)(?!\d+\/?)(?:\/\/)?)/, // match protocol, allow in format "http://" or "mailto:". However, do not match the first part of something like 'link:http://www.google.com' (i.e. don't match "link:"). Also, make sure we don't interpret 'google.com:8000' as if 'google.com' was a protocol here (i.e. ignore a trailing port number in this regex) wwwRegex = /(?:www\.)/, // starting with 'www.' domainNameRegex = Autolinker.RegexLib.domainNameRegex, tldRegex = Autolinker.RegexLib.tldRegex, // match our known top level domains (TLDs) alphaNumericCharsStr = Autolinker.RegexLib.alphaNumericCharsStr, // Allow optional path, query string, and hash anchor, not ending in the following characters: "?!:,.;" // http://blog.codinghorror.com/the-problem-with-urls/ urlSuffixRegex = new RegExp( '[' + alphaNumericCharsStr + '\\-+&@#/%=~_()|\'$*\\[\\]?!:,.;]*[' + alphaNumericCharsStr + '\\-+&@#/%=~_()|\'$*\\[\\]]' ); return new RegExp( [ '(?:', // parens to cover match for scheme (optional), and domain '(', // *** Capturing group $1, for a scheme-prefixed url (ex: http://google.com) schemeRegex.source, domainNameRegex.source, ')', '|', '(', // *** Capturing group $2, for a 'www.' prefixed url (ex: www.google.com) '(//)?', // *** Capturing group $3 for an optional protocol-relative URL. Must be at the beginning of the string or start with a non-word character (handled later) wwwRegex.source, domainNameRegex.source, ')', '|', '(', // *** Capturing group $4, for known a TLD url (ex: google.com) '(//)?', // *** Capturing group $5 for an optional protocol-relative URL. Must be at the beginning of the string or start with a non-word character (handled later) domainNameRegex.source + '\\.', tldRegex.source, ')', ')', '(?:' + urlSuffixRegex.source + ')?' // match for path, query string, and/or hash anchor - optional ].join( "" ), 'gi' ); } )(), /** * A regular expression to use to check the character before a protocol-relative * URL match. We don't want to match a protocol-relative URL if it is part * of another word. * * For example, we want to match something like "Go to: //google.com", * but we don't want to match something like "abc//google.com" * * This regular expression is used to test the character before the '//'. * * @private * @type {RegExp} wordCharRegExp */ wordCharRegExp : /\w/, /** * The regular expression to match opening parenthesis in a URL match. * * This is to determine if we have unbalanced parenthesis in the URL, and to * drop the final parenthesis that was matched if so. * * Ex: The text "(check out: wikipedia.com/something_(disambiguation))" * should only autolink the inner "wikipedia.com/something_(disambiguation)" * part, so if we find that we have unbalanced parenthesis, we will drop the * last one for the match. * * @private * @property {RegExp} */ openParensRe : /\(/g, /** * The regular expression to match closing parenthesis in a URL match. See * {@link #openParensRe} for more information. * * @private * @property {RegExp} */ closeParensRe : /\)/g, /** * @constructor * @param {Object} cfg The configuration properties for the Match instance, * specified in an Object (map). */ constructor : function( cfg ) { Autolinker.matcher.Matcher.prototype.constructor.call( this, cfg ); this.stripPrefix = cfg.stripPrefix; if( this.stripPrefix == null ) throw new Error( '`stripPrefix` cfg required' ); }, /** * @inheritdoc */ parseMatches : function( text ) { var matcherRegex = this.matcherRegex, stripPrefix = this.stripPrefix, tagBuilder = this.tagBuilder, matches = [], match; while( ( match = matcherRegex.exec( text ) ) !== null ) { var matchStr = match[ 0 ], schemeUrlMatch = match[ 1 ], wwwUrlMatch = match[ 2 ], wwwProtocolRelativeMatch = match[ 3 ], //tldUrlMatch = match[ 4 ], -- not needed at the moment tldProtocolRelativeMatch = match[ 5 ], offset = match.index, protocolRelativeMatch = wwwProtocolRelativeMatch || tldProtocolRelativeMatch, prevChar = text.charAt( offset - 1 ); if( !Autolinker.matcher.UrlMatchValidator.isValid( matchStr, schemeUrlMatch ) ) { continue; } // If the match is preceded by an '@' character, then it is either // an email address or a username. Skip these types of matches. if( offset > 0 && prevChar === '@' ) { continue; } // If it's a protocol-relative '//' match, but the character before the '//' // was a word character (i.e. a letter/number), then we found the '//' in the // middle of another word (such as "asdf//asdf.com"). In this case, skip the // match. if( offset > 0 && protocolRelativeMatch && this.wordCharRegExp.test( prevChar ) ) { continue; } // Handle a closing parenthesis at the end of the match, and exclude // it if there is not a matching open parenthesis in the match // itself. if( this.matchHasUnbalancedClosingParen( matchStr ) ) { matchStr = matchStr.substr( 0, matchStr.length - 1 ); // remove the trailing ")" } else { // Handle an invalid character after the TLD var pos = this.matchHasInvalidCharAfterTld( matchStr, schemeUrlMatch ); if( pos > -1 ) { matchStr = matchStr.substr( 0, pos ); // remove the trailing invalid chars } } var urlMatchType = schemeUrlMatch ? 'scheme' : ( wwwUrlMatch ? 'www' : 'tld' ), protocolUrlMatch = !!schemeUrlMatch; matches.push( new Autolinker.match.Url( { tagBuilder : tagBuilder, matchedText : matchStr, offset : offset, urlMatchType : urlMatchType, url : matchStr, protocolUrlMatch : protocolUrlMatch, protocolRelativeMatch : !!protocolRelativeMatch, stripPrefix : stripPrefix } ) ); } return matches; }, /** * Determines if a match found has an unmatched closing parenthesis. If so, * this parenthesis will be removed from the match itself, and appended * after the generated anchor tag. * * A match may have an extra closing parenthesis at the end of the match * because the regular expression must include parenthesis for URLs such as * "wikipedia.com/something_(disambiguation)", which should be auto-linked. * * However, an extra parenthesis *will* be included when the URL itself is * wrapped in parenthesis, such as in the case of "(wikipedia.com/something_(disambiguation))". * In this case, the last closing parenthesis should *not* be part of the * URL itself, and this method will return `true`. * * @private * @param {String} matchStr The full match string from the {@link #matcherRegex}. * @return {Boolean} `true` if there is an unbalanced closing parenthesis at * the end of the `matchStr`, `false` otherwise. */ matchHasUnbalancedClosingParen : function( matchStr ) { var lastChar = matchStr.charAt( matchStr.length - 1 ); if( lastChar === ')' ) { var openParensMatch = matchStr.match( this.openParensRe ), closeParensMatch = matchStr.match( this.closeParensRe ), numOpenParens = ( openParensMatch && openParensMatch.length ) || 0, numCloseParens = ( closeParensMatch && closeParensMatch.length ) || 0; if( numOpenParens < numCloseParens ) { return true; } } return false; }, /** * Determine if there's an invalid character after the TLD in a URL. Valid * characters after TLD are ':/?#'. Exclude scheme matched URLs from this * check. * * @private * @param {String} urlMatch The matched URL, if there was one. Will be an * empty string if the match is not a URL match. * @param {String} schemeUrlMatch The match URL string for a scheme * match. Ex: 'http://yahoo.com'. This is used to match something like * 'http://localhost', where we won't double check that the domain name * has at least one '.' in it. * @return {Number} the position where the invalid character was found. If * no such character was found, returns -1 */ matchHasInvalidCharAfterTld : function( urlMatch, schemeUrlMatch ) { if( !urlMatch ) { return -1; } var offset = 0; if ( schemeUrlMatch ) { offset = urlMatch.indexOf(':'); urlMatch = urlMatch.slice(offset); } var re = /^((.?\/\/)?[A-Za-z0-9\u00C0-\u017F\.\-]*[A-Za-z0-9\u00C0-\u017F\-]\.[A-Za-z]+)/; var res = re.exec( urlMatch ); if ( res === null ) { return -1; } offset += res[1].length; urlMatch = urlMatch.slice(res[1].length); if (/^[^.A-Za-z:\/?#]/.test(urlMatch)) { return offset; } return -1; } } ); /*global Autolinker */ /*jshint scripturl:true */ /** * @private * @class Autolinker.matcher.UrlMatchValidator * @singleton * * Used by Autolinker to filter out false URL positives from the * {@link Autolinker.matcher.Url UrlMatcher}. * * Due to the limitations of regular expressions (including the missing feature * of look-behinds in JS regular expressions), we cannot always determine the * validity of a given match. This class applies a bit of additional logic to * filter out any false positives that have been matched by the * {@link Autolinker.matcher.Url UrlMatcher}. */ Autolinker.matcher.UrlMatchValidator = { /** * Regex to test for a full protocol, with the two trailing slashes. Ex: 'http://' * * @private * @property {RegExp} hasFullProtocolRegex */ hasFullProtocolRegex : /^[A-Za-z][-.+A-Za-z0-9]*:\/\//, /** * Regex to find the URI scheme, such as 'mailto:'. * * This is used to filter out 'javascript:' and 'vbscript:' schemes. * * @private * @property {RegExp} uriSchemeRegex */ uriSchemeRegex : /^[A-Za-z][-.+A-Za-z0-9]*:/, /** * Regex to determine if at least one word char exists after the protocol (i.e. after the ':') * * @private * @property {RegExp} hasWordCharAfterProtocolRegex */ hasWordCharAfterProtocolRegex : /:[^\s]*?[A-Za-z\u00C0-\u017F]/, /** * Regex to determine if the string is a valid IP address * * @private * @property {RegExp} ipRegex */ ipRegex: /[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?\.[0-9][0-9]?[0-9]?(:[0-9]*)?\/?$/, /** * Determines if a given URL match found by the {@link Autolinker.matcher.Url UrlMatcher} * is valid. Will return `false` for: * * 1) URL matches which do not have at least have one period ('.') in the * domain name (effectively skipping over matches like "abc:def"). * However, URL matches with a protocol will be allowed (ex: 'http://localhost') * 2) URL matches which do not have at least one word character in the * domain name (effectively skipping over matches like "git:1.0"). * 3) A protocol-relative url match (a URL beginning with '//') whose * previous character is a word character (effectively skipping over * strings like "abc//google.com") * * Otherwise, returns `true`. * * @param {String} urlMatch The matched URL, if there was one. Will be an * empty string if the match is not a URL match. * @param {String} protocolUrlMatch The match URL string for a protocol * match. Ex: 'http://yahoo.com'. This is used to match something like * 'http://localhost', where we won't double check that the domain name * has at least one '.' in it. * @return {Boolean} `true` if the match given is valid and should be * processed, or `false` if the match is invalid and/or should just not be * processed. */ isValid : function( urlMatch, protocolUrlMatch ) { if( ( protocolUrlMatch && !this.isValidUriScheme( protocolUrlMatch ) ) || this.urlMatchDoesNotHaveProtocolOrDot( urlMatch, protocolUrlMatch ) || // At least one period ('.') must exist in the URL match for us to consider it an actual URL, *unless* it was a full protocol match (like 'http://localhost') (this.urlMatchDoesNotHaveAtLeastOneWordChar( urlMatch, protocolUrlMatch ) && // At least one letter character must exist in the domain name after a protocol match. Ex: skip over something like "git:1.0" !this.isValidIpAddress( urlMatch ) // Except if it's an IP address ) ) { return false; } return true; }, isValidIpAddress : function ( uriSchemeMatch ) { var newRegex = new RegExp(this.hasFullProtocolRegex.source + this.ipRegex.source); var uriScheme = uriSchemeMatch.match( newRegex ); return uriScheme !== null; }, /** * Determines if the URI scheme is a valid scheme to be autolinked. Returns * `false` if the scheme is 'javascript:' or 'vbscript:' * * @private * @param {String} uriSchemeMatch The match URL string for a full URI scheme * match. Ex: 'http://yahoo.com' or 'mailto:a@a.com'. * @return {Boolean} `true` if the scheme is a valid one, `false` otherwise. */ isValidUriScheme : function( uriSchemeMatch ) { var uriScheme = uriSchemeMatch.match( this.uriSchemeRegex )[ 0 ].toLowerCase(); return ( uriScheme !== 'javascript:' && uriScheme !== 'vbscript:' ); }, /** * Determines if a URL match does not have either: * * a) a full protocol (i.e. 'http://'), or * b) at least one dot ('.') in the domain name (for a non-full-protocol * match). * * Either situation is considered an invalid URL (ex: 'git:d' does not have * either the '://' part, or at least one dot in the domain name. If the * match was 'git:abc.com', we would consider this valid.) * * @private * @param {String} urlMatch The matched URL, if there was one. Will be an * empty string if the match is not a URL match. * @param {String} protocolUrlMatch The match URL string for a protocol * match. Ex: 'http://yahoo.com'. This is used to match something like * 'http://localhost', where we won't double check that the domain name * has at least one '.' in it. * @return {Boolean} `true` if the URL match does not have a full protocol, * or at least one dot ('.') in a non-full-protocol match. */ urlMatchDoesNotHaveProtocolOrDot : function( urlMatch, protocolUrlMatch ) { return ( !!urlMatch && ( !protocolUrlMatch || !this.hasFullProtocolRegex.test( protocolUrlMatch ) ) && urlMatch.indexOf( '.' ) === -1 ); }, /** * Determines if a URL match does not have at least one word character after * the protocol (i.e. in the domain name). * * At least one letter character must exist in the domain name after a * protocol match. Ex: skip over something like "git:1.0" * * @private * @param {String} urlMatch The matched URL, if there was one. Will be an * empty string if the match is not a URL match. * @param {String} protocolUrlMatch The match URL string for a protocol * match. Ex: 'http://yahoo.com'. This is used to know whether or not we * have a protocol in the URL string, in order to check for a word * character after the protocol separator (':'). * @return {Boolean} `true` if the URL match does not have at least one word * character in it after the protocol, `false` otherwise. */ urlMatchDoesNotHaveAtLeastOneWordChar : function( urlMatch, protocolUrlMatch ) { if( urlMatch && protocolUrlMatch ) { return !this.hasWordCharAfterProtocolRegex.test( urlMatch ); } else { return false; } } }; /*global Autolinker */ /** * A truncation feature where the ellipsis will be placed at the end of the URL. * * @param {String} anchorText * @param {Number} truncateLen The maximum length of the truncated output URL string. * @param {String} ellipsisChars The characters to place within the url, e.g. "..". * @return {String} The truncated URL. */ Autolinker.truncate.TruncateEnd = function(anchorText, truncateLen, ellipsisChars){ return Autolinker.Util.ellipsis( anchorText, truncateLen, ellipsisChars ); }; /*global Autolinker */ /** * Date: 2015-10-05 * Author: Kasper Søfren (https://github.com/kafoso) * * A truncation feature, where the ellipsis will be placed in the dead-center of the URL. * * @param {String} url A URL. * @param {Number} truncateLen The maximum length of the truncated output URL string. * @param {String} ellipsisChars The characters to place within the url, e.g. "..". * @return {String} The truncated URL. */ Autolinker.truncate.TruncateMiddle = function(url, truncateLen, ellipsisChars){ if (url.length <= truncateLen) { return url; } var availableLength = truncateLen - ellipsisChars.length; var end = ""; if (availableLength > 0) { end = url.substr((-1)*Math.floor(availableLength/2)); } return (url.substr(0, Math.ceil(availableLength/2)) + ellipsisChars + end).substr(0, truncateLen); }; /*global Autolinker */ /** * Date: 2015-10-05 * Author: Kasper Søfren (https://github.com/kafoso) * * A truncation feature, where the ellipsis will be placed at a section within * the URL making it still somewhat human readable. * * @param {String} url A URL. * @param {Number} truncateLen The maximum length of the truncated output URL string. * @param {String} ellipsisChars The characters to place within the url, e.g. "..". * @return {String} The truncated URL. */ Autolinker.truncate.TruncateSmart = function(url, truncateLen, ellipsisChars){ var parse_url = function(url){ // Functionality inspired by PHP function of same name var urlObj = {}; var urlSub = url; var match = urlSub.match(/^([a-z]+):\/\//i); if (match) { urlObj.scheme = match[1]; urlSub = urlSub.substr(match[0].length); } match = urlSub.match(/^(.*?)(?=(\?|#|\/|$))/i); if (match) { urlObj.host = match[1]; urlSub = urlSub.substr(match[0].length); } match = urlSub.match(/^\/(.*?)(?=(\?|#|$))/i); if (match) { urlObj.path = match[1]; urlSub = urlSub.substr(match[0].length); } match = urlSub.match(/^\?(.*?)(?=(#|$))/i); if (match) { urlObj.query = match[1]; urlSub = urlSub.substr(match[0].length); } match = urlSub.match(/^#(.*?)$/i); if (match) { urlObj.fragment = match[1]; //urlSub = urlSub.substr(match[0].length); -- not used. Uncomment if adding another block. } return urlObj; }; var buildUrl = function(urlObj){ var url = ""; if (urlObj.scheme && urlObj.host) { url += urlObj.scheme + "://"; } if (urlObj.host) { url += urlObj.host; } if (urlObj.path) { url += "/" + urlObj.path; } if (urlObj.query) { url += "?" + urlObj.query; } if (urlObj.fragment) { url += "#" + urlObj.fragment; } return url; }; var buildSegment = function(segment, remainingAvailableLength){ var remainingAvailableLengthHalf = remainingAvailableLength/ 2, startOffset = Math.ceil(remainingAvailableLengthHalf), endOffset = (-1)*Math.floor(remainingAvailableLengthHalf), end = ""; if (endOffset < 0) { end = segment.substr(endOffset); } return segment.substr(0, startOffset) + ellipsisChars + end; }; if (url.length <= truncateLen) { return url; } var availableLength = truncateLen - ellipsisChars.length; var urlObj = parse_url(url); // Clean up the URL if (urlObj.query) { var matchQuery = urlObj.query.match(/^(.*?)(?=(\?|\#))(.*?)$/i); if (matchQuery) { // Malformed URL; two or more "?". Removed any content behind the 2nd. urlObj.query = urlObj.query.substr(0, matchQuery[1].length); url = buildUrl(urlObj); } } if (url.length <= truncateLen) { return url; } if (urlObj.host) { urlObj.host = urlObj.host.replace(/^www\./, ""); url = buildUrl(urlObj); } if (url.length <= truncateLen) { return url; } // Process and build the URL var str = ""; if (urlObj.host) { str += urlObj.host; } if (str.length >= availableLength) { if (urlObj.host.length == truncateLen) { return (urlObj.host.substr(0, (truncateLen - ellipsisChars.length)) + ellipsisChars).substr(0, truncateLen); } return buildSegment(str, availableLength).substr(0, truncateLen); } var pathAndQuery = ""; if (urlObj.path) { pathAndQuery += "/" + urlObj.path; } if (urlObj.query) { pathAndQuery += "?" + urlObj.query; } if (pathAndQuery) { if ((str+pathAndQuery).length >= availableLength) { if ((str+pathAndQuery).length == truncateLen) { return (str + pathAndQuery).substr(0, truncateLen); } var remainingAvailableLength = availableLength - str.length; return (str + buildSegment(pathAndQuery, remainingAvailableLength)).substr(0, truncateLen); } else { str += pathAndQuery; } } if (urlObj.fragment) { var fragment = "#"+urlObj.fragment; if ((str+fragment).length >= availableLength) { if ((str+fragment).length == truncateLen) { return (str + fragment).substr(0, truncateLen); } var remainingAvailableLength2 = availableLength - str.length; return (str + buildSegment(fragment, remainingAvailableLength2)).substr(0, truncateLen); } else { str += fragment; } } if (urlObj.scheme && urlObj.host) { var scheme = urlObj.scheme + "://"; if ((str+scheme).length < availableLength) { return (scheme + str).substr(0, truncateLen); } } if (str.length <= truncateLen) { return str; } var end = ""; if (availableLength > 0) { end = str.substr((-1)*Math.floor(availableLength/2)); } return (str.substr(0, Math.ceil(availableLength/2)) + ellipsisChars + end).substr(0, truncateLen); }; return Autolinker; })); },{}],"/":[function(require,module,exports){ 'use strict'; module.exports = require('./lib/'); },{"./lib/":14}]},{},[])("/") });