X-Git-Url: https://git.mdrn.pl/wl-app.git/blobdiff_plain/48b2fe9f7c2dc3d9aeaaa6dbfb27c7da4f3235ff..269195b3729c1bdc22e9053ee4ebca667ea8549d:/Android/folioreader/src/main/assets/js/rangy-classapplier.js diff --git a/Android/folioreader/src/main/assets/js/rangy-classapplier.js b/Android/folioreader/src/main/assets/js/rangy-classapplier.js new file mode 100755 index 0000000..41d9f8d --- /dev/null +++ b/Android/folioreader/src/main/assets/js/rangy-classapplier.js @@ -0,0 +1,1110 @@ +/** + * Class Applier module for Rangy. + * Adds, removes and toggles classes on Ranges and Selections + * + * Part of Rangy, a cross-browser JavaScript range and selection library + * https://github.com/timdown/rangy + * + * Depends on Rangy core. + * + * Copyright 2015, Tim Down + * Licensed under the MIT license. + * Version: 1.3.0 + * Build date: 10 May 2015 + */ +(function(factory, root) { + if (typeof define == "function" && define.amd) { + // AMD. Register as an anonymous module with a dependency on Rangy. + define(["./rangy-core"], factory); + } else if (typeof module != "undefined" && typeof exports == "object") { + // Node/CommonJS style + module.exports = factory( require("rangy") ); + } else { + // No AMD or CommonJS support so we use the rangy property of root (probably the global variable) + factory(root.rangy); + } +})(function(rangy) { + rangy.createModule("ClassApplier", ["WrappedSelection"], function(api, module) { + var dom = api.dom; + var DomPosition = dom.DomPosition; + var contains = dom.arrayContains; + var util = api.util; + var forEach = util.forEach; + + + var defaultTagName = "span"; + var createElementNSSupported = util.isHostMethod(document, "createElementNS"); + + function each(obj, func) { + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + if (func(i, obj[i]) === false) { + return false; + } + } + } + return true; + } + + function trim(str) { + return str.replace(/^\s\s*/, "").replace(/\s\s*$/, ""); + } + + function classNameContainsClass(fullClassName, className) { + return !!fullClassName && new RegExp("(?:^|\\s)" + className + "(?:\\s|$)").test(fullClassName); + } + + // Inefficient, inelegant nonsense for IE's svg element, which has no classList and non-HTML className implementation + function hasClass(el, className) { + if (typeof el.classList == "object") { + return el.classList.contains(className); + } else { + var classNameSupported = (typeof el.className == "string"); + var elClass = classNameSupported ? el.className : el.getAttribute("class"); + return classNameContainsClass(elClass, className); + } + } + + function addClass(el, className,serializedHighlight) { + if (typeof el.classList == "object") { + el.classList.add(className); + el.setAttribute("id", serializedHighlight); + el.setAttribute("onclick","callHighlightURL(this)"); + } else { + var classNameSupported = (typeof el.className == "string"); + var elClass = classNameSupported ? el.className : el.getAttribute("class"); + if (elClass) { + if (!classNameContainsClass(elClass, className)) { + elClass += " " + className; + } + } else { + elClass = className; + } + if (classNameSupported) { + el.className = elClass; + } else { + el.setAttribute("class", elClass); + } + } + } + + var removeClass = (function() { + function replacer(matched, whiteSpaceBefore, whiteSpaceAfter) { + return (whiteSpaceBefore && whiteSpaceAfter) ? " " : ""; + } + + return function(el, className) { + if (typeof el.classList == "object") { + el.classList.remove(className); + el.removeAttribute('onclick'); + el.removeAttribute('id'); + } else { + var classNameSupported = (typeof el.className == "string"); + var elClass = classNameSupported ? el.className : el.getAttribute("class"); + elClass = elClass.replace(new RegExp("(^|\\s)" + className + "(\\s|$)"), replacer); + if (classNameSupported) { + el.className = elClass; + } else { + el.setAttribute("class", elClass); + } + } + }; + })(); + + function getClass(el) { + var classNameSupported = (typeof el.className == "string"); + return classNameSupported ? el.className : el.getAttribute("class"); + } + + function sortClassName(className) { + return className && className.split(/\s+/).sort().join(" "); + } + + function getSortedClassName(el) { + return sortClassName( getClass(el) ); + } + + function haveSameClasses(el1, el2) { + return getSortedClassName(el1) == getSortedClassName(el2); + } + + function hasAllClasses(el, className) { + var classes = className.split(/\s+/); + for (var i = 0, len = classes.length; i < len; ++i) { + if (!hasClass(el, trim(classes[i]))) { + return false; + } + } + return true; + } + + function canTextBeStyled(textNode) { + var parent = textNode.parentNode; + return (parent && parent.nodeType == 1 && !/^(textarea|style|script|select|iframe)$/i.test(parent.nodeName)); + } + + function movePosition(position, oldParent, oldIndex, newParent, newIndex) { + var posNode = position.node, posOffset = position.offset; + var newNode = posNode, newOffset = posOffset; + + if (posNode == newParent && posOffset > newIndex) { + ++newOffset; + } + + if (posNode == oldParent && (posOffset == oldIndex || posOffset == oldIndex + 1)) { + newNode = newParent; + newOffset += newIndex - oldIndex; + } + + if (posNode == oldParent && posOffset > oldIndex + 1) { + --newOffset; + } + + position.node = newNode; + position.offset = newOffset; + } + + function movePositionWhenRemovingNode(position, parentNode, index) { + if (position.node == parentNode && position.offset > index) { + --position.offset; + } + } + + function movePreservingPositions(node, newParent, newIndex, positionsToPreserve) { + // For convenience, allow newIndex to be -1 to mean "insert at the end". + if (newIndex == -1) { + newIndex = newParent.childNodes.length; + } + + var oldParent = node.parentNode; + var oldIndex = dom.getNodeIndex(node); + + forEach(positionsToPreserve, function(position) { + movePosition(position, oldParent, oldIndex, newParent, newIndex); + }); + + // Now actually move the node. + if (newParent.childNodes.length == newIndex) { + newParent.appendChild(node); + } else { + newParent.insertBefore(node, newParent.childNodes[newIndex]); + } + } + + function removePreservingPositions(node, positionsToPreserve) { + + var oldParent = node.parentNode; + var oldIndex = dom.getNodeIndex(node); + + forEach(positionsToPreserve, function(position) { + movePositionWhenRemovingNode(position, oldParent, oldIndex); + }); + + dom.removeNode(node); + } + + function moveChildrenPreservingPositions(node, newParent, newIndex, removeNode, positionsToPreserve) { + var child, children = []; + while ( (child = node.firstChild) ) { + movePreservingPositions(child, newParent, newIndex++, positionsToPreserve); + children.push(child); + } + if (removeNode) { + removePreservingPositions(node, positionsToPreserve); + } + return children; + } + + function replaceWithOwnChildrenPreservingPositions(element, positionsToPreserve) { + return moveChildrenPreservingPositions(element, element.parentNode, dom.getNodeIndex(element), true, positionsToPreserve); + } + + function rangeSelectsAnyText(range, textNode) { + var textNodeRange = range.cloneRange(); + textNodeRange.selectNodeContents(textNode); + + var intersectionRange = textNodeRange.intersection(range); + var text = intersectionRange ? intersectionRange.toString() : ""; + + return text != ""; + } + + function getEffectiveTextNodes(range) { + var nodes = range.getNodes([3]); + + // Optimization as per issue 145 + + // Remove non-intersecting text nodes from the start of the range + var start = 0, node; + while ( (node = nodes[start]) && !rangeSelectsAnyText(range, node) ) { + ++start; + } + + // Remove non-intersecting text nodes from the start of the range + var end = nodes.length - 1; + while ( (node = nodes[end]) && !rangeSelectsAnyText(range, node) ) { + --end; + } + + return nodes.slice(start, end + 1); + } + + function elementsHaveSameNonClassAttributes(el1, el2) { + if (el1.attributes.length != el2.attributes.length) return false; + for (var i = 0, len = el1.attributes.length, attr1, attr2, name; i < len; ++i) { + attr1 = el1.attributes[i]; + name = attr1.name; + if (name != "class") { + attr2 = el2.attributes.getNamedItem(name); + if ( (attr1 === null) != (attr2 === null) ) return false; + if (attr1.specified != attr2.specified) return false; + if (attr1.specified && attr1.nodeValue !== attr2.nodeValue) return false; + } + } + return true; + } + + function elementHasNonClassAttributes(el, exceptions) { + for (var i = 0, len = el.attributes.length, attrName; i < len; ++i) { + attrName = el.attributes[i].name; + if ( !(exceptions && contains(exceptions, attrName)) && el.attributes[i].specified && attrName != "class") { + return true; + } + } + return false; + } + + var getComputedStyleProperty = dom.getComputedStyleProperty; + var isEditableElement = (function() { + var testEl = document.createElement("div"); + return typeof testEl.isContentEditable == "boolean" ? + function (node) { + return node && node.nodeType == 1 && node.isContentEditable; + } : + function (node) { + if (!node || node.nodeType != 1 || node.contentEditable == "false") { + return false; + } + return node.contentEditable == "true" || isEditableElement(node.parentNode); + }; + })(); + + function isEditingHost(node) { + var parent; + return node && node.nodeType == 1 && + (( (parent = node.parentNode) && parent.nodeType == 9 && parent.designMode == "on") || + (isEditableElement(node) && !isEditableElement(node.parentNode))); + } + + function isEditable(node) { + return (isEditableElement(node) || (node.nodeType != 1 && isEditableElement(node.parentNode))) && !isEditingHost(node); + } + + var inlineDisplayRegex = /^inline(-block|-table)?$/i; + + function isNonInlineElement(node) { + return node && node.nodeType == 1 && !inlineDisplayRegex.test(getComputedStyleProperty(node, "display")); + } + + // White space characters as defined by HTML 4 (http://www.w3.org/TR/html401/struct/text.html) + var htmlNonWhiteSpaceRegex = /[^\r\n\t\f \u200B]/; + + function isUnrenderedWhiteSpaceNode(node) { + if (node.data.length == 0) { + return true; + } + if (htmlNonWhiteSpaceRegex.test(node.data)) { + return false; + } + var cssWhiteSpace = getComputedStyleProperty(node.parentNode, "whiteSpace"); + switch (cssWhiteSpace) { + case "pre": + case "pre-wrap": + case "-moz-pre-wrap": + return false; + case "pre-line": + if (/[\r\n]/.test(node.data)) { + return false; + } + } + + // We now have a whitespace-only text node that may be rendered depending on its context. If it is adjacent to a + // non-inline element, it will not be rendered. This seems to be a good enough definition. + return isNonInlineElement(node.previousSibling) || isNonInlineElement(node.nextSibling); + } + + function getRangeBoundaries(ranges) { + var positions = [], i, range; + for (i = 0; range = ranges[i++]; ) { + positions.push( + new DomPosition(range.startContainer, range.startOffset), + new DomPosition(range.endContainer, range.endOffset) + ); + } + return positions; + } + + function updateRangesFromBoundaries(ranges, positions) { + for (var i = 0, range, start, end, len = ranges.length; i < len; ++i) { + range = ranges[i]; + start = positions[i * 2]; + end = positions[i * 2 + 1]; + range.setStartAndEnd(start.node, start.offset, end.node, end.offset); + } + } + + function isSplitPoint(node, offset) { + if (dom.isCharacterDataNode(node)) { + if (offset == 0) { + return !!node.previousSibling; + } else if (offset == node.length) { + return !!node.nextSibling; + } else { + return true; + } + } + + return offset > 0 && offset < node.childNodes.length; + } + + function splitNodeAt(node, descendantNode, descendantOffset, positionsToPreserve) { + var newNode, parentNode; + var splitAtStart = (descendantOffset == 0); + + if (dom.isAncestorOf(descendantNode, node)) { + return node; + } + + if (dom.isCharacterDataNode(descendantNode)) { + var descendantIndex = dom.getNodeIndex(descendantNode); + if (descendantOffset == 0) { + descendantOffset = descendantIndex; + } else if (descendantOffset == descendantNode.length) { + descendantOffset = descendantIndex + 1; + } else { + throw module.createError("splitNodeAt() should not be called with offset in the middle of a data node (" + + descendantOffset + " in " + descendantNode.data); + } + descendantNode = descendantNode.parentNode; + } + + if (isSplitPoint(descendantNode, descendantOffset)) { + // descendantNode is now guaranteed not to be a text or other character node + newNode = descendantNode.cloneNode(false); + parentNode = descendantNode.parentNode; + if (newNode.id) { + newNode.removeAttribute("id"); + } + var child, newChildIndex = 0; + + while ( (child = descendantNode.childNodes[descendantOffset]) ) { + movePreservingPositions(child, newNode, newChildIndex++, positionsToPreserve); + } + movePreservingPositions(newNode, parentNode, dom.getNodeIndex(descendantNode) + 1, positionsToPreserve); + return (descendantNode == node) ? newNode : splitNodeAt(node, parentNode, dom.getNodeIndex(newNode), positionsToPreserve); + } else if (node != descendantNode) { + newNode = descendantNode.parentNode; + + // Work out a new split point in the parent node + var newNodeIndex = dom.getNodeIndex(descendantNode); + + if (!splitAtStart) { + newNodeIndex++; + } + return splitNodeAt(node, newNode, newNodeIndex, positionsToPreserve); + } + return node; + } + + function areElementsMergeable(el1, el2) { + return el1.namespaceURI == el2.namespaceURI && + el1.tagName.toLowerCase() == el2.tagName.toLowerCase() && + haveSameClasses(el1, el2) && + elementsHaveSameNonClassAttributes(el1, el2) && + getComputedStyleProperty(el1, "display") == "inline" && + getComputedStyleProperty(el2, "display") == "inline"; + } + + function createAdjacentMergeableTextNodeGetter(forward) { + var siblingPropName = forward ? "nextSibling" : "previousSibling"; + + return function(textNode, checkParentElement) { + var el = textNode.parentNode; + var adjacentNode = textNode[siblingPropName]; + if (adjacentNode) { + // Can merge if the node's previous/next sibling is a text node + if (adjacentNode && adjacentNode.nodeType == 3) { + return adjacentNode; + } + } else if (checkParentElement) { + // Compare text node parent element with its sibling + adjacentNode = el[siblingPropName]; + if (adjacentNode && adjacentNode.nodeType == 1 && areElementsMergeable(el, adjacentNode)) { + var adjacentNodeChild = adjacentNode[forward ? "firstChild" : "lastChild"]; + if (adjacentNodeChild && adjacentNodeChild.nodeType == 3) { + return adjacentNodeChild; + } + } + } + return null; + }; + } + + var getPreviousMergeableTextNode = createAdjacentMergeableTextNodeGetter(false), + getNextMergeableTextNode = createAdjacentMergeableTextNodeGetter(true); + + + function Merge(firstNode) { + this.isElementMerge = (firstNode.nodeType == 1); + this.textNodes = []; + var firstTextNode = this.isElementMerge ? firstNode.lastChild : firstNode; + if (firstTextNode) { + this.textNodes[0] = firstTextNode; + } + } + + Merge.prototype = { + doMerge: function(positionsToPreserve) { + var textNodes = this.textNodes; + var firstTextNode = textNodes[0]; + if (textNodes.length > 1) { + var firstTextNodeIndex = dom.getNodeIndex(firstTextNode); + var textParts = [], combinedTextLength = 0, textNode, parent; + forEach(textNodes, function(textNode, i) { + parent = textNode.parentNode; + if (i > 0) { + parent.removeChild(textNode); + if (!parent.hasChildNodes()) { + dom.removeNode(parent); + } + if (positionsToPreserve) { + forEach(positionsToPreserve, function(position) { + // Handle case where position is inside the text node being merged into a preceding node + if (position.node == textNode) { + position.node = firstTextNode; + position.offset += combinedTextLength; + } + // Handle case where both text nodes precede the position within the same parent node + if (position.node == parent && position.offset > firstTextNodeIndex) { + --position.offset; + if (position.offset == firstTextNodeIndex + 1 && i < len - 1) { + position.node = firstTextNode; + position.offset = combinedTextLength; + } + } + }); + } + } + textParts[i] = textNode.data; + combinedTextLength += textNode.data.length; + }); + firstTextNode.data = textParts.join(""); + } + return firstTextNode.data; + }, + + getLength: function() { + var i = this.textNodes.length, len = 0; + while (i--) { + len += this.textNodes[i].length; + } + return len; + }, + + toString: function() { + var textParts = []; + forEach(this.textNodes, function(textNode, i) { + textParts[i] = "'" + textNode.data + "'"; + }); + return "[Merge(" + textParts.join(",") + ")]"; + } + }; + + var optionProperties = ["elementTagName", "ignoreWhiteSpace", "applyToEditableOnly", "useExistingElements", + "removeEmptyElements", "onElementCreate"]; + + // TODO: Populate this with every attribute name that corresponds to a property with a different name. Really?? + var attrNamesForProperties = {}; + + function ClassApplier(className, options, tagNames) { + var normalize, i, len, propName, applier = this; + applier.cssClass = applier.className = className; // cssClass property is for backward compatibility + + var elementPropertiesFromOptions = null, elementAttributes = {}; + + // Initialize from options object + if (typeof options == "object" && options !== null) { + if (typeof options.elementTagName !== "undefined") { + options.elementTagName = options.elementTagName.toLowerCase(); + } + tagNames = options.tagNames; + elementPropertiesFromOptions = options.elementProperties; + elementAttributes = options.elementAttributes; + + for (i = 0; propName = optionProperties[i++]; ) { + if (options.hasOwnProperty(propName)) { + applier[propName] = options[propName]; + } + } + normalize = options.normalize; + } else { + normalize = options; + } + + // Backward compatibility: the second parameter can also be a Boolean indicating to normalize after unapplying + applier.normalize = (typeof normalize == "undefined") ? true : normalize; + + // Initialize element properties and attribute exceptions + applier.attrExceptions = []; + var el = document.createElement(applier.elementTagName); + applier.elementProperties = applier.copyPropertiesToElement(elementPropertiesFromOptions, el, true); + each(elementAttributes, function(attrName, attrValue) { + applier.attrExceptions.push(attrName); + // Ensure each attribute value is a string + elementAttributes[attrName] = "" + attrValue; + }); + applier.elementAttributes = elementAttributes; + + applier.elementSortedClassName = applier.elementProperties.hasOwnProperty("className") ? + sortClassName(applier.elementProperties.className + " " + className) : className; + + // Initialize tag names + applier.applyToAnyTagName = false; + var type = typeof tagNames; + if (type == "string") { + if (tagNames == "*") { + applier.applyToAnyTagName = true; + } else { + applier.tagNames = trim(tagNames.toLowerCase()).split(/\s*,\s*/); + } + } else if (type == "object" && typeof tagNames.length == "number") { + applier.tagNames = []; + for (i = 0, len = tagNames.length; i < len; ++i) { + if (tagNames[i] == "*") { + applier.applyToAnyTagName = true; + } else { + applier.tagNames.push(tagNames[i].toLowerCase()); + } + } + } else { + applier.tagNames = [applier.elementTagName]; + } + } + + ClassApplier.prototype = { + elementTagName: defaultTagName, + elementProperties: {}, + elementAttributes: {}, + ignoreWhiteSpace: true, + applyToEditableOnly: false, + useExistingElements: true, + removeEmptyElements: true, + onElementCreate: null, + + copyPropertiesToElement: function(props, el, createCopy) { + var s, elStyle, elProps = {}, elPropsStyle, propValue, elPropValue, attrName; + + for (var p in props) { + if (props.hasOwnProperty(p)) { + propValue = props[p]; + elPropValue = el[p]; + + // Special case for class. The copied properties object has the applier's class as well as its own + // to simplify checks when removing styling elements + if (p == "className") { + addClass(el, propValue); + addClass(el, this.className); + el[p] = sortClassName(el[p]); + if (createCopy) { + elProps[p] = propValue; + } + } + + // Special case for style + else if (p == "style") { + elStyle = elPropValue; + if (createCopy) { + elProps[p] = elPropsStyle = {}; + } + for (s in props[p]) { + if (props[p].hasOwnProperty(s)) { + elStyle[s] = propValue[s]; + if (createCopy) { + elPropsStyle[s] = elStyle[s]; + } + } + } + this.attrExceptions.push(p); + } else { + el[p] = propValue; + // Copy the property back from the dummy element so that later comparisons to check whether + // elements may be removed are checking against the right value. For example, the href property + // of an element returns a fully qualified URL even if it was previously assigned a relative + // URL. + if (createCopy) { + elProps[p] = el[p]; + + // Not all properties map to identically-named attributes + attrName = attrNamesForProperties.hasOwnProperty(p) ? attrNamesForProperties[p] : p; + this.attrExceptions.push(attrName); + } + } + } + } + + return createCopy ? elProps : ""; + }, + + copyAttributesToElement: function(attrs, el) { + for (var attrName in attrs) { + if (attrs.hasOwnProperty(attrName) && !/^class(?:Name)?$/i.test(attrName)) { + el.setAttribute(attrName, attrs[attrName]); + } + } + }, + + appliesToElement: function(el) { + return contains(this.tagNames, el.tagName.toLowerCase()); + }, + + getEmptyElements: function(range) { + var applier = this; + return range.getNodes([1], function(el) { + return applier.appliesToElement(el) && !el.hasChildNodes(); + }); + }, + + hasClass: function(node) { + return node.nodeType == 1 && + (this.applyToAnyTagName || this.appliesToElement(node)) && + hasClass(node, this.className); + }, + + getSelfOrAncestorWithClass: function(node) { + while (node) { + if (this.hasClass(node)) { + return node; + } + node = node.parentNode; + } + return null; + }, + + isModifiable: function(node) { + return !this.applyToEditableOnly || isEditable(node); + }, + + // White space adjacent to an unwrappable node can be ignored for wrapping + isIgnorableWhiteSpaceNode: function(node) { + return this.ignoreWhiteSpace && node && node.nodeType == 3 && isUnrenderedWhiteSpaceNode(node); + }, + + // Normalizes nodes after applying a class to a Range. + postApply: function(textNodes, range, positionsToPreserve, isUndo) { + var firstNode = textNodes[0], lastNode = textNodes[textNodes.length - 1]; + + var merges = [], currentMerge; + + var rangeStartNode = firstNode, rangeEndNode = lastNode; + var rangeStartOffset = 0, rangeEndOffset = lastNode.length; + + var textNode, precedingTextNode; + + // Check for every required merge and create a Merge object for each + forEach(textNodes, function(textNode) { + precedingTextNode = getPreviousMergeableTextNode(textNode, !isUndo); + if (precedingTextNode) { + if (!currentMerge) { + currentMerge = new Merge(precedingTextNode); + merges.push(currentMerge); + } + currentMerge.textNodes.push(textNode); + if (textNode === firstNode) { + rangeStartNode = currentMerge.textNodes[0]; + rangeStartOffset = rangeStartNode.length; + } + if (textNode === lastNode) { + rangeEndNode = currentMerge.textNodes[0]; + rangeEndOffset = currentMerge.getLength(); + } + } else { + currentMerge = null; + } + }); + + // Test whether the first node after the range needs merging + var nextTextNode = getNextMergeableTextNode(lastNode, !isUndo); + + if (nextTextNode) { + if (!currentMerge) { + currentMerge = new Merge(lastNode); + merges.push(currentMerge); + } + currentMerge.textNodes.push(nextTextNode); + } + + // Apply the merges + if (merges.length) { + for (i = 0, len = merges.length; i < len; ++i) { + merges[i].doMerge(positionsToPreserve); + } + + // Set the range boundaries + range.setStartAndEnd(rangeStartNode, rangeStartOffset, rangeEndNode, rangeEndOffset); + } + }, + + createContainer: function(parentNode,serializedHighlight) { + var doc = dom.getDocument(parentNode); + var namespace; + var el = createElementNSSupported && !dom.isHtmlNamespace(parentNode) && (namespace = parentNode.namespaceURI) ? + doc.createElementNS(parentNode.namespaceURI, this.elementTagName) : + doc.createElement(this.elementTagName); + + this.copyPropertiesToElement(this.elementProperties, el, false); + this.copyAttributesToElement(this.elementAttributes, el); + //Highlight.printData("createContainer"); + addClass(el, this.className, serializedHighlight); + if (this.onElementCreate) { + this.onElementCreate(el, this); + } + return el; + }, + + elementHasProperties: function(el, props) { + var applier = this; + return each(props, function(p, propValue) { + if (p == "className") { + // For checking whether we should reuse an existing element, we just want to check that the element + // has all the classes specified in the className property. When deciding whether the element is + // removable when unapplying a class, there is separate special handling to check whether the + // element has extra classes so the same simple check will do. + return hasAllClasses(el, propValue); + } else if (typeof propValue == "object") { + if (!applier.elementHasProperties(el[p], propValue)) { + return false; + } + } else if (el[p] !== propValue) { + return false; + } + }); + }, + + elementHasAttributes: function(el, attrs) { + return each(attrs, function(name, value) { + if (el.getAttribute(name) !== value) { + return false; + } + }); + }, + + applyToTextNode: function(textNode, positionsToPreserve,serializedHighlight) { + + // Check whether the text node can be styled. Text within a