loleaflet/.eslintignore | 1
loleaflet/Makefile.am | 5
loleaflet/js/Autolinker.js | 4187 +++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 4191 insertions(+), 2 deletions(-)
New commits:
commit c537bea9389be67479f6347740fcbbe5b8ac4e87
Author: Henry Castro <hcas...@collabora.com>
AuthorDate: Thu Feb 20 12:21:44 2020 -0400
Commit: Henry Castro <hcas...@collabora.com>
CommitDate: Fri Feb 21 00:49:04 2020 +0100
loleaflet: import Autolinker.js library
The file was imported from node_modules/autolinker/dist/Autolinker.js
the main reason is to analyze the source code, debug and patch
if necessary
To get the source code from npm repository
make libs
Change-Id: I3eea7cc6e8d61623398d77ed74e751ccd861252b
Reviewed-on: https://gerrit.libreoffice.org/c/online/+/89150
Tested-by: Jenkins CollaboraOffice <jenkinscollaboraoff...@gmail.com>
Reviewed-by: Henry Castro <hcas...@collabora.com>
diff --git a/loleaflet/.eslintignore b/loleaflet/.eslintignore
index ca03adc2e..64caf1af1 100644
--- a/loleaflet/.eslintignore
+++ b/loleaflet/.eslintignore
@@ -1,4 +1,5 @@
# We only directly edit toolbar.js in dist/
+**/js/Autolinker.js
**/js/json2.js
**/js/select2.js
**/js/vex.combined.js
diff --git a/loleaflet/Makefile.am b/loleaflet/Makefile.am
index 413ef7f66..ea6e31621 100644
--- a/loleaflet/Makefile.am
+++ b/loleaflet/Makefile.am
@@ -72,6 +72,7 @@ define npm_source
endef
NODE_MODULES_SRC =\
+ autolinker@1.4.3 \
json-js@1.1.2 \
select2@4.0.1 \
vex-js@4.1.0 \
@@ -122,10 +123,10 @@ NODE_MODULES_JS =\
node_modules/jquery-mousewheel/jquery.mousewheel.js \
node_modules/jquery-contextmenu/dist/jquery.contextMenu.js \
node_modules/jquery-ui/jquery-ui.js \
- node_modules/smartmenus/dist/jquery.smartmenus.js \
- node_modules/autolinker/dist/Autolinker.js
+ node_modules/smartmenus/dist/jquery.smartmenus.js
LOLEAFLET_LIBS_JS =\
+ Autolinker.js \
json2.js \
select2.js \
vex.combined.js \
diff --git a/loleaflet/js/Autolinker.js b/loleaflet/js/Autolinker.js
new file mode 100644
index 000000000..d463c331a
--- /dev/null
+++ b/loleaflet/js/Autolinker.js
@@ -0,0 +1,4187 @@
+/*!
+ * Autolinker.js
+ * 1.4.3
+ *
+ * Copyright(c) 2017 Gregory Jacobs <g...@greg-jacobs.com>
+ * 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 <a href="http://www.yahoo.com";>yahoo.com</a>'
+ *
+ *
+ * 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 <a href="http://www.yahoo.com";>yahoo.com</a>'
+ *
+ *
+ * ## 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#/Hashtag/Mention (Twitter, Instagram)
+ * match that is encountered.
+ *
+ * For example:
+ *
+ * var input = "..."; // string with URLs, Email Addresses, Phone #s,
Hashtags, and Mentions (Twitter, Instagram)
+ *
+ * var linkedText = Autolinker.link( input, {
+ * replaceFn : function( 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 = match.buildTag(); // 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 '<a
href="http://newplace.to.link.phone.numbers.to/";>' + phoneNumber + '</a>';
+ *
+ * case 'hashtag' :
+ * var hashtag = match.getHashtag();
+ * console.log( hashtag );
+ *
+ * return '<a
href="http://newplace.to.link.hashtag.handles.to/";>' + hashtag + '</a>';
+ *
+ * case 'mention' :
+ * var mention = match.getMention();
+ * console.log( mention );
+ *
+ * return '<a href="http://newplace.to.link.mention.to/";>'
+ mention + '</a>';
+ * }
+ * }
+ * } );
+ *
+ *
+ * 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.phone = typeof cfg.phone === 'boolean' ? cfg.phone : true;
+ this.hashtag = cfg.hashtag || false;
+ this.mention = cfg.mention || false;
+ this.newWindow = typeof cfg.newWindow === 'boolean' ? cfg.newWindow :
true;
+ this.stripPrefix = this.normalizeStripPrefixCfg( cfg.stripPrefix );
+ this.stripTrailingSlash = typeof cfg.stripTrailingSlash === 'boolean' ?
cfg.stripTrailingSlash : true;
+
+ // Validate the value of the `mention` cfg
+ var mention = this.mention;
+ if( mention !== false && mention !== 'twitter' && mention !==
'instagram' ) {
+ throw new Error( "invalid `mention` cfg - see docs" );
+ }
+
+ // 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.context = cfg.context || this;
+
+ this.htmlParser = null;
+ this.matchers = null;
+ this.tagBuilder = null;
+};
+
+
+
+/**
+ * Automatically links URLs, Email addresses, Phone Numbers, Twitter handles,
+ * Hashtags, and Mentions 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 <a href="http://google.com";>google.com</a>"
+ *
+ * @static
+ * @param {String} textOrHtml The HTML or text to find matches within
(depending
+ * on if the {@link #urls}, {@link #email}, {@link #phone}, {@link #mention},
+ * {@link #hashtag}, and {@link #mention} 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 );
+};
+
+
+
+/**
+ * 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 (without making any replacements).
+ *
+ * Note that if parsing multiple pieces of text, it is slightly more efficient
+ * to create an Autolinker instance, and use the instance-level {@link #parse}
+ * method.
+ *
+ * Example:
+ *
+ * var matches = Autolinker.parse( "Hello google.com, I am a...@asdf.com",
{
+ * urls: true,
+ * email: true
+ * } );
+ *
+ * console.log( matches.length ); // 2
+ * console.log( matches[ 0 ].getType() ); // 'url'
+ * console.log( matches[ 0 ].getUrl() ); // 'google.com'
+ * console.log( matches[ 1 ].getType() ); // 'email'
+ * console.log( matches[ 1 ].getEmail() ); // 'a...@asdf.com'
+ *
+ * @static
+ * @param {String} textOrHtml The HTML or text to find matches within
+ * (depending on if the {@link #urls}, {@link #email}, {@link #phone},
+ * {@link #hashtag}, and {@link #mention} 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 {Autolinker.match.Match[]} The array of Matches found in the
+ * given input `textOrHtml`.
+ */
+Autolinker.parse = function( textOrHtml, options ) {
+ var autolinker = new Autolinker( options );
+ return autolinker.parse( textOrHtml );
+};
+
+
+/**
+ * @static
+ * @property {String} version (readonly)
+ *
+ * The Autolinker version number in the form major.minor.patch
+ *
+ * Ex: 0.25.1
+ */
+Autolinker.version = '1.4.3';
+
+
+Autolinker.prototype = {
+ constructor : Autolinker, // fix constructor property
+
+ /**
+ * @cfg {Boolean/Object} [urls]
+ *
+ * `true` if URLs should be automatically linked, `false` if they
should not
+ * be. Defaults to `true`.
+ *
+ * Examples:
+ *
+ * urls: true
+ *
+ * // or
+ *
+ * urls: {
+ * schemeMatches : true,
+ * wwwMatches : true,
+ * tldMatches : true
+ * }
+ *
+ * As shown above, this option also accepts an Object form with 3
properties
+ * to allow for more customization of what exactly gets linked. All
default
+ * to `true`:
+ *
+ * @cfg {Boolean} [urls.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.
+ * @cfg {Boolean} [urls.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.
+ * @cfg {Boolean} [urls.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} [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 {String/Boolean} [mention=false]
+ *
+ * A string for the service name to have mentions (ex: "@myuser")
+ * auto-linked to. The currently supported values are:
+ *
+ * - 'twitter'
+ * - 'instagram'
+ *
+ * Defaults to `false` to skip auto-linking of mentions.
+ */
+
+ /**
+ * @cfg {Boolean} [newWindow=true]
+ *
+ * `true` if the links should open in a new window, `false` otherwise.
+ */
+
+ /**
+ * @cfg {Boolean/Object} [stripPrefix]
+ *
+ * `true` if 'http://' (or 'https://') and/or the 'www.' should be
stripped
+ * from the beginning of URL links' text, `false` otherwise. Defaults to
+ * `true`.
+ *
+ * Examples:
+ *
+ * stripPrefix: true
+ *
+ * // or
+ *
+ * stripPrefix: {
+ * scheme : true,
+ * www : true
+ * }
+ *
+ * As shown above, this option also accepts an Object form with 2
properties
+ * to allow for more customization of what exactly is prevented from
being
+ * displayed. Both default to `true`:
+ *
+ * @cfg {Boolean} [stripPrefix.scheme] `true` to prevent the scheme
part of
+ * a URL match from being displayed to the user. Example:
+ * `'http://google.com'` will be displayed as `'google.com'`. `false`
to
+ * not strip the scheme. NOTE: Only an `'http://'` or `'https://'`
scheme
+ * will be removed, so as not to remove a potentially dangerous scheme
+ * (such as `'file://'` or `'javascript:'`)
+ * @cfg {Boolean} [stripPrefix.www] www (Boolean): `true` to prevent the
+ * `'www.'` part of a URL match from being displayed to the user. Ex:
+ * `'www.google.com'` will be displayed as `'google.com'`. `false` to
not
+ * strip the `'www'`.
+ */
+
+ /**
+ * @cfg {Boolean} [stripTrailingSlash=true]
+ *
+ * `true` to remove the trailing slash from URL matches, `false` to keep
+ * the trailing slash.
+ *
+ * Example when `true`: `http://google.com/` will be displayed as
+ * `http://google.com`.
+ */
+
+ /**
+ * @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/hashtag/mention 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
+ * - Phone links will have the CSS classes: "myLink myLink-phone"
+ * - Hashtag links will have the CSS classes: "myLink myLink-hashtag"
+ * - Mention links will have the CSS classes: "myLink myLink-mention
myLink-[type]"
+ * where [type] is either "instagram" or "twitter"
+ */
+
+ /**
+ * @cfg {Function} replaceFn
+ *
+ * A function to individually process each match found in the input
string.
+ *
+ * See the class's description for usage.
+ *
+ * The `replaceFn` can be called with a different context object (`this`
+ * reference) using the {@link #context} cfg.
+ *
+ * This function is called with the following parameter:
+ *
+ * @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.
+ */
+
+ /**
+ * @cfg {Object} context
+ *
+ * The context object (`this` reference) to call the `replaceFn` with.
+ *
+ * Defaults to this Autolinker instance.
+ */
+
+
+ /**
+ * @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 #stripPrefix} config into an Object with 2
+ * properties: `scheme`, and `www` - both Booleans.
+ *
+ * See {@link #stripPrefix} config for details.
+ *
+ * @private
+ * @param {Boolean/Object} stripPrefix
+ * @return {Object}
+ */
+ normalizeStripPrefixCfg : function( stripPrefix ) {
+ if( stripPrefix == null ) stripPrefix = true; // default to
`true`
+
+ if( typeof stripPrefix === 'boolean' ) {
+ return { scheme: stripPrefix, www: stripPrefix };
+
+ } else { // object form
+ return {
+ scheme : typeof stripPrefix.scheme ===
'boolean' ? stripPrefix.scheme : true,
+ www : typeof stripPrefix.www === 'boolean'
? stripPrefix.www : 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 (without making any replacements).
+ *
+ * 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.
+ *
+ * Example usage:
+ *
+ * var autolinker = new Autolinker( {
+ * urls: true,
+ * email: true
+ * } );
+ *
+ * var matches = autolinker.parse( "Hello google.com, I am
a...@asdf.com" );
+ *
+ * console.log( matches.length ); // 2
+ * console.log( matches[ 0 ].getType() ); // 'url'
+ * console.log( matches[ 0 ].getUrl() ); // 'google.com'
+ * console.log( matches[ 1 ].getType() ); // 'email'
+ * console.log( matches[ 1 ].getEmail() ); // 'a...@asdf.com'
+ *
+ * @param {String} textOrHtml The HTML or text to find matches within
+ * (depending on if the {@link #urls}, {@link #email}, {@link #phone},
+ * {@link #hashtag}, and {@link #mention} 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 <a> 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 <a> tag
+ if( !node.isClosing() ) { // it's the start
<a> tag
+ anchorTagStackCount++;
+ } else { // it's the end </a> tag
+ anchorTagStackCount = Math.max(
anchorTagStackCount - 1, 0 ); // attempt to handle extraneous </a> 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 <a> 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 ],
+ offset = match.getOffset(),
+ matchedTextLength =
match.getMatchedText().length,
+ endIdx = offset + matchedTextLength;
+
+ if( i + 1 < matches.length ) {
+ // Remove subsequent matches that equal offset
with current match
+ if( matches[ i + 1 ].getOffset() === offset ) {
+ var removeIdx = matches[ i + 1
].getMatchedText().length > matchedTextLength ? i : i + 1;
+ matches.splice( removeIdx, 1 );
+ continue;
+ }
+
+ // Remove subsequent matches that overlap with
the current match
+ if( 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.mention ) remove( matches, function( match ) { return
match.getType() === 'mention'; } );
+ 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 #hashtag}, and {@link #mention} 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, Hashtags,
+ * and Mentions (Twitter, Instagram) 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 #hashtag}, and {@link #mention} 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.context,
match ); // Autolinker instance is the context
+ }
+
+ 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.Mention( { tagBuilder:
tagBuilder, serviceName: this.mention } ),
+ new matchersNs.Url( { tagBuilder: tagBuilder,
stripPrefix: this.stripPrefix, stripTrailingSlash: this.stripTrailingSlash } )
+ ];
+
+ 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( match ) {
+ * var tag = match.buildTag(); // returns an {@link
Autolinker.HtmlTag} instance
+ * tag.setAttr( 'rel', 'nofollow' );
+ *
+ * return tag;
+ * }
+ * } );
+ *
+ * // generated html:
+ * // Test <a href="http://google.com"; target="_blank"
rel="nofollow">google.com</a>
+ *
+ * @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 ) {
+ var ellipsisLength;
+
+ if( str.length > truncateLen ) {
+ if(ellipsisChars == null) {
+ ellipsisChars = '…';
+ ellipsisLength = 3;
+ } else {
+ ellipsisLength = ellipsisChars.length;
+ }
+
+ str = str.substring( 0, truncateLen - ellipsisLength )
+ 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(); // <a href="http://google.com";
class="external-link">Google</a>
+ *
+ * // 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(); // <a href="http://google.com";
class="external-link">Google</a>
+ *
+ *
+ * ## Example use within a {@link Autolinker#replaceFn replaceFn}
+ *
+ * var html = Autolinker.link( "Test google.com", {
+ * replaceFn : function( 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 <a href="http://google.com"; target="_blank"
rel="nofollow">google.com</a>
+ *
+ *
+ * ## Example use with a new tag for the replacement
+ *
+ * var html = Autolinker.link( "Test google.com", {
+ * replaceFn : function( match ) {
+ * var tag = new Autolinker.HtmlTag( {
+ * tagName : 'button',
+ * attrs : { 'title': 'Load URL: ' + match.getAnchorHref() },
+ * innerHtml : 'Load URL: ' + match.getAnchorText()
+ * } );
+ *
+ * return tag;
+ * }
+ * } );
+ *
+ * // generated html:
+ * // Test <button title="Load URL: http://google.com";>Load URL:
google.com</button>
+ */
+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.<String, String>} 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.<String, String>} 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.<String, String>} 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(),
'</', tagName, '>' ].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\u2
D27\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\u
FB00-\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 + '\\-]' );
+
+ 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,
+
+ /**
+ * The string form of a regular expression that would match all
of the
+ * letters and in the unicode character set when placed
+ * in a RegExp character class (`[]`).
+ *
+ * These would be the characters matched by unicode regex
engines `[\p{L}]`
+ * escape ("all letters")
+ *
+ * @property {String} alphaCharsStr
+ */
+ alphaCharsStr : alphaCharsStr,
+
+ /**
+ * 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,
+
+ };
+
+
+}() );
+
+/*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 used indirectly 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( match ) {
+ * var tag = match.buildTag(); // returns an {@link
Autolinker.HtmlTag} instance
+ * tag.setAttr( 'rel', 'nofollow' );
+ *
+ * return tag;
+ * }
+ * } );
+ *
+ * // generated html:
+ * // Test <a href="http://google.com"; target="_blank"
rel="nofollow">google.com</a>
+ */
+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 ) {
+ cfg = cfg || {};
+
+ this.newWindow = cfg.newWindow;
+ this.truncate = cfg.truncate;
+ this.className = cfg.className;
+ },
+
+
+ /**
+ * 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 ),
+ innerHtml : this.processAnchorText(
match.getAnchorText() )
+ } );
+ },
+
+
+ /**
+ * Creates the Object (map) of the HTML attributes for the anchor
(<a>)
+ * tag being generated.
+ *
+ * @protected
+ * @param {Autolinker.match.Match} match The Match instance to generate
an
+ * anchor tag from.
+ * @return {Object} A key/value Object (map) of the anchor tag's
attributes.
+ */
+ createAttrs : function( match ) {
+ var attrs = {
+ 'href' : match.getAnchorHref() // we'll always have
the `href` attribute
+ };
+
+ var cssClass = this.createCssClass( match );
+ if( cssClass ) {
+ attrs[ 'class' ] = cssClass;
+ }
+ if( this.newWindow ) {
+ attrs[ 'target' ] = "_blank";
+ attrs[ 'rel' ] = "noopener noreferrer";
+ }
+
+ if( this.truncate ) {
+ if( this.truncate.length && this.truncate.length <
match.getAnchorText().length ) {
+ attrs[ 'title' ] = match.getAnchorHref();
+ }
+ }
+
+ return attrs;
+ },
+
+
+ /**
+ * Creates the CSS class that will be used for a given anchor tag,
based on
+ * the `matchType` and the {@link #className} config.
+ *
+ * Example returns:
+ *
+ * - "" // no {@link #className}
+ * - "myLink myLink-url" // url match
+ * - "myLink myLink-email" // email match
+ * - "myLink myLink-phone" // phone match
+ * - "myLink myLink-hashtag" // hashtag match
+ * - "myLink myLink-mention myLink-twitter" // mention match with
Twitter service
+ *
+ * @private
+ * @param {Autolinker.match.Match} match The Match instance to generate
an
+ * anchor tag from.
+ * @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( match ) {
+ var className = this.className;
+
+ if( !className ) {
+ return "";
+
+ } else {
+ var returnClasses = [ className ],
+ cssClassSuffixes = match.getCssClassSuffixes();
+
+ for( var i = 0, len = cssClassSuffixes.length; i < len;
i++ ) {
+ returnClasses.push( className + '-' +
cssClassSuffixes[ i ] );
+ }
+ return returnClasses.join( ' ' );
+ }
+ },
+
+
+ /**
+ * 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/mentions 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 a tag without attributes (other than the
<!DOCTYPE> tag)
+ * 5. The tag name for a tag with attributes (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 <!DOCTYPE> tag. Ex: <!DOCTYPE html PUBLIC
"-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd";>)
+ '(?:',
+ '<(!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: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd";>)
+ '(?:', nameEqualsValueRegex,
'|', attrValueRegex.source + ')',
+ ')*',
+ '>',
+ ')',
+
+ '|',
+
+ // All other HTML tags (i.e. tags that are not
<!DOCTYPE>)
+ '(?:',
+ '<(/)?', // Beginning of a tag or comment.
Either '<' for a start tag, or '</' for an end tag.
+ // *** Capturing Group 2: The slash
or an empty string. Slash ('/') for end tag, empty string for start or
self-closing tag.
+
+ '(?:',
+ commentTagRegex.source, // ***
Capturing Group 3 - A Comment Tag's Text
+
+ '|',
+
+ // Handle tag without
attributes.
+ // Doing this separately from a
tag that has attributes
+ // to fix a regex time
complexity issue seen with the
+ // example in
https://github.com/gregjacobs/Autolinker.js/issues/172
+ '(?:',
+ // *** Capturing Group
4 - The tag name for a tag without attributes
+ '(' +
tagNameRegex.source + ')',
+
+ '\\s*/?', // any
trailing spaces and optional '/' before the closing '>'
+ ')',
+
+ '|',
+
+ // Handle tag with attributes
+ // Doing this separately from a
tag with no attributes
+ // to fix a regex time
complexity issue seen with the
+ // example in
https://github.com/gregjacobs/Autolinker.js/issues/172
+ '(?:',
+ // *** Capturing Group
5 - The tag name for a tag with attributes
+ '(' +
tagNameRegex.source + ')',
+
+ '\\s+', // must have
at least one space after the tag name to prevent ReDoS issue (issue #172)
+
+ // Zero or more
attributes following the tag name
+ '(?:',
+ '(?:\\s+|\\b)',
// any number of whitespace chars before an attribute. NOTE: Using \s*
here throws Chrome into an infinite loop for some reason, so using \s+|\b
instead
+
nameEqualsValueRegex, // attr="value" (with optional ="value" part)
+ ')*',
+
+ '\\s*/?', // any
trailing spaces and optional '/' before the closing '>'
+ ')',
+ ')',
+ '>',
+ ')'
+ ].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 ]
|| currentResult[ 5 ], // The <!DOCTYPE> 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 );
+
+ // Note: the following 3 lines were previously:
+ // nodes.push.apply( nodes,
textAndEntityNodes );
+ // but this was causing a "Maximum Call Stack
Size Exceeded"
+ // error on inputs with a large number of html
entities.
+ textAndEntityNodes.forEach( function( node ) {
+ nodes.push( node );
+ } );
+ }
+ }
+
+ 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 Mentions
(Twitter, Instagram)
+ *
+ * var linkedText = Autolinker.link( input, {
+ * replaceFn : function( 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 'mention' :
+ * console.log( "mention: ", match.getMention() );
+ * }
+ * }
+ * } );
+ *
+ * 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,
+
+
+ /**
+ * Returns the CSS class suffix(es) for this match.
+ *
+ * A CSS class suffix is appended to the {@link Autolinker#className} in
+ * the {@link Autolinker.AnchorTagBuilder} when a match is translated
into
+ * an anchor tag.
+ *
+ * For example, if {@link Autolinker#className} was configured as
'myLink',
+ * and this method returns `[ 'url' ]`, the final class name of the
element
+ * will become: 'myLink myLink-url'.
+ *
+ * The match may provide multiple CSS class suffixes to be appended to
the
+ * {@link Autolinker#className} in order to facilitate better styling
+ * options for different match criteria. See {@link
Autolinker.match.Mention}
+ * for an example.
+ *
+ * By default, this method returns a single array with the match's
+ * {@link #getType type} name, but may be overridden by subclasses.
+ *
+ * @return {String[]}
+ */
+ getCssClassSuffixes : function() {
+ return [ this.getType() ];
+ },
+
+
+ /**
+ * 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(); // <a href="http://google.com";
class="cordova-link" target="_system">Google</a>
+ */
+ 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.Mention
+ * @extends Autolinker.match.Match
+ *
+ * Represents a Mention match found in an input string which should be
Autolinked.
+ *
+ * See this class's superclass ({@link Autolinker.match.Match}) for more
details.
+ */
+Autolinker.match.Mention = Autolinker.Util.extend( Autolinker.match.Match, {
+
+ /**
+ * @cfg {String} serviceName
+ *
+ * The service to point mention matches to. See {@link
Autolinker#mention}
+ * for available values.
+ */
+
+ /**
+ * @cfg {String} mention (required)
+ *
+ * The Mention 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.serviceName ) throw new Error( '`serviceName` cfg
required' );
+ if( !cfg.mention ) throw new Error( '`mention` cfg required' );
+
+ this.mention = cfg.mention;
+ this.serviceName = cfg.serviceName;
+ },
+
+
+ /**
+ * Returns the type of match that this class represents.
+ *
+ * @return {String}
+ */
+ getType : function() {
+ return 'mention';
+ },
+
+
+ /**
+ * Returns the mention, without the '@' character.
+ *
+ * @return {String}
+ */
+ getMention : function() {
+ return this.mention;
+ },
+
+
+ /**
+ * Returns the configured {@link #serviceName} to point the mention to.
+ * Ex: 'instagram', 'twitter'.
+ *
+ * @return {String}
+ */
+ getServiceName : function() {
+ return this.serviceName;
+ },
+
+
+ /**
+ * Returns the anchor href that should be generated for the match.
+ *
+ * @return {String}
+ */
+ getAnchorHref : function() {
+ switch( this.serviceName ) {
+ case 'twitter' :
+ return 'https://twitter.com/' + this.mention;
+ case 'instagram' :
+ return 'https://instagram.com/' + this.mention;
+
+ 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
mention to: ', this.serviceName );
+ }
+ },
+
+
+ /**
+ * Returns the anchor text that should be generated for the match.
+ *
+ * @return {String}
+ */
+ getAnchorText : function() {
+ return '@' + this.mention;
+ },
+
+
+ /**
+ * Returns the CSS class suffixes that should be used on a tag built
with
+ * the match. See {@link Autolinker.match.Match#getCssClassSuffixes} for
+ * details.
+ *
+ * @return {String[]}
+ */
+ getCssClassSuffixes : function() {
+ var cssClassSuffixes =
Autolinker.match.Match.prototype.getCssClassSuffixes.call( this ),
+ serviceName = this.getServiceName();
+
+ if( serviceName ) {
+ cssClassSuffixes.push( serviceName );
+ }
+ return cssClassSuffixes;
+ }
+
+} );
+
+/*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 {Object} stripPrefix (required)
+ *
+ * The Object form of {@link Autolinker#cfg-stripPrefix}.
+ */
+
+ /**
+ * @cfg {Boolean} stripTrailingSlash (required)
+ * @inheritdoc Autolinker#cfg-stripTrailingSlash
+ */
+
+
+ /**
+ * @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' );
+ if( cfg.stripTrailingSlash == null ) throw new Error(
'`stripTrailingSlash` cfg required' );
+
+ this.urlMatchType = cfg.urlMatchType;
+ this.url = cfg.url;
+ this.protocolUrlMatch = cfg.protocolUrlMatch;
+ this.protocolRelativeMatch = cfg.protocolRelativeMatch;
+ this.stripPrefix = cfg.stripPrefix;
+ this.stripTrailingSlash = cfg.stripTrailingSlash;
+ },
+
+
+ /**
+ * @private
+ * @property {RegExp} schemePrefixRegex
+ *
+ * A regular expression used to remove the 'http://' or 'https://' from
+ * URLs.
+ */
+ schemePrefixRegex: /^(https?:\/\/)?/i,
+
+ /**
+ * @private
+ * @property {RegExp} wwwPrefixRegex
+ *
+ * A regular expression used to remove the 'www.' from URLs.
+ */
+ wwwPrefixRegex: /^(https?:\/\/)?(www\.)?/i,
+
+ /**
... etc. - the rest is truncated
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
