\";\n crashyTextNodes = isBrokenNode(textNode);\n\n api.features.crashyTextNodes = crashyTextNodes;\n })();\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n function inspectNode(node) {\n if (!node) {\n return \"[No node]\";\n }\n if (crashyTextNodes && isBrokenNode(node)) {\n return \"[Broken node]\";\n }\n if (isCharacterDataNode(node)) {\n return '\"' + node.data + '\"';\n }\n if (node.nodeType == 1) {\n var idAttr = node.id ? ' id=\"' + node.id + '\"' : \"\";\n return \"<\" + node.nodeName + idAttr + \">[index:\" + getNodeIndex(node) + \",length:\" + node.childNodes.length + \"][\" + (node.innerHTML || \"[innerHTML not supported]\").slice(0, 25) + \"]\";\n }\n return node.nodeName;\n }\n\n function fragmentFromNodeChildren(node) {\n var fragment = getDocument(node).createDocumentFragment(), child;\n while ( (child = node.firstChild) ) {\n fragment.appendChild(child);\n }\n return fragment;\n }\n\n var getComputedStyleProperty;\n if (typeof window.getComputedStyle != UNDEF) {\n getComputedStyleProperty = function(el, propName) {\n return getWindow(el).getComputedStyle(el, null)[propName];\n };\n } else if (typeof document.documentElement.currentStyle != UNDEF) {\n getComputedStyleProperty = function(el, propName) {\n return el.currentStyle ? el.currentStyle[propName] : \"\";\n };\n } else {\n module.fail(\"No means of obtaining computed style properties found\");\n }\n\n function createTestElement(doc, html, contentEditable) {\n var body = getBody(doc);\n var el = doc.createElement(\"div\");\n el.contentEditable = \"\" + !!contentEditable;\n if (html) {\n el.innerHTML = html;\n }\n\n // Insert the test element at the start of the body to prevent scrolling to the bottom in iOS (issue #292)\n var bodyFirstChild = body.firstChild;\n if (bodyFirstChild) {\n body.insertBefore(el, bodyFirstChild);\n } else {\n body.appendChild(el);\n }\n\n return el;\n }\n\n function removeNode(node) {\n return node.parentNode.removeChild(node);\n }\n\n function NodeIterator(root) {\n this.root = root;\n this._next = root;\n }\n\n NodeIterator.prototype = {\n _current: null,\n\n hasNext: function() {\n return !!this._next;\n },\n\n next: function() {\n var n = this._current = this._next;\n var child, next;\n if (this._current) {\n child = n.firstChild;\n if (child) {\n this._next = child;\n } else {\n next = null;\n while ((n !== this.root) && !(next = n.nextSibling)) {\n n = n.parentNode;\n }\n this._next = next;\n }\n }\n return this._current;\n },\n\n detach: function() {\n this._current = this._next = this.root = null;\n }\n };\n\n function createIterator(root) {\n return new NodeIterator(root);\n }\n\n function DomPosition(node, offset) {\n this.node = node;\n this.offset = offset;\n }\n\n DomPosition.prototype = {\n equals: function(pos) {\n return !!pos && this.node === pos.node && this.offset == pos.offset;\n },\n\n inspect: function() {\n return \"[DomPosition(\" + inspectNode(this.node) + \":\" + this.offset + \")]\";\n },\n\n toString: function() {\n return this.inspect();\n }\n };\n\n function DOMException(codeName) {\n this.code = this[codeName];\n this.codeName = codeName;\n this.message = \"DOMException: \" + this.codeName;\n }\n\n DOMException.prototype = {\n INDEX_SIZE_ERR: 1,\n HIERARCHY_REQUEST_ERR: 3,\n WRONG_DOCUMENT_ERR: 4,\n NO_MODIFICATION_ALLOWED_ERR: 7,\n NOT_FOUND_ERR: 8,\n NOT_SUPPORTED_ERR: 9,\n INVALID_STATE_ERR: 11,\n INVALID_NODE_TYPE_ERR: 24\n };\n\n DOMException.prototype.toString = function() {\n return this.message;\n };\n\n api.dom = {\n arrayContains: arrayContains,\n isHtmlNamespace: isHtmlNamespace,\n parentElement: parentElement,\n getNodeIndex: getNodeIndex,\n getNodeLength: getNodeLength,\n getCommonAncestor: getCommonAncestor,\n isAncestorOf: isAncestorOf,\n isOrIsAncestorOf: isOrIsAncestorOf,\n getClosestAncestorIn: getClosestAncestorIn,\n isCharacterDataNode: isCharacterDataNode,\n isTextOrCommentNode: isTextOrCommentNode,\n insertAfter: insertAfter,\n splitDataNode: splitDataNode,\n getDocument: getDocument,\n getWindow: getWindow,\n getIframeWindow: getIframeWindow,\n getIframeDocument: getIframeDocument,\n getBody: getBody,\n isWindow: isWindow,\n getContentDocument: getContentDocument,\n getRootContainer: getRootContainer,\n comparePoints: comparePoints,\n isBrokenNode: isBrokenNode,\n inspectNode: inspectNode,\n getComputedStyleProperty: getComputedStyleProperty,\n createTestElement: createTestElement,\n removeNode: removeNode,\n fragmentFromNodeChildren: fragmentFromNodeChildren,\n createIterator: createIterator,\n DomPosition: DomPosition\n };\n\n api.DOMException = DOMException;\n });\r\n\r\n /*----------------------------------------------------------------------------------------------------------------*/\r\n\r\n // Pure JavaScript implementation of DOM Range\n api.createCoreModule(\"DomRange\", [\"DomUtil\"], function(api, module) {\n var dom = api.dom;\n var util = api.util;\n var DomPosition = dom.DomPosition;\n var DOMException = api.DOMException;\n\n var isCharacterDataNode = dom.isCharacterDataNode;\n var getNodeIndex = dom.getNodeIndex;\n var isOrIsAncestorOf = dom.isOrIsAncestorOf;\n var getDocument = dom.getDocument;\n var comparePoints = dom.comparePoints;\n var splitDataNode = dom.splitDataNode;\n var getClosestAncestorIn = dom.getClosestAncestorIn;\n var getNodeLength = dom.getNodeLength;\n var arrayContains = dom.arrayContains;\n var getRootContainer = dom.getRootContainer;\n var crashyTextNodes = api.features.crashyTextNodes;\n\n var removeNode = dom.removeNode;\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n // Utility functions\n\n function isNonTextPartiallySelected(node, range) {\n return (node.nodeType != 3) &&\n (isOrIsAncestorOf(node, range.startContainer) || isOrIsAncestorOf(node, range.endContainer));\n }\n\n function getRangeDocument(range) {\n return range.document || getDocument(range.startContainer);\n }\n\n function getRangeRoot(range) {\n return getRootContainer(range.startContainer);\n }\n\n function getBoundaryBeforeNode(node) {\n return new DomPosition(node.parentNode, getNodeIndex(node));\n }\n\n function getBoundaryAfterNode(node) {\n return new DomPosition(node.parentNode, getNodeIndex(node) + 1);\n }\n\n function insertNodeAtPosition(node, n, o) {\n var firstNodeInserted = node.nodeType == 11 ? node.firstChild : node;\n if (isCharacterDataNode(n)) {\n if (o == n.length) {\n dom.insertAfter(node, n);\n } else {\n n.parentNode.insertBefore(node, o == 0 ? n : splitDataNode(n, o));\n }\n } else if (o >= n.childNodes.length) {\n n.appendChild(node);\n } else {\n n.insertBefore(node, n.childNodes[o]);\n }\n return firstNodeInserted;\n }\n\n function rangesIntersect(rangeA, rangeB, touchingIsIntersecting) {\n assertRangeValid(rangeA);\n assertRangeValid(rangeB);\n\n if (getRangeDocument(rangeB) != getRangeDocument(rangeA)) {\n throw new DOMException(\"WRONG_DOCUMENT_ERR\");\n }\n\n var startComparison = comparePoints(rangeA.startContainer, rangeA.startOffset, rangeB.endContainer, rangeB.endOffset),\n endComparison = comparePoints(rangeA.endContainer, rangeA.endOffset, rangeB.startContainer, rangeB.startOffset);\n\n return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;\n }\n\n function cloneSubtree(iterator) {\n var partiallySelected;\n for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator; node = iterator.next(); ) {\n partiallySelected = iterator.isPartiallySelectedSubtree();\n node = node.cloneNode(!partiallySelected);\n if (partiallySelected) {\n subIterator = iterator.getSubtreeIterator();\n node.appendChild(cloneSubtree(subIterator));\n subIterator.detach();\n }\n\n if (node.nodeType == 10) { // DocumentType\n throw new DOMException(\"HIERARCHY_REQUEST_ERR\");\n }\n frag.appendChild(node);\n }\n return frag;\n }\n\n function iterateSubtree(rangeIterator, func, iteratorState) {\n var it, n;\n iteratorState = iteratorState || { stop: false };\n for (var node, subRangeIterator; node = rangeIterator.next(); ) {\n if (rangeIterator.isPartiallySelectedSubtree()) {\n if (func(node) === false) {\n iteratorState.stop = true;\n return;\n } else {\n // The node is partially selected by the Range, so we can use a new RangeIterator on the portion of\n // the node selected by the Range.\n subRangeIterator = rangeIterator.getSubtreeIterator();\n iterateSubtree(subRangeIterator, func, iteratorState);\n subRangeIterator.detach();\n if (iteratorState.stop) {\n return;\n }\n }\n } else {\n // The whole node is selected, so we can use efficient DOM iteration to iterate over the node and its\n // descendants\n it = dom.createIterator(node);\n while ( (n = it.next()) ) {\n if (func(n) === false) {\n iteratorState.stop = true;\n return;\n }\n }\n }\n }\n }\n\n function deleteSubtree(iterator) {\n var subIterator;\n while (iterator.next()) {\n if (iterator.isPartiallySelectedSubtree()) {\n subIterator = iterator.getSubtreeIterator();\n deleteSubtree(subIterator);\n subIterator.detach();\n } else {\n iterator.remove();\n }\n }\n }\n\n function extractSubtree(iterator) {\n for (var node, frag = getRangeDocument(iterator.range).createDocumentFragment(), subIterator; node = iterator.next(); ) {\n\n if (iterator.isPartiallySelectedSubtree()) {\n node = node.cloneNode(false);\n subIterator = iterator.getSubtreeIterator();\n node.appendChild(extractSubtree(subIterator));\n subIterator.detach();\n } else {\n iterator.remove();\n }\n if (node.nodeType == 10) { // DocumentType\n throw new DOMException(\"HIERARCHY_REQUEST_ERR\");\n }\n frag.appendChild(node);\n }\n return frag;\n }\n\n function getNodesInRange(range, nodeTypes, filter) {\n var filterNodeTypes = !!(nodeTypes && nodeTypes.length), regex;\n var filterExists = !!filter;\n if (filterNodeTypes) {\n regex = new RegExp(\"^(\" + nodeTypes.join(\"|\") + \")$\");\n }\n\n var nodes = [];\n iterateSubtree(new RangeIterator(range, false), function(node) {\n if (filterNodeTypes && !regex.test(node.nodeType)) {\n return;\n }\n if (filterExists && !filter(node)) {\n return;\n }\n // Don't include a boundary container if it is a character data node and the range does not contain any\n // of its character data. See issue 190.\n var sc = range.startContainer;\n if (node == sc && isCharacterDataNode(sc) && range.startOffset == sc.length) {\n return;\n }\n\n var ec = range.endContainer;\n if (node == ec && isCharacterDataNode(ec) && range.endOffset == 0) {\n return;\n }\n\n nodes.push(node);\n });\n return nodes;\n }\n\n function inspect(range) {\n var name = (typeof range.getName == \"undefined\") ? \"Range\" : range.getName();\n return \"[\" + name + \"(\" + dom.inspectNode(range.startContainer) + \":\" + range.startOffset + \", \" +\n dom.inspectNode(range.endContainer) + \":\" + range.endOffset + \")]\";\n }\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n // RangeIterator code partially borrows from IERange by Tim Ryan (http://github.com/timcameronryan/IERange)\n\n function RangeIterator(range, clonePartiallySelectedTextNodes) {\n this.range = range;\n this.clonePartiallySelectedTextNodes = clonePartiallySelectedTextNodes;\n\n\n if (!range.collapsed) {\n this.sc = range.startContainer;\n this.so = range.startOffset;\n this.ec = range.endContainer;\n this.eo = range.endOffset;\n var root = range.commonAncestorContainer;\n\n if (this.sc === this.ec && isCharacterDataNode(this.sc)) {\n this.isSingleCharacterDataNode = true;\n this._first = this._last = this._next = this.sc;\n } else {\n this._first = this._next = (this.sc === root && !isCharacterDataNode(this.sc)) ?\n this.sc.childNodes[this.so] : getClosestAncestorIn(this.sc, root, true);\n this._last = (this.ec === root && !isCharacterDataNode(this.ec)) ?\n this.ec.childNodes[this.eo - 1] : getClosestAncestorIn(this.ec, root, true);\n }\n }\n }\n\n RangeIterator.prototype = {\n _current: null,\n _next: null,\n _first: null,\n _last: null,\n isSingleCharacterDataNode: false,\n\n reset: function() {\n this._current = null;\n this._next = this._first;\n },\n\n hasNext: function() {\n return !!this._next;\n },\n\n next: function() {\n // Move to next node\n var current = this._current = this._next;\n if (current) {\n this._next = (current !== this._last) ? current.nextSibling : null;\n\n // Check for partially selected text nodes\n if (isCharacterDataNode(current) && this.clonePartiallySelectedTextNodes) {\n if (current === this.ec) {\n (current = current.cloneNode(true)).deleteData(this.eo, current.length - this.eo);\n }\n if (this._current === this.sc) {\n (current = current.cloneNode(true)).deleteData(0, this.so);\n }\n }\n }\n\n return current;\n },\n\n remove: function() {\n var current = this._current, start, end;\n\n if (isCharacterDataNode(current) && (current === this.sc || current === this.ec)) {\n start = (current === this.sc) ? this.so : 0;\n end = (current === this.ec) ? this.eo : current.length;\n if (start != end) {\n current.deleteData(start, end - start);\n }\n } else {\n if (current.parentNode) {\n removeNode(current);\n } else {\n }\n }\n },\n\n // Checks if the current node is partially selected\n isPartiallySelectedSubtree: function() {\n var current = this._current;\n return isNonTextPartiallySelected(current, this.range);\n },\n\n getSubtreeIterator: function() {\n var subRange;\n if (this.isSingleCharacterDataNode) {\n subRange = this.range.cloneRange();\n subRange.collapse(false);\n } else {\n subRange = new Range(getRangeDocument(this.range));\n var current = this._current;\n var startContainer = current, startOffset = 0, endContainer = current, endOffset = getNodeLength(current);\n\n if (isOrIsAncestorOf(current, this.sc)) {\n startContainer = this.sc;\n startOffset = this.so;\n }\n if (isOrIsAncestorOf(current, this.ec)) {\n endContainer = this.ec;\n endOffset = this.eo;\n }\n\n updateBoundaries(subRange, startContainer, startOffset, endContainer, endOffset);\n }\n return new RangeIterator(subRange, this.clonePartiallySelectedTextNodes);\n },\n\n detach: function() {\n this.range = this._current = this._next = this._first = this._last = this.sc = this.so = this.ec = this.eo = null;\n }\n };\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n var beforeAfterNodeTypes = [1, 3, 4, 5, 7, 8, 10];\n var rootContainerNodeTypes = [2, 9, 11];\n var readonlyNodeTypes = [5, 6, 10, 12];\n var insertableNodeTypes = [1, 3, 4, 5, 7, 8, 10, 11];\n var surroundNodeTypes = [1, 3, 4, 5, 7, 8];\n\n function createAncestorFinder(nodeTypes) {\n return function(node, selfIsAncestor) {\n var t, n = selfIsAncestor ? node : node.parentNode;\n while (n) {\n t = n.nodeType;\n if (arrayContains(nodeTypes, t)) {\n return n;\n }\n n = n.parentNode;\n }\n return null;\n };\n }\n\n var getDocumentOrFragmentContainer = createAncestorFinder( [9, 11] );\n var getReadonlyAncestor = createAncestorFinder(readonlyNodeTypes);\n var getDocTypeNotationEntityAncestor = createAncestorFinder( [6, 10, 12] );\n\n function assertNoDocTypeNotationEntityAncestor(node, allowSelf) {\n if (getDocTypeNotationEntityAncestor(node, allowSelf)) {\n throw new DOMException(\"INVALID_NODE_TYPE_ERR\");\n }\n }\n\n function assertValidNodeType(node, invalidTypes) {\n if (!arrayContains(invalidTypes, node.nodeType)) {\n throw new DOMException(\"INVALID_NODE_TYPE_ERR\");\n }\n }\n\n function assertValidOffset(node, offset) {\n if (offset < 0 || offset > (isCharacterDataNode(node) ? node.length : node.childNodes.length)) {\n throw new DOMException(\"INDEX_SIZE_ERR\");\n }\n }\n\n function assertSameDocumentOrFragment(node1, node2) {\n if (getDocumentOrFragmentContainer(node1, true) !== getDocumentOrFragmentContainer(node2, true)) {\n throw new DOMException(\"WRONG_DOCUMENT_ERR\");\n }\n }\n\n function assertNodeNotReadOnly(node) {\n if (getReadonlyAncestor(node, true)) {\n throw new DOMException(\"NO_MODIFICATION_ALLOWED_ERR\");\n }\n }\n\n function assertNode(node, codeName) {\n if (!node) {\n throw new DOMException(codeName);\n }\n }\n\n function isValidOffset(node, offset) {\n return offset <= (isCharacterDataNode(node) ? node.length : node.childNodes.length);\n }\n\n function isRangeValid(range) {\n return (!!range.startContainer && !!range.endContainer &&\n !(crashyTextNodes && (dom.isBrokenNode(range.startContainer) || dom.isBrokenNode(range.endContainer))) &&\n getRootContainer(range.startContainer) == getRootContainer(range.endContainer) &&\n isValidOffset(range.startContainer, range.startOffset) &&\n isValidOffset(range.endContainer, range.endOffset));\n }\n\n function assertRangeValid(range) {\n if (!isRangeValid(range)) {\n throw new Error(\"Range error: Range is not valid. This usually happens after DOM mutation. Range: (\" + range.inspect() + \")\");\n }\n }\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n // Test the browser's innerHTML support to decide how to implement createContextualFragment\n var styleEl = document.createElement(\"style\");\n var htmlParsingConforms = false;\n try {\n styleEl.innerHTML = \"x\";\n htmlParsingConforms = (styleEl.firstChild.nodeType == 3); // Opera incorrectly creates an element node\n } catch (e) {\n // IE 6 and 7 throw\n }\n\n api.features.htmlParsingConforms = htmlParsingConforms;\n\n var createContextualFragment = htmlParsingConforms ?\n\n // Implementation as per HTML parsing spec, trusting in the browser's implementation of innerHTML. See\n // discussion and base code for this implementation at issue 67.\n // Spec: http://html5.org/specs/dom-parsing.html#extensions-to-the-range-interface\n // Thanks to Aleks Williams.\n function(fragmentStr) {\n // \"Let node the context object's start's node.\"\n var node = this.startContainer;\n var doc = getDocument(node);\n\n // \"If the context object's start's node is null, raise an INVALID_STATE_ERR\n // exception and abort these steps.\"\n if (!node) {\n throw new DOMException(\"INVALID_STATE_ERR\");\n }\n\n // \"Let element be as follows, depending on node's interface:\"\n // Document, Document Fragment: null\n var el = null;\n\n // \"Element: node\"\n if (node.nodeType == 1) {\n el = node;\n\n // \"Text, Comment: node's parentElement\"\n } else if (isCharacterDataNode(node)) {\n el = dom.parentElement(node);\n }\n\n // \"If either element is null or element's ownerDocument is an HTML document\n // and element's local name is \"html\" and element's namespace is the HTML\n // namespace\"\n if (el === null || (\n el.nodeName == \"HTML\" &&\n dom.isHtmlNamespace(getDocument(el).documentElement) &&\n dom.isHtmlNamespace(el)\n )) {\n\n // \"let element be a new Element with \"body\" as its local name and the HTML\n // namespace as its namespace.\"\"\n el = doc.createElement(\"body\");\n } else {\n el = el.cloneNode(false);\n }\n\n // \"If the node's document is an HTML document: Invoke the HTML fragment parsing algorithm.\"\n // \"If the node's document is an XML document: Invoke the XML fragment parsing algorithm.\"\n // \"In either case, the algorithm must be invoked with fragment as the input\n // and element as the context element.\"\n el.innerHTML = fragmentStr;\n\n // \"If this raises an exception, then abort these steps. Otherwise, let new\n // children be the nodes returned.\"\n\n // \"Let fragment be a new DocumentFragment.\"\n // \"Append all new children to fragment.\"\n // \"Return fragment.\"\n return dom.fragmentFromNodeChildren(el);\n } :\n\n // In this case, innerHTML cannot be trusted, so fall back to a simpler, non-conformant implementation that\n // previous versions of Rangy used (with the exception of using a body element rather than a div)\n function(fragmentStr) {\n var doc = getRangeDocument(this);\n var el = doc.createElement(\"body\");\n el.innerHTML = fragmentStr;\n\n return dom.fragmentFromNodeChildren(el);\n };\n\n function splitRangeBoundaries(range, positionsToPreserve) {\n assertRangeValid(range);\n\n var sc = range.startContainer, so = range.startOffset, ec = range.endContainer, eo = range.endOffset;\n var startEndSame = (sc === ec);\n\n if (isCharacterDataNode(ec) && eo > 0 && eo < ec.length) {\n splitDataNode(ec, eo, positionsToPreserve);\n }\n\n if (isCharacterDataNode(sc) && so > 0 && so < sc.length) {\n sc = splitDataNode(sc, so, positionsToPreserve);\n if (startEndSame) {\n eo -= so;\n ec = sc;\n } else if (ec == sc.parentNode && eo >= getNodeIndex(sc)) {\n eo++;\n }\n so = 0;\n }\n range.setStartAndEnd(sc, so, ec, eo);\n }\n\n function rangeToHtml(range) {\n assertRangeValid(range);\n var container = range.commonAncestorContainer.parentNode.cloneNode(false);\n container.appendChild( range.cloneContents() );\n return container.innerHTML;\n }\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n var rangeProperties = [\"startContainer\", \"startOffset\", \"endContainer\", \"endOffset\", \"collapsed\",\n \"commonAncestorContainer\"];\n\n var s2s = 0, s2e = 1, e2e = 2, e2s = 3;\n var n_b = 0, n_a = 1, n_b_a = 2, n_i = 3;\n\n util.extend(api.rangePrototype, {\n compareBoundaryPoints: function(how, range) {\n assertRangeValid(this);\n assertSameDocumentOrFragment(this.startContainer, range.startContainer);\n\n var nodeA, offsetA, nodeB, offsetB;\n var prefixA = (how == e2s || how == s2s) ? \"start\" : \"end\";\n var prefixB = (how == s2e || how == s2s) ? \"start\" : \"end\";\n nodeA = this[prefixA + \"Container\"];\n offsetA = this[prefixA + \"Offset\"];\n nodeB = range[prefixB + \"Container\"];\n offsetB = range[prefixB + \"Offset\"];\n return comparePoints(nodeA, offsetA, nodeB, offsetB);\n },\n\n insertNode: function(node) {\n assertRangeValid(this);\n assertValidNodeType(node, insertableNodeTypes);\n assertNodeNotReadOnly(this.startContainer);\n\n if (isOrIsAncestorOf(node, this.startContainer)) {\n throw new DOMException(\"HIERARCHY_REQUEST_ERR\");\n }\n\n // No check for whether the container of the start of the Range is of a type that does not allow\n // children of the type of node: the browser's DOM implementation should do this for us when we attempt\n // to add the node\n\n var firstNodeInserted = insertNodeAtPosition(node, this.startContainer, this.startOffset);\n this.setStartBefore(firstNodeInserted);\n },\n\n cloneContents: function() {\n assertRangeValid(this);\n\n var clone, frag;\n if (this.collapsed) {\n return getRangeDocument(this).createDocumentFragment();\n } else {\n if (this.startContainer === this.endContainer && isCharacterDataNode(this.startContainer)) {\n clone = this.startContainer.cloneNode(true);\n clone.data = clone.data.slice(this.startOffset, this.endOffset);\n frag = getRangeDocument(this).createDocumentFragment();\n frag.appendChild(clone);\n return frag;\n } else {\n var iterator = new RangeIterator(this, true);\n clone = cloneSubtree(iterator);\n iterator.detach();\n }\n return clone;\n }\n },\n\n canSurroundContents: function() {\n assertRangeValid(this);\n assertNodeNotReadOnly(this.startContainer);\n assertNodeNotReadOnly(this.endContainer);\n\n // Check if the contents can be surrounded. Specifically, this means whether the range partially selects\n // no non-text nodes.\n var iterator = new RangeIterator(this, true);\n var boundariesInvalid = (iterator._first && (isNonTextPartiallySelected(iterator._first, this)) ||\n (iterator._last && isNonTextPartiallySelected(iterator._last, this)));\n iterator.detach();\n return !boundariesInvalid;\n },\n\n surroundContents: function(node) {\n assertValidNodeType(node, surroundNodeTypes);\n\n if (!this.canSurroundContents()) {\n throw new DOMException(\"INVALID_STATE_ERR\");\n }\n\n // Extract the contents\n var content = this.extractContents();\n\n // Clear the children of the node\n if (node.hasChildNodes()) {\n while (node.lastChild) {\n node.removeChild(node.lastChild);\n }\n }\n\n // Insert the new node and add the extracted contents\n insertNodeAtPosition(node, this.startContainer, this.startOffset);\n node.appendChild(content);\n\n this.selectNode(node);\n },\n\n cloneRange: function() {\n assertRangeValid(this);\n var range = new Range(getRangeDocument(this));\n var i = rangeProperties.length, prop;\n while (i--) {\n prop = rangeProperties[i];\n range[prop] = this[prop];\n }\n return range;\n },\n\n toString: function() {\n assertRangeValid(this);\n var sc = this.startContainer;\n if (sc === this.endContainer && isCharacterDataNode(sc)) {\n return (sc.nodeType == 3 || sc.nodeType == 4) ? sc.data.slice(this.startOffset, this.endOffset) : \"\";\n } else {\n var textParts = [], iterator = new RangeIterator(this, true);\n iterateSubtree(iterator, function(node) {\n // Accept only text or CDATA nodes, not comments\n if (node.nodeType == 3 || node.nodeType == 4) {\n textParts.push(node.data);\n }\n });\n iterator.detach();\n return textParts.join(\"\");\n }\n },\n\n // The methods below are all non-standard. The following batch were introduced by Mozilla but have since\n // been removed from Mozilla.\n\n compareNode: function(node) {\n assertRangeValid(this);\n\n var parent = node.parentNode;\n var nodeIndex = getNodeIndex(node);\n\n if (!parent) {\n throw new DOMException(\"NOT_FOUND_ERR\");\n }\n\n var startComparison = this.comparePoint(parent, nodeIndex),\n endComparison = this.comparePoint(parent, nodeIndex + 1);\n\n if (startComparison < 0) { // Node starts before\n return (endComparison > 0) ? n_b_a : n_b;\n } else {\n return (endComparison > 0) ? n_a : n_i;\n }\n },\n\n comparePoint: function(node, offset) {\n assertRangeValid(this);\n assertNode(node, \"HIERARCHY_REQUEST_ERR\");\n assertSameDocumentOrFragment(node, this.startContainer);\n\n if (comparePoints(node, offset, this.startContainer, this.startOffset) < 0) {\n return -1;\n } else if (comparePoints(node, offset, this.endContainer, this.endOffset) > 0) {\n return 1;\n }\n return 0;\n },\n\n createContextualFragment: createContextualFragment,\n\n toHtml: function() {\n return rangeToHtml(this);\n },\n\n // touchingIsIntersecting determines whether this method considers a node that borders a range intersects\n // with it (as in WebKit) or not (as in Gecko pre-1.9, and the default)\n intersectsNode: function(node, touchingIsIntersecting) {\n assertRangeValid(this);\n if (getRootContainer(node) != getRangeRoot(this)) {\n return false;\n }\n\n var parent = node.parentNode, offset = getNodeIndex(node);\n if (!parent) {\n return true;\n }\n\n var startComparison = comparePoints(parent, offset, this.endContainer, this.endOffset),\n endComparison = comparePoints(parent, offset + 1, this.startContainer, this.startOffset);\n\n return touchingIsIntersecting ? startComparison <= 0 && endComparison >= 0 : startComparison < 0 && endComparison > 0;\n },\n\n isPointInRange: function(node, offset) {\n assertRangeValid(this);\n assertNode(node, \"HIERARCHY_REQUEST_ERR\");\n assertSameDocumentOrFragment(node, this.startContainer);\n\n return (comparePoints(node, offset, this.startContainer, this.startOffset) >= 0) &&\n (comparePoints(node, offset, this.endContainer, this.endOffset) <= 0);\n },\n\n // The methods below are non-standard and invented by me.\n\n // Sharing a boundary start-to-end or end-to-start does not count as intersection.\n intersectsRange: function(range) {\n return rangesIntersect(this, range, false);\n },\n\n // Sharing a boundary start-to-end or end-to-start does count as intersection.\n intersectsOrTouchesRange: function(range) {\n return rangesIntersect(this, range, true);\n },\n\n intersection: function(range) {\n if (this.intersectsRange(range)) {\n var startComparison = comparePoints(this.startContainer, this.startOffset, range.startContainer, range.startOffset),\n endComparison = comparePoints(this.endContainer, this.endOffset, range.endContainer, range.endOffset);\n\n var intersectionRange = this.cloneRange();\n if (startComparison == -1) {\n intersectionRange.setStart(range.startContainer, range.startOffset);\n }\n if (endComparison == 1) {\n intersectionRange.setEnd(range.endContainer, range.endOffset);\n }\n return intersectionRange;\n }\n return null;\n },\n\n union: function(range) {\n if (this.intersectsOrTouchesRange(range)) {\n var unionRange = this.cloneRange();\n if (comparePoints(range.startContainer, range.startOffset, this.startContainer, this.startOffset) == -1) {\n unionRange.setStart(range.startContainer, range.startOffset);\n }\n if (comparePoints(range.endContainer, range.endOffset, this.endContainer, this.endOffset) == 1) {\n unionRange.setEnd(range.endContainer, range.endOffset);\n }\n return unionRange;\n } else {\n throw new DOMException(\"Ranges do not intersect\");\n }\n },\n\n containsNode: function(node, allowPartial) {\n if (allowPartial) {\n return this.intersectsNode(node, false);\n } else {\n return this.compareNode(node) == n_i;\n }\n },\n\n containsNodeContents: function(node) {\n return this.comparePoint(node, 0) >= 0 && this.comparePoint(node, getNodeLength(node)) <= 0;\n },\n\n containsRange: function(range) {\n var intersection = this.intersection(range);\n return intersection !== null && range.equals(intersection);\n },\n\n containsNodeText: function(node) {\n var nodeRange = this.cloneRange();\n nodeRange.selectNode(node);\n var textNodes = nodeRange.getNodes([3]);\n if (textNodes.length > 0) {\n nodeRange.setStart(textNodes[0], 0);\n var lastTextNode = textNodes.pop();\n nodeRange.setEnd(lastTextNode, lastTextNode.length);\n return this.containsRange(nodeRange);\n } else {\n return this.containsNodeContents(node);\n }\n },\n\n getNodes: function(nodeTypes, filter) {\n assertRangeValid(this);\n return getNodesInRange(this, nodeTypes, filter);\n },\n\n getDocument: function() {\n return getRangeDocument(this);\n },\n\n collapseBefore: function(node) {\n this.setEndBefore(node);\n this.collapse(false);\n },\n\n collapseAfter: function(node) {\n this.setStartAfter(node);\n this.collapse(true);\n },\n\n getBookmark: function(containerNode) {\n var doc = getRangeDocument(this);\n var preSelectionRange = api.createRange(doc);\n containerNode = containerNode || dom.getBody(doc);\n preSelectionRange.selectNodeContents(containerNode);\n var range = this.intersection(preSelectionRange);\n var start = 0, end = 0;\n if (range) {\n preSelectionRange.setEnd(range.startContainer, range.startOffset);\n start = preSelectionRange.toString().length;\n end = start + range.toString().length;\n }\n\n return {\n start: start,\n end: end,\n containerNode: containerNode\n };\n },\n\n moveToBookmark: function(bookmark) {\n var containerNode = bookmark.containerNode;\n var charIndex = 0;\n this.setStart(containerNode, 0);\n this.collapse(true);\n var nodeStack = [containerNode], node, foundStart = false, stop = false;\n var nextCharIndex, i, childNodes;\n\n while (!stop && (node = nodeStack.pop())) {\n if (node.nodeType == 3) {\n nextCharIndex = charIndex + node.length;\n if (!foundStart && bookmark.start >= charIndex && bookmark.start <= nextCharIndex) {\n this.setStart(node, bookmark.start - charIndex);\n foundStart = true;\n }\n if (foundStart && bookmark.end >= charIndex && bookmark.end <= nextCharIndex) {\n this.setEnd(node, bookmark.end - charIndex);\n stop = true;\n }\n charIndex = nextCharIndex;\n } else {\n childNodes = node.childNodes;\n i = childNodes.length;\n while (i--) {\n nodeStack.push(childNodes[i]);\n }\n }\n }\n },\n\n getName: function() {\n return \"DomRange\";\n },\n\n equals: function(range) {\n return Range.rangesEqual(this, range);\n },\n\n isValid: function() {\n return isRangeValid(this);\n },\n\n inspect: function() {\n return inspect(this);\n },\n\n detach: function() {\n // In DOM4, detach() is now a no-op.\n }\n });\n\n function copyComparisonConstantsToObject(obj) {\n obj.START_TO_START = s2s;\n obj.START_TO_END = s2e;\n obj.END_TO_END = e2e;\n obj.END_TO_START = e2s;\n\n obj.NODE_BEFORE = n_b;\n obj.NODE_AFTER = n_a;\n obj.NODE_BEFORE_AND_AFTER = n_b_a;\n obj.NODE_INSIDE = n_i;\n }\n\n function copyComparisonConstants(constructor) {\n copyComparisonConstantsToObject(constructor);\n copyComparisonConstantsToObject(constructor.prototype);\n }\n\n function createRangeContentRemover(remover, boundaryUpdater) {\n return function() {\n assertRangeValid(this);\n\n var sc = this.startContainer, so = this.startOffset, root = this.commonAncestorContainer;\n\n var iterator = new RangeIterator(this, true);\n\n // Work out where to position the range after content removal\n var node, boundary;\n if (sc !== root) {\n node = getClosestAncestorIn(sc, root, true);\n boundary = getBoundaryAfterNode(node);\n sc = boundary.node;\n so = boundary.offset;\n }\n\n // Check none of the range is read-only\n iterateSubtree(iterator, assertNodeNotReadOnly);\n\n iterator.reset();\n\n // Remove the content\n var returnValue = remover(iterator);\n iterator.detach();\n\n // Move to the new position\n boundaryUpdater(this, sc, so, sc, so);\n\n return returnValue;\n };\n }\n\n function createPrototypeRange(constructor, boundaryUpdater) {\n function createBeforeAfterNodeSetter(isBefore, isStart) {\n return function(node) {\n assertValidNodeType(node, beforeAfterNodeTypes);\n assertValidNodeType(getRootContainer(node), rootContainerNodeTypes);\n\n var boundary = (isBefore ? getBoundaryBeforeNode : getBoundaryAfterNode)(node);\n (isStart ? setRangeStart : setRangeEnd)(this, boundary.node, boundary.offset);\n };\n }\n\n function setRangeStart(range, node, offset) {\n var ec = range.endContainer, eo = range.endOffset;\n if (node !== range.startContainer || offset !== range.startOffset) {\n // Check the root containers of the range and the new boundary, and also check whether the new boundary\n // is after the current end. In either case, collapse the range to the new position\n if (getRootContainer(node) != getRootContainer(ec) || comparePoints(node, offset, ec, eo) == 1) {\n ec = node;\n eo = offset;\n }\n boundaryUpdater(range, node, offset, ec, eo);\n }\n }\n\n function setRangeEnd(range, node, offset) {\n var sc = range.startContainer, so = range.startOffset;\n if (node !== range.endContainer || offset !== range.endOffset) {\n // Check the root containers of the range and the new boundary, and also check whether the new boundary\n // is after the current end. In either case, collapse the range to the new position\n if (getRootContainer(node) != getRootContainer(sc) || comparePoints(node, offset, sc, so) == -1) {\n sc = node;\n so = offset;\n }\n boundaryUpdater(range, sc, so, node, offset);\n }\n }\n\n // Set up inheritance\n var F = function() {};\n F.prototype = api.rangePrototype;\n constructor.prototype = new F();\n\n util.extend(constructor.prototype, {\n setStart: function(node, offset) {\n assertNoDocTypeNotationEntityAncestor(node, true);\n assertValidOffset(node, offset);\n\n setRangeStart(this, node, offset);\n },\n\n setEnd: function(node, offset) {\n assertNoDocTypeNotationEntityAncestor(node, true);\n assertValidOffset(node, offset);\n\n setRangeEnd(this, node, offset);\n },\n\n /**\n * Convenience method to set a range's start and end boundaries. Overloaded as follows:\n * - Two parameters (node, offset) creates a collapsed range at that position\n * - Three parameters (node, startOffset, endOffset) creates a range contained with node starting at\n * startOffset and ending at endOffset\n * - Four parameters (startNode, startOffset, endNode, endOffset) creates a range starting at startOffset in\n * startNode and ending at endOffset in endNode\n */\n setStartAndEnd: function() {\n var args = arguments;\n var sc = args[0], so = args[1], ec = sc, eo = so;\n\n switch (args.length) {\n case 3:\n eo = args[2];\n break;\n case 4:\n ec = args[2];\n eo = args[3];\n break;\n }\n\n boundaryUpdater(this, sc, so, ec, eo);\n },\n\n setBoundary: function(node, offset, isStart) {\n this[\"set\" + (isStart ? \"Start\" : \"End\")](node, offset);\n },\n\n setStartBefore: createBeforeAfterNodeSetter(true, true),\n setStartAfter: createBeforeAfterNodeSetter(false, true),\n setEndBefore: createBeforeAfterNodeSetter(true, false),\n setEndAfter: createBeforeAfterNodeSetter(false, false),\n\n collapse: function(isStart) {\n assertRangeValid(this);\n if (isStart) {\n boundaryUpdater(this, this.startContainer, this.startOffset, this.startContainer, this.startOffset);\n } else {\n boundaryUpdater(this, this.endContainer, this.endOffset, this.endContainer, this.endOffset);\n }\n },\n\n selectNodeContents: function(node) {\n assertNoDocTypeNotationEntityAncestor(node, true);\n\n boundaryUpdater(this, node, 0, node, getNodeLength(node));\n },\n\n selectNode: function(node) {\n assertNoDocTypeNotationEntityAncestor(node, false);\n assertValidNodeType(node, beforeAfterNodeTypes);\n\n var start = getBoundaryBeforeNode(node), end = getBoundaryAfterNode(node);\n boundaryUpdater(this, start.node, start.offset, end.node, end.offset);\n },\n\n extractContents: createRangeContentRemover(extractSubtree, boundaryUpdater),\n\n deleteContents: createRangeContentRemover(deleteSubtree, boundaryUpdater),\n\n canSurroundContents: function() {\n assertRangeValid(this);\n assertNodeNotReadOnly(this.startContainer);\n assertNodeNotReadOnly(this.endContainer);\n\n // Check if the contents can be surrounded. Specifically, this means whether the range partially selects\n // no non-text nodes.\n var iterator = new RangeIterator(this, true);\n var boundariesInvalid = (iterator._first && isNonTextPartiallySelected(iterator._first, this) ||\n (iterator._last && isNonTextPartiallySelected(iterator._last, this)));\n iterator.detach();\n return !boundariesInvalid;\n },\n\n splitBoundaries: function() {\n splitRangeBoundaries(this);\n },\n\n splitBoundariesPreservingPositions: function(positionsToPreserve) {\n splitRangeBoundaries(this, positionsToPreserve);\n },\n\n normalizeBoundaries: function() {\n assertRangeValid(this);\n\n var sc = this.startContainer, so = this.startOffset, ec = this.endContainer, eo = this.endOffset;\n\n var mergeForward = function(node) {\n var sibling = node.nextSibling;\n if (sibling && sibling.nodeType == node.nodeType) {\n ec = node;\n eo = node.length;\n node.appendData(sibling.data);\n removeNode(sibling);\n }\n };\n\n var mergeBackward = function(node) {\n var sibling = node.previousSibling;\n if (sibling && sibling.nodeType == node.nodeType) {\n sc = node;\n var nodeLength = node.length;\n so = sibling.length;\n node.insertData(0, sibling.data);\n removeNode(sibling);\n if (sc == ec) {\n eo += so;\n ec = sc;\n } else if (ec == node.parentNode) {\n var nodeIndex = getNodeIndex(node);\n if (eo == nodeIndex) {\n ec = node;\n eo = nodeLength;\n } else if (eo > nodeIndex) {\n eo--;\n }\n }\n }\n };\n\n var normalizeStart = true;\n var sibling;\n\n if (isCharacterDataNode(ec)) {\n if (eo == ec.length) {\n mergeForward(ec);\n } else if (eo == 0) {\n sibling = ec.previousSibling;\n if (sibling && sibling.nodeType == ec.nodeType) {\n eo = sibling.length;\n if (sc == ec) {\n normalizeStart = false;\n }\n sibling.appendData(ec.data);\n removeNode(ec);\n ec = sibling;\n }\n }\n } else {\n if (eo > 0) {\n var endNode = ec.childNodes[eo - 1];\n if (endNode && isCharacterDataNode(endNode)) {\n mergeForward(endNode);\n }\n }\n normalizeStart = !this.collapsed;\n }\n\n if (normalizeStart) {\n if (isCharacterDataNode(sc)) {\n if (so == 0) {\n mergeBackward(sc);\n } else if (so == sc.length) {\n sibling = sc.nextSibling;\n if (sibling && sibling.nodeType == sc.nodeType) {\n if (ec == sibling) {\n ec = sc;\n eo += sc.length;\n }\n sc.appendData(sibling.data);\n removeNode(sibling);\n }\n }\n } else {\n if (so < sc.childNodes.length) {\n var startNode = sc.childNodes[so];\n if (startNode && isCharacterDataNode(startNode)) {\n mergeBackward(startNode);\n }\n }\n }\n } else {\n sc = ec;\n so = eo;\n }\n\n boundaryUpdater(this, sc, so, ec, eo);\n },\n\n collapseToPoint: function(node, offset) {\n assertNoDocTypeNotationEntityAncestor(node, true);\n assertValidOffset(node, offset);\n this.setStartAndEnd(node, offset);\n }\n });\n\n copyComparisonConstants(constructor);\n }\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n // Updates commonAncestorContainer and collapsed after boundary change\n function updateCollapsedAndCommonAncestor(range) {\n range.collapsed = (range.startContainer === range.endContainer && range.startOffset === range.endOffset);\n range.commonAncestorContainer = range.collapsed ?\n range.startContainer : dom.getCommonAncestor(range.startContainer, range.endContainer);\n }\n\n function updateBoundaries(range, startContainer, startOffset, endContainer, endOffset) {\n range.startContainer = startContainer;\n range.startOffset = startOffset;\n range.endContainer = endContainer;\n range.endOffset = endOffset;\n range.document = dom.getDocument(startContainer);\n\n updateCollapsedAndCommonAncestor(range);\n }\n\n function Range(doc) {\n this.startContainer = doc;\n this.startOffset = 0;\n this.endContainer = doc;\n this.endOffset = 0;\n this.document = doc;\n updateCollapsedAndCommonAncestor(this);\n }\n\n createPrototypeRange(Range, updateBoundaries);\n\n util.extend(Range, {\n rangeProperties: rangeProperties,\n RangeIterator: RangeIterator,\n copyComparisonConstants: copyComparisonConstants,\n createPrototypeRange: createPrototypeRange,\n inspect: inspect,\n toHtml: rangeToHtml,\n getRangeDocument: getRangeDocument,\n rangesEqual: function(r1, r2) {\n return r1.startContainer === r2.startContainer &&\n r1.startOffset === r2.startOffset &&\n r1.endContainer === r2.endContainer &&\n r1.endOffset === r2.endOffset;\n }\n });\n\n api.DomRange = Range;\n });\r\n\r\n /*----------------------------------------------------------------------------------------------------------------*/\r\n\r\n // Wrappers for the browser's native DOM Range and/or TextRange implementation\n api.createCoreModule(\"WrappedRange\", [\"DomRange\"], function(api, module) {\n var WrappedRange, WrappedTextRange;\n var dom = api.dom;\n var util = api.util;\n var DomPosition = dom.DomPosition;\n var DomRange = api.DomRange;\n var getBody = dom.getBody;\n var getContentDocument = dom.getContentDocument;\n var isCharacterDataNode = dom.isCharacterDataNode;\n\n\n /*----------------------------------------------------------------------------------------------------------------*/\n\n if (api.features.implementsDomRange) {\n // This is a wrapper around the browser's native DOM Range. It has two aims:\n // - Provide workarounds for specific browser bugs\n // - provide convenient extensions, which are inherited from Rangy's DomRange\n\n (function() {\n var rangeProto;\n var rangeProperties = DomRange.rangeProperties;\n\n function updateRangeProperties(range) {\n var i = rangeProperties.length, prop;\n while (i--) {\n prop = rangeProperties[i];\n range[prop] = range.nativeRange[prop];\n }\n // Fix for broken collapsed property in IE 9.\n range.collapsed = (range.startContainer === range.endContainer && range.startOffset === range.endOffset);\n }\n\n function updateNativeRange(range, startContainer, startOffset, endContainer, endOffset) {\n var startMoved = (range.startContainer !== startContainer || range.startOffset != startOffset);\n var endMoved = (range.endContainer !== endContainer || range.endOffset != endOffset);\n var nativeRangeDifferent = !range.equals(range.nativeRange);\n\n // Always set both boundaries for the benefit of IE9 (see issue 35)\n if (startMoved || endMoved || nativeRangeDifferent) {\n range.setEnd(endContainer, endOffset);\n range.setStart(startContainer, startOffset);\n }\n }\n\n var createBeforeAfterNodeSetter;\n\n WrappedRange = function(range) {\n if (!range) {\n throw module.createError(\"WrappedRange: Range must be specified\");\n }\n this.nativeRange = range;\n updateRangeProperties(this);\n };\n\n DomRange.createPrototypeRange(WrappedRange, updateNativeRange);\n\n rangeProto = WrappedRange.prototype;\n\n rangeProto.selectNode = function(node) {\n this.nativeRange.selectNode(node);\n updateRangeProperties(this);\n };\n\n rangeProto.cloneContents = function() {\n return this.nativeRange.cloneContents();\n };\n\n // Due to a long-standing Firefox bug that I have not been able to find a reliable way to detect,\n // insertNode() is never delegated to the native range.\n\n rangeProto.surroundContents = function(node) {\n this.nativeRange.surroundContents(node);\n updateRangeProperties(this);\n };\n\n rangeProto.collapse = function(isStart) {\n this.nativeRange.collapse(isStart);\n updateRangeProperties(this);\n };\n\n rangeProto.cloneRange = function() {\n return new WrappedRange(this.nativeRange.cloneRange());\n };\n\n rangeProto.refresh = function() {\n updateRangeProperties(this);\n };\n\n rangeProto.toString = function() {\n return this.nativeRange.toString();\n };\n\n // Create test range and node for feature detection\n\n var testTextNode = document.createTextNode(\"test\");\n getBody(document).appendChild(testTextNode);\n var range = document.createRange();\n\n /*--------------------------------------------------------------------------------------------------------*/\n\n // Test for Firefox 2 bug that prevents moving the start of a Range to a point after its current end and\n // correct for it\n\n range.setStart(testTextNode, 0);\n range.setEnd(testTextNode, 0);\n\n try {\n range.setStart(testTextNode, 1);\n\n rangeProto.setStart = function(node, offset) {\n this.nativeRange.setStart(node, offset);\n updateRangeProperties(this);\n };\n\n rangeProto.setEnd = function(node, offset) {\n this.nativeRange.setEnd(node, offset);\n updateRangeProperties(this);\n };\n\n createBeforeAfterNodeSetter = function(name) {\n return function(node) {\n this.nativeRange[name](node);\n updateRangeProperties(this);\n };\n };\n\n } catch(ex) {\n\n rangeProto.setStart = function(node, offset) {\n try {\n this.nativeRange.setStart(node, offset);\n } catch (ex) {\n this.nativeRange.setEnd(node, offset);\n this.nativeRange.setStart(node, offset);\n }\n updateRangeProperties(this);\n };\n\n rangeProto.setEnd = function(node, offset) {\n try {\n this.nativeRange.setEnd(node, offset);\n } catch (ex) {\n this.nativeRange.setStart(node, offset);\n this.nativeRange.setEnd(node, offset);\n }\n updateRangeProperties(this);\n };\n\n createBeforeAfterNodeSetter = function(name, oppositeName) {\n return function(node) {\n try {\n this.nativeRange[name](node);\n } catch (ex) {\n this.nativeRange[oppositeName](node);\n this.nativeRange[name](node);\n }\n updateRangeProperties(this);\n };\n };\n }\n\n rangeProto.setStartBefore = createBeforeAfterNodeSetter(\"setStartBefore\", \"setEndBefore\");\n rangeProto.setStartAfter = createBeforeAfterNodeSetter(\"setStartAfter\", \"setEndAfter\");\n rangeProto.setEndBefore = createBeforeAfterNodeSetter(\"setEndBefore\", \"setStartBefore\");\n rangeProto.setEndAfter = createBeforeAfterNodeSetter(\"setEndAfter\", \"setStartAfter\");\n\n /*--------------------------------------------------------------------------------------------------------*/\n\n // Always use DOM4-compliant selectNodeContents implementation: it's simpler and less code than testing\n // whether the native implementation can be trusted\n rangeProto.selectNodeContents = function(node) {\n this.setStartAndEnd(node, 0, dom.getNodeLength(node));\n };\n\n /*--------------------------------------------------------------------------------------------------------*/\n\n // Test for and correct WebKit bug that has the behaviour of compareBoundaryPoints round the wrong way for\n // constants START_TO_END and END_TO_START: https://bugs.webkit.org/show_bug.cgi?id=20738\n\n range.selectNodeContents(testTextNode);\n range.setEnd(testTextNode, 3);\n\n var range2 = document.createRange();\n range2.selectNodeContents(testTextNode);\n range2.setEnd(testTextNode, 4);\n range2.setStart(testTextNode, 2);\n\n if (range.compareBoundaryPoints(range.START_TO_END, range2) == -1 &&\n range.compareBoundaryPoints(range.END_TO_START, range2) == 1) {\n // This is the wrong way round, so correct for it\n\n rangeProto.compareBoundaryPoints = function(type, range) {\n range = range.nativeRange || range;\n if (type == range.START_TO_END) {\n type = range.END_TO_START;\n } else if (type == range.END_TO_START) {\n type = range.START_TO_END;\n }\n return this.nativeRange.compareBoundaryPoints(type, range);\n };\n } else {\n rangeProto.compareBoundaryPoints = function(type, range) {\n return this.nativeRange.compareBoundaryPoints(type, range.nativeRange || range);\n };\n }\n\n /*--------------------------------------------------------------------------------------------------------*/\n\n // Test for IE deleteContents() and extractContents() bug and correct it. See issue 107.\n\n var el = document.createElement(\"div\");\n el.innerHTML = \"123\";\n var textNode = el.firstChild;\n var body = getBody(document);\n body.appendChild(el);\n\n range.setStart(textNode, 1);\n range.setEnd(textNode, 2);\n range.deleteContents();\n\n if (textNode.data == \"13\") {\n // Behaviour is correct per DOM4 Range so wrap the browser's implementation of deleteContents() and\n // extractContents()\n rangeProto.deleteContents = function() {\n this.nativeRange.deleteContents();\n updateRangeProperties(this);\n };\n\n rangeProto.extractContents = function() {\n var frag = this.nativeRange.extractContents();\n updateRangeProperties(this);\n return frag;\n };\n } else {\n }\n\n body.removeChild(el);\n body = null;\n\n /*--------------------------------------------------------------------------------------------------------*/\n\n // Test for existence of createContextualFragment and delegate to it if it exists\n if (util.isHostMethod(range, \"createContextualFragment\")) {\n rangeProto.createContextualFragment = function(fragmentStr) {\n return this.nativeRange.createContextualFragment(fragmentStr);\n };\n }\n\n /*--------------------------------------------------------------------------------------------------------*/\n\n // Clean up\n getBody(document).removeChild(testTextNode);\n\n rangeProto.getName = function() {\n return \"WrappedRange\";\n };\n\n api.WrappedRange = WrappedRange;\n\n api.createNativeRange = function(doc) {\n doc = getContentDocument(doc, module, \"createNativeRange\");\n return doc.createRange();\n };\n })();\n }\n\n if (api.features.implementsTextRange) {\n /*\n This is a workaround for a bug where IE returns the wrong container element from the TextRange's parentElement()\n method. For example, in the following (where pipes denote the selection boundaries):\n\n
- | a
- b |
element, for example), we need a slightly complicated approach to get the boundary's offset in\n IE. The facts:\n\n - Each line break is represented as \\r in the text node's data/nodeValue properties\n - Each line break is represented as \\r\\n in the TextRange's 'text' property\n - The 'text' property of the TextRange does not contain trailing line breaks\n\n To get round the problem presented by the final fact above, we can use the fact that TextRange's\n moveStart() and moveEnd() methods return the actual number of characters moved, which is not\n necessarily the same as the number of characters it was instructed to move. The simplest approach is\n to use this to store the characters moved when moving both the start and end of the range to the\n start of the document body and subtracting the start offset from the end offset (the\n \"move-negative-gazillion\" method). However, this is extremely slow when the document is large and\n the range is near the end of it. Clearly doing the mirror image (i.e. moving the range boundaries to\n the end of the document) has the same problem.\n\n Another approach that works is to use moveStart() to move the start boundary of the range up to the\n end boundary one character at a time and incrementing a counter with the value returned by the\n moveStart() call. However, the check for whether the start boundary has reached the end boundary is\n expensive, so this method is slow (although unlike \"move-negative-gazillion\" is largely unaffected\n by the location of the range within the document).\n\n The approach used below is a hybrid of the two methods above. It uses the fact that a string\n containing the TextRange's 'text' property with each \\r\\n converted to a single \\r character cannot\n be longer than the text of the TextRange, so the start of the range is moved that length initially\n and then a character at a time to make up for any trailing line breaks not contained in the 'text'\n property. This has good performance in most situations compared to the previous two methods.\n */\n var tempRange = workingRange.duplicate();\n var rangeLength = tempRange.text.replace(/\\r\\n/g, \"\\r\").length;\n\n offset = tempRange.moveStart(\"character\", rangeLength);\n while ( (comparison = tempRange.compareEndPoints(\"StartToEnd\", tempRange)) == -1) {\n offset++;\n tempRange.moveStart(\"character\", 1);\n }\n } else {\n offset = workingRange.text.length;\n }\n boundaryPosition = new DomPosition(boundaryNode, offset);\n } else {\n\n // If the boundary immediately follows a character data node and this is the end boundary, we should favour\n // a position within that, and likewise for a start boundary preceding a character data node\n previousNode = (isCollapsed || !isStart) && workingNode.previousSibling;\n nextNode = (isCollapsed || isStart) && workingNode.nextSibling;\n if (nextNode && isCharacterDataNode(nextNode)) {\n boundaryPosition = new DomPosition(nextNode, 0);\n } else if (previousNode && isCharacterDataNode(previousNode)) {\n boundaryPosition = new DomPosition(previousNode, previousNode.data.length);\n } else {\n boundaryPosition = new DomPosition(containerElement, dom.getNodeIndex(workingNode));\n }\n }\n\n // Clean up\n dom.removeNode(workingNode);\n\n return {\n boundaryPosition: boundaryPosition,\n nodeInfo: {\n nodeIndex: nodeIndex,\n containerElement: containerElement\n }\n };\n };\n\n // Returns a TextRange representing the boundary of a TextRange expressed as a node and an offset within that\n // node. This function started out as an optimized version of code found in Tim Cameron Ryan's IERange\n // (http://code.google.com/p/ierange/)\n var createBoundaryTextRange = function(boundaryPosition, isStart) {\n var boundaryNode, boundaryParent, boundaryOffset = boundaryPosition.offset;\n var doc = dom.getDocument(boundaryPosition.node);\n var workingNode, childNodes, workingRange = getBody(doc).createTextRange();\n var nodeIsDataNode = isCharacterDataNode(boundaryPosition.node);\n\n if (nodeIsDataNode) {\n boundaryNode = boundaryPosition.node;\n boundaryParent = boundaryNode.parentNode;\n } else {\n childNodes = boundaryPosition.node.childNodes;\n boundaryNode = (boundaryOffset < childNodes.length) ? childNodes[boundaryOffset] : null;\n boundaryParent = boundaryPosition.node;\n }\n\n // Position the range immediately before the node containing the boundary\n workingNode = doc.createElement(\"span\");\n\n // Making the working element non-empty element persuades IE to consider the TextRange boundary to be within\n // the element rather than immediately before or after it\n workingNode.innerHTML = \"&#feff;\";\n\n // insertBefore is supposed to work like appendChild if the second parameter is null. However, a bug report\n // for IERange suggests that it can crash the browser: http://code.google.com/p/ierange/issues/detail?id=12\n if (boundaryNode) {\n boundaryParent.insertBefore(workingNode, boundaryNode);\n } else {\n boundaryParent.appendChild(workingNode);\n }\n\n workingRange.moveToElementText(workingNode);\n workingRange.collapse(!isStart);\n\n // Clean up\n boundaryParent.removeChild(workingNode);\n\n // Move the working range to the text offset, if required\n if (nodeIsDataNode) {\n workingRange[isStart ? \"moveStart\" : \"moveEnd\"](\"character\", boundaryOffset);\n }\n\n return workingRange;\n };\n\n /*------------------------------------------------------------------------------------------------------------*/\n\n // This is a wrapper around a TextRange, providing full DOM Range functionality using rangy's DomRange as a\n // prototype\n\n WrappedTextRange = function(textRange) {\n this.textRange = textRange;\n this.refresh();\n };\n\n WrappedTextRange.prototype = new DomRange(document);\n\n WrappedTextRange.prototype.refresh = function() {\n var start, end, startBoundary;\n\n // TextRange's parentElement() method cannot be trusted. getTextRangeContainerElement() works around that.\n var rangeContainerElement = getTextRangeContainerElement(this.textRange);\n\n if (textRangeIsCollapsed(this.textRange)) {\n end = start = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true,\n true).boundaryPosition;\n } else {\n startBoundary = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, true, false);\n start = startBoundary.boundaryPosition;\n\n // An optimization used here is that if the start and end boundaries have the same parent element, the\n // search scope for the end boundary can be limited to exclude the portion of the element that precedes\n // the start boundary\n end = getTextRangeBoundaryPosition(this.textRange, rangeContainerElement, false, false,\n startBoundary.nodeInfo).boundaryPosition;\n }\n\n this.setStart(start.node, start.offset);\n this.setEnd(end.node, end.offset);\n };\n\n WrappedTextRange.prototype.getName = function() {\n return \"WrappedTextRange\";\n };\n\n DomRange.copyComparisonConstants(WrappedTextRange);\n\n var rangeToTextRange = function(range) {\n if (range.collapsed) {\n return createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);\n } else {\n var startRange = createBoundaryTextRange(new DomPosition(range.startContainer, range.startOffset), true);\n var endRange = createBoundaryTextRange(new DomPosition(range.endContainer, range.endOffset), false);\n var textRange = getBody( DomRange.getRangeDocument(range) ).createTextRange();\n textRange.setEndPoint(\"StartToStart\", startRange);\n textRange.setEndPoint(\"EndToEnd\", endRange);\n return textRange;\n }\n };\n\n WrappedTextRange.rangeToTextRange = rangeToTextRange;\n\n WrappedTextRange.prototype.toTextRange = function() {\n return rangeToTextRange(this);\n };\n\n api.WrappedTextRange = WrappedTextRange;\n\n // IE 9 and above have both implementations and Rangy makes both available. The next few lines sets which\n // implementation to use by default.\n if (!api.features.implementsDomRange || api.config.preferTextRange) {\n // Add WrappedTextRange as the Range property of the global object to allow expression like Range.END_TO_END to work\n var globalObj = (function(f) { return f(\"return this;\")(); })(Function);\n if (typeof globalObj.Range == \"undefined\") {\n globalObj.Range = WrappedTextRange;\n }\n\n api.createNativeRange = function(doc) {\n doc = getContentDocument(doc, module, \"createNativeRange\");\n return getBody(doc).createTextRange();\n };\n\n api.WrappedRange = WrappedTextRange;\n }\n }\n\n api.createRange = function(doc) {\n doc = getContentDocument(doc, module, \"createRange\");\n return new api.WrappedRange(api.createNativeRange(doc));\n };\n\n api.createRangyRange = function(doc) {\n doc = getContentDocument(doc, module, \"createRangyRange\");\n return new DomRange(doc);\n };\n\n util.createAliasForDeprecatedMethod(api, \"createIframeRange\", \"createRange\");\n util.createAliasForDeprecatedMethod(api, \"createIframeRangyRange\", \"createRangyRange\");\n\n api.addShimListener(function(win) {\n var doc = win.document;\n if (typeof doc.createRange == \"undefined\") {\n doc.createRange = function() {\n return api.createRange(doc);\n };\n }\n doc = win = null;\n });\n });\r\n\r\n /*----------------------------------------------------------------------------------------------------------------*/\r\n\r\n // This module creates a selection object wrapper that conforms as closely as possible to the Selection specification\n // in the HTML Editing spec (http://dvcs.w3.org/hg/editing/raw-file/tip/editing.html#selections)\n api.createCoreModule(\"WrappedSelection\", [\"DomRange\", \"WrappedRange\"], function(api, module) {\n api.config.checkSelectionRanges = true;\n\n var BOOLEAN = \"boolean\";\n var NUMBER = \"number\";\n var dom = api.dom;\n var util = api.util;\n var isHostMethod = util.isHostMethod;\n var DomRange = api.DomRange;\n var WrappedRange = api.WrappedRange;\n var DOMException = api.DOMException;\n var DomPosition = dom.DomPosition;\n var getNativeSelection;\n var selectionIsCollapsed;\n var features = api.features;\n var CONTROL = \"Control\";\n var getDocument = dom.getDocument;\n var getBody = dom.getBody;\n var rangesEqual = DomRange.rangesEqual;\n\n\n // Utility function to support direction parameters in the API that may be a string (\"backward\", \"backwards\",\n // \"forward\" or \"forwards\") or a Boolean (true for backwards).\n function isDirectionBackward(dir) {\n return (typeof dir == \"string\") ? /^backward(s)?$/i.test(dir) : !!dir;\n }\n\n function getWindow(win, methodName) {\n if (!win) {\n return window;\n } else if (dom.isWindow(win)) {\n return win;\n } else if (win instanceof WrappedSelection) {\n return win.win;\n } else {\n var doc = dom.getContentDocument(win, module, methodName);\n return dom.getWindow(doc);\n }\n }\n\n function getWinSelection(winParam) {\n return getWindow(winParam, \"getWinSelection\").getSelection();\n }\n\n function getDocSelection(winParam) {\n return getWindow(winParam, \"getDocSelection\").document.selection;\n }\n\n function winSelectionIsBackward(sel) {\n var backward = false;\n if (sel.anchorNode) {\n backward = (dom.comparePoints(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset) == 1);\n }\n return backward;\n }\n\n // Test for the Range/TextRange and Selection features required\n // Test for ability to retrieve selection\n var implementsWinGetSelection = isHostMethod(window, \"getSelection\"),\n implementsDocSelection = util.isHostObject(document, \"selection\");\n\n features.implementsWinGetSelection = implementsWinGetSelection;\n features.implementsDocSelection = implementsDocSelection;\n\n var useDocumentSelection = implementsDocSelection && (!implementsWinGetSelection || api.config.preferTextRange);\n\n if (useDocumentSelection) {\n getNativeSelection = getDocSelection;\n api.isSelectionValid = function(winParam) {\n var doc = getWindow(winParam, \"isSelectionValid\").document, nativeSel = doc.selection;\n\n // Check whether the selection TextRange is actually contained within the correct document\n return (nativeSel.type != \"None\" || getDocument(nativeSel.createRange().parentElement()) == doc);\n };\n } else if (implementsWinGetSelection) {\n getNativeSelection = getWinSelection;\n api.isSelectionValid = function() {\n return true;\n };\n } else {\n module.fail(\"Neither document.selection or window.getSelection() detected.\");\n return false;\n }\n\n api.getNativeSelection = getNativeSelection;\n\n var testSelection = getNativeSelection();\n\n // In Firefox, the selection is null in an iframe with display: none. See issue #138.\n if (!testSelection) {\n module.fail(\"Native selection was null (possibly issue 138?)\");\n return false;\n }\n\n var testRange = api.createNativeRange(document);\n var body = getBody(document);\n\n // Obtaining a range from a selection\n var selectionHasAnchorAndFocus = util.areHostProperties(testSelection,\n [\"anchorNode\", \"focusNode\", \"anchorOffset\", \"focusOffset\"]);\n\n features.selectionHasAnchorAndFocus = selectionHasAnchorAndFocus;\n\n // Test for existence of native selection extend() method\n var selectionHasExtend = isHostMethod(testSelection, \"extend\");\n features.selectionHasExtend = selectionHasExtend;\n\n // Test if rangeCount exists\n var selectionHasRangeCount = (typeof testSelection.rangeCount == NUMBER);\n features.selectionHasRangeCount = selectionHasRangeCount;\n\n var selectionSupportsMultipleRanges = false;\n var collapsedNonEditableSelectionsSupported = true;\n\n var addRangeBackwardToNative = selectionHasExtend ?\n function(nativeSelection, range) {\n var doc = DomRange.getRangeDocument(range);\n var endRange = api.createRange(doc);\n endRange.collapseToPoint(range.endContainer, range.endOffset);\n nativeSelection.addRange(getNativeRange(endRange));\n nativeSelection.extend(range.startContainer, range.startOffset);\n } : null;\n\n if (util.areHostMethods(testSelection, [\"addRange\", \"getRangeAt\", \"removeAllRanges\"]) &&\n typeof testSelection.rangeCount == NUMBER && features.implementsDomRange) {\n\n (function() {\n // Previously an iframe was used but this caused problems in some circumstances in IE, so tests are\n // performed on the current document's selection. See issue 109.\n\n // Note also that if a selection previously existed, it is wiped and later restored by these tests. This\n // will result in the selection direction begin reversed if the original selection was backwards and the\n // browser does not support setting backwards selections (Internet Explorer, I'm looking at you).\n var sel = window.getSelection();\n if (sel) {\n // Store the current selection\n var originalSelectionRangeCount = sel.rangeCount;\n var selectionHasMultipleRanges = (originalSelectionRangeCount > 1);\n var originalSelectionRanges = [];\n var originalSelectionBackward = winSelectionIsBackward(sel);\n for (var i = 0; i < originalSelectionRangeCount; ++i) {\n originalSelectionRanges[i] = sel.getRangeAt(i);\n }\n\n // Create some test elements\n var testEl = dom.createTestElement(document, \"\", false);\n var textNode = testEl.appendChild( document.createTextNode(\"\\u00a0\\u00a0\\u00a0\") );\n\n // Test whether the native selection will allow a collapsed selection within a non-editable element\n var r1 = document.createRange();\n\n r1.setStart(textNode, 1);\n r1.collapse(true);\n sel.removeAllRanges();\n sel.addRange(r1);\n collapsedNonEditableSelectionsSupported = (sel.rangeCount == 1);\n sel.removeAllRanges();\n\n // Test whether the native selection is capable of supporting multiple ranges.\n if (!selectionHasMultipleRanges) {\n // Doing the original feature test here in Chrome 36 (and presumably later versions) prints a\n // console error of \"Discontiguous selection is not supported.\" that cannot be suppressed. There's\n // nothing we can do about this while retaining the feature test so we have to resort to a browser\n // sniff. I'm not happy about it. See\n // https://code.google.com/p/chromium/issues/detail?id=399791\n var chromeMatch = window.navigator.appVersion.match(/Chrome\\/(.*?) /);\n if (chromeMatch && parseInt(chromeMatch[1]) >= 36) {\n selectionSupportsMultipleRanges = false;\n } else {\n var r2 = r1.cloneRange();\n r1.setStart(textNode, 0);\n r2.setEnd(textNode, 3);\n r2.setStart(textNode, 2);\n sel.addRange(r1);\n sel.addRange(r2);\n selectionSupportsMultipleRanges = (sel.rangeCount == 2);\n }\n }\n\n // Clean up\n dom.removeNode(testEl);\n sel.removeAllRanges();\n\n for (i = 0; i < originalSelectionRangeCount; ++i) {\n if (i == 0 && originalSelectionBackward) {\n if (addRangeBackwardToNative) {\n addRangeBackwardToNative(sel, originalSelectionRanges[i]);\n } else {\n api.warn(\"Rangy initialization: original selection was backwards but selection has been restored forwards because the browser does not support Selection.extend\");\n sel.addRange(originalSelectionRanges[i]);\n }\n } else {\n sel.addRange(originalSelectionRanges[i]);\n }\n }\n }\n })();\n }\n\n features.selectionSupportsMultipleRanges = selectionSupportsMultipleRanges;\n features.collapsedNonEditableSelectionsSupported = collapsedNonEditableSelectionsSupported;\n\n // ControlRanges\n var implementsControlRange = false, testControlRange;\n\n if (body && isHostMethod(body, \"createControlRange\")) {\n testControlRange = body.createControlRange();\n if (util.areHostProperties(testControlRange, [\"item\", \"add\"])) {\n implementsControlRange = true;\n }\n }\n features.implementsControlRange = implementsControlRange;\n\n // Selection collapsedness\n if (selectionHasAnchorAndFocus) {\n selectionIsCollapsed = function(sel) {\n return sel.anchorNode === sel.focusNode && sel.anchorOffset === sel.focusOffset;\n };\n } else {\n selectionIsCollapsed = function(sel) {\n return sel.rangeCount ? sel.getRangeAt(sel.rangeCount - 1).collapsed : false;\n };\n }\n\n function updateAnchorAndFocusFromRange(sel, range, backward) {\n var anchorPrefix = backward ? \"end\" : \"start\", focusPrefix = backward ? \"start\" : \"end\";\n sel.anchorNode = range[anchorPrefix + \"Container\"];\n sel.anchorOffset = range[anchorPrefix + \"Offset\"];\n sel.focusNode = range[focusPrefix + \"Container\"];\n sel.focusOffset = range[focusPrefix + \"Offset\"];\n }\n\n function updateAnchorAndFocusFromNativeSelection(sel) {\n var nativeSel = sel.nativeSelection;\n sel.anchorNode = nativeSel.anchorNode;\n sel.anchorOffset = nativeSel.anchorOffset;\n sel.focusNode = nativeSel.focusNode;\n sel.focusOffset = nativeSel.focusOffset;\n }\n\n function updateEmptySelection(sel) {\n sel.anchorNode = sel.focusNode = null;\n sel.anchorOffset = sel.focusOffset = 0;\n sel.rangeCount = 0;\n sel.isCollapsed = true;\n sel._ranges.length = 0;\n }\n\n function getNativeRange(range) {\n var nativeRange;\n if (range instanceof DomRange) {\n nativeRange = api.createNativeRange(range.getDocument());\n nativeRange.setEnd(range.endContainer, range.endOffset);\n nativeRange.setStart(range.startContainer, range.startOffset);\n } else if (range instanceof WrappedRange) {\n nativeRange = range.nativeRange;\n } else if (features.implementsDomRange && (range instanceof dom.getWindow(range.startContainer).Range)) {\n nativeRange = range;\n }\n return nativeRange;\n }\n\n function rangeContainsSingleElement(rangeNodes) {\n if (!rangeNodes.length || rangeNodes[0].nodeType != 1) {\n return false;\n }\n for (var i = 1, len = rangeNodes.length; i < len; ++i) {\n if (!dom.isAncestorOf(rangeNodes[0], rangeNodes[i])) {\n return false;\n }\n }\n return true;\n }\n\n function getSingleElementFromRange(range) {\n var nodes = range.getNodes();\n if (!rangeContainsSingleElement(nodes)) {\n throw module.createError(\"getSingleElementFromRange: range \" + range.inspect() + \" did not consist of a single element\");\n }\n return nodes[0];\n }\n\n // Simple, quick test which only needs to distinguish between a TextRange and a ControlRange\n function isTextRange(range) {\n return !!range && typeof range.text != \"undefined\";\n }\n\n function updateFromTextRange(sel, range) {\n // Create a Range from the selected TextRange\n var wrappedRange = new WrappedRange(range);\n sel._ranges = [wrappedRange];\n\n updateAnchorAndFocusFromRange(sel, wrappedRange, false);\n sel.rangeCount = 1;\n sel.isCollapsed = wrappedRange.collapsed;\n }\n\n function updateControlSelection(sel) {\n // Update the wrapped selection based on what's now in the native selection\n sel._ranges.length = 0;\n if (sel.docSelection.type == \"None\") {\n updateEmptySelection(sel);\n } else {\n var controlRange = sel.docSelection.createRange();\n if (isTextRange(controlRange)) {\n // This case (where the selection type is \"Control\" and calling createRange() on the selection returns\n // a TextRange) can happen in IE 9. It happens, for example, when all elements in the selected\n // ControlRange have been removed from the ControlRange and removed from the document.\n updateFromTextRange(sel, controlRange);\n } else {\n sel.rangeCount = controlRange.length;\n var range, doc = getDocument(controlRange.item(0));\n for (var i = 0; i < sel.rangeCount; ++i) {\n range = api.createRange(doc);\n range.selectNode(controlRange.item(i));\n sel._ranges.push(range);\n }\n sel.isCollapsed = sel.rangeCount == 1 && sel._ranges[0].collapsed;\n updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);\n }\n }\n }\n\n function addRangeToControlSelection(sel, range) {\n var controlRange = sel.docSelection.createRange();\n var rangeElement = getSingleElementFromRange(range);\n\n // Create a new ControlRange containing all the elements in the selected ControlRange plus the element\n // contained by the supplied range\n var doc = getDocument(controlRange.item(0));\n var newControlRange = getBody(doc).createControlRange();\n for (var i = 0, len = controlRange.length; i < len; ++i) {\n newControlRange.add(controlRange.item(i));\n }\n try {\n newControlRange.add(rangeElement);\n } catch (ex) {\n throw module.createError(\"addRange(): Element within the specified Range could not be added to control selection (does it have layout?)\");\n }\n newControlRange.select();\n\n // Update the wrapped selection based on what's now in the native selection\n updateControlSelection(sel);\n }\n\n var getSelectionRangeAt;\n\n if (isHostMethod(testSelection, \"getRangeAt\")) {\n // try/catch is present because getRangeAt() must have thrown an error in some browser and some situation.\n // Unfortunately, I didn't write a comment about the specifics and am now scared to take it out. Let that be a\n // lesson to us all, especially me.\n getSelectionRangeAt = function(sel, index) {\n try {\n return sel.getRangeAt(index);\n } catch (ex) {\n return null;\n }\n };\n } else if (selectionHasAnchorAndFocus) {\n getSelectionRangeAt = function(sel) {\n var doc = getDocument(sel.anchorNode);\n var range = api.createRange(doc);\n range.setStartAndEnd(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset);\n\n // Handle the case when the selection was selected backwards (from the end to the start in the\n // document)\n if (range.collapsed !== this.isCollapsed) {\n range.setStartAndEnd(sel.focusNode, sel.focusOffset, sel.anchorNode, sel.anchorOffset);\n }\n\n return range;\n };\n }\n\n function WrappedSelection(selection, docSelection, win) {\n this.nativeSelection = selection;\n this.docSelection = docSelection;\n this._ranges = [];\n this.win = win;\n this.refresh();\n }\n\n WrappedSelection.prototype = api.selectionPrototype;\n\n function deleteProperties(sel) {\n sel.win = sel.anchorNode = sel.focusNode = sel._ranges = null;\n sel.rangeCount = sel.anchorOffset = sel.focusOffset = 0;\n sel.detached = true;\n }\n\n var cachedRangySelections = [];\n\n function actOnCachedSelection(win, action) {\n var i = cachedRangySelections.length, cached, sel;\n while (i--) {\n cached = cachedRangySelections[i];\n sel = cached.selection;\n if (action == \"deleteAll\") {\n deleteProperties(sel);\n } else if (cached.win == win) {\n if (action == \"delete\") {\n cachedRangySelections.splice(i, 1);\n return true;\n } else {\n return sel;\n }\n }\n }\n if (action == \"deleteAll\") {\n cachedRangySelections.length = 0;\n }\n return null;\n }\n\n var getSelection = function(win) {\n // Check if the parameter is a Rangy Selection object\n if (win && win instanceof WrappedSelection) {\n win.refresh();\n return win;\n }\n\n win = getWindow(win, \"getNativeSelection\");\n\n var sel = actOnCachedSelection(win);\n var nativeSel = getNativeSelection(win), docSel = implementsDocSelection ? getDocSelection(win) : null;\n if (sel) {\n sel.nativeSelection = nativeSel;\n sel.docSelection = docSel;\n sel.refresh();\n } else {\n sel = new WrappedSelection(nativeSel, docSel, win);\n cachedRangySelections.push( { win: win, selection: sel } );\n }\n return sel;\n };\n\n api.getSelection = getSelection;\n\n util.createAliasForDeprecatedMethod(api, \"getIframeSelection\", \"getSelection\");\n\n var selProto = WrappedSelection.prototype;\n\n function createControlSelection(sel, ranges) {\n // Ensure that the selection becomes of type \"Control\"\n var doc = getDocument(ranges[0].startContainer);\n var controlRange = getBody(doc).createControlRange();\n for (var i = 0, el, len = ranges.length; i < len; ++i) {\n el = getSingleElementFromRange(ranges[i]);\n try {\n controlRange.add(el);\n } catch (ex) {\n throw module.createError(\"setRanges(): Element within one of the specified Ranges could not be added to control selection (does it have layout?)\");\n }\n }\n controlRange.select();\n\n // Update the wrapped selection based on what's now in the native selection\n updateControlSelection(sel);\n }\n\n // Selecting a range\n if (!useDocumentSelection && selectionHasAnchorAndFocus && util.areHostMethods(testSelection, [\"removeAllRanges\", \"addRange\"])) {\n selProto.removeAllRanges = function() {\n this.nativeSelection.removeAllRanges();\n updateEmptySelection(this);\n };\n\n var addRangeBackward = function(sel, range) {\n addRangeBackwardToNative(sel.nativeSelection, range);\n sel.refresh();\n };\n\n if (selectionHasRangeCount) {\n selProto.addRange = function(range, direction) {\n if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {\n addRangeToControlSelection(this, range);\n } else {\n if (isDirectionBackward(direction) && selectionHasExtend) {\n addRangeBackward(this, range);\n } else {\n var previousRangeCount;\n if (selectionSupportsMultipleRanges) {\n previousRangeCount = this.rangeCount;\n } else {\n this.removeAllRanges();\n previousRangeCount = 0;\n }\n // Clone the native range so that changing the selected range does not affect the selection.\n // This is contrary to the spec but is the only way to achieve consistency between browsers. See\n // issue 80.\n var clonedNativeRange = getNativeRange(range).cloneRange();\n try {\n this.nativeSelection.addRange(clonedNativeRange);\n } catch (ex) {\n }\n\n // Check whether adding the range was successful\n this.rangeCount = this.nativeSelection.rangeCount;\n\n if (this.rangeCount == previousRangeCount + 1) {\n // The range was added successfully\n\n // Check whether the range that we added to the selection is reflected in the last range extracted from\n // the selection\n if (api.config.checkSelectionRanges) {\n var nativeRange = getSelectionRangeAt(this.nativeSelection, this.rangeCount - 1);\n if (nativeRange && !rangesEqual(nativeRange, range)) {\n // Happens in WebKit with, for example, a selection placed at the start of a text node\n range = new WrappedRange(nativeRange);\n }\n }\n this._ranges[this.rangeCount - 1] = range;\n updateAnchorAndFocusFromRange(this, range, selectionIsBackward(this.nativeSelection));\n this.isCollapsed = selectionIsCollapsed(this);\n } else {\n // The range was not added successfully. The simplest thing is to refresh\n this.refresh();\n }\n }\n }\n };\n } else {\n selProto.addRange = function(range, direction) {\n if (isDirectionBackward(direction) && selectionHasExtend) {\n addRangeBackward(this, range);\n } else {\n this.nativeSelection.addRange(getNativeRange(range));\n this.refresh();\n }\n };\n }\n\n selProto.setRanges = function(ranges) {\n if (implementsControlRange && implementsDocSelection && ranges.length > 1) {\n createControlSelection(this, ranges);\n } else {\n this.removeAllRanges();\n for (var i = 0, len = ranges.length; i < len; ++i) {\n this.addRange(ranges[i]);\n }\n }\n };\n } else if (isHostMethod(testSelection, \"empty\") && isHostMethod(testRange, \"select\") &&\n implementsControlRange && useDocumentSelection) {\n\n selProto.removeAllRanges = function() {\n // Added try/catch as fix for issue #21\n try {\n this.docSelection.empty();\n\n // Check for empty() not working (issue #24)\n if (this.docSelection.type != \"None\") {\n // Work around failure to empty a control selection by instead selecting a TextRange and then\n // calling empty()\n var doc;\n if (this.anchorNode) {\n doc = getDocument(this.anchorNode);\n } else if (this.docSelection.type == CONTROL) {\n var controlRange = this.docSelection.createRange();\n if (controlRange.length) {\n doc = getDocument( controlRange.item(0) );\n }\n }\n if (doc) {\n var textRange = getBody(doc).createTextRange();\n textRange.select();\n this.docSelection.empty();\n }\n }\n } catch(ex) {}\n updateEmptySelection(this);\n };\n\n selProto.addRange = function(range) {\n if (this.docSelection.type == CONTROL) {\n addRangeToControlSelection(this, range);\n } else {\n api.WrappedTextRange.rangeToTextRange(range).select();\n this._ranges[0] = range;\n this.rangeCount = 1;\n this.isCollapsed = this._ranges[0].collapsed;\n updateAnchorAndFocusFromRange(this, range, false);\n }\n };\n\n selProto.setRanges = function(ranges) {\n this.removeAllRanges();\n var rangeCount = ranges.length;\n if (rangeCount > 1) {\n createControlSelection(this, ranges);\n } else if (rangeCount) {\n this.addRange(ranges[0]);\n }\n };\n } else {\n module.fail(\"No means of selecting a Range or TextRange was found\");\n return false;\n }\n\n selProto.getRangeAt = function(index) {\n if (index < 0 || index >= this.rangeCount) {\n throw new DOMException(\"INDEX_SIZE_ERR\");\n } else {\n // Clone the range to preserve selection-range independence. See issue 80.\n return this._ranges[index].cloneRange();\n }\n };\n\n var refreshSelection;\n\n if (useDocumentSelection) {\n refreshSelection = function(sel) {\n var range;\n if (api.isSelectionValid(sel.win)) {\n range = sel.docSelection.createRange();\n } else {\n range = getBody(sel.win.document).createTextRange();\n range.collapse(true);\n }\n\n if (sel.docSelection.type == CONTROL) {\n updateControlSelection(sel);\n } else if (isTextRange(range)) {\n updateFromTextRange(sel, range);\n } else {\n updateEmptySelection(sel);\n }\n };\n } else if (isHostMethod(testSelection, \"getRangeAt\") && typeof testSelection.rangeCount == NUMBER) {\n refreshSelection = function(sel) {\n if (implementsControlRange && implementsDocSelection && sel.docSelection.type == CONTROL) {\n updateControlSelection(sel);\n } else {\n sel._ranges.length = sel.rangeCount = sel.nativeSelection.rangeCount;\n if (sel.rangeCount) {\n for (var i = 0, len = sel.rangeCount; i < len; ++i) {\n sel._ranges[i] = new api.WrappedRange(sel.nativeSelection.getRangeAt(i));\n }\n updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], selectionIsBackward(sel.nativeSelection));\n sel.isCollapsed = selectionIsCollapsed(sel);\n } else {\n updateEmptySelection(sel);\n }\n }\n };\n } else if (selectionHasAnchorAndFocus && typeof testSelection.isCollapsed == BOOLEAN && typeof testRange.collapsed == BOOLEAN && features.implementsDomRange) {\n refreshSelection = function(sel) {\n var range, nativeSel = sel.nativeSelection;\n if (nativeSel.anchorNode) {\n range = getSelectionRangeAt(nativeSel, 0);\n sel._ranges = [range];\n sel.rangeCount = 1;\n updateAnchorAndFocusFromNativeSelection(sel);\n sel.isCollapsed = selectionIsCollapsed(sel);\n } else {\n updateEmptySelection(sel);\n }\n };\n } else {\n module.fail(\"No means of obtaining a Range or TextRange from the user's selection was found\");\n return false;\n }\n\n selProto.refresh = function(checkForChanges) {\n var oldRanges = checkForChanges ? this._ranges.slice(0) : null;\n var oldAnchorNode = this.anchorNode, oldAnchorOffset = this.anchorOffset;\n\n refreshSelection(this);\n if (checkForChanges) {\n // Check the range count first\n var i = oldRanges.length;\n if (i != this._ranges.length) {\n return true;\n }\n\n // Now check the direction. Checking the anchor position is the same is enough since we're checking all the\n // ranges after this\n if (this.anchorNode != oldAnchorNode || this.anchorOffset != oldAnchorOffset) {\n return true;\n }\n\n // Finally, compare each range in turn\n while (i--) {\n if (!rangesEqual(oldRanges[i], this._ranges[i])) {\n return true;\n }\n }\n return false;\n }\n };\n\n // Removal of a single range\n var removeRangeManually = function(sel, range) {\n var ranges = sel.getAllRanges();\n sel.removeAllRanges();\n for (var i = 0, len = ranges.length; i < len; ++i) {\n if (!rangesEqual(range, ranges[i])) {\n sel.addRange(ranges[i]);\n }\n }\n if (!sel.rangeCount) {\n updateEmptySelection(sel);\n }\n };\n\n if (implementsControlRange && implementsDocSelection) {\n selProto.removeRange = function(range) {\n if (this.docSelection.type == CONTROL) {\n var controlRange = this.docSelection.createRange();\n var rangeElement = getSingleElementFromRange(range);\n\n // Create a new ControlRange containing all the elements in the selected ControlRange minus the\n // element contained by the supplied range\n var doc = getDocument(controlRange.item(0));\n var newControlRange = getBody(doc).createControlRange();\n var el, removed = false;\n for (var i = 0, len = controlRange.length; i < len; ++i) {\n el = controlRange.item(i);\n if (el !== rangeElement || removed) {\n newControlRange.add(controlRange.item(i));\n } else {\n removed = true;\n }\n }\n newControlRange.select();\n\n // Update the wrapped selection based on what's now in the native selection\n updateControlSelection(this);\n } else {\n removeRangeManually(this, range);\n }\n };\n } else {\n selProto.removeRange = function(range) {\n removeRangeManually(this, range);\n };\n }\n\n // Detecting if a selection is backward\n var selectionIsBackward;\n if (!useDocumentSelection && selectionHasAnchorAndFocus && features.implementsDomRange) {\n selectionIsBackward = winSelectionIsBackward;\n\n selProto.isBackward = function() {\n return selectionIsBackward(this);\n };\n } else {\n selectionIsBackward = selProto.isBackward = function() {\n return false;\n };\n }\n\n // Create an alias for backwards compatibility. From 1.3, everything is \"backward\" rather than \"backwards\"\n selProto.isBackwards = selProto.isBackward;\n\n // Selection stringifier\n // This is conformant to the old HTML5 selections draft spec but differs from WebKit and Mozilla's implementation.\n // The current spec does not yet define this method.\n selProto.toString = function() {\n var rangeTexts = [];\n for (var i = 0, len = this.rangeCount; i < len; ++i) {\n rangeTexts[i] = \"\" + this._ranges[i];\n }\n return rangeTexts.join(\"\");\n };\n\n function assertNodeInSameDocument(sel, node) {\n if (sel.win.document != getDocument(node)) {\n throw new DOMException(\"WRONG_DOCUMENT_ERR\");\n }\n }\n\n // No current browser conforms fully to the spec for this method, so Rangy's own method is always used\n selProto.collapse = function(node, offset) {\n assertNodeInSameDocument(this, node);\n var range = api.createRange(node);\n range.collapseToPoint(node, offset);\n this.setSingleRange(range);\n this.isCollapsed = true;\n };\n\n selProto.collapseToStart = function() {\n if (this.rangeCount) {\n var range = this._ranges[0];\n this.collapse(range.startContainer, range.startOffset);\n } else {\n throw new DOMException(\"INVALID_STATE_ERR\");\n }\n };\n\n selProto.collapseToEnd = function() {\n if (this.rangeCount) {\n var range = this._ranges[this.rangeCount - 1];\n this.collapse(range.endContainer, range.endOffset);\n } else {\n throw new DOMException(\"INVALID_STATE_ERR\");\n }\n };\n\n // The spec is very specific on how selectAllChildren should be implemented and not all browsers implement it as\n // specified so the native implementation is never used by Rangy.\n selProto.selectAllChildren = function(node) {\n assertNodeInSameDocument(this, node);\n var range = api.createRange(node);\n range.selectNodeContents(node);\n this.setSingleRange(range);\n };\n\n selProto.deleteFromDocument = function() {\n // Sepcial behaviour required for IE's control selections\n if (implementsControlRange && implementsDocSelection && this.docSelection.type == CONTROL) {\n var controlRange = this.docSelection.createRange();\n var element;\n while (controlRange.length) {\n element = controlRange.item(0);\n controlRange.remove(element);\n dom.removeNode(element);\n }\n this.refresh();\n } else if (this.rangeCount) {\n var ranges = this.getAllRanges();\n if (ranges.length) {\n this.removeAllRanges();\n for (var i = 0, len = ranges.length; i < len; ++i) {\n ranges[i].deleteContents();\n }\n // The spec says nothing about what the selection should contain after calling deleteContents on each\n // range. Firefox moves the selection to where the final selected range was, so we emulate that\n this.addRange(ranges[len - 1]);\n }\n }\n };\n\n // The following are non-standard extensions\n selProto.eachRange = function(func, returnValue) {\n for (var i = 0, len = this._ranges.length; i < len; ++i) {\n if ( func( this.getRangeAt(i) ) ) {\n return returnValue;\n }\n }\n };\n\n selProto.getAllRanges = function() {\n var ranges = [];\n this.eachRange(function(range) {\n ranges.push(range);\n });\n return ranges;\n };\n\n selProto.setSingleRange = function(range, direction) {\n this.removeAllRanges();\n this.addRange(range, direction);\n };\n\n selProto.callMethodOnEachRange = function(methodName, params) {\n var results = [];\n this.eachRange( function(range) {\n results.push( range[methodName].apply(range, params || []) );\n } );\n return results;\n };\n\n function createStartOrEndSetter(isStart) {\n return function(node, offset) {\n var range;\n if (this.rangeCount) {\n range = this.getRangeAt(0);\n range[\"set\" + (isStart ? \"Start\" : \"End\")](node, offset);\n } else {\n range = api.createRange(this.win.document);\n range.setStartAndEnd(node, offset);\n }\n this.setSingleRange(range, this.isBackward());\n };\n }\n\n selProto.setStart = createStartOrEndSetter(true);\n selProto.setEnd = createStartOrEndSetter(false);\n\n // Add select() method to Range prototype. Any existing selection will be removed.\n api.rangePrototype.select = function(direction) {\n getSelection( this.getDocument() ).setSingleRange(this, direction);\n };\n\n selProto.changeEachRange = function(func) {\n var ranges = [];\n var backward = this.isBackward();\n\n this.eachRange(function(range) {\n func(range);\n ranges.push(range);\n });\n\n this.removeAllRanges();\n if (backward && ranges.length == 1) {\n this.addRange(ranges[0], \"backward\");\n } else {\n this.setRanges(ranges);\n }\n };\n\n selProto.containsNode = function(node, allowPartial) {\n return this.eachRange( function(range) {\n return range.containsNode(node, allowPartial);\n }, true ) || false;\n };\n\n selProto.getBookmark = function(containerNode) {\n return {\n backward: this.isBackward(),\n rangeBookmarks: this.callMethodOnEachRange(\"getBookmark\", [containerNode])\n };\n };\n\n selProto.moveToBookmark = function(bookmark) {\n var selRanges = [];\n for (var i = 0, rangeBookmark, range; rangeBookmark = bookmark.rangeBookmarks[i++]; ) {\n range = api.createRange(this.win);\n range.moveToBookmark(rangeBookmark);\n selRanges.push(range);\n }\n if (bookmark.backward) {\n this.setSingleRange(selRanges[0], \"backward\");\n } else {\n this.setRanges(selRanges);\n }\n };\n\n selProto.saveRanges = function() {\n return {\n backward: this.isBackward(),\n ranges: this.callMethodOnEachRange(\"cloneRange\")\n };\n };\n\n selProto.restoreRanges = function(selRanges) {\n this.removeAllRanges();\n for (var i = 0, range; range = selRanges.ranges[i]; ++i) {\n this.addRange(range, (selRanges.backward && i == 0));\n }\n };\n\n selProto.toHtml = function() {\n var rangeHtmls = [];\n this.eachRange(function(range) {\n rangeHtmls.push( DomRange.toHtml(range) );\n });\n return rangeHtmls.join(\"\");\n };\n\n if (features.implementsTextRange) {\n selProto.getNativeTextRange = function() {\n var sel, textRange;\n if ( (sel = this.docSelection) ) {\n var range = sel.createRange();\n if (isTextRange(range)) {\n return range;\n } else {\n throw module.createError(\"getNativeTextRange: selection is a control selection\");\n }\n } else if (this.rangeCount > 0) {\n return api.WrappedTextRange.rangeToTextRange( this.getRangeAt(0) );\n } else {\n throw module.createError(\"getNativeTextRange: selection contains no range\");\n }\n };\n }\n\n function inspect(sel) {\n var rangeInspects = [];\n var anchor = new DomPosition(sel.anchorNode, sel.anchorOffset);\n var focus = new DomPosition(sel.focusNode, sel.focusOffset);\n var name = (typeof sel.getName == \"function\") ? sel.getName() : \"Selection\";\n\n if (typeof sel.rangeCount != \"undefined\") {\n for (var i = 0, len = sel.rangeCount; i < len; ++i) {\n rangeInspects[i] = DomRange.inspect(sel.getRangeAt(i));\n }\n }\n return \"[\" + name + \"(Ranges: \" + rangeInspects.join(\", \") +\n \")(anchor: \" + anchor.inspect() + \", focus: \" + focus.inspect() + \"]\";\n }\n\n selProto.getName = function() {\n return \"WrappedSelection\";\n };\n\n selProto.inspect = function() {\n return inspect(this);\n };\n\n selProto.detach = function() {\n actOnCachedSelection(this.win, \"delete\");\n deleteProperties(this);\n };\n\n WrappedSelection.detachAll = function() {\n actOnCachedSelection(null, \"deleteAll\");\n };\n\n WrappedSelection.inspect = inspect;\n WrappedSelection.isDirectionBackward = isDirectionBackward;\n\n api.Selection = WrappedSelection;\n\n api.selectionPrototype = selProto;\n\n api.addShimListener(function(win) {\n if (typeof win.getSelection == \"undefined\") {\n win.getSelection = function() {\n return getSelection(win);\n };\n }\n win = null;\n });\n });\n \r\n\r\n /*----------------------------------------------------------------------------------------------------------------*/\r\n\r\n // Wait for document to load before initializing\r\n var docReady = false;\r\n\r\n var loadHandler = function(e) {\r\n if (!docReady) {\r\n docReady = true;\r\n if (!api.initialized && api.config.autoInitialize) {\r\n init();\r\n }\r\n }\r\n };\r\n\r\n if (isBrowser) {\r\n // Test whether the document has already been loaded and initialize immediately if so\r\n if (document.readyState == \"complete\") {\r\n loadHandler();\r\n } else {\r\n if (isHostMethod(document, \"addEventListener\")) {\r\n document.addEventListener(\"DOMContentLoaded\", loadHandler, false);\r\n }\r\n\r\n // Add a fallback in case the DOMContentLoaded event isn't supported\r\n addListener(window, \"load\", loadHandler);\r\n }\r\n }\r\n\r\n return api;\r\n}, this);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rangy/lib/rangy-core.js\n// module id = 213\n// module chunks = 0","import Vue from 'vue';\nVue.use(require('vue-resource'));\n\nVue.http.headers.common['X-CSRF-TOKEN'] = document.querySelector('#csrf-token').getAttribute('value');\n\nVue.http.interceptors.push({\n response: function (response) {\n if (response.status === 401) {\n this.$root.showLoginModal = true;\n }\n\n return response;\n }\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/vue-resource.js","global.cp_url = function(url) {\n url = Statamic.cpRoot + '/' + url;\n return url.replace(/\\/+/g, '/');\n};\n\nglobal.resource_url = function(url) {\n url = Statamic.resourceUrl + '/' + url;\n return url.replace(/\\/+/g, '/');\n};\n\n// Get url segments from the nth segment\nglobal.get_from_segment = function(count) {\n return Statamic.urlPath.split('/').splice(count).join('/');\n};\n\nglobal.format_input_options = function(options) {\n\n\tif (typeof options[0] === 'string') {\n\t\treturn options;\n\t}\n\n\tvar formatted = [];\n\t_.each(options, function(value, key, list) {\n\t formatted.push({'value': key, 'text': value});\n\t});\n\n\treturn formatted;\n};\n\nglobal.file_icon = function(extension) {\n return resource_url('img/filetypes/'+ extension +'.png');\n};\n\nglobal.dd = function(args) {\n console.log(args);\n};\n\nglobal.data_get = function(obj, key) {\n return key.split(\".\").reduce(function(o, x) {\n return (typeof o == \"undefined\" || o === null) ? o : o[x];\n }, obj);\n};\n\nglobal.Cookies = require('cookies-js');\n\nglobal.tailwind_width_class = function (width) {\n const widths = {\n 25: '1/4',\n 33: '1/3',\n 50: '1/2',\n 66: '2/3',\n 75: '3/4',\n 100: 'full'\n };\n\n return `w-${widths[width] || 'full'}`;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/globals.js","// String.includes() polyfill.\n// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\nif (!String.prototype.includes) {\n String.prototype.includes = function(search, start) {\n 'use strict';\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > this.length) {\n return false;\n } else {\n return this.indexOf(search, start) !== -1;\n }\n };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/polyfills.js","_.mixin({\n // ### _.objMap\n // _.map for objects, keeps key/value associations\n objMap: function (input, mapper, context) {\n return _.reduce(input, function (obj, v, k) {\n obj[k] = mapper.call(context, v, k, input);\n return obj;\n }, {}, context);\n },\n // ### _.objFilter\n // _.filter for objects, keeps key/value associations\n // but only includes the properties that pass test().\n objFilter: function (input, test, context) {\n return _.reduce(input, function (obj, v, k) {\n if (test.call(context, v, k, input)) {\n obj[k] = v;\n }\n return obj;\n }, {}, context);\n },\n // ### _.objReject\n //\n // _.reject for objects, keeps key/value associations\n // but does not include the properties that pass test().\n objReject: function (input, test, context) {\n return _.reduce(input, function (obj, v, k) {\n if (!test.call(context, v, k, input)) {\n obj[k] = v;\n }\n return obj;\n }, {}, context);\n }\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/underscore-mixins.js","jQuery.extend( jQuery.fn, {\n // Name of our method & one argument (the parent selector)\n within: function( pSelector ) {\n // Returns a subset of items using jQuery.filter\n return this.filter(function(){\n // Return truthy/falsey based on presence in parent\n return $(this).closest( pSelector ).length;\n });\n }\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/jquery-plugins.js","$.Redactor.prototype.assets = function () {\n\n return {\n\n init: function () {\n // If assets aren't enabled, don't add the button.\n if (! this.assets.vue().assetsEnabled) {\n return;\n }\n\n var button = this.button.add('assets', translate_choice('cp.assets', 2));\n this.button.addCallback(button, this.assets.show);\n },\n\n show: function () {\n this.selection.save();\n this.assets.vue().addAsset();\n },\n\n vue: function () {\n return this.opts.vueInstance;\n }\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/redactor-plugins.js"," var Lang = function() {\n };\n\n // Methods //\n\n /**\n * Set messages source.\n *\n * @param messages {object} The messages source.\n *\n * @return void\n */\n Lang.prototype.setMessages = function(messages) {\n this.messages = messages;\n };\n\n /**\n * Returns a translation message.\n *\n * @param key {string} The key of the message.\n * @param replacements {object} The replacements to be done in the message.\n *\n * @return {string} The translation message, if not found the given key.\n */\n Lang.prototype.get = function(key, replacements) {\n if (!this.has(key)) {\n return key;\n }\n\n var message = this._getMessage(key, replacements);\n if (message === null) {\n return key;\n }\n\n if (replacements) {\n message = this._applyReplacements(message, replacements);\n }\n\n return message;\n };\n\n /**\n * Returns true if the key is defined on the messages source.\n *\n * @param key {string} The key of the message.\n *\n * @return {boolean} true if the given key is defined on the messages source, otherwise false.\n */\n Lang.prototype.has = function(key) {\n if (typeof key !== 'string' || !this.messages) {\n return false;\n }\n\n return this._getMessage(key) !== null;\n };\n\n /**\n * Gets the plural or singular form of the message specified based on an integer value.\n *\n * @param key {string} The key of the message.\n * @param count {integer} The number of elements.\n * @param replacements {object} The replacements to be done in the message.\n *\n * @return {string} The translation message according to an integer value.\n */\n Lang.prototype.choice = function(key, count, replacements) {\n // Set default values for parameters replace and locale\n replacements = typeof replacements !== 'undefined' ? replacements : {};\n\n // The count must be replaced if found in the message\n replacements['count'] = count;\n\n // Message to get the plural or singular\n var message = this.get(key, replacements);\n\n // Check if message is not null or undefined\n if (message === null || message === undefined) {\n return message;\n }\n\n // Separate the plural from the singular, if any\n var messageParts = message.split('|');\n\n // Get the explicit rules, If any\n var explicitRules = [];\n var regex = /{\\d+}\\s(.+)|\\[\\d+,\\d+\\]\\s(.+)|\\[\\d+,Inf\\]\\s(.+)/;\n\n for (var i = 0; i < messageParts.length; i++) {\n messageParts[i] = messageParts[i].trim();\n\n if (regex.test(messageParts[i])) {\n var messageSpaceSplit = messageParts[i].split(/\\s/);\n explicitRules.push(messageSpaceSplit.shift());\n messageParts[i] = messageSpaceSplit.join(' ');\n }\n }\n\n // Check if there's only one message\n if (messageParts.length === 1) {\n // Nothing to do here\n return message;\n }\n\n // Check the explicit rules\n for (var i = 0; i < explicitRules.length; i++) {\n if (this._testInterval(count, explicitRules[i])) {\n return messageParts[i];\n }\n }\n\n // Standard rules\n if (count === 1) {\n return messageParts[0];\n } else {\n return messageParts[1];\n }\n };\n\n /**\n * Parse a message key into components.\n *\n * @param key {string} The message key to parse.\n *\n * @return {object} A key object with source and entries properties.\n */\n Lang.prototype._parseKey = function(key) {\n if (typeof key !== 'string') {\n return null;\n }\n\n var segments = key.split('.');\n\n /**\n * @note This is deteting if the key is an add on but to be honest,\n * this should just work the same since the indexes stays the\n * same all throughout the translations.\n *\n * I'm just not sure if there are any edge cases of nested\n * translations are included though I'm doubtful there are.\n *\n * Just to clarify though, we _can_ just use this if there\n * aren't any nested translations.\n */\n if (key.includes('::')) {\n return {\n source: segments.splice(0, segments.length - 1).join('.'),\n entries: segments.slice(segments.length - 1)\n };\n }\n\n return {\n source: segments[0],\n entries: segments.slice(1)\n };\n };\n\n /**\n * Returns a translation message. Use `Lang.get()` method instead, this methods assumes the key exists.\n *\n * @param key {string} The key of the message.\n *\n * @return {string} The translation message for the given key.\n */\n Lang.prototype._getMessage = function(key) {\n\n key = this._parseKey(key);\n\n // Ensure message source exists.\n if (this.messages[key.source] === undefined) {\n return null;\n }\n\n // Get message text.\n var message = this.messages[key.source];\n while (key.entries.length && (message = message[key.entries.shift()]));\n\n if (typeof message !== 'string') {\n return null;\n }\n\n return message;\n };\n\n /**\n * Apply replacements to a string message containing placeholders.\n *\n * @param message {string} The text message.\n * @param replacements {object} The replacements to be done in the message.\n *\n * @return {string} The string message with replacements applied.\n */\n Lang.prototype._applyReplacements = function(message, replacements) {\n for (var replace in replacements) {\n message = message.split(':' + replace).join(replacements[replace]);\n }\n return message;\n };\n\n /**\n * Checks if the given `count` is within the interval defined by the {string} `interval`\n *\n * @param count {int} The amount of items.\n * @param interval {string} The interval to be compared with the count.\n * @return {boolean} Returns true if count is within interval; false otherwise.\n */\n Lang.prototype._testInterval = function(count, interval) {\n /**\n * From the Symfony\\Component\\Translation\\Interval Docs\n *\n * Tests if a given number belongs to a given math interval.\n * An interval can represent a finite set of numbers: {1,2,3,4}\n * An interval can represent numbers between two numbers: [1, +Inf] ]-1,2[\n * The left delimiter can be [ (inclusive) or ] (exclusive).\n * The right delimiter can be [ (exclusive) or ] (inclusive).\n * Beside numbers, you can use -Inf and +Inf for the infinite.\n */\n\n return false;\n };\n\n export default new Lang;\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/l10n/lang.js","// Bring in the Lang library\nimport Lang from './lang';\n\nwindow.translate = function(key, replacements) {\n var message = Lang.get(key, replacements);\n\n if (message === key) {\n return makeTitle(message.replace('cp.', ''));\n }\n\n return message;\n};\n\nwindow.translate_choice = function(key, count, replacements) {\n return Lang.choice(key, count, replacements);\n};\n\n// Set the translation messages. The object will be in the page body.\nLang.setMessages(Statamic.translations);\n\nfunction makeTitle(slug) {\n var words = slug.split(/[-_]/);\n\n for(var i = 0; i < words.length; i++) {\n var word = words[i];\n words[i] = word.charAt(0).toUpperCase() + word.slice(1);\n }\n\n return words.join(' ');\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/l10n/l10n.js","export default {\n\n install(Vue, options) {\n\n Vue.prototype.cp_url = function(url) {\n return cp_url(url);\n };\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/plugins/cp_url.js","export default {\n\n install(Vue, options) {\n\n Vue.prototype.translate = function(key, replacements) {\n return translate(key, replacements);\n };\n\n Vue.prototype.translate_choice = function(key, count, replacements) {\n return translate_choice(key, count, replacements);\n };\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/plugins/translate.js","export default {\n\n install(Vue, options) {\n\n Vue.prototype.resource_url = function(url) {\n return resource_url(url);\n };\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/plugins/resource_url.js","export default {\n\n install(Vue, options) {\n\n Vue.prototype.file_icon = function(url) {\n return file_icon(url);\n };\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/plugins/file_icon.js","var getSlug = require('speakingurl');\n\nexport default {\n install(Vue, options) {\n Vue.prototype.$slugify = function(text, glue) {\n return getSlug(text, {\n separator: glue || '-',\n custom: {'\\'': ''}\n });\n };\n }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/plugins/slugify.js","import Vue from 'vue'\nimport CpUrl from '../plugins/cp_url';\nimport Translate from '../plugins/translate';\nimport ResourceUrl from '../plugins/resource_url';\nimport FileIcon from '../plugins/file_icon';\nimport Can from '../plugins/can';\nimport Slugify from '../plugins/slugify';\n\nVue.use(CpUrl);\nVue.use(Translate);\nVue.use(ResourceUrl);\nVue.use(FileIcon);\nVue.use(Can);\nVue.use(Slugify);\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/plugins.js","if (Statamic.permissions) {\n var permissions = JSON.parse(atob(Statamic.permissions));\n}\n\nvar can = function(permission) {\n if (_.contains(permissions, 'super')) {\n return true;\n }\n\n var colons = permission.split(':').length - 1;\n\n if (colons === 2) {\n var parts = permission.split(':');\n var cascade = parts[0] + ':';\n if (parts[2] === 'delete') {\n cascade += 'delete';\n } else {\n cascade += 'manage';\n }\n\n if (_.contains(permissions, cascade)) {\n return true;\n }\n }\n\n return _.contains(permissions, permission);\n};\n\nexport default {\n\n install(Vue, options) {\n\n Vue.prototype.can = function(permission) {\n return can(permission);\n };\n\n Vue.can = function(permission) {\n return can(permission);\n };\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/plugins/can.js","import Vue from 'vue';\n\nVue.filter('deslugify', require('../filters/deslugify'));\nVue.filter('titleize', require('../filters/titleize'));\nVue.filter('pre', require('../filters/pre'));\nVue.filter('reverse', require('../filters/reverse'));\nVue.filter('pluck', require('../filters/pluck'));\nVue.filter('parse', require('../filters/parse'));\nVue.filter('optionize', require('../filters/optionize'));\nVue.filter('markdown', require('../filters/markdown'));\nVue.filter('caseInsensitiveOrderBy', require('../filters/orderby'));\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/filters.js","module.exports = function(value) {\n\treturn value.replace(/[-_]/g, \" \")\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/deslugify.js","module.exports = function(value) {\n if(!value.split) return value;\n\n var _titleizeWord = function(string) {\n return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();\n },\n result = [];\n\n value.split(\" \").forEach(function(w) {\n result.push(_titleizeWord(w));\n });\n\n return result.join(\" \");\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/titleize.js","module.exports = function(value) {\n return ''+JSON.stringify(value, null, 2)+'
';\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/pre.js","module.exports = function(val) {\n\treturn val.split('').reverse().join('');\n};\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/reverse.js","module.exports = function(value, plucked) {\n\treturn value.map(function(item) {\n\t return item[plucked];\n\t});\n};\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/pluck.js","module.exports = function(value) {\n\treturn JSON.parse(value);\n};\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/parse.js","// Format option lists correctly, supporting both primitive and complex objects\n\nmodule.exports = function(value) {\n\toptions = JSON.parse(JSON.stringify(value));\n\n\treturn format_input_options(options);\n};\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/optionize.js","var marked = require('marked');\n\nmarked.setOptions({\n gfm: true,\n breaks: Statamic.markdownHardWrap,\n tables: true\n});\n\nmodule.exports = function(value) {\n return marked(value);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/markdown.js","module.exports = function (arr, sortKey, reverse) {\n if (!sortKey) {\n return arr\n }\n var order = (reverse && reverse < 0) ? -1 : 1\n // sort on a copy to avoid mutating original array\n return arr.slice().sort(function (a, b) {\n if (sortKey !== '$key') {\n if (Vue.util.isObject(a) && '$value' in a) a = a.$value\n if (Vue.util.isObject(b) && '$value' in b) b = b.$value\n }\n a = Vue.util.isObject(a) ? Vue.parsers.path.getPath(a, sortKey) : a\n b = Vue.util.isObject(b) ? Vue.parsers.path.getPath(b, sortKey) : b\n\n a = (typeof a === 'string') ? a.toLowerCase() : a\n b = (typeof b === 'string') ? b.toLowerCase() : b\n\n return a === b ? 0 : a > b ? order : -order\n })\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/filters/orderby.js","// Mixins\nimport Vue from 'vue'\nimport Dossier from '../components/dossier/Dossier.vue'\nimport Fieldtype from '../components/fieldtypes/Fieldtype.js'\nimport AutoSlug from '../components/fieldtypes/AutoSlug.js'\n\nwindow.Dossier = Dossier;\nwindow.Fieldtype = Fieldtype;\nwindow.AutoSlug = AutoSlug;\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/bootstrap/mixins.js","export default {\n\n props: {\n data: {},\n config: {},\n name: {},\n leaveAlert: {\n default: false\n }\n },\n\n data() {\n return {\n autoBindChangeWatcher: true,\n changeWatcherIsBound: false,\n changeWatcherWatchDeep: true\n };\n },\n\n computed: {\n\n /**\n * Whether this field is nested somewhere inside a Grid fieldtype.\n */\n isInsideGridField() {\n let vm = this;\n\n while (true) {\n let parent = vm.$parent;\n\n if (! parent) return false;\n\n if (parent.constructor.name === 'GridFieldtype') {\n return true;\n }\n\n vm = parent;\n }\n }\n\n },\n\n ready() {\n if (this.autoBindChangeWatcher) {\n this.bindChangeWatcher();\n }\n },\n\n methods: {\n\n bindChangeWatcher() {\n if (!this.leaveAlert) return;\n if (this.changeWatcherIsBound) return;\n\n this.$watch('data', function () {\n this.$dispatch('changesMade', true);\n }, { deep: this.changeWatcherWatchDeep });\n\n this.changeWatcherIsBound = true;\n },\n\n getReplicatorPreviewText() {\n return this.data;\n },\n\n focus() {\n this.$el.focus();\n }\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/fieldtypes/Fieldtype.js","export default {\n\n data() {\n return {\n autoSlugOptions: {\n isActive: true\n }\n };\n },\n\n computed: {\n\n autoSlugPublishFieldsComponent() {\n return this.$parent.$parent;\n }\n\n },\n\n methods: {\n\n autoSlug(from, to) {\n // The second argument indicates the name of the instance variable we should\n // be updating. If left blank, we'll assume it's the field's data variable.\n to = to || 'data';\n\n // If there is already data, we assume there's already a slug.\n // We don't want to automatically generate anything.\n if (this[to]) return;\n\n // Whenever the \"to\" field is modified. ie, when the slug field is edited...\n this.$watch(to, (slug) => {\n const fromVal = this.autoSlugPublishFieldsComponent.data[from] || '';\n // Mark it modified if the slug matches the slugified version. This allows\n // the automatic slugification to recommence if the slug is modified to\n this.autoSlugOptions.isActive = slug === this.$slugify(fromVal);\n });\n\n // Whenever the \"from\" field is modified. ie, when the watched field is edited...\n this.autoSlugPublishFieldsComponent.$watch(`data.${from}`, (value) => {\n if (!this.autoSlugOptions.isActive) return;\n this[to] = this.$slugify(value);\n });\n }\n\n }\n\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/fieldtypes/AutoSlug.js","var __vue_script__, __vue_template__\nvar __vue_styles__ = {}\n__vue_script__ = require(\"!!babel-loader?{\\\"cacheDirectory\\\":true,\\\"presets\\\":[[\\\"env\\\",{\\\"modules\\\":false,\\\"targets\\\":{\\\"browsers\\\":[\\\"> 2%\\\"],\\\"uglify\\\":true}}]],\\\"plugins\\\":[\\\"transform-object-rest-spread\\\",[\\\"transform-runtime\\\",{\\\"polyfill\\\":false,\\\"helpers\\\":false}]]}!../../../../../../node_modules/vue-loader/lib/selector.js?type=script&index=0!./Dossier.vue\")\nmodule.exports = __vue_script__ || {}\nif (module.exports.__esModule) module.exports = module.exports.default\nvar __vue_options__ = typeof module.exports === \"function\" ? (module.exports.options || (module.exports.options = {})) : module.exports\nif (__vue_template__) {\n__vue_options__.template = __vue_template__\n}\nif (!__vue_options__.computed) __vue_options__.computed = {}\nObject.keys(__vue_styles__).forEach(function (key) {\nvar module = __vue_styles__[key]\n__vue_options__.computed[key] = function () { return module }\n})\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/statamic/resources/js/components/dossier/Dossier.vue\n// module id = 251\n// module chunks = 0","\n\n\n\n// WEBPACK FOOTER //\n// Dossier.vue?02b1b548","var __vue_script__, __vue_template__\nvar __vue_styles__ = {}\n__vue_script__ = require(\"!!babel-loader?{\\\"cacheDirectory\\\":true,\\\"presets\\\":[[\\\"env\\\",{\\\"modules\\\":false,\\\"targets\\\":{\\\"browsers\\\":[\\\"> 2%\\\"],\\\"uglify\\\":true}}]],\\\"plugins\\\":[\\\"transform-object-rest-spread\\\",[\\\"transform-runtime\\\",{\\\"polyfill\\\":false,\\\"helpers\\\":false}]]}!../../../../../../node_modules/vue-loader/lib/selector.js?type=script&index=0!./DossierTable.vue\")\n__vue_template__ = require(\"!!vue-html-loader!../../../../../../node_modules/vue-loader/lib/selector.js?type=template&index=0!./DossierTable.vue\")\nmodule.exports = __vue_script__ || {}\nif (module.exports.__esModule) module.exports = module.exports.default\nvar __vue_options__ = typeof module.exports === \"function\" ? (module.exports.options || (module.exports.options = {})) : module.exports\nif (__vue_template__) {\n__vue_options__.template = __vue_template__\n}\nif (!__vue_options__.computed) __vue_options__.computed = {}\nObject.keys(__vue_styles__).forEach(function (key) {\nvar module = __vue_styles__[key]\n__vue_options__.computed[key] = function () { return module }\n})\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/statamic/resources/js/components/dossier/DossierTable.vue\n// module id = 253\n// module chunks = 0","\n \n \n \n \n \n \n \n \n\n \n {{ column.header }}\n \n \n\n \n \n \n \n\n \n \n \n \n\n \n \n \n \n \n\n \n {{ column.header }}\n \n\n \n \n \n \n \n \n \n \n \n
\n\n \n \n \n \n\n 1\"\n :total=\"pagination.totalPages\"\n :current=\"pagination.currentPage\"\n :segments=\"pagination.segments\"\n @selected=\"paginationPageSelected\">\n \n\n \n\n\n\n\n\n\n// WEBPACK FOOTER //\n// DossierTable.vue?63fc01ab","module.exports = \" {{ column.header }} {{ column.header }}
1\\\" :total=pagination.totalPages :current=pagination.currentPage :segments=pagination.segments @selected=paginationPageSelected> \";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-html-loader!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./app/statamic/resources/js/components/dossier/DossierTable.vue\n// module id = 255\n// module chunks = 0","export default {\n\n data() {\n return {\n pagination: {},\n selectedPage: 1\n }\n }\n\n}\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/Paginates.js","import HasLocaleSelector from '../HasLocaleSelector';\nimport HasShowDraftsSelector from '../HasShowDraftsSelector';\n\nexport default {\n\n mixins: [HasLocaleSelector, HasShowDraftsSelector, Dossier],\n\n props: ['get', 'delete', 'reorder', 'search', 'canCreate', 'canDelete', 'sort', 'sortOrder', 'reorderable', 'collection', 'createEntryRoute'],\n\n data: function() {\n return {\n ajax: {\n get: this.get,\n delete: this.delete,\n reorder: this.reorder,\n search: this.search\n },\n tableOptions: {\n sort: this.sort,\n sortOrder: this.sortOrder,\n reorderable: this.reorderable,\n checkboxes: this.canDelete,\n partials: {}\n }\n }\n },\n\n computed: {\n\n getParameters() {\n return {\n sort: this.sort,\n order: this.sortOrder,\n page: this.selectedPage,\n locale: this.locale,\n drafts: this.showDrafts ? 1 : 0\n };\n },\n\n createEntryUrl() {\n let url = this.createEntryRoute;\n\n if (this.locale !== Object.keys(Statamic.locales)[0]) {\n url += '?locale=' + this.locale;\n }\n\n return url;\n }\n\n },\n\n ready: function () {\n this.addActionPartial();\n this.bindLocaleWatcher();\n this.bindShowDraftsWatcher();\n },\n\n methods: {\n\n addActionPartial: function () {\n var str = `{{ error }}
\n{{ error }}
{{ translate('cp.drop_to_upload') }}
\n\n \n {{ translate('cp.search_results') }}\n \n \n \n {{ folder.title || folder.path }}\n \n \n {{ container.title }}\n \n \n\n \n \n \n
\n\n \n\n {{ translate('cp.no_search_results') }}
\n| \n | \n | |
|---|---|---|
| \n \n \n \n | \n \n ..\n | \n.. | \n
| {{ column.label }} | ||||
|---|---|---|---|---|
| .. | .. | |||
{{ translate_choice('cp.uploads', uploads.length) }}
\n{{ translate_choice('cp.uploads', uploads.length) }}
- \n
- {{ error }} \n
{{ error }}
\n{{ error }}
- {{ error }}
{{ translate('cp.create_folder') }}
\n{{ translate('cp.edit_folder') }}
\n \n\n \n\n{{ error }}
\n{{ translate('cp.create_folder') }}
{{ translate('cp.edit_folder') }}
{{ error }}
{{ translate('cp.drop_to_upload') }}
{{ translate('cp.search_results') }} {{ folder.title || folder.path }} {{ container.title }}
{{ translate('cp.no_search_results') }}
- \n
- {{ error }} \n
{{ translate('cp.creating_asset_container') }}
\n{{ translate('cp.editing_asset_container') }}
\n \n- \n\n
- \n \n Validating...\n \n\n
- \n \n Invalid Credentials
\n {{ validationError }}\n \n\n - \n \n \n Valid credentials.\n
\n Files detected: {{ filesDetected }}\n \n\n
- Validating...
- Invalid Credentials
{{ validationError }} - Valid credentials.
Files detected: {{ filesDetected }}
- {{ error }}
{{ translate('cp.creating_asset_container') }}
{{ translate('cp.editing_asset_container') }}
{{ translate('cp.creating_asset_container') }}
\n\n- \n
- \n \n \n \n
- \n \n \n \n
{{ translate('cp.creating_asset_container') }}
{{ translate('cp.create_formset') }}
{{ translate('cp.editing_formset') }}: {{ formsetTitle }}
{{ errorMessage }}
{{ translate_choice('cp.fields', 2) }}
{{ translate('cp.formset_fields_instructions') }}| {{ translate('cp.handle') }} | {{ translate('cp.label') }} | {{ translate_choice('cp.columns', 1) }} | |
|---|---|---|---|
| |
\n {{ translate('cp.create_fieldset') }}\n
\n\n\n {{ translate('cp.editing_fieldset') }}:\n {{ fieldsetTitle }}\n
\n \n- \n
- {{ error }} \n
{{ errorMessage }}
\nFields
\nFields
{{ translate('cp.create_fieldset') }}
{{ translate('cp.editing_fieldset') }}: {{ fieldsetTitle }}
- {{ error }}
{{ errorMessage }}
- \n
- \n
- \n {{ fieldset.text }}\n \n
{{ parent }}{{ parent }}- \n
- \n {{ collection.text }}\n \n
- \n
- {{ error }} \n
\n {{ title }}\n
\n\n- \n
- \n \n \n \n
{{ translate_choice('cp.permissions', 2) }}
{{ translate('cp.folders_unwritable') }}
{{ path }}
{{ translate('cp.folders_permission_valid') }}
{{ translate('cp.license_key') }}
{{ translate('cp.license_valid') }}
{{ translate('cp.license_invalid') }}
{{ translate_choice('cp.settings', 2) }}
{{ translate('cp.settings_updated') }}
{{ translate('cp.create_a_user') }}
{{ error }}
{{ translate('cp.user_account_created') }}
{{ translate('cp.login') }}
{{ translate('cp.logged_in_taking_you_to_cp') }}
- \n
- \n
\n \n
| {{ translate_choice('cp.statuses', 1) }} | {{ key }} | {{ translate_choice('cp.actions', 2) }} | |
|---|---|---|---|
| | | |
\n\n
| {{ key.text }} | \n\n \n | \n
|---|
| {{ valueHeader }} | \n{{ textHeader }} | \n\n |
|---|---|---|
| \n \n | \n\n \n | \n\n \n \n | \n
| {{ key.text }} |
|---|
| {{ valueHeader }} | {{ textHeader }} | |
|---|---|---|
{{ translate('cp.drop_to_upload') }}
\n{{ translate('cp.or_drag_and_drop_files') }}
\n\n{{ translate('cp.drop_to_upload') }}
{{ translate('cp.or_drag_and_drop_files') }}
$/, ''));\n };\n\n Scribe.prototype.getTextContent = function () {\n return this.el.textContent;\n };\n\n Scribe.prototype.pushHistory = function () {\n /**\n * Chrome and Firefox: If we did push to the history, this would break\n * browser magic around `Document.queryCommandState` (http://jsbin.com/eDOxacI/1/edit?js,console,output).\n * This happens when doing any DOM manipulation.\n */\n var scribe = this;\n\n if (scribe.options.undo.enabled) {\n // Get scribe previous content, and strip markers.\n var lastContentNoMarkers = scribe._lastItem.content.replace(/]*class=\"scribe-marker\"[^>]*>[^<]*?<\\/em>/g, '');\n\n // We only want to push the history if the content actually changed.\n if (scribe.getHTML() !== lastContentNoMarkers) {\n var selection = new scribe.api.Selection();\n\n selection.placeMarkers();\n var content = scribe.getHTML();\n selection.removeMarkers();\n\n // Checking if there is a need to merge, and that the previous history item\n // is the last history item of the same scribe instance.\n // It is possible the last transaction is not for the same instance, or\n // even not a scribe transaction (e.g. when using a shared undo manager).\n var previousItem = scribe.undoManager.item(scribe.undoManager.position);\n if ((scribe._merge || scribe._forceMerge) && previousItem && scribe._lastItem == previousItem[0]) {\n // If so, merge manually with the last item to save more memory space.\n scribe._lastItem.content = content;\n }\n else {\n // Otherwise, create a new history item, and register it as a new transaction\n scribe._lastItem = {\n previousItem: scribe._lastItem,\n content: content,\n scribe: scribe,\n execute: function () { },\n undo: function () { this.scribe.restoreFromHistory(this.previousItem); },\n redo: function () { this.scribe.restoreFromHistory(this); }\n };\n\n scribe.undoManager.transact(scribe._lastItem, false);\n }\n\n // Merge next transaction if it happens before the interval option, otherwise don't merge.\n clearTimeout(scribe._mergeTimer);\n scribe._merge = true;\n scribe._mergeTimer = setTimeout(function() { scribe._merge = false; }, scribe.options.undo.interval);\n\n return true;\n }\n }\n\n return false;\n };\n\n Scribe.prototype.getCommand = function (commandName) {\n return this.commands[commandName] || this.commandPatches[commandName] || new this.api.Command(commandName);\n };\n\n Scribe.prototype.restoreFromHistory = function (historyItem) {\n this._lastItem = historyItem;\n\n this.setHTML(historyItem.content, true);\n\n // Restore the selection\n var selection = new this.api.Selection();\n selection.selectMarkers();\n\n // Because we skip the formatters, a transaction is not run, so we have to\n // emit this event ourselves.\n this.trigger(eventNames.legacyContentChanged);\n this.trigger(eventNames.contentChanged);\n };\n\n // This will most likely be moved to another object eventually\n Scribe.prototype.allowsBlockElements = function () {\n return this.options.allowBlockElements;\n };\n\n Scribe.prototype.setContent = function (content) {\n if (! this.allowsBlockElements()) {\n // Set bogus BR element for Firefox — see explanation in BR mode files.\n content = content + '
';\n }\n\n this.setHTML(content);\n\n this.trigger(eventNames.legacyContentChanged);\n this.trigger(eventNames.contentChanged);\n };\n\n Scribe.prototype.insertPlainText = function (plainText) {\n this.insertHTML('
' + this._plainTextFormatterFactory.format(plainText) + '
');\n };\n\n Scribe.prototype.insertHTML = function (html) {\n /**\n * When pasting text from Google Docs in both Chrome and Firefox,\n * the resulting text will be wrapped in a B tag. So it would look\n * something likeText
, which is invalid HTML. The command\n * insertHTML will then attempt to fix this content by moving the B tag\n * inside the P. The result is:Text
, which is valid\n * but means an extra P is inserted into the text. To avoid this we run the\n * formatters before the insertHTML command as the formatter will\n * unwrap the P and delete the B tag. It is acceptable to remove invalid\n * HTML as Scribe should only accept valid HTML.\n *\n * See http://jsbin.com/cayosada/3/edit for more\n **/\n\n // TODO: error if the selection is not within the Scribe instance? Or\n // focus the Scribe instance if it is not already focused?\n this.getCommand('insertHTML').execute(this._htmlFormatterFactory.format(html));\n };\n\n Scribe.prototype.isDebugModeEnabled = function () {\n return this.options.debug;\n };\n\n /**\n * Applies HTML formatting to all editor text.\n * @param {String} phase sanitize/normalize/export are the standard phases\n * @param {Function} fn Function that takes the current editor HTML and returns a formatted version.\n */\n Scribe.prototype.registerHTMLFormatter = function (phase, formatter) {\n this._htmlFormatterFactory.formatters[phase]\n = this._htmlFormatterFactory.formatters[phase].push(formatter);\n };\n\n Scribe.prototype.registerPlainTextFormatter = function (formatter) {\n this._plainTextFormatterFactory.formatters\n = this._plainTextFormatterFactory.formatters.push(formatter);\n };\n\n Scribe.prototype.destroy = function (options) {\n this.trigger(eventNames.destroy);\n };\n\n // TODO: abstract\n function FormatterFactory() {\n this.formatters = Immutable.List();\n }\n\n FormatterFactory.prototype.format = function (html) {\n // Map the object to an array: Array[Formatter]\n var formatted = this.formatters.reduce(function (formattedData, formatter) {\n return formatter(formattedData);\n }, html);\n\n return formatted;\n };\n\n function HTMLFormatterFactory() {\n // Define phases\n // For a list of formatters, see https://github.com/guardian/scribe/issues/126\n this.formatters = {\n // Configurable sanitization of the HTML, e.g. converting/filter/removing\n // elements\n sanitize: Immutable.List(),\n // Normalize content to ensure it is ready for interaction\n normalize: Immutable.List(),\n 'export': Immutable.List()\n };\n }\n\n HTMLFormatterFactory.prototype = Object.create(FormatterFactory.prototype);\n HTMLFormatterFactory.prototype.constructor = HTMLFormatterFactory;\n\n HTMLFormatterFactory.prototype.format = function (html) {\n var formatters = this.formatters.sanitize.concat(this.formatters.normalize);\n\n var formatted = formatters.reduce(function (formattedData, formatter) {\n return formatter(formattedData);\n }, html);\n\n return formatted;\n };\n\n HTMLFormatterFactory.prototype.formatForExport = function (html) {\n return this.formatters['export'].reduce(function (formattedData, formatter) {\n return formatter(formattedData);\n }, html);\n };\n\n return Scribe;\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/scribe.js","define([\n './set-root-p-element',\n './formatters/html/enforce-p-elements',\n './formatters/html/ensure-selectable-containers',\n './inline-elements-mode'\n], function (\n setRootPElement,\n enforcePElements,\n ensureSelectableContainers,\n inlineElementsMode\n) {\n 'use strict';\n\n return {\n setRootPElement: setRootPElement,\n enforcePElements: enforcePElements,\n ensureSelectableContainers: ensureSelectableContainers,\n inlineElementsMode: inlineElementsMode\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/plugins.js","define(function () {\n\n /**\n * Sets the default content of the scribe so that each carriage return creates\n * a P.\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n // The content might have already been set, in which case we don't want\n // to apply.\n if (scribe.getHTML().trim() === '') {\n /**\n * We have to begin with the following HTML, because otherwise some\n * browsers(?) will position the caret outside of the P when the scribe is\n * focused.\n */\n scribe.setContent('`s (in Firefox) where previously we\n * had `
`'s. This patches the behaviour of delete/backspace so\n * that we do not end up in a pristine state.\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var nodeHelpers = scribe.node;\n\n /**\n * Wrap consecutive inline elements and text nodes in a P element.\n */\n function wrapChildNodes(parentNode) {\n var index = 0;\n\n Immutable.List(parentNode.childNodes)\n .filterNot(function(node) {\n return nodeHelpers.isWhitespaceOnlyTextNode(Node, node);\n })\n .filter(function(node) {\n return node.nodeType === Node.TEXT_NODE || !nodeHelpers.isBlockElement(node);\n })\n .groupBy(function(node, key, list) {\n return key === 0 || node.previousSibling === list.get(key - 1) ?\n index :\n index += 1;\n })\n .forEach(function(nodeGroup) {\n nodeHelpers.wrap(nodeGroup.toArray(), document.createElement('p'));\n });\n }\n\n // Traverse the tree, wrapping child nodes as we go.\n function traverse(parentNode) {\n var i = 0, node;\n\n while (node = parentNode.children[i++]) {\n if (node.tagName === 'BLOCKQUOTE') {\n wrapChildNodes(node);\n }\n }\n }\n\n scribe.registerHTMLFormatter('normalize', function (html) {\n /**\n * Ensure P mode.\n *\n * Wrap any orphan text nodes in a P element.\n */\n // TODO: This should be configurable and also correct markup such as\n // `
- 1
- 2
` to\n * remain selectable. (Unless they have a width and height explicitly set with\n * CSS(?), as per: http://jsbin.com/gulob/2/edit?html,css,js,output)\n */\n\n 'use strict';\n\n // http://www.w3.org/TR/html-markup/syntax.html#syntax-elements\n var html5VoidElements = Immutable.Set.of('AREA', 'BASE', 'BR', 'COL', 'COMMAND', 'EMBED', 'HR', 'IMG', 'INPUT', 'KEYGEN', 'LINK', 'META', 'PARAM', 'SOURCE', 'TRACK', 'WBR');\n\n function parentHasNoTextContent(node) {\n if (nodeHelpers.isCaretPositionNode(node)) {\n return true;\n } else {\n return node.parentNode.textContent.trim() === '';\n }\n }\n\n\n function traverse(parentNode) {\n // Instead of TreeWalker, which gets confused when the BR is added to the dom,\n // we recursively traverse the tree to look for an empty node that can have childNodes\n\n var node = parentNode.firstElementChild;\n\n function isEmpty(node) {\n\n if ((node.children.length === 0 && nodeHelpers.isBlockElement(node))\n || (node.children.length === 1 && nodeHelpers.isSelectionMarkerNode(node.children[0]))) {\n return true;\n }\n\n // Do not insert BR in empty non block elements with parent containing text\n if (!nodeHelpers.isBlockElement(node) && node.children.length === 0) {\n return parentHasNoTextContent(node);\n }\n\n return false;\n }\n\n while (node) {\n if (!nodeHelpers.isSelectionMarkerNode(node)) {\n // Find any node that contains no child *elements*, or just contains\n // whitespace, is not self-closing and is not a custom element\n if (isEmpty(node) &&\n node.textContent.trim() === '' &&\n !html5VoidElements.includes(node.nodeName) &&\n node.nodeName.indexOf('-') === -1) {\n node.appendChild(document.createElement('br'));\n } else if (node.children.length > 0) {\n traverse(node);\n }\n }\n node = node.nextElementSibling;\n }\n }\n\n return function () {\n return function (scribe) {\n\n scribe.registerHTMLFormatter('normalize', function (html) {\n var bin = document.createElement('div');\n bin.innerHTML = html;\n\n traverse(bin);\n\n return bin.innerHTML;\n });\n\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/formatters/html/ensure-selectable-containers.js","define([\n 'immutable'\n], function (Immutable) {\n // Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Inline_elemente\n var inlineElementNames = Immutable.Set.of('B', 'BIG', 'I', 'SMALL', 'TT',\n 'ABBR', 'ACRONYM', 'CITE', 'CODE', 'DFN', 'EM', 'KBD', 'STRONG', 'SAMP', 'VAR',\n 'A', 'BDO', 'BR', 'IMG', 'MAP', 'OBJECT', 'Q', 'SCRIPT', 'SPAN', 'SUB', 'SUP',\n 'BUTTON', 'INPUT', 'LABEL', 'SELECT', 'TEXTAREA');\n\n return inlineElementNames;\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/constants/inline-element-names.js","define([\n 'immutable'\n], function(Immutable) {\n var blockElementNames = Immutable.Set.of('ADDRESS', 'ARTICLE', 'ASIDE', 'AUDIO', 'BLOCKQUOTE', 'CANVAS', 'DD',\n 'DIV', 'FIELDSET', 'FIGCAPTION', 'FIGURE', 'FOOTER', 'FORM', 'H1',\n 'H2', 'H3', 'H4', 'H5', 'H6', 'HEADER', 'HGROUP', 'HR', 'LI',\n 'NOSCRIPT', 'OL', 'OUTPUT', 'P', 'PRE', 'SECTION', 'TABLE', 'TD',\n 'TH', 'TFOOT', 'UL', 'VIDEO');\n\n return blockElementNames;\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/constants/block-element-names.js","define(['../../node'], function (nodeHelpers) {\n\n 'use strict';\n\n // TODO: abstract\n function hasContent(rootNode) {\n var treeWalker = document.createTreeWalker(rootNode, NodeFilter.SHOW_ALL, null, false);\n\n while (treeWalker.nextNode()) {\n if (treeWalker.currentNode) {\n\n // If the node is a non-empty element or has content\n if(nodeHelpers.hasContent(treeWalker.currentNode) || nodeHelpers.isTextNodeWithContent(Node, treeWalker.currentNode)) {\n return true;\n }\n }\n }\n\n return false;\n }\n\n return function () {\n return function (scribe) {\n /**\n * Firefox has a `insertBrOnReturn` command, but this is not a part of\n * any standard. One day we might have an `insertLineBreak` command,\n * proposed by this spec:\n * https://dvcs.w3.org/hg/editing/raw-file/tip/editing.html#the-insertlinebreak-command\n * As per: http://jsbin.com/IQUraXA/1/edit?html,js,output\n */\n scribe.el.addEventListener('keydown', function (event) {\n if (event.keyCode === 13) { // enter\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n var blockNode = selection.getContaining(function (node) {\n return node.nodeName === 'LI' || (/^(H[1-6])$/).test(node.nodeName);\n });\n\n if (! blockNode) {\n event.preventDefault();\n\n scribe.transactionManager.run(function () {\n \n if (!range.collapsed) {\n range.deleteContents();\n }\n\n\n /**\n * Firefox: Delete the bogus BR as we insert another one later.\n * We have to do this because otherwise the browser will believe\n * there is content to the right of the selection.\n */\n if (scribe.el.lastChild && scribe.el.lastChild.nodeName === 'BR') {\n scribe.el.removeChild(scribe.el.lastChild);\n }\n\n var brNode = document.createElement('br');\n\n range.insertNode(brNode);\n\n // Safari does not update the endoffset after inserting the BR element\n // so we have to do it ourselves.\n // References: \n // https://bugs.webkit.org/show_bug.cgi?id=63538#c3\n // https://dom.spec.whatwg.org/#dom-range-selectnode\n range.setEndAfter(brNode);\n \n // After inserting the BR into the range is no longer collapsed, so\n // we have to collapse it again.\n // TODO: Older versions of Firefox require this argument even though\n // it is supposed to be optional. Proxy/polyfill?\n range.collapse(false);\n\n /**\n * Chrome: If there is no right-hand side content, inserting a BR\n * will not appear to create a line break.\n * Firefox: If there is no right-hand side content, inserting a BR\n * will appear to create a weird \"half-line break\".\n *\n * Possible solution: Insert two BRs.\n * ✓ Chrome: Inserting two BRs appears to create a line break.\n * Typing will then delete the bogus BR element.\n * Firefox: Inserting two BRs will create two line breaks.\n *\n * Solution: Only insert two BRs if there is no right-hand\n * side content.\n *\n * If the user types on a line immediately after a BR element,\n * Chrome will replace the BR element with the typed characters,\n * whereas Firefox will not. Thus, to satisfy Firefox we have to\n * insert a bogus BR element on initialization (see below).\n */\n\n var contentToEndRange = range.cloneRange();\n if (scribe.el.lastChild) {\n contentToEndRange.setEndAfter(scribe.el.lastChild);\n }\n\n // Get the content from the range to the end of the heading\n var contentToEndFragment = contentToEndRange.cloneContents();\n\n // If there is not already a right hand side content we need to\n // insert a bogus BR element.\n if (! hasContent(contentToEndFragment)) {\n var bogusBrNode = document.createElement('br');\n range.insertNode(bogusBrNode);\n }\n\n var newRange = range.cloneRange();\n\n newRange.setStartAfter(brNode);\n newRange.setEndAfter(brNode);\n\n selection.selection.removeAllRanges();\n selection.selection.addRange(newRange);\n });\n }\n }\n }.bind(this));\n\n if (scribe.getHTML().trim() === '') {\n // Bogus BR element for Firefox — see explanation above.\n // TODO: also append when consumer sets the content manually.\n // TODO: hide when the user calls `getHTML`?\n scribe.setContent('');\n }\n };\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/inline-elements-mode.js","define([\n './commands/indent',\n './commands/insert-list',\n './commands/outdent',\n './commands/redo',\n './commands/subscript',\n './commands/superscript',\n './commands/undo'\n], function (\n indent,\n insertList,\n outdent,\n redo,\n subscript,\n superscript,\n undo\n) {\n\n 'use strict';\n\n return {\n indent: indent,\n insertList: insertList,\n outdent: outdent,\n redo: redo,\n subscript: subscript,\n superscript: superscript,\n undo: undo\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands.js","define(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var indentCommand = new scribe.api.Command('indent');\n\n indentCommand.queryEnabled = function () {\n /**\n * FIXME: Chrome nests ULs inside of ULs\n * Currently we just disable the command when the selection is inside of\n * a list.\n * As per: http://jsbin.com/ORikUPa/3/edit?html,js,output\n */\n var selection = new scribe.api.Selection();\n var listElement = selection.getContaining(function (element) {\n return element.nodeName === 'UL' || element.nodeName === 'OL';\n });\n\n return scribe.api.Command.prototype.queryEnabled.call(this) && scribe.allowsBlockElements() && ! listElement;\n };\n\n scribe.commands.indent = indentCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/indent.js","define([\n 'immutable'\n], function (Immutable) {\n\n /**\n * If the paragraphs option is set to true, then when the list is\n * unapplied, ensure that we enter a P element.\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var nodeHelpers = scribe.node;\n\n var InsertListCommand = function (commandName) {\n scribe.api.Command.call(this, commandName);\n };\n\n InsertListCommand.prototype = Object.create(scribe.api.Command.prototype);\n InsertListCommand.prototype.constructor = InsertListCommand;\n\n InsertListCommand.prototype.execute = function (value) {\n function splitList(listItemElements) {\n if (!!listItemElements.size) {\n var newListNode = document.createElement(listNode.nodeName);\n\n while (!!listItemElements.size) {\n newListNode.appendChild(listItemElements.first());\n listItemElements = listItemElements.shift();\n }\n\n listNode.parentNode.insertBefore(newListNode, listNode.nextElementSibling);\n }\n }\n\n if (this.queryState()) {\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n var listNode = selection.getContaining(function (node) {\n return node.nodeName === 'OL' || node.nodeName === 'UL';\n });\n\n var listItemElement = selection.getContaining(function (node) {\n return node.nodeName === 'LI';\n });\n\n scribe.transactionManager.run(function () {\n if (listItemElement) {\n var nextListItemElements = nodeHelpers.nextSiblings(listItemElement);\n\n /**\n * If we are not at the start or end of a UL/OL, we have to\n * split the node and insert the P(s) in the middle.\n */\n splitList(nextListItemElements);\n\n /**\n * Insert a paragraph in place of the list item.\n */\n\n selection.placeMarkers();\n\n var pNode = document.createElement('p');\n pNode.innerHTML = listItemElement.innerHTML;\n\n listNode.parentNode.insertBefore(pNode, listNode.nextElementSibling);\n listItemElement.parentNode.removeChild(listItemElement);\n } else {\n /**\n * When multiple list items are selected, we replace each list\n * item with a paragraph.\n */\n\n // We can't query for list items in the selection so we loop\n // through them all and find the intersection ourselves.\n var selectedListItemElements = Immutable.List(listNode.querySelectorAll('li'))\n .filter(function (listItemElement) {\n return range.intersectsNode(listItemElement);\n });\n var lastSelectedListItemElement = selectedListItemElements.last();\n var listItemElementsAfterSelection = nodeHelpers.nextSiblings(lastSelectedListItemElement);\n\n /**\n * If we are not at the start or end of a UL/OL, we have to\n * split the node and insert the P(s) in the middle.\n */\n splitList(listItemElementsAfterSelection);\n\n // Store the caret/range positioning inside of the list items so\n // we can restore it from the newly created P elements soon\n // afterwards.\n selection.placeMarkers();\n\n var documentFragment = document.createDocumentFragment();\n selectedListItemElements.forEach(function (listItemElement) {\n var pElement = document.createElement('p');\n pElement.innerHTML = listItemElement.innerHTML;\n documentFragment.appendChild(pElement);\n });\n\n // Insert the Ps\n listNode.parentNode.insertBefore(documentFragment, listNode.nextElementSibling);\n\n // Remove the LIs\n selectedListItemElements.forEach(function (listItemElement) {\n listItemElement.parentNode.removeChild(listItemElement);\n });\n }\n\n // If the list is now empty, clean it up.\n if (listNode.childNodes.length === 0) {\n listNode.parentNode.removeChild(listNode);\n }\n\n selection.selectMarkers();\n }.bind(this));\n } else {\n scribe.api.Command.prototype.execute.call(this, value);\n }\n };\n\n InsertListCommand.prototype.queryEnabled = function () {\n return scribe.api.Command.prototype.queryEnabled.call(this) && scribe.allowsBlockElements();\n };\n\n scribe.commands.insertOrderedList = new InsertListCommand('insertOrderedList');\n scribe.commands.insertUnorderedList = new InsertListCommand('insertUnorderedList');\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/insert-list.js","define(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var outdentCommand = new scribe.api.Command('outdent');\n\n outdentCommand.queryEnabled = function () {\n /**\n * FIXME: If the paragraphs option is set to true, then when the\n * list is unapplied, ensure that we enter a P element.\n * Currently we just disable the command when the selection is inside of\n * a list.\n */\n var selection = new scribe.api.Selection();\n var listElement = selection.getContaining(function (element) {\n return element.nodeName === 'UL' || element.nodeName === 'OL';\n });\n\n // FIXME: define block element rule here?\n return scribe.api.Command.prototype.queryEnabled.call(this) && scribe.allowsBlockElements() && ! listElement;\n };\n\n scribe.commands.outdent = outdentCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/outdent.js","define([\n '../../../keystrokes'\n], function (keystrokes) {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var redoCommand = new scribe.api.Command('redo');\n\n redoCommand.execute = function () {\n scribe.undoManager.redo();\n };\n\n redoCommand.queryEnabled = function () {\n return scribe.undoManager.position > 0;\n };\n\n scribe.commands.redo = redoCommand;\n\n //is scribe is configured to undo assign listener\n if (scribe.options.undo.enabled) {\n scribe.el.addEventListener('keydown', function (event) {\n if (keystrokes.isRedoKeyCombination(event)) {\n event.preventDefault();\n redoCommand.execute();\n }\n });\n }\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/redo.js","define(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var subscriptCommand = new scribe.api.Command('subscript');\n\n scribe.commands.subscript = subscriptCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/subscript.js","define(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var superscriptCommand = new scribe.api.Command('superscript');\n\n scribe.commands.superscript = superscriptCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/superscript.js","define([\n '../../../keystrokes'\n], function (keystrokes) {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var undoCommand = new scribe.api.Command('undo');\n\n undoCommand.execute = function () {\n scribe.undoManager.undo();\n };\n\n undoCommand.queryEnabled = function () {\n return scribe.undoManager.position < scribe.undoManager.length;\n };\n\n scribe.commands.undo = undoCommand;\n\n if (scribe.options.undo.enabled) {\n scribe.el.addEventListener('keydown', function (event) {\n if (keystrokes.isUndoKeyCombination(event)) {\n event.preventDefault();\n undoCommand.execute();\n }\n });\n }\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/commands/undo.js","define([\n './formatters/html/replace-nbsp-chars',\n './formatters/plain-text/escape-html-characters'\n], function (\n replaceNbspCharsFormatter,\n escapeHtmlCharactersFormatter\n) {\n 'use strict';\n\n return {\n replaceNbspCharsFormatter: replaceNbspCharsFormatter,\n escapeHtmlCharactersFormatter: escapeHtmlCharactersFormatter\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/formatters.js","define(function () {\n\n /**\n * Chrome:\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var nbspCharRegExp = /(\\s| )+/g;\n\n // TODO: should we be doing this on paste?\n scribe.registerHTMLFormatter('export', function (html) {\n return html.replace(nbspCharRegExp, ' ');\n });\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/formatters/html/replace-nbsp-chars.js","define('lodash-amd/modern/internal/baseToString',[], function() {\n\n /**\n * Converts `value` to a string if it is not one. An empty string is returned\n * for `null` or `undefined` values.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\n function baseToString(value) {\n if (typeof value == 'string') {\n return value;\n }\n return value == null ? '' : (value + '');\n }\n\n return baseToString;\n});\n\ndefine('lodash-amd/modern/internal/escapeHtmlChar',[], function() {\n\n /** Used to map characters to HTML entities. */\n var htmlEscapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n '`': '`'\n };\n\n /**\n * Used by `_.escape` to convert characters to HTML entities.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\n function escapeHtmlChar(chr) {\n return htmlEscapes[chr];\n }\n\n return escapeHtmlChar;\n});\n\ndefine('lodash-amd/modern/string/escape',['../internal/baseToString', '../internal/escapeHtmlChar'], function(baseToString, escapeHtmlChar) {\n\n /** Used to match HTML entities and HTML characters. */\n var reUnescapedHtml = /[&<>\"'`]/g,\n reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n /**\n * Converts the characters \"&\", \"<\", \">\", '\"', \"'\", and \"\\`\", in `string` to\n * their corresponding HTML entities.\n *\n * **Note:** No other characters are escaped. To escape additional characters\n * use a third-party library like [_he_](https://mths.be/he).\n *\n * Though the \">\" character is escaped for symmetry, characters like\n * \">\" and \"/\" don't require escaping in HTML and have no special meaning\n * unless they're part of a tag or unquoted attribute value.\n * See [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n * (under \"semi-related fun fact\") for more details.\n *\n * Backticks are escaped because in Internet Explorer < 9, they can break out\n * of attribute values or HTML comments. See [#102](https://html5sec.org/#102),\n * [#108](https://html5sec.org/#108), and [#133](https://html5sec.org/#133) of\n * the [HTML5 Security Cheatsheet](https://html5sec.org/) for more details.\n *\n * When working with HTML you should always quote attribute values to reduce\n * XSS vectors. See [Ryan Grove's article](http://wonko.com/post/html-escaping)\n * for more details.\n *\n * @static\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escape('fred, barney, & pebbles');\n * // => 'fred, barney, & pebbles'\n */\n function escape(string) {\n // Reset `lastIndex` because in IE < 9 `String#replace` does not.\n string = baseToString(string);\n return (string && reHasUnescapedHtml.test(string))\n ? string.replace(reUnescapedHtml, escapeHtmlChar)\n : string;\n }\n\n return escape;\n});\n\n\ndefine([\n 'lodash-amd/modern/string/escape'\n], function (\n escape\n) {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n scribe.registerPlainTextFormatter(escape);\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/formatters/plain-text/escape-html-characters.js","define([\n '../../dom-observer',\n 'immutable'\n], function (\n observeDomChanges,\n Immutable\n) {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var nodeHelpers = scribe.node;\n\n /**\n * Firefox: Giving focus to a `contenteditable` will place the caret\n * outside of any block elements. Chrome behaves correctly by placing the\n * caret at the earliest point possible inside the first block element.\n * As per: http://jsbin.com/eLoFOku/1/edit?js,console,output\n *\n * We detect when this occurs and fix it by placing the caret ourselves.\n */\n scribe.el.addEventListener('focus', function placeCaretOnFocus() {\n var selection = new scribe.api.Selection();\n // In Chrome, the range is not created on or before this event loop.\n // It doesn’t matter because this is a fix for Firefox.\n if (selection.range) {\n\n var isFirefoxBug = scribe.allowsBlockElements() &&\n selection.range.startContainer === scribe.el;\n\n if (isFirefoxBug) {\n var focusElement = nodeHelpers.firstDeepestChild(scribe.el);\n\n var range = selection.range;\n\n range.setStart(focusElement, 0);\n range.setEnd(focusElement, 0);\n\n selection.selection.removeAllRanges();\n selection.selection.addRange(range);\n }\n }\n }.bind(scribe));\n\n /**\n * Apply the formatters when there is a DOM mutation.\n */\n var applyFormatters = function() {\n if (!scribe._skipFormatters) {\n var selection = new scribe.api.Selection();\n var isEditorActive = selection.range;\n\n var runFormatters = function () {\n if (isEditorActive) {\n selection.placeMarkers();\n }\n scribe.setHTML(scribe._htmlFormatterFactory.format(scribe.getHTML()));\n selection.selectMarkers();\n }.bind(scribe);\n\n // We only want to wrap the formatting in a transaction if the editor is\n // active. If the DOM is mutated when the editor isn't active (e.g.\n // `scribe.setContent`), we do not want to push to the history. (This\n // happens on the first `focus` event).\n\n // The previous check is no longer needed, and the above comments are no longer valid.\n // Now `scribe.setContent` updates the content manually, and `scribe.pushHistory`\n // will not detect any changes, and nothing will be push into the history.\n // Any mutations made without `scribe.getContent` will be pushed into the history normally.\n\n // Pass content through formatters, place caret back\n scribe.transactionManager.run(runFormatters);\n }\n\n delete scribe._skipFormatters;\n }.bind(scribe);\n\n observeDomChanges(scribe.el, applyFormatters);\n\n // TODO: disconnect on tear down:\n // observer.disconnect();\n\n /**\n * If the paragraphs option is set to true, we need to manually handle\n * keyboard navigation inside a heading to ensure a P element is created.\n */\n if (scribe.allowsBlockElements()) {\n scribe.el.addEventListener('keydown', function (event) {\n if (event.keyCode === 13) { // enter\n\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n var headingNode = selection.getContaining(function (node) {\n return (/^(H[1-6])$/).test(node.nodeName);\n });\n\n /**\n * If we are at the end of the heading, insert a P. Otherwise handle\n * natively.\n */\n if (headingNode && range.collapsed) {\n var contentToEndRange = range.cloneRange();\n contentToEndRange.setEndAfter(headingNode);\n\n // Get the content from the range to the end of the heading\n var contentToEndFragment = contentToEndRange.cloneContents();\n\n if (contentToEndFragment.firstChild.textContent === '') {\n event.preventDefault();\n\n scribe.transactionManager.run(function () {\n // Default P\n // TODO: Abstract somewhere\n var pNode = document.createElement('p');\n var brNode = document.createElement('br');\n pNode.appendChild(brNode);\n\n headingNode.parentNode.insertBefore(pNode, headingNode.nextElementSibling);\n\n // Re-apply range\n range.setStart(pNode, 0);\n range.setEnd(pNode, 0);\n\n selection.selection.removeAllRanges();\n selection.selection.addRange(range);\n });\n }\n }\n }\n });\n }\n\n /**\n * If the paragraphs option is set to true, we need to manually handle\n * keyboard navigation inside list item nodes.\n */\n if (scribe.allowsBlockElements()) {\n scribe.el.addEventListener('keydown', function (event) {\n if (event.keyCode === 13 || event.keyCode === 8) { // enter || backspace\n\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n if (range.collapsed) {\n var containerLIElement = selection.getContaining(function (node) {\n return node.nodeName === 'LI';\n });\n if (containerLIElement && containerLIElement.textContent.trim() === '') {\n /**\n * LIs\n */\n\n event.preventDefault();\n\n var listNode = selection.getContaining(function (node) {\n return node.nodeName === 'UL' || node.nodeName === 'OL';\n });\n\n var command = scribe.getCommand(listNode.nodeName === 'OL' ? 'insertOrderedList' : 'insertUnorderedList');\n\n command.event = event;\n\n command.execute();\n }\n }\n }\n });\n }\n\n /**\n * We have to hijack the paste event to ensure it uses\n * `scribe.insertHTML`, which executes the Scribe version of the command\n * and also runs the formatters.\n */\n\n /**\n * TODO: could we implement this as a polyfill for `event.clipboardData` instead?\n * I also don't like how it has the authority to perform `event.preventDefault`.\n */\n\n scribe.el.addEventListener('paste', function handlePaste(event) {\n /**\n * Browsers without the Clipboard API (specifically `ClipboardEvent.clipboardData`)\n * will execute the second branch here.\n *\n * Chrome on android provides `ClipboardEvent.clipboardData` but the types array is not filled\n */\n if (event.clipboardData && event.clipboardData.types.length > 0) {\n event.preventDefault();\n\n if (Immutable.List(event.clipboardData.types).includes('text/html')) {\n scribe.insertHTML(event.clipboardData.getData('text/html'));\n } else {\n scribe.insertPlainText(event.clipboardData.getData('text/plain'));\n }\n } else {\n /**\n * If the browser doesn't have `ClipboardEvent.clipboardData`, we run through a\n * sequence of events:\n *\n * - Save the text selection\n * - Focus another, hidden textarea so we paste there\n * - Copy the pasted content of said textarea\n * - Give focus back to the scribe\n * - Restore the text selection\n *\n * This is required because, without access to the Clipboard API, there is literally\n * no other way to manipulate content on paste.\n * As per: https://github.com/jejacks0n/mercury/issues/23#issuecomment-2308347\n *\n * Firefox <= 21\n * https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent.clipboardData\n */\n\n var selection = new scribe.api.Selection();\n\n // Store the caret position\n selection.placeMarkers();\n\n var bin = document.createElement('div');\n document.body.appendChild(bin);\n bin.setAttribute('contenteditable', true);\n bin.focus();\n\n // Wait for the paste to happen (next loop?)\n setTimeout(function () {\n var data = bin.innerHTML;\n bin.parentNode.removeChild(bin);\n\n // Restore the caret position\n selection.selectMarkers();\n /**\n * Firefox 19 (and maybe others): even though the applied range\n * exists within the Scribe instance, we need to focus it.\n */\n scribe.el.focus();\n\n scribe.insertHTML(data);\n }, 1);\n }\n });\n\n };\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/events.js","define([\n './node',\n './mutations'\n], function (nodeHelpers, mutations) {\n\n var maybeWindow = typeof window === 'object' ? window : undefined;\n\n var MutationObserver = mutations.determineMutationObserver(maybeWindow);\n\n function hasRealMutation(n) {\n return ! nodeHelpers.isEmptyTextNode(n) &&\n ! nodeHelpers.isSelectionMarkerNode(n);\n }\n\n function includeRealMutations(mutations) {\n return mutations.some(function(mutation) {\n return Array.prototype.some.call(mutation.addedNodes, hasRealMutation) ||\n Array.prototype.some.call(mutation.removedNodes, hasRealMutation);\n });\n }\n\n function observeDomChanges(el, callback) {\n // Flag to avoid running recursively\n var runningPostMutation = false;\n\n var observer = new MutationObserver(function(mutations) {\n if (! runningPostMutation && includeRealMutations(mutations)) {\n runningPostMutation = true;\n\n try {\n callback();\n } catch(e) {\n // The catch block is required but we don't want to swallow the error\n throw e;\n } finally {\n // We must yield to let any mutation we caused be triggered\n // in the next cycle\n setTimeout(function() {\n runningPostMutation = false;\n }, 0);\n }\n }\n });\n\n observer.observe(el, {\n childList: true,\n subtree: true\n });\n\n return observer;\n }\n\n return observeDomChanges;\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/dom-observer.js","define([], function() {\n\n function determineMutationObserver(window) {\n // This enables server side rendering\n if (typeof window === 'undefined') {\n // Stub observe function to avoid error\n return function() {\n return {\n observe: function() {}\n };\n }\n } else {\n return window.MutationObserver ||\n window.WebKitMutationObserver ||\n window.MozMutationObserver;\n }\n }\n\n return {\n determineMutationObserver: determineMutationObserver\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/mutations.js","define([\n './patches/commands/bold',\n './patches/commands/indent',\n './patches/commands/insert-html',\n './patches/commands/insert-list',\n './patches/commands/outdent',\n './patches/commands/create-link',\n './patches/events'\n], function (\n boldCommand,\n indentCommand,\n insertHTMLCommand,\n insertListCommands,\n outdentCommand,\n createLinkCommand,\n events\n) {\n\n /**\n * Command patches browser inconsistencies. They do not perform core features\n * of the editor, such as ensuring P elements are created when\n * applying/unapplying commands — that is the job of the core commands.\n */\n\n 'use strict';\n\n return {\n commands: {\n bold: boldCommand,\n indent: indentCommand,\n insertHTML: insertHTMLCommand,\n insertList: insertListCommands,\n outdent: outdentCommand,\n createLink: createLinkCommand,\n },\n events: events\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches.js","define(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var boldCommand = new scribe.api.CommandPatch('bold');\n\n /**\n * Chrome: Executing the bold command inside a heading corrupts the markup.\n * Disabling for now.\n */\n boldCommand.queryEnabled = function () {\n var selection = new scribe.api.Selection();\n var headingNode = selection.getContaining(function (node) {\n return (/^(H[1-6])$/).test(node.nodeName);\n });\n\n return scribe.api.CommandPatch.prototype.queryEnabled.apply(this, arguments) && ! headingNode;\n };\n\n // TODO: We can't use STRONGs because this would mean we have to\n // re-implement the `queryState` command, which would be difficult.\n\n scribe.commandPatches.bold = boldCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/commands/bold.js","define(function () {\n\n /**\n * Prevent Chrome from inserting BLOCKQUOTEs inside of Ps, and also from\n * adding a redundant `style` attribute to the created BLOCKQUOTE.\n */\n\n 'use strict';\n\n var INVISIBLE_CHAR = '\\uFEFF';\n\n return function () {\n return function (scribe) {\n var indentCommand = new scribe.api.CommandPatch('indent');\n\n indentCommand.execute = function (value) {\n scribe.transactionManager.run(function () {\n /**\n * Chrome: If we apply the indent command on an empty P, the\n * BLOCKQUOTE will be nested inside the P.\n * As per: http://jsbin.com/oDOriyU/3/edit?html,js,output\n */\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n var isCaretOnNewLine =\n (range.commonAncestorContainer.nodeName === 'P'\n && range.commonAncestorContainer.innerHTML === '
');\n if (isCaretOnNewLine) {\n // FIXME: this text node is left behind. Tidy it up somehow,\n // or don't use it at all.\n var textNode = document.createTextNode(INVISIBLE_CHAR);\n\n range.insertNode(textNode);\n\n range.setStart(textNode, 0);\n range.setEnd(textNode, 0);\n\n selection.selection.removeAllRanges();\n selection.selection.addRange(range);\n }\n\n scribe.api.CommandPatch.prototype.execute.call(this, value);\n\n /**\n * Chrome: The BLOCKQUOTE created contains a redundant style attribute.\n * As per: http://jsbin.com/AkasOzu/1/edit?html,js,output\n */\n\n // Renew the selection\n selection = new scribe.api.Selection();\n var blockquoteNode = selection.getContaining(function (node) {\n return node.nodeName === 'BLOCKQUOTE';\n });\n\n if (blockquoteNode) {\n blockquoteNode.removeAttribute('style');\n }\n }.bind(this));\n };\n\n scribe.commandPatches.indent = indentCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/commands/indent.js","define([], function () {\n \"use strict\";\n return function () {\n return function (scribe) {\n var insertHTMLCommandPatch = new scribe.api.CommandPatch('insertHTML');\n var nodeHelpers = scribe.node;\n\n insertHTMLCommandPatch.execute = function (value) {\n scribe.transactionManager.run(function () {\n scribe.api.CommandPatch.prototype.execute.call(this, value);\n nodeHelpers.removeChromeArtifacts(scribe.el);\n }.bind(this));\n };\n\n scribe.commandPatches.insertHTML = insertHTMLCommandPatch;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/commands/insert-html.js","define([], function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var nodeHelpers = scribe.node;\n\n var InsertListCommandPatch = function (commandName) {\n scribe.api.CommandPatch.call(this, commandName);\n };\n\n InsertListCommandPatch.prototype = Object.create(scribe.api.CommandPatch.prototype);\n InsertListCommandPatch.prototype.constructor = InsertListCommandPatch;\n\n InsertListCommandPatch.prototype.execute = function (value) {\n scribe.transactionManager.run(function () {\n scribe.api.CommandPatch.prototype.execute.call(this, value);\n\n if (this.queryState()) {\n var selection = new scribe.api.Selection();\n\n var listElement = selection.getContaining(function (node) {\n return node.nodeName === 'OL' || node.nodeName === 'UL';\n });\n\n if (listElement) {\n\n /**\n * Firefox: If we apply the insertOrderedList or the insertUnorderedList\n * command on an empty block, a P will be inserted after the OL/UL.\n * As per: http://jsbin.com/cubacoli/3/edit?html,js,output\n */\n\n if (listElement.nextElementSibling &&\n listElement.nextElementSibling.childNodes.length === 0) {\n nodeHelpers.removeNode(listElement.nextElementSibling);\n }\n\n /**\n * Chrome: If we apply the insertOrderedList or the insertUnorderedList\n * command on an empty block, the OL/UL will be nested inside the block.\n * As per: http://jsbin.com/eFiRedUc/1/edit?html,js,output\n */\n\n var listParentNode = listElement.parentNode;\n // If list is within a text block then split that block\n if (listParentNode && /^(H[1-6]|P)$/.test(listParentNode.nodeName)) {\n selection.placeMarkers();\n // Move listElement out of the block\n nodeHelpers.insertAfter(listElement, listParentNode);\n selection.selectMarkers();\n\n /**\n * Chrome 27-34: An empty text node is inserted.\n */\n if (listParentNode.childNodes.length === 2 &&\n nodeHelpers.isEmptyTextNode(listParentNode.firstChild)) {\n nodeHelpers.removeNode(listParentNode);\n }\n\n // Remove the block if it's empty\n if (listParentNode.childNodes.length === 0) {\n nodeHelpers.removeNode(listParentNode);\n }\n }\n\n nodeHelpers.removeChromeArtifacts(listElement);\n }\n }\n }.bind(this));\n };\n\n InsertListCommandPatch.prototype.queryState = function() {\n try {\n return scribe.api.CommandPatch.prototype.queryState.apply(this, arguments);\n } catch (err) {\n // Explicitly catch unexpected error when calling queryState - bug in Firefox: https://github.com/guardian/scribe/issues/208\n if (err.name == 'NS_ERROR_UNEXPECTED') {\n return false;\n } else {\n throw err;\n }\n }\n };\n\n scribe.commandPatches.insertOrderedList = new InsertListCommandPatch('insertOrderedList');\n scribe.commandPatches.insertUnorderedList = new InsertListCommandPatch('insertUnorderedList');\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/commands/insert-list.js","define(function () {\n\n /**\n * Prevent Chrome from removing formatting of BLOCKQUOTE contents.\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var nodeHelpers = scribe.node;\n var outdentCommand = new scribe.api.CommandPatch('outdent');\n\n outdentCommand.execute = function () {\n scribe.transactionManager.run(function () {\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n var blockquoteNode = selection.getContaining(function (node) {\n return node.nodeName === 'BLOCKQUOTE';\n });\n\n if (range.commonAncestorContainer.nodeName === 'BLOCKQUOTE') {\n /**\n * Chrome: Applying the outdent command when a whole BLOCKQUOTE is\n * selected removes the formatting of its contents.\n * As per: http://jsbin.com/okAYaHa/1/edit?html,js,output\n */\n\n // Insert a copy of the selection before the BLOCKQUOTE, and then\n // restore the selection on the copy.\n selection.placeMarkers();\n // We want to copy the selected nodes *with* the markers\n selection.selectMarkers(true);\n var selectedNodes = range.cloneContents();\n blockquoteNode.parentNode.insertBefore(selectedNodes, blockquoteNode);\n range.deleteContents();\n selection.selectMarkers();\n\n // Delete the BLOCKQUOTE if it's empty\n if (blockquoteNode.textContent === '') {\n blockquoteNode.parentNode.removeChild(blockquoteNode);\n }\n } else {\n /**\n * Chrome: If we apply the outdent command on a P, the contents of the\n * P will be outdented instead of the whole P element.\n * As per: http://jsbin.com/IfaRaFO/1/edit?html,js,output\n */\n\n var pNode = selection.getContaining(function (node) {\n return node.nodeName === 'P';\n });\n\n if (pNode) {\n /**\n * If we are not at the start of end of a BLOCKQUOTE, we have to\n * split the node and insert the P in the middle.\n */\n\n var nextSiblingNodes = nodeHelpers.nextSiblings(pNode);\n\n if (!!nextSiblingNodes.size) {\n var newContainerNode = document.createElement(blockquoteNode.nodeName);\n\n while (!!nextSiblingNodes.size) {\n newContainerNode.appendChild(nextSiblingNodes.first());\n nextSiblingNodes = nextSiblingNodes.shift();\n }\n\n blockquoteNode.parentNode.insertBefore(newContainerNode, blockquoteNode.nextElementSibling);\n }\n\n selection.placeMarkers();\n blockquoteNode.parentNode.insertBefore(pNode, blockquoteNode.nextElementSibling);\n selection.selectMarkers();\n\n // If the BLOCKQUOTE is now empty, clean it up.\n if (blockquoteNode.innerHTML === '') {\n blockquoteNode.parentNode.removeChild(blockquoteNode);\n }\n } else {\n scribe.api.CommandPatch.prototype.execute.call(this);\n }\n }\n }.bind(this));\n };\n\n scribe.commandPatches.outdent = outdentCommand;\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/commands/outdent.js","define(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var createLinkCommand = new scribe.api.CommandPatch('createLink');\n scribe.commandPatches.createLink = createLinkCommand;\n\n createLinkCommand.execute = function (value) {\n var selection = new scribe.api.Selection();\n\n /**\n * make sure we're not touching any none Scribe elements\n * in the page\n */\n if (!selection.isInScribe()) {\n return;\n }\n\n /**\n * Firefox does not create a link when selection is collapsed\n * so we create it manually. http://jsbin.com/tutufi/2/edit?js,output\n */\n // using range.collapsed vs selection.isCollapsed - https://code.google.com/p/chromium/issues/detail?id=447523\n if (selection.range.collapsed) {\n var aElement = document.createElement('a');\n aElement.setAttribute('href', value);\n aElement.textContent = value;\n\n selection.range.insertNode(aElement);\n\n // Select the created link\n var newRange = document.createRange();\n newRange.setStartBefore(aElement);\n newRange.setEndAfter(aElement);\n\n selection.selection.removeAllRanges();\n selection.selection.addRange(newRange);\n } else {\n scribe.api.CommandPatch.prototype.execute.call(this, value);\n }\n };\n };\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/commands/create-link.js","define([], function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n // TODO: do we need to run this on every key press, or could we\n // detect when the issue may have occurred?\n // TODO: run in a transaction so as to record the change? how do\n // we know in advance whether there will be a change though?\n // TODO: share somehow with `InsertList` command\n\n var nodeHelpers = scribe.node;\n\n if (scribe.allowsBlockElements()) {\n scribe.el.addEventListener('keyup', function (event) {\n if (event.keyCode === 8 || event.keyCode === 46) { // backspace or delete\n\n var selection = new scribe.api.Selection();\n\n // Note: the range is always collapsed on keyup here\n var containerPElement = selection.getContaining(function (node) {\n return node.nodeName === 'P';\n });\n if (containerPElement) {\n /**\n * The 'input' event listener has already triggered\n * and recorded the faulty content as an item in the\n * UndoManager. We interfere with the undoManager\n * by force merging that transaction with the next\n * transaction which produce a clean one instead.\n *\n * FIXME: ideally we would not trigger a\n * 'content-changed' event with faulty HTML at all, but\n * it's too late to cancel it at this stage (and it's\n * not happened yet at keydown time).\n */\n\n scribe.transactionManager.run(function () {\n // Store the caret position\n selection.placeMarkers();\n nodeHelpers.removeChromeArtifacts(containerPElement);\n selection.selectMarkers();\n }, true);\n }\n }\n });\n }\n };\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/plugins/core/patches/events.js","define([\n './api/command-patch',\n './api/command',\n './api/selection',\n './api/simple-command'\n], function (\n buildCommandPatch,\n buildCommand,\n buildSelection,\n buildSimpleCommand\n) {\n\n 'use strict';\n\n return function Api(scribe) {\n this.CommandPatch = buildCommandPatch(scribe);\n this.Command = buildCommand(scribe);\n this.Selection = buildSelection(scribe);\n this.SimpleCommand = buildSimpleCommand(this, scribe);\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/api.js","define(function () {\n\n 'use strict';\n\n return function (scribe) {\n function CommandPatch(commandName) {\n this.commandName = commandName;\n }\n\n CommandPatch.prototype.execute = function (value) {\n scribe.transactionManager.run(function () {\n document.execCommand(this.commandName, false, value || null);\n }.bind(this));\n };\n\n CommandPatch.prototype.queryState = function () {\n return document.queryCommandState(this.commandName);\n };\n\n CommandPatch.prototype.queryEnabled = function () {\n return document.queryCommandEnabled(this.commandName);\n };\n\n return CommandPatch;\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/api/command-patch.js","define(function () {\n\n 'use strict';\n\n return function (scribe) {\n function Command(commandName) {\n this.commandName = commandName;\n this.patch = scribe.commandPatches[this.commandName];\n }\n\n Command.prototype.execute = function (value) {\n if (this.patch) {\n this.patch.execute(value);\n } else {\n scribe.transactionManager.run(function () {\n document.execCommand(this.commandName, false, value || null);\n }.bind(this));\n }\n };\n\n Command.prototype.queryState = function () {\n if (this.patch) {\n return this.patch.queryState();\n } else {\n return document.queryCommandState(this.commandName);\n }\n };\n\n Command.prototype.queryEnabled = function () {\n if (this.patch) {\n return this.patch.queryEnabled();\n } else {\n return document.queryCommandEnabled(this.commandName);\n }\n };\n\n return Command;\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/api/command.js","define(function () {\n\n 'use strict';\n\n return function (scribe) {\n var rootDoc = scribe.el.ownerDocument;\n var nodeHelpers = scribe.node;\n\n // find the parent document or document fragment\n if( rootDoc.compareDocumentPosition(scribe.el) & Node.DOCUMENT_POSITION_DISCONNECTED ) {\n var currentElement = scribe.el.parentNode;\n while(currentElement && nodeHelpers.isFragment(currentElement)) {\n currentElement = currentElement.parentNode;\n }\n\n // if we found a document fragment and it has a getSelection method, set it to the root doc\n if (currentElement && currentElement.getSelection) {\n rootDoc = currentElement;\n }\n }\n\n function createMarker() {\n var node = document.createElement('em');\n node.style.display = 'none';\n node.classList.add('scribe-marker');\n return node;\n }\n\n function insertMarker(range, marker) {\n range.insertNode(marker);\n\n /**\n * Chrome and Firefox: `Range.insertNode` inserts a bogus text node after\n * the inserted element. We just remove it. This in turn creates several\n * bugs when perfoming commands on selections that contain an empty text\n * node (`removeFormat`, `unlink`).\n * As per: http://jsbin.com/hajim/5/edit?js,console,output\n */\n if (marker.nextSibling && nodeHelpers.isEmptyTextNode(marker.nextSibling)) {\n nodeHelpers.removeNode(marker.nextSibling);\n }\n\n /**\n * Chrome and Firefox: `Range.insertNode` inserts a bogus text node before\n * the inserted element when the child element is at the start of a block\n * element. We just remove it.\n * FIXME: Document why we need to remove this\n * As per: http://jsbin.com/sifez/1/edit?js,console,output\n */\n if (marker.previousSibling && nodeHelpers.isEmptyTextNode(marker.previousSibling)) {\n nodeHelpers.removeNode(marker.previousSibling);\n }\n }\n\n /**\n * Wrapper for object holding currently selected text.\n */\n function Selection() {\n this.selection = rootDoc.getSelection();\n if (this.selection.rangeCount && this.selection.anchorNode) {\n var startNode = this.selection.anchorNode;\n var startOffset = this.selection.anchorOffset;\n var endNode = this.selection.focusNode;\n var endOffset = this.selection.focusOffset;\n\n // if the range starts and ends on the same node, then we must swap the\n // offsets if ever focusOffset is smaller than anchorOffset\n if (startNode === endNode && endOffset < startOffset) {\n var tmp = startOffset;\n startOffset = endOffset;\n endOffset = tmp;\n }\n // if the range ends *before* it starts, then we must reverse the range\n else if (nodeHelpers.isBefore(endNode, startNode) && !endNode.contains(startNode)) {\n var tmpNode = startNode,\n tmpOffset = startOffset;\n startNode = endNode;\n startOffset = endOffset;\n endNode = tmpNode;\n endOffset = tmpOffset;\n }\n\n // create the range to avoid chrome bug from getRangeAt / window.getSelection()\n // https://code.google.com/p/chromium/issues/detail?id=380690\n this.range = document.createRange();\n this.range.setStart(startNode, startOffset);\n this.range.setEnd(endNode, endOffset);\n }\n }\n\n /**\n * @returns Closest ancestor Node satisfying nodeFilter. Undefined if none exist before reaching Scribe container.\n */\n Selection.prototype.getContaining = function (nodeFilter) {\n var range = this.range;\n if (!range) { return; }\n\n var node = this.range.commonAncestorContainer;\n return ! (node && scribe.el === node) && nodeFilter(node) ?\n node :\n nodeHelpers.getAncestor(node, scribe.el, nodeFilter);\n };\n\n Selection.prototype.isInScribe = function () {\n var range = this.range;\n return range\n //we need to ensure that the scribe's element lives within the current document to avoid errors with the range comparison (see below)\n //one way to do this is to check if it's visible (is this the best way?).\n && document.contains(scribe.el)\n //we want to ensure that the current selection is within the current scribe node\n //if this isn't true scribe will place markers within the selections parent\n //we want to ensure that scribe ONLY places markers within it's own element\n && scribe.el.contains(range.startContainer)\n && scribe.el.contains(range.endContainer);\n }\n\n Selection.prototype.placeMarkers = function () {\n var range = this.range;\n\n if (!this.isInScribe()) {\n return;\n }\n\n // insert start marker\n insertMarker(range.cloneRange(), createMarker());\n\n if (! range.collapsed ) {\n // End marker\n var rangeEnd = range.cloneRange();\n rangeEnd.collapse(false);\n insertMarker(rangeEnd, createMarker());\n }\n\n this.selection.removeAllRanges();\n this.selection.addRange(range);\n };\n\n Selection.prototype.getMarkers = function () {\n return scribe.el.querySelectorAll('em.scribe-marker');\n };\n\n Selection.prototype.removeMarkers = function () {\n Array.prototype.forEach.call(this.getMarkers(), function (marker) {\n var markerParent = marker.parentNode;\n nodeHelpers.removeNode(marker);\n // Placing the markers may have split a text node. Sew it up, otherwise\n // if the user presses space between the nodes the browser will insert\n // an ` ` and that will cause word wrapping issues.\n markerParent.normalize();\n });\n };\n\n // This will select markers if there are any. You will need to focus the\n // Scribe instance’s element if it is not already for the selection to\n // become active.\n Selection.prototype.selectMarkers = function (keepMarkers) {\n var markers = this.getMarkers();\n if (!markers.length) {\n return;\n }\n\n var newRange = document.createRange();\n\n newRange.setStartBefore(markers[0]);\n // We always reset the end marker because otherwise it will just\n // use the current range’s end marker.\n newRange.setEndAfter(markers.length >= 2 ? markers[1] : markers[0]);\n\n if (! keepMarkers) {\n this.removeMarkers();\n }\n\n this.selection.removeAllRanges();\n this.selection.addRange(newRange);\n };\n\n Selection.prototype.isCaretOnNewLine = function () {\n var containerPElement = this.getContaining(function (node) {\n return node.nodeName === 'P';\n });\n return !! containerPElement && nodeHelpers.isEmptyInlineElement(containerPElement);\n };\n\n return Selection;\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/api/selection.js","define(function () {\n\n 'use strict';\n\n return function (api, scribe) {\n function SimpleCommand(commandName, nodeName) {\n scribe.api.Command.call(this, commandName);\n\n this._nodeName = nodeName;\n }\n\n SimpleCommand.prototype = Object.create(api.Command.prototype);\n SimpleCommand.prototype.constructor = SimpleCommand;\n\n SimpleCommand.prototype.queryState = function () {\n var selection = new scribe.api.Selection();\n return scribe.api.Command.prototype.queryState.call(this) && !! selection.getContaining(function (node) {\n return node.nodeName === this._nodeName;\n }.bind(this));\n };\n\n return SimpleCommand;\n };\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/api/simple-command.js","define([\n './events'\n ], function (events) {\n\n 'use strict';\n\n return function (scribe) {\n function TransactionManager() {\n this.history = [];\n }\n\n Object.assign(TransactionManager.prototype, {\n start: function () {\n this.history.push(1);\n },\n\n end: function () {\n this.history.pop();\n\n if (this.history.length === 0) {\n scribe.pushHistory();\n scribe.trigger(events.legacyContentChanged);\n scribe.trigger(events.contentChanged);\n }\n },\n\n run: function (transaction, forceMerge) {\n this.start();\n // If there is an error, don't prevent the transaction from ending.\n try {\n if (transaction) {\n transaction();\n }\n } finally {\n scribe._forceMerge = forceMerge === true;\n this.end();\n scribe._forceMerge = false;\n }\n }\n });\n\n return TransactionManager;\n };\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/transaction-manager.js","define([\n 'immutable'\n], function (Immutable) {\n 'use strict';\n\n function UndoManager(limit, undoScopeHost) {\n this._stack = Immutable.List();\n this._limit = limit;\n this._fireEvent = typeof CustomEvent != 'undefined' && undoScopeHost && undoScopeHost.dispatchEvent;\n this._ush = undoScopeHost;\n\n this.position = 0;\n this.length = 0;\n }\n\n UndoManager.prototype.transact = function (transaction, merge) {\n if (arguments.length < 2) {\n throw new TypeError('Not enough arguments to UndoManager.transact.');\n }\n\n transaction.execute();\n\n if (this.position > 0) {\n this.clearRedo();\n }\n\n var transactions;\n if (merge && this.length) {\n transactions = this._stack.first().push(transaction);\n this._stack = this._stack.shift().unshift(transactions);\n }\n else {\n transactions = Immutable.List.of(transaction);\n this._stack = this._stack.unshift(transactions);\n this.length++;\n\n if (this._limit && this.length > this._limit) {\n this.clearUndo(this._limit);\n }\n }\n\n this._dispatch('DOMTransaction', transactions);\n };\n\n UndoManager.prototype.undo = function () {\n if (this.position >= this.length) { return; }\n\n var transactions = this._stack.get(this.position);\n var i = transactions.size;\n while (i--) {\n transactions.get(i).undo();\n }\n this.position++;\n\n this._dispatch('undo', transactions);\n };\n\n UndoManager.prototype.redo = function () {\n if (this.position === 0) { return; }\n\n this.position--;\n var transactions = this._stack.get(this.position);\n for (var i = 0; i < transactions.size; i++) {\n transactions.get(i).redo();\n }\n\n this._dispatch('redo', transactions);\n };\n\n UndoManager.prototype.item = function (index) {\n return index >= 0 && index < this.length ?\n this._stack.get(index).toArray() :\n null;\n };\n\n UndoManager.prototype.clearUndo = function (position) {\n this._stack = this._stack.take(position !== undefined ? position : this.position);\n this.length = this._stack.size;\n };\n\n UndoManager.prototype.clearRedo = function () {\n this._stack = this._stack.skip(this.position);\n this.length = this._stack.size;\n this.position = 0;\n };\n\n UndoManager.prototype._dispatch = function(event, transactions) {\n if (this._fireEvent) {\n this._ush.dispatchEvent(new CustomEvent(event, {\n detail: {transactions: transactions.toArray()},\n bubbles: true,\n cancelable: false\n }));\n }\n }\n\n return UndoManager;\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/undo-manager.js","define(['immutable'], function (Immutable) {\n\n 'use strict';\n\n // TODO: once\n // TODO: unit test\n // Good example of a complete(?) implementation: https://github.com/Wolfy87/EventEmitter\n function EventEmitter() {\n this._listeners = {};\n }\n\n EventEmitter.prototype.on = function (eventName, fn) {\n var listeners = this._listeners[eventName] || Immutable.Set();\n\n this._listeners[eventName] = listeners.add(fn);\n };\n\n EventEmitter.prototype.off = function (eventName, fn) {\n var listeners = this._listeners[eventName] || Immutable.Set();\n if (fn) {\n this._listeners[eventName] = listeners.delete(fn);\n } else {\n this._listeners[eventName] = listeners.clear();\n }\n };\n\n EventEmitter.prototype.trigger = function (eventName, args) {\n\n //fire events like my:custom:event -> my:custom -> my\n var events = eventName.split(':');\n while(!!events.length){\n var currentEvent = events.join(':');\n var listeners = this._listeners[currentEvent] || Immutable.Set();\n //trigger handles\n listeners.forEach(function (listener) {\n listener.apply(null, args);\n });\n events.splice((events.length - 1), 1);\n }\n };\n\n return EventEmitter;\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/vendor/scribe-editor/event-emitter.js","define(['immutable'], function (immutable) {\n\n var blockModePlugins = [\n 'setRootPElement',\n 'enforcePElements',\n 'ensureSelectableContainers',\n ],\n inlineModePlugins = [\n 'inlineElementsMode'\n ],\n defaultOptions = {\n allowBlockElements: true,\n debug: false,\n undo: {\n manager: false,\n enabled: true,\n limit: 100,\n interval: 250\n },\n defaultCommandPatches: [\n 'bold',\n 'indent',\n 'insertHTML',\n 'insertList',\n 'outdent',\n 'createLink'\n ],\n\n defaultPlugins: blockModePlugins.concat(inlineModePlugins),\n\n defaultFormatters: [\n 'escapeHtmlCharactersFormatter',\n 'replaceNbspCharsFormatter'\n ]\n };\n\n\n function defaults(options, defaultOptions) {\n var optionsCopy = immutable.fromJS(options);\n var defaultsCopy = immutable.fromJS(defaultOptions);\n var mergedOptions = defaultsCopy.merge(optionsCopy);\n return mergedOptions.toJS();\n }\n\n /**\n * Overrides defaults with user's options\n *\n * @param {Object} userSuppliedOptions The user's options\n * @return {Object} The overridden options\n */\n function checkOptions(userSuppliedOptions) {\n var options = userSuppliedOptions || {};\n\n // Remove invalid plugins\n if (options.defaultPlugins) {\n options.defaultPlugins = options.defaultPlugins.filter(filterByPluginExists(defaultOptions.defaultPlugins));\n }\n\n if (options.defaultFormatters) {\n options.defaultFormatters = options.defaultFormatters.filter(filterByPluginExists(defaultOptions.defaultFormatters));\n }\n\n return Object.freeze(defaults(options, defaultOptions));\n }\n\n /**\n * Sorts a plugin list by a specified plugin name\n *\n * @param {String} priorityPlugin The plugin name to be given priority\n * @return {Function} Sorting function for the given plugin name\n */\n function sortByPlugin(priorityPlugin) {\n return function (pluginCurrent, pluginNext) {\n if (pluginCurrent === priorityPlugin) {\n // pluginCurrent comes before plugin next\n return -1;\n } else if (pluginNext === priorityPlugin) {\n // pluginNext comes before pluginCurrent\n return 1;\n }\n\n // Do no swap\n return 0;\n }\n }\n\n /**\n * Filters a list of plugins by block level / inline level mode.\n *\n * @param {Boolean} isBlockLevelMode Whether block level mode is enabled\n * @return {Function} Filtering function based upon the given mode\n */\n function filterByBlockLevelMode(isBlockLevelMode) {\n return function (plugin) {\n return (isBlockLevelMode ? blockModePlugins : inlineModePlugins).indexOf(plugin) !== -1;\n }\n }\n\n /**\n * Filters a list of plugins by their validity\n *\n * @param {Array
');\n } else {\n scribe.api.Command.prototype.execute.call(this, tag);\n }\n };\n\n headingCommand.queryState = function () {\n var selection = new scribe.api.Selection();\n return !! selection.getContaining(function (node) {\n return node.nodeName === nodeName;\n });\n };\n\n /**\n * All: Executing a heading command inside a list element corrupts the markup.\n * Disabling for now.\n */\n headingCommand.queryEnabled = function () {\n var selection = new scribe.api.Selection();\n var listNode = selection.getContaining(function (node) {\n return node.nodeName === 'OL' || node.nodeName === 'UL';\n });\n\n return scribe.api.Command.prototype.queryEnabled.apply(this, arguments)\n && scribe.allowsBlockElements() && ! listNode;\n };\n\n scribe.commands[commandName] = headingCommand;\n };\n };\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/scribe-plugin-heading-command/src/scribe-plugin-heading-command.js\n// module id = 625\n// module chunks = 0","define(function () {\n\n /**\n * Adds a command for using BLOCKQUOTEs.\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var blockquoteCommand = new scribe.api.SimpleCommand('blockquote', 'BLOCKQUOTE');\n\n blockquoteCommand.execute = function () {\n var command = scribe.getCommand(this.queryState() ? 'outdent' : 'indent');\n command.execute();\n };\n\n blockquoteCommand.queryEnabled = function () {\n var command = scribe.getCommand(this.queryState() ? 'outdent' : 'indent');\n return command.queryEnabled();\n };\n\n blockquoteCommand.queryState = function () {\n var selection = new scribe.api.Selection();\n var blockquoteElement = selection.getContaining(function (element) {\n return element.nodeName === 'BLOCKQUOTE';\n });\n\n return scribe.allowsBlockElements() && !! blockquoteElement;\n };\n\n scribe.commands.blockquote = blockquoteCommand;\n\n /**\n * If the paragraphs option is set to true, we unapply the blockquote on\n * ...); if\n // they are, we want to unwrap the inner block element.\n var isNotTopContainer = !! parentNode.parentNode;\n var isNestedBlockElement =\n isBlockElement(parentNode) &&\n isBlockElement(node) &&\n isNotTopContainer;\n\n var nodeName = node.nodeName.toLowerCase();\n\n var allowedAttrs = getAllowedAttrs(this.config, nodeName, node);\n\n var isInvalid = isInline && containsBlockElement;\n\n // Drop tag entirely according to the whitelist *and* if the markup\n // is invalid.\n if (isInvalid || shouldRejectNode(node, allowedAttrs)\n || (!this.config.keepNestedBlockElements && isNestedBlockElement)) {\n // Do not keep the inner text of SCRIPT/STYLE elements.\n if (! (node.nodeName === 'SCRIPT' || node.nodeName === 'STYLE')) {\n while (node.childNodes.length > 0) {\n parentNode.insertBefore(node.childNodes[0], node);\n }\n }\n parentNode.removeChild(node);\n\n this._sanitize(document, parentNode);\n break;\n }\n\n // Sanitize attributes\n for (var a = 0; a < node.attributes.length; a += 1) {\n var attr = node.attributes[a];\n\n if (shouldRejectAttr(attr, allowedAttrs, node)) {\n node.removeAttribute(attr.name);\n // Shift the array to continue looping.\n a = a - 1;\n }\n }\n\n // Sanitize children\n this._sanitize(document, node);\n\n } while ((node = treeWalker.nextSibling()));\n };\n\n function createTreeWalker(document, node) {\n return document.createTreeWalker(node,\n NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT,\n null, false);\n }\n\n function getAllowedAttrs(config, nodeName, node){\n if (typeof config.tags[nodeName] === 'function') {\n return config.tags[nodeName](node);\n } else {\n return config.tags[nodeName];\n }\n }\n\n function shouldRejectNode(node, allowedAttrs){\n if (typeof allowedAttrs === 'undefined') {\n return true;\n } else if (typeof allowedAttrs === 'boolean') {\n return !allowedAttrs;\n }\n\n return false;\n }\n\n function shouldRejectAttr(attr, allowedAttrs, node){\n var attrName = attr.name.toLowerCase();\n\n if (allowedAttrs === true){\n return false;\n } else if (typeof allowedAttrs[attrName] === 'function'){\n return !allowedAttrs[attrName](attr.value, node);\n } else if (typeof allowedAttrs[attrName] === 'undefined'){\n return true;\n } else if (allowedAttrs[attrName] === false) {\n return true;\n } else if (typeof allowedAttrs[attrName] === 'string') {\n return (allowedAttrs[attrName] !== attr.value);\n }\n\n return false;\n }\n\n return HTMLJanitor;\n\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/html-janitor/src/html-janitor.js\n// module id = 628\n// module chunks = 0","define(['../internal/baseMerge', '../internal/createAssigner'], function(baseMerge, createAssigner) {\n\n /**\n * Recursively merges own enumerable properties of the source object(s), that\n * don't resolve to `undefined` into the destination object. Subsequent sources\n * overwrite property assignments of previous sources. If `customizer` is\n * provided it is invoked to produce the merged values of the destination and\n * source properties. If `customizer` returns `undefined` merging is handled\n * by the method instead. The `customizer` is bound to `thisArg` and invoked\n * with five arguments; (objectValue, sourceValue, key, object, source).\n *\n * @static\n * @memberOf _\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @param {Function} [customizer] The function to customize merging properties.\n * @param {*} [thisArg] The `this` binding of `customizer`.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var users = {\n * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }]\n * };\n *\n * var ages = {\n * 'data': [{ 'age': 36 }, { 'age': 40 }]\n * };\n *\n * _.merge(users, ages);\n * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }\n *\n * // using a customizer callback\n * var object = {\n * 'fruits': ['apple'],\n * 'vegetables': ['beet']\n * };\n *\n * var other = {\n * 'fruits': ['banana'],\n * 'vegetables': ['carrot']\n * };\n *\n * _.merge(object, other, function(a, b) {\n * if (_.isArray(a)) {\n * return a.concat(b);\n * }\n * });\n * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }\n */\n var merge = createAssigner(baseMerge);\n\n return merge;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/object/merge.js\n// module id = 629\n// module chunks = 0","define(['./arrayEach', './baseForOwn', './baseMergeDeep', '../lang/isArray', './isLength', '../lang/isObject', './isObjectLike', '../lang/isTypedArray'], function(arrayEach, baseForOwn, baseMergeDeep, isArray, isLength, isObject, isObjectLike, isTypedArray) {\n\n /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n var undefined;\n\n /**\n * The base implementation of `_.merge` without support for argument juggling,\n * multiple sources, and `this` binding `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {Function} [customizer] The function to customize merging properties.\n * @param {Array} [stackA=[]] Tracks traversed source objects.\n * @param {Array} [stackB=[]] Associates values with source counterparts.\n * @returns {Object} Returns the destination object.\n */\n function baseMerge(object, source, customizer, stackA, stackB) {\n if (!isObject(object)) {\n return object;\n }\n var isSrcArr = isLength(source.length) && (isArray(source) || isTypedArray(source));\n (isSrcArr ? arrayEach : baseForOwn)(source, function(srcValue, key, source) {\n if (isObjectLike(srcValue)) {\n stackA || (stackA = []);\n stackB || (stackB = []);\n return baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB);\n }\n var value = object[key],\n result = customizer ? customizer(value, srcValue, key, object, source) : undefined,\n isCommon = typeof result == 'undefined';\n\n if (isCommon) {\n result = srcValue;\n }\n if ((isSrcArr || typeof result != 'undefined') &&\n (isCommon || (result === result ? (result !== value) : (value === value)))) {\n object[key] = result;\n }\n });\n return object;\n }\n\n return baseMerge;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/baseMerge.js\n// module id = 630\n// module chunks = 0","define(['../lang/isObject'], function(isObject) {\n\n /**\n * Converts `value` to an object if it is not one.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {Object} Returns the object.\n */\n function toObject(value) {\n return isObject(value) ? value : Object(value);\n }\n\n return toObject;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/toObject.js\n// module id = 631\n// module chunks = 0","define(['../internal/baseToString'], function(baseToString) {\n\n /**\n * Used to match `RegExp` special characters.\n * See this [article on `RegExp` characters](http://www.regular-expressions.info/characters.html#special)\n * for more details.\n */\n var reRegExpChars = /[.*+?^${}()|[\\]\\/\\\\]/g,\n reHasRegExpChars = RegExp(reRegExpChars.source);\n\n /**\n * Escapes the `RegExp` special characters \"\\\", \"^\", \"$\", \".\", \"|\", \"?\", \"*\",\n * \"+\", \"(\", \")\", \"[\", \"]\", \"{\" and \"}\" in `string`.\n *\n * @static\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escapeRegExp('[lodash](https://lodash.com/)');\n * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n */\n function escapeRegExp(string) {\n string = baseToString(string);\n return (string && reHasRegExpChars.test(string))\n ? string.replace(reRegExpChars, '\\\\$&')\n : string;\n }\n\n return escapeRegExp;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/string/escapeRegExp.js\n// module id = 632\n// module chunks = 0","define([], function() {\n\n /**\n * Converts `value` to a string if it is not one. An empty string is returned\n * for `null` or `undefined` values.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\n function baseToString(value) {\n if (typeof value == 'string') {\n return value;\n }\n return value == null ? '' : (value + '');\n }\n\n return baseToString;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/baseToString.js\n// module id = 633\n// module chunks = 0","define(['../lang/isArguments', '../lang/isArray', './isIndex', './isLength', '../object/keysIn', '../support'], function(isArguments, isArray, isIndex, isLength, keysIn, support) {\n\n /** Used for native method references. */\n var objectProto = Object.prototype;\n\n /** Used to check objects for own properties. */\n var hasOwnProperty = objectProto.hasOwnProperty;\n\n /**\n * A fallback implementation of `Object.keys` which creates an array of the\n * own enumerable property names of `object`.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @returns {Array} Returns the array of property names.\n */\n function shimKeys(object) {\n var props = keysIn(object),\n propsLength = props.length,\n length = propsLength && object.length;\n\n var allowIndexes = length && isLength(length) &&\n (isArray(object) || (support.nonEnumArgs && isArguments(object)));\n\n var index = -1,\n result = [];\n\n while (++index < propsLength) {\n var key = props[index];\n if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {\n result.push(key);\n }\n }\n return result;\n }\n\n return shimKeys;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/shimKeys.js\n// module id = 634\n// module chunks = 0","define(['./arrayCopy', '../lang/isArguments', '../lang/isArray', './isLength', '../lang/isPlainObject', '../lang/isTypedArray', '../lang/toPlainObject'], function(arrayCopy, isArguments, isArray, isLength, isPlainObject, isTypedArray, toPlainObject) {\n\n /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n var undefined;\n\n /**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize merging properties.\n * @param {Array} [stackA=[]] Tracks traversed source objects.\n * @param {Array} [stackB=[]] Associates values with source counterparts.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) {\n var length = stackA.length,\n srcValue = source[key];\n\n while (length--) {\n if (stackA[length] == srcValue) {\n object[key] = stackB[length];\n return;\n }\n }\n var value = object[key],\n result = customizer ? customizer(value, srcValue, key, object, source) : undefined,\n isCommon = typeof result == 'undefined';\n\n if (isCommon) {\n result = srcValue;\n if (isLength(srcValue.length) && (isArray(srcValue) || isTypedArray(srcValue))) {\n result = isArray(value)\n ? value\n : (value ? arrayCopy(value) : []);\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n result = isArguments(value)\n ? toPlainObject(value)\n : (isPlainObject(value) ? value : {});\n }\n else {\n isCommon = false;\n }\n }\n // Add the source value to the stack of traversed objects and associate\n // it with its merged value.\n stackA.push(srcValue);\n stackB.push(result);\n\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB);\n } else if (result === result ? (result !== value) : (value === value)) {\n object[key] = result;\n }\n }\n\n return baseMergeDeep;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/baseMergeDeep.js\n// module id = 635\n// module chunks = 0","define(['./isNative', '../internal/shimIsPlainObject'], function(isNative, shimIsPlainObject) {\n\n /** `Object#toString` result references. */\n var objectTag = '[object Object]';\n\n /** Used for native method references. */\n var objectProto = Object.prototype;\n\n /**\n * Used to resolve the `toStringTag` of values.\n * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)\n * for more details.\n */\n var objToString = objectProto.toString;\n\n /** Native method references. */\n var getPrototypeOf = isNative(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf;\n\n /**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * **Note:** This method assumes objects created by the `Object` constructor\n * have no inherited enumerable properties.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\n var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) {\n if (!(value && objToString.call(value) == objectTag)) {\n return false;\n }\n var valueOf = value.valueOf,\n objProto = isNative(valueOf) && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);\n\n return objProto\n ? (value == objProto || getPrototypeOf(value) == objProto)\n : shimIsPlainObject(value);\n };\n\n return isPlainObject;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/lang/isPlainObject.js\n// module id = 636\n// module chunks = 0","define(['./baseForIn', './isObjectLike'], function(baseForIn, isObjectLike) {\n\n /** `Object#toString` result references. */\n var objectTag = '[object Object]';\n\n /** Used for native method references. */\n var objectProto = Object.prototype;\n\n /** Used to check objects for own properties. */\n var hasOwnProperty = objectProto.hasOwnProperty;\n\n /**\n * Used to resolve the `toStringTag` of values.\n * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)\n * for more details.\n */\n var objToString = objectProto.toString;\n\n /**\n * A fallback implementation of `_.isPlainObject` which checks if `value`\n * is an object created by the `Object` constructor or has a `[[Prototype]]`\n * of `null`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n */\n function shimIsPlainObject(value) {\n var Ctor;\n\n // Exit early for non `Object` objects.\n if (!(isObjectLike(value) && objToString.call(value) == objectTag) ||\n (!hasOwnProperty.call(value, 'constructor') &&\n (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {\n return false;\n }\n // IE < 9 iterates inherited properties before own properties. If the first\n // iterated property is an object's own property then there are no inherited\n // enumerable properties.\n var result;\n // In most environments an object's own properties are iterated before\n // its inherited properties. If the last iterated property is an object's\n // own property then there are no inherited enumerable properties.\n baseForIn(value, function(subValue, key) {\n result = key;\n });\n return typeof result == 'undefined' || hasOwnProperty.call(value, result);\n }\n\n return shimIsPlainObject;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/shimIsPlainObject.js\n// module id = 637\n// module chunks = 0","define(['./baseFor', '../object/keysIn'], function(baseFor, keysIn) {\n\n /**\n * The base implementation of `_.forIn` without support for callback\n * shorthands and `this` binding.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\n function baseForIn(object, iteratee) {\n return baseFor(object, iteratee, keysIn);\n }\n\n return baseForIn;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/baseForIn.js\n// module id = 638\n// module chunks = 0","define(['../internal/baseCopy', '../object/keysIn'], function(baseCopy, keysIn) {\n\n /**\n * Converts `value` to a plain object flattening inherited enumerable\n * properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\n function toPlainObject(value) {\n return baseCopy(value, keysIn(value));\n }\n\n return toPlainObject;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/lang/toPlainObject.js\n// module id = 639\n// module chunks = 0","define(['./bindCallback', './isIterateeCall'], function(bindCallback, isIterateeCall) {\n\n /**\n * Creates a function that assigns properties of source object(s) to a given\n * destination object.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\n function createAssigner(assigner) {\n return function() {\n var args = arguments,\n length = args.length,\n object = args[0];\n\n if (length < 2 || object == null) {\n return object;\n }\n var customizer = args[length - 2],\n thisArg = args[length - 1],\n guard = args[3];\n\n if (length > 3 && typeof customizer == 'function') {\n customizer = bindCallback(customizer, thisArg, 5);\n length -= 2;\n } else {\n customizer = (length > 2 && typeof thisArg == 'function') ? thisArg : null;\n length -= (customizer ? 1 : 0);\n }\n if (guard && isIterateeCall(args[1], args[2], guard)) {\n customizer = length == 3 ? null : customizer;\n length = 2;\n }\n var index = 0;\n while (++index < length) {\n var source = args[index];\n if (source) {\n assigner(object, source, customizer);\n }\n }\n return object;\n };\n }\n\n return createAssigner;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/createAssigner.js\n// module id = 640\n// module chunks = 0","define([], function() {\n\n /**\n * This method returns the first argument provided to it.\n *\n * @static\n * @memberOf _\n * @category Utility\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'user': 'fred' };\n *\n * _.identity(object) === object;\n * // => true\n */\n function identity(value) {\n return value;\n }\n\n return identity;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/utility/identity.js\n// module id = 641\n// module chunks = 0","define(['./isIndex', './isLength', '../lang/isObject'], function(isIndex, isLength, isObject) {\n\n /**\n * Checks if the provided arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.\n */\n function isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number') {\n var length = object.length,\n prereq = isLength(length) && isIndex(index, length);\n } else {\n prereq = type == 'string' && index in object;\n }\n if (prereq) {\n var other = object[index];\n return value === value ? (value === other) : (other !== other);\n }\n return false;\n }\n\n return isIterateeCall;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/isIterateeCall.js\n// module id = 642\n// module chunks = 0","define(['../internal/baseClone', '../internal/bindCallback'], function(baseClone, bindCallback) {\n\n /**\n * Creates a deep clone of `value`. If `customizer` is provided it is invoked\n * to produce the cloned values. If `customizer` returns `undefined` cloning\n * is handled by the method instead. The `customizer` is bound to `thisArg`\n * and invoked with two argument; (value [, index|key, object]).\n *\n * **Note:** This method is loosely based on the structured clone algorithm.\n * The enumerable properties of `arguments` objects and objects created by\n * constructors other than `Object` are cloned to plain `Object` objects. An\n * empty object is returned for uncloneable values such as functions, DOM nodes,\n * Maps, Sets, and WeakMaps. See the [HTML5 specification](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm)\n * for more details.\n *\n * @static\n * @memberOf _\n * @category Lang\n * @param {*} value The value to deep clone.\n * @param {Function} [customizer] The function to customize cloning values.\n * @param {*} [thisArg] The `this` binding of `customizer`.\n * @returns {*} Returns the deep cloned value.\n * @example\n *\n * var users = [\n * { 'user': 'barney' },\n * { 'user': 'fred' }\n * ];\n *\n * var deep = _.cloneDeep(users);\n * deep[0] === users[0];\n * // => false\n *\n * // using a customizer callback\n * var el = _.cloneDeep(document.body, function(value) {\n * if (_.isElement(value)) {\n * return value.cloneNode(true);\n * }\n * });\n *\n * el === document.body\n * // => false\n * el.nodeName\n * // => BODY\n * el.childNodes.length;\n * // => 20\n */\n function cloneDeep(value, customizer, thisArg) {\n customizer = typeof customizer == 'function' && bindCallback(customizer, thisArg, 1);\n return baseClone(value, true, customizer);\n }\n\n return cloneDeep;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/lang/cloneDeep.js\n// module id = 643\n// module chunks = 0","define(['./arrayCopy', './arrayEach', './baseCopy', './baseForOwn', './initCloneArray', './initCloneByTag', './initCloneObject', '../lang/isArray', '../lang/isObject', '../object/keys'], function(arrayCopy, arrayEach, baseCopy, baseForOwn, initCloneArray, initCloneByTag, initCloneObject, isArray, isObject, keys) {\n\n /** `Object#toString` result references. */\n var argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\n var arrayBufferTag = '[object ArrayBuffer]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n /** Used to identify `toStringTag` values supported by `_.clone`. */\n var cloneableTags = {};\n cloneableTags[argsTag] = cloneableTags[arrayTag] =\n cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =\n cloneableTags[dateTag] = cloneableTags[float32Tag] =\n cloneableTags[float64Tag] = cloneableTags[int8Tag] =\n cloneableTags[int16Tag] = cloneableTags[int32Tag] =\n cloneableTags[numberTag] = cloneableTags[objectTag] =\n cloneableTags[regexpTag] = cloneableTags[stringTag] =\n cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n cloneableTags[errorTag] = cloneableTags[funcTag] =\n cloneableTags[mapTag] = cloneableTags[setTag] =\n cloneableTags[weakMapTag] = false;\n\n /** Used for native method references. */\n var objectProto = Object.prototype;\n\n /**\n * Used to resolve the `toStringTag` of values.\n * See the [ES spec](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.prototype.tostring)\n * for more details.\n */\n var objToString = objectProto.toString;\n\n /**\n * The base implementation of `_.clone` without support for argument juggling\n * and `this` binding `customizer` functions.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @param {Function} [customizer] The function to customize cloning values.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The object `value` belongs to.\n * @param {Array} [stackA=[]] Tracks traversed source objects.\n * @param {Array} [stackB=[]] Associates clones with source counterparts.\n * @returns {*} Returns the cloned value.\n */\n function baseClone(value, isDeep, customizer, key, object, stackA, stackB) {\n var result;\n if (customizer) {\n result = object ? customizer(value, key, object) : customizer(value);\n }\n if (typeof result != 'undefined') {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return arrayCopy(value, result);\n }\n } else {\n var tag = objToString.call(value),\n isFunc = tag == funcTag;\n\n if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n result = initCloneObject(isFunc ? {} : value);\n if (!isDeep) {\n return baseCopy(value, result, keys(value));\n }\n } else {\n return cloneableTags[tag]\n ? initCloneByTag(value, tag, isDeep)\n : (object ? value : {});\n }\n }\n // Check for circular references and return corresponding clone.\n stackA || (stackA = []);\n stackB || (stackB = []);\n\n var length = stackA.length;\n while (length--) {\n if (stackA[length] == value) {\n return stackB[length];\n }\n }\n // Add the source value to the stack of traversed objects and associate it with its clone.\n stackA.push(value);\n stackB.push(result);\n\n // Recursively populate clone (susceptible to call stack limits).\n (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {\n result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB);\n });\n return result;\n }\n\n return baseClone;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/baseClone.js\n// module id = 644\n// module chunks = 0","define([], function() {\n\n /** Used for native method references. */\n var objectProto = Object.prototype;\n\n /** Used to check objects for own properties. */\n var hasOwnProperty = objectProto.hasOwnProperty;\n\n /**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\n function initCloneArray(array) {\n var length = array.length,\n result = new array.constructor(length);\n\n // Add array properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n }\n\n return initCloneArray;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/initCloneArray.js\n// module id = 645\n// module chunks = 0","define(['./bufferClone'], function(bufferClone) {\n\n /** `Object#toString` result references. */\n var boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n numberTag = '[object Number]',\n regexpTag = '[object RegExp]',\n stringTag = '[object String]';\n\n var arrayBufferTag = '[object ArrayBuffer]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n /** Used to match `RegExp` flags from their coerced string values. */\n var reFlags = /\\w*$/;\n\n /**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneByTag(object, tag, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return bufferClone(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n var buffer = object.buffer;\n return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length);\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n var result = new Ctor(object.source, reFlags.exec(object));\n result.lastIndex = object.lastIndex;\n }\n return result;\n }\n\n return initCloneByTag;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/initCloneByTag.js\n// module id = 646\n// module chunks = 0","define(['../utility/constant', '../lang/isNative', './root'], function(constant, isNative, root) {\n\n /** Native method references. */\n var ArrayBuffer = isNative(ArrayBuffer = root.ArrayBuffer) && ArrayBuffer,\n bufferSlice = isNative(bufferSlice = ArrayBuffer && new ArrayBuffer(0).slice) && bufferSlice,\n floor = Math.floor,\n Uint8Array = isNative(Uint8Array = root.Uint8Array) && Uint8Array;\n\n /** Used to clone array buffers. */\n var Float64Array = (function() {\n // Safari 5 errors when using an array buffer to initialize a typed array\n // where the array buffer's `byteLength` is not a multiple of the typed\n // array's `BYTES_PER_ELEMENT`.\n try {\n var func = isNative(func = root.Float64Array) && func,\n result = new func(new ArrayBuffer(10), 0, 1) && func;\n } catch(e) {}\n return result;\n }());\n\n /** Used as the size, in bytes, of each `Float64Array` element. */\n var FLOAT64_BYTES_PER_ELEMENT = Float64Array ? Float64Array.BYTES_PER_ELEMENT : 0;\n\n /**\n * Creates a clone of the given array buffer.\n *\n * @private\n * @param {ArrayBuffer} buffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\n function bufferClone(buffer) {\n return bufferSlice.call(buffer, 0);\n }\n if (!bufferSlice) {\n // PhantomJS has `ArrayBuffer` and `Uint8Array` but not `Float64Array`.\n bufferClone = !(ArrayBuffer && Uint8Array) ? constant(null) : function(buffer) {\n var byteLength = buffer.byteLength,\n floatLength = Float64Array ? floor(byteLength / FLOAT64_BYTES_PER_ELEMENT) : 0,\n offset = floatLength * FLOAT64_BYTES_PER_ELEMENT,\n result = new ArrayBuffer(byteLength);\n\n if (floatLength) {\n var view = new Float64Array(result, 0, floatLength);\n view.set(new Float64Array(buffer, 0, floatLength));\n }\n if (byteLength != offset) {\n view = new Uint8Array(result, offset);\n view.set(new Uint8Array(buffer, offset));\n }\n return result;\n };\n }\n\n return bufferClone;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/bufferClone.js\n// module id = 647\n// module chunks = 0","define([], function() {\n\n /**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @category Utility\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var object = { 'user': 'fred' };\n * var getter = _.constant(object);\n *\n * getter() === object;\n * // => true\n */\n function constant(value) {\n return function() {\n return value;\n };\n }\n\n return constant;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/utility/constant.js\n// module id = 648\n// module chunks = 0","define([], function() {\n\n /**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneObject(object) {\n var Ctor = object.constructor;\n if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) {\n Ctor = Object;\n }\n return new Ctor;\n }\n\n return initCloneObject;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-amd/modern/internal/initCloneObject.js\n// module id = 649\n// module chunks = 0","define(function () {\n\n /**\n * Adds a command for using CODEs.\n */\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var codeCommand = new scribe.api.SimpleCommand('code', 'CODE');\n\n codeCommand.execute = function () {\n scribe.transactionManager.run(function () {\n // TODO: When this command supports all types of ranges we can abstract\n // it and use it for any command that applies inline styles.\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n var selectedHtmlDocumentFragment = range.extractContents();\n\n var codeElement = document.createElement('code');\n codeElement.appendChild(selectedHtmlDocumentFragment);\n\n range.insertNode(codeElement);\n\n range.selectNode(codeElement);\n\n // Re-apply the range\n selection.selection.removeAllRanges();\n selection.selection.addRange(range);\n });\n };\n\n // There is no native command for CODE elements, so we have to provide\n // our own `queryState` method.\n // TODO: Find a way to make it explicit what the sequence of commands will\n // be.\n codeCommand.queryState = function () {\n var selection = new scribe.api.Selection();\n return !! selection.getContaining(function (node) {\n return node.nodeName === this.nodeName;\n }.bind(this));\n };\n\n // There is no native command for CODE elements, so we have to provide\n // our own `queryEnabled` method.\n // TODO: Find a way to make it explicit what the sequence of commands will\n // be.\n codeCommand.queryEnabled = function () {\n var selection = new scribe.api.Selection();\n var range = selection.range;\n\n // TODO: Support uncollapsed ranges\n return ! range.collapsed;\n };\n\n scribe.commands.code = codeCommand;\n };\n };\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/scribe-plugin-code-command/src/scribe-plugin-code-command.js\n// module id = 650\n// module chunks = 0","define([], function () {\n\n 'use strict';\n\n return function () {\n\n var keys = {\n 32: 'Space',\n 42: '*',\n 45: '-',\n 46: '.',\n 49: '1',\n // Bullet insertion keycode, most likely only working on OS X...\n 8226: '•'\n };\n\n function isUnorderedListChar(string) {\n return string === '*' || string === '-' || string === '•';\n }\n\n return function (scribe) {\n\n var preLastChar, lastChar, currentChar;\n\n function findBlockContainer(node) {\n while (node && ! scribe.node.isBlockElement(node)) {\n node = node.parentNode;\n }\n\n return node;\n }\n\n function removeSelectedTextNode() {\n var selection = new scribe.api.Selection();\n var container = selection.selection.anchorNode;\n\n if(container.data) {\n container.data = container.data.replace(/^([•*-.\\d]+)/, \"\");\n }\n\n if(!container.data\n && container.firstChild\n && container.firstChild.nodeType === Node.TEXT_NODE) {\n container.removeChild(container.firstChild);\n }\n\n }\n\n function input(event) {\n var listCommand;\n\n preLastChar = lastChar;\n lastChar = currentChar;\n // FIXME: Chrome / FF, theoretically we should be using event.key?\n // can we abstract this madness?\n currentChar = keys[event.charCode];\n\n var selection = new scribe.api.Selection();\n\n // TODO: if a with just this content\n var container = selection.range.commonAncestorContainer;\n\n // If in a \n var blockContainer = findBlockContainer(container);\n if (blockContainer && blockContainer.tagName === 'P') {\n // Warning: There is no guarantee that `container` will be a text node\n // Failing Firefox tests\n\n var startOfLineIsUList = isUnorderedListChar(container.textContent[0]);\n var cursorIsInSecondPosition = selection.range.endOffset === 1;\n if (isUnorderedListChar(lastChar) && currentChar === 'Space' && startOfLineIsUList && cursorIsInSecondPosition) {\n listCommand = 'insertUnorderedList';\n }\n\n /**\n * Firefox: Selection object never gets access to text nodes, only\n * parent elements. This means that *sometimes* unordered lists\n * will not work.\n * As per: http://jsbin.com/rotus/2/edit?js,output,console\n * Bugzilla: https://bugzilla.mozilla.org/show_bug.cgi?id=1042701\n */\n\n // Some browsers split text nodes randomly, so we can't be sure the\n // prefix will be contained within a single text node (observed in\n // Firefox)\n var startOfLineIsOList = [\n container.previousSibling && container.previousSibling.textContent,\n container.textContent\n ].join('').slice(0, 2) === '1.';\n if (preLastChar === '1' && lastChar === '.' && currentChar === 'Space' && startOfLineIsOList) {\n listCommand = 'insertOrderedList';\n }\n }\n\n if (listCommand) {\n // Ignore the typed character\n event.preventDefault();\n\n scribe.transactionManager.run(function() {\n scribe.getCommand(listCommand).execute();\n\n // Clear \"* \"/etc from the list item\n removeSelectedTextNode();\n });\n }\n }\n\n scribe.el.addEventListener('keypress', input);\n };\n };\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/scribe-plugin-smart-lists/src/scribe-plugin-smart-lists.js\n// module id = 651\n// module chunks = 0","/**\n * Plugin to replace unsemantic HTML tags with semantic ones\n *\n * Currently replaces:\n * B => STRONG\n * I => EM\n *\n */\ndefine(function () {\n\n 'use strict';\n\n return function () {\n return function (scribe) {\n var map = {\n 'B': 'strong',\n 'I': 'em'\n };\n\n /**\n * Moves the children elements from one node into another\n * @param fromNode {HTMLElement} source node\n * @param toNode {HTMLElement} destination node\n */\n function moveChildren(fromNode, toNode) {\n var nextChild;\n var child = fromNode.firstChild;\n while (child) {\n nextChild = child.nextSibling;\n toNode.appendChild(child);\n child = nextChild;\n }\n }\n\n /**\n * Copies the attributes from one node to another\n * @param fromNode {HTMLElement} source node\n * @param toNode {HTMLElement} destination node\n */\n function copyAttributes(fromNode, toNode) {\n if (fromNode.hasAttributes()) {\n for (var i = 0, ii = fromNode.attributes.length; i < ii; i++) {\n var attr = fromNode.attributes[i].cloneNode(false);\n toNode.attributes.setNamedItem(attr);\n }\n }\n }\n\n /**\n * Replaces a node with a new node of different name\n * @param node {HTMLElement} node to replace\n * @param nodeName {String} name of the new node\n */\n function replaceNode(node, nodeName) {\n var newNode = document.createElement(nodeName);\n moveChildren(node, newNode);\n copyAttributes(node, newNode);\n node.parentNode.replaceChild(newNode, node);\n }\n\n /**\n * Recursively traverse the tree replacing unsemantic nodes with semantic version\n * @param parentNode {HTMLElement}\n */\n function traverse(parentNode) {\n var el = parentNode.firstElementChild;\n var nextSibling;\n while (el) {\n nextSibling = el.nextElementSibling;\n traverse(el);\n var nodeName = map[el.nodeName];\n if (nodeName) {\n replaceNode(el, nodeName);\n }\n el = nextSibling;\n }\n }\n\n scribe.registerHTMLFormatter('normalize', function (html) {\n if (typeof html === 'string') {\n var node = document.createElement('div');\n node.innerHTML = html;\n traverse(node);\n return node.innerHTML;\n } else {\n traverse(html);\n return html\n }\n });\n };\n };\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/scribe-plugin-formatter-html-ensure-semantic-elements/src/scribe-plugin-formatter-html-ensure-semantic-elements.js\n// module id = 652\n// module chunks = 0","module.exports = function (vue) {\n return function (scribe) {\n var insertAssetCommand = new scribe.api.Command('insertAsset');\n\n insertAssetCommand.nodeName = 'A';\n\n insertAssetCommand.execute = function () {\n var selection = new scribe.api.Selection();\n selection.placeMarkers();\n\n // hack to prevent the markers from disappearing\n // see: https://github.com/guardian/scribe/issues/199#issuecomment-95259176\n scribe._skipFormatters = true;\n\n vue.addAsset();\n }\n\n // whether its currently applied\n insertAssetCommand.queryState = function () {\n // Taken from https://github.com/guardian/scribe-plugin-link-prompt-command\n // It's just checking that we're in an anchor.\n var selection = new scribe.api.Selection();\n return !! selection.getContaining(node => {\n return node.nodeName === this.nodeName;\n });\n }\n\n insertAssetCommand.queryEnabled = function () {\n return true;\n };\n\n scribe.commands.insertAsset = insertAssetCommand;\n };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/fieldtypes/bard/AssetCommand.js","// This file is adapted from https://github.com/ePages-de/scribe-plugin-enhanced-link-tooltip\n\nmodule.exports = function (vue) {\n\n // http://stackoverflow.com/a/25206094/1317451\n function findClosestParent(startElement, fn) {\n var parent = startElement.parentElement;\n if (!parent) {\n return undefined;\n }\n return fn(parent) ? parent : findClosestParent(parent, fn);\n }\n\n return function (scribe) {\n\n const showTooltipForCreatingLink = () => {\n var selection = new scribe.api.Selection();\n\n addBlurListener();\n\n vue.resetState();\n vue.scribe = scribe;\n vue.command = linkTooltipCommand;\n\n vue.createCallback = (url) => {\n getSelection().removeAllRanges();\n getSelection().addRange(selection.range);\n scribe.api.SimpleCommand.prototype.execute.call(linkTooltipCommand, url);\n scribe.el.focus();\n\n // Get the anchor that was just created so vue will have a reference to it.\n // The focusNode property appeared to be the only consistent thing between browsers.\n // It is the text at the end of the selection.\n return findClosestParent(selection.selection.focusNode, node => node.nodeName === 'A');\n }\n\n vue.edit();\n repositionTooltip();\n }\n\n const addBlurListener = () => {\n const listener = (e) => {\n const isTooltipUiElement = !!findClosestParent(e.target, el => el === vue.$el);\n if (isTooltipUiElement) {\n return true; // let blur event pass through\n }\n document.removeEventListener('mouseup', listener);\n };\n document.addEventListener('mouseup', listener);\n }\n\n const showTooltipForExistingLink = (anchor) => {\n addBlurListener();\n\n vue.scribe = scribe;\n vue.anchorElement = anchor;\n vue.isEditing = false;\n repositionTooltip();\n }\n\n const repositionTooltip = (coords) => {\n const { top, left } = getCoordinates();\n vue.positionTop = top;\n vue.positionLeft = left;\n };\n\n const hideTooltip = () => {\n vue.positionTop = '-999em';\n vue.positionleft = '-999em';\n };\n\n const getCoordinates = () => {\n const selection = new scribe.api.Selection();\n\n // calculate position\n const selectionRects = (function () {\n let rects = selection.range.getClientRects();\n if (!rects.length) {\n rects = selection.range.startContainer.getClientRects();\n }\n return rects;\n }());\n\n const scribeParentRect = scribe.el.parentNode.parentNode.parentNode.getBoundingClientRect();\n const biggestSelection = [].reduce.call(selectionRects, function (biggest, rect) {\n return rect.width >= biggest.width ? {\n rect: rect,\n width: rect.width\n } : {\n rect: biggest.rect,\n width: biggest.width\n };\n }, {\n width: 0\n });\n\n const left = biggestSelection.rect ? biggestSelection.rect.left : 0;\n const top = selectionRects.length ? selectionRects[selectionRects.length - 1].bottom : 0;\n const tooltipWidth = parseFloat(getComputedStyle(vue.$el).width);\n const offsetLeft = left - scribeParentRect.left - tooltipWidth / 2;\n const correctedOffsetLeft = offsetLeft < 0 ? 0 : Math.min(offsetLeft, scribeParentRect.width - tooltipWidth - 10);\n\n return {\n top: top - scribeParentRect.top + 'px',\n left: correctedOffsetLeft + 'px'\n };\n };\n\n const linkTooltipCommand = new scribe.api.Command('createLink');\n scribe.commands.linkTooltip = linkTooltipCommand;\n\n // Whether the selection is considered a link. Makes the toolbar button active.\n linkTooltipCommand.queryState = function () {\n const selection = new scribe.api.Selection();\n const anchor = selection.getContaining(node => node.nodeName === 'A');\n const isInsideAnchor = !!anchor;\n const containsAnchor = !!selection.range.cloneContents().querySelector('a');\n\n // Since queryState is called all the time, even when navigating using\n // the keyboard, it's a good opportunity to reposition the tooltip.\n (isInsideAnchor && selection.isInScribe())\n ? showTooltipForExistingLink(anchor)\n : hideTooltip();\n\n return isInsideAnchor || containsAnchor;\n };\n\n // Whether the selection can be made into a link. Enables the toolbar button.\n linkTooltipCommand.queryEnabled = function () {\n const selection = new scribe.api.Selection();\n const anchor = selection.getContaining(node => node.nodeName === 'A');\n const isInsideAnchor = !!anchor;\n const containsAnchor = !!selection.range.cloneContents().querySelector('a');\n return !isInsideAnchor && !containsAnchor;\n };\n\n // When the command is executed. ie. the toolbar button is clicked, or a keyboard shortcut is used.\n linkTooltipCommand.execute = function () {\n // This is needed since scribe toolbar executes the command on mousedown\n // (see https://github.com/guardian/scribe-plugin-toolbar/pull/18)\n const handler = () => {\n document.removeEventListener('click', handler);\n showTooltipForCreatingLink();\n };\n document.addEventListener('click', handler);\n };\n };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/fieldtypes/bard/LinkTooltip.js","export default function () {\n\n return function (scribe) {\n\n function findBlockContainer(node) {\n while (node && !scribe.node.isBlockElement(node)) {\n node = node.parentNode;\n }\n\n return node;\n }\n\n function input() {\n const selection = new scribe.api.Selection();\n const container = selection.range.commonAncestorContainer;\n const block = findBlockContainer(container);\n\n if (block.nodeName !== 'P') {\n return; // This should only work inside paragraphs.\n }\n\n if (block.textContent !== '---') {\n return; // It's not the hr, we're done.\n }\n\n const range = selection.range;\n range.selectNode(block);\n selection.selection.removeAllRanges();\n selection.selection.addRange(range);\n\n scribe.getCommand('insertHorizontalRule').execute();\n }\n\n scribe.el.addEventListener('keyup', input);\n };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/fieldtypes/bard/AutoHr.js","export default function () {\n\n return function (scribe) {\n\n function findBlockContainer(node) {\n while (node && !scribe.node.isBlockElement(node)) {\n node = node.parentNode;\n }\n\n return node;\n }\n\n function removeQuoteCharacter(el) {\n const firstChild = el.childNodes[0];\n\n if (firstChild.nodeName === '#text') {\n firstChild.textContent = firstChild.textContent.substr(2);\n return;\n }\n\n removeQuoteCharacter(firstChild);\n }\n\n function getBlockFromSelection(selection) {\n selection = selection || new scribe.api.Selection();\n const container = selection.range.commonAncestorContainer;\n return findBlockContainer(container);\n }\n\n function input() {\n const selection = new scribe.api.Selection();\n const block = getBlockFromSelection(selection);\n\n if (block.nodeName !== 'P') {\n return; // This should only work inside paragraphs.\n }\n\n if (block.parentNode !== scribe.el) {\n return; // Bail if the p tag isn't top level (like, inside another blockquote)\n }\n\n if (! block.textContent.substr(0, 2).match(/\\>\\s/)) {\n return; // It's not the blockquote, we're done.\n }\n\n const range = selection.range;\n range.selectNode(block);\n selection.selection.removeAllRanges();\n selection.selection.addRange(range);\n\n scribe.transactionManager.run(function() {\n scribe.getCommand('blockquote').execute();\n removeQuoteCharacter(getBlockFromSelection());\n getSelection().collapseToStart();\n });\n }\n\n scribe.el.addEventListener('keyup', input);\n };\n};\n\n\n\n// WEBPACK FOOTER //\n// ./app/statamic/resources/js/components/fieldtypes/bard/AutoBlockquote.js","module.exports = \" \n
\n\n\n\n\n\n\n// WEBPACK FOOTER //\n// CheckboxesFieldtype.vue?2ed03c1e","module.exports = \"
\";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-html-loader!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./app/statamic/resources/js/components/fieldtypes/CheckboxesFieldtype.vue\n// module id = 667\n// module chunks = 0","var __vue_script__, __vue_template__\nvar __vue_styles__ = {}\n__vue_script__ = require(\"!!babel-loader?{\\\"cacheDirectory\\\":true,\\\"presets\\\":[[\\\"env\\\",{\\\"modules\\\":false,\\\"targets\\\":{\\\"browsers\\\":[\\\"> 2%\\\"],\\\"uglify\\\":true}}]],\\\"plugins\\\":[\\\"transform-object-rest-spread\\\",[\\\"transform-runtime\\\",{\\\"polyfill\\\":false,\\\"helpers\\\":false}]]}!../../../../../../node_modules/vue-loader/lib/selector.js?type=script&index=0!./CollectionFieldtype.vue\")\nmodule.exports = __vue_script__ || {}\nif (module.exports.__esModule) module.exports = module.exports.default\nvar __vue_options__ = typeof module.exports === \"function\" ? (module.exports.options || (module.exports.options = {})) : module.exports\nif (__vue_template__) {\n__vue_options__.template = __vue_template__\n}\nif (!__vue_options__.computed) __vue_options__.computed = {}\nObject.keys(__vue_styles__).forEach(function (key) {\nvar module = __vue_styles__[key]\n__vue_options__.computed[key] = function () { return module }\n})\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/statamic/resources/js/components/fieldtypes/CollectionFieldtype.vue\n// module id = 668\n// module chunks = 0","\n\n\n\n// WEBPACK FOOTER //\n// CollectionFieldtype.vue?bf2afb84","\n\n \n\t\t\n\t\t\t
\n\n\t\n\t\t\t\t \n\t\t\n\t\t\n\t\t\t\n\t\t\t\t\t \n \n\t\t\t \n\t\t\t\t \n\t\t\n\t\n\t\t\t\t\t \n \n \n \n \n \n \n\t\t\t
\n\t
\n\n\n\n\n\n\n// WEBPACK FOOTER //\n// ListFieldtype.vue?016efc26","module.exports = \"
\";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-html-loader!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./app/statamic/resources/js/components/fieldtypes/ListFieldtype.vue\n// module id = 693\n// module chunks = 0","var __vue_script__, __vue_template__\nvar __vue_styles__ = {}\n__vue_script__ = require(\"!!babel-loader?{\\\"cacheDirectory\\\":true,\\\"presets\\\":[[\\\"env\\\",{\\\"modules\\\":false,\\\"targets\\\":{\\\"browsers\\\":[\\\"> 2%\\\"],\\\"uglify\\\":true}}]],\\\"plugins\\\":[\\\"transform-object-rest-spread\\\",[\\\"transform-runtime\\\",{\\\"polyfill\\\":false,\\\"helpers\\\":false}]]}!../../../../../../node_modules/vue-loader/lib/selector.js?type=script&index=0!./LocaleSettingsFieldtype.vue\")\n__vue_template__ = require(\"!!vue-html-loader!../../../../../../node_modules/vue-loader/lib/selector.js?type=template&index=0!./LocaleSettingsFieldtype.vue\")\nmodule.exports = __vue_script__ || {}\nif (module.exports.__esModule) module.exports = module.exports.default\nvar __vue_options__ = typeof module.exports === \"function\" ? (module.exports.options || (module.exports.options = {})) : module.exports\nif (__vue_template__) {\n__vue_options__.template = __vue_template__\n}\nif (!__vue_options__.computed) __vue_options__.computed = {}\nObject.keys(__vue_styles__).forEach(function (key) {\nvar module = __vue_styles__[key]\n__vue_options__.computed[key] = function () { return module }\n})\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./app/statamic/resources/js/components/fieldtypes/LocaleSettingsFieldtype.vue\n// module id = 694\n// module chunks = 0","\n {{ translate('cp.drop_to_upload') }}
\n {{ translate('cp.drop_to_upload') }}
\n
\n
\n \t\t\n \t\t\t
\n\n \t\n \n \t\t\t\t \n \t\t\n \t\t\n \t\t\t\n \t\t\t\t\t{{ $index + 1 }}\n \t\t\t\t\t\n \t\t\t\t \n \t\t\t\t\n \t\t\t \n \t\t\t\t \n \t\t\n \t\n \t\t\t\t\t\n \t\t\t\t \n \t\t\t\t\n \t\t\t\t\t\n \t\t\t\t\t\n \t\t\t\t \n \t\t\t