updated bunch of file paths and changed the way posts are loaded

2026-01-12 18:52:50 +00:00 · 2016-01-05 12:28:04 -06:00
parent 4bb8cae81e
commit 6ab45fe935
13249 changed files with 317868 additions and 2101398 deletions
--- a/node_modules/parse5/lib/tree_construction/location_info_mixin.js
+++ b/node_modules/parse5/lib/tree_construction/location_info_mixin.js
@@ -0,0 +1,197 @@
+'use strict';
+
+var OpenElementStack = require('./open_element_stack'),
+    Tokenizer = require('../tokenization/tokenizer'),
+    HTML = require('../common/html');
+
+
+//Aliases
+var $ = HTML.TAG_NAMES;
+
+
+function setEndLocation(element, closingToken, treeAdapter) {
+    var loc = element.__location;
+
+    if (!loc)
+        return;
+
+    if (!loc.startTag) {
+        loc.startTag = {
+            start: loc.start,
+            end: loc.end
+        };
+    }
+
+    if (closingToken.location) {
+        var tn = treeAdapter.getTagName(element),
+            // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing tag and
+            // for cases like <td> <p> </td> - 'p' closes without a closing tag
+            isClosingEndTag = closingToken.type === Tokenizer.END_TAG_TOKEN &&
+                              tn === closingToken.tagName;
+
+        if (isClosingEndTag) {
+            loc.endTag = {
+                start: closingToken.location.start,
+                end: closingToken.location.end
+            };
+        }
+
+        loc.end = closingToken.location.end;
+    }
+}
+
+//NOTE: patch open elements stack, so we can assign end location for the elements
+function patchOpenElementsStack(stack, parser) {
+    var treeAdapter = parser.treeAdapter;
+
+    stack.pop = function () {
+        setEndLocation(this.current, parser.currentToken, treeAdapter);
+        OpenElementStack.prototype.pop.call(this);
+    };
+
+    stack.popAllUpToHtmlElement = function () {
+        for (var i = this.stackTop; i > 0; i--)
+            setEndLocation(this.items[i], parser.currentToken, treeAdapter);
+
+        OpenElementStack.prototype.popAllUpToHtmlElement.call(this);
+    };
+
+    stack.remove = function (element) {
+        setEndLocation(element, parser.currentToken, treeAdapter);
+        OpenElementStack.prototype.remove.call(this, element);
+    };
+}
+
+exports.assign = function (parser) {
+    //NOTE: obtain Parser proto this way to avoid module circular references
+    var parserProto = Object.getPrototypeOf(parser),
+        treeAdapter = parser.treeAdapter;
+
+
+    //NOTE: patch _reset method
+    parser._reset = function (html, document, fragmentContext) {
+        parserProto._reset.call(this, html, document, fragmentContext);
+
+        this.attachableElementLocation = null;
+        this.lastFosterParentingLocation = null;
+        this.currentToken = null;
+
+        patchOpenElementsStack(this.openElements, parser);
+    };
+
+    parser._processTokenInForeignContent = function (token) {
+        this.currentToken = token;
+        parserProto._processTokenInForeignContent.call(this, token);
+    };
+
+    parser._processToken = function (token) {
+        this.currentToken = token;
+        parserProto._processToken.call(this, token);
+
+        //NOTE: <body> and <html> are never popped from the stack, so we need to updated
+        //their end location explicitly.
+        if (token.type === Tokenizer.END_TAG_TOKEN &&
+            (token.tagName === $.HTML ||
+            (token.tagName === $.BODY && this.openElements.hasInScope($.BODY)))) {
+            for (var i = this.openElements.stackTop; i >= 0; i--) {
+                var element = this.openElements.items[i];
+
+                if (this.treeAdapter.getTagName(element) === token.tagName) {
+                    setEndLocation(element, token, treeAdapter);
+                    break;
+                }
+            }
+        }
+    };
+
+    //Doctype
+    parser._setDocumentType = function (token) {
+        parserProto._setDocumentType.call(this, token);
+
+        var documentChildren = this.treeAdapter.getChildNodes(this.document),
+            cnLength = documentChildren.length;
+
+        for (var i = 0; i < cnLength; i++) {
+            var node = documentChildren[i];
+
+            if (this.treeAdapter.isDocumentTypeNode(node)) {
+                node.__location = token.location;
+                break;
+            }
+        }
+    };
+
+    //Elements
+    parser._attachElementToTree = function (element) {
+        //NOTE: _attachElementToTree is called from _appendElement, _insertElement and _insertTemplate methods.
+        //So we will use token location stored in this methods for the element.
+        element.__location = this.attachableElementLocation || null;
+        this.attachableElementLocation = null;
+        parserProto._attachElementToTree.call(this, element);
+    };
+
+    parser._appendElement = function (token, namespaceURI) {
+        this.attachableElementLocation = token.location;
+        parserProto._appendElement.call(this, token, namespaceURI);
+    };
+
+    parser._insertElement = function (token, namespaceURI) {
+        this.attachableElementLocation = token.location;
+        parserProto._insertElement.call(this, token, namespaceURI);
+    };
+
+    parser._insertTemplate = function (token) {
+        this.attachableElementLocation = token.location;
+        parserProto._insertTemplate.call(this, token);
+
+        var tmplContent = this.treeAdapter.getChildNodes(this.openElements.current)[0];
+
+        tmplContent.__location = null;
+    };
+
+    parser._insertFakeRootElement = function () {
+        parserProto._insertFakeRootElement.call(this);
+        this.openElements.current.__location = null;
+    };
+
+    //Comments
+    parser._appendCommentNode = function (token, parent) {
+        parserProto._appendCommentNode.call(this, token, parent);
+
+        var children = this.treeAdapter.getChildNodes(parent),
+            commentNode = children[children.length - 1];
+
+        commentNode.__location = token.location;
+    };
+
+    //Text
+    parser._findFosterParentingLocation = function () {
+        //NOTE: store last foster parenting location, so we will be able to find inserted text
+        //in case of foster parenting
+        this.lastFosterParentingLocation = parserProto._findFosterParentingLocation.call(this);
+        return this.lastFosterParentingLocation;
+    };
+
+    parser._insertCharacters = function (token) {
+        parserProto._insertCharacters.call(this, token);
+
+        var hasFosterParent = this._shouldFosterParentOnInsertion(),
+            parentingLocation = this.lastFosterParentingLocation,
+            parent = (hasFosterParent && parentingLocation.parent) ||
+                     this.openElements.currentTmplContent ||
+                     this.openElements.current,
+            siblings = this.treeAdapter.getChildNodes(parent),
+            textNodeIdx = hasFosterParent && parentingLocation.beforeElement ?
+                          siblings.indexOf(parentingLocation.beforeElement) - 1 :
+                          siblings.length - 1,
+            textNode = siblings[textNodeIdx];
+
+        //NOTE: if we have location assigned by another token, then just update end position
+        if (textNode.__location)
+            textNode.__location.end = token.location.end;
+
+        else
+            textNode.__location = token.location;
+    };
+};
+