occam-dom 4.0.16 → 5.0.0

package/lib/utilities/node.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    endIndexFromSpreadNode: function() {
+        return endIndexFromSpreadNode;
+    },
+    errorNodesFromExpressionNode: function() {
+        return errorNodesFromExpressionNode;
+    },
+    indexFromIndexNode: function() {
+        return indexFromIndexNode;
+    },
+    indexFromSpreadNode: function() {
+        return indexFromSpreadNode;
+    },
+    infiniteDescentFromPathNode: function() {
+        return infiniteDescentFromPathNode;
+    },
+    pathNodeFromExpressionNode: function() {
+        return pathNodeFromExpressionNode;
+    },
+    pathNodeFromSubExpressionNode: function() {
+        return pathNodeFromSubExpressionNode;
+    },
+    ruleNamesFromPathNode: function() {
+        return ruleNamesFromPathNode;
+    },
+    selectorNodesFromPathNode: function() {
+        return selectorNodesFromPathNode;
+    },
+    spreadNodeFromExpressionNode: function() {
+        return spreadNodeFromExpressionNode;
+    },
+    spreadNodeFromSubExpressionNode: function() {
+        return spreadNodeFromSubExpressionNode;
+    },
+    startIndexFromSpreadNode: function() {
+        return startIndexFromSpreadNode;
+    },
+    subExpressionNodeFromExpressionNode: function() {
+        return subExpressionNodeFromExpressionNode;
+    },
+    subExpressionNodeFromSubExpressionNode: function() {
+        return subExpressionNodeFromSubExpressionNode;
+    },
+    tokenTypesFromPathNode: function() {
+        return tokenTypesFromPathNode;
+    },
+    uniqueFromSpreadNode: function() {
+        return uniqueFromSpreadNode;
+    }
+});
+var _ruleNames = require("../ruleNames");
+function indexFromIndexNode(indexNode) {
+    var nonTerminalNode = indexNode, index = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+        var terminalNode = firstChildNode, content = terminalNode.getContent(), index = Number(content);
+        return index;
+    });
+    return index;
+}
+function ruleNamesFromPathNode(pathNode) {
+    var selectorNodes = selectorNodesFromPathNode(pathNode), ruleNameNodes = selectorNodes.reduce(function(ruleNameNodes, selectorNode) {
+        var nonTerminalNode = selectorNode, ruleNameNode = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+            var ruleNameNode = null;
+            var nonTerminalNode = firstChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameRuleNameRuleName = ruleName === _ruleNames.RULE_NAME_RULE_NAME;
+            if (ruleNameRuleNameRuleName) {
+                ruleNameNode = nonTerminalNode; ///
+            }
+            return ruleNameNode;
+        });
+        if (ruleNameNode !== null) {
+            ruleNameNodes.push(ruleNameNode);
+        }
+        return ruleNameNodes;
+    }, []), ruleNames = ruleNameNodes.map(function(ruleNameNode) {
+        var nonTerminalNode = ruleNameNode, ruleName = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+            var terminalNode = firstChildNode, content = terminalNode.getContent(), ruleName = content; ///
+            return ruleName;
+        });
+        return ruleName;
+    });
+    return ruleNames;
+}
+function tokenTypesFromPathNode(pathNode) {
+    var selectorNodes = selectorNodesFromPathNode(pathNode), tokenTypeNodes = selectorNodes.reduce(function(tokenTypeNodes, selectorNode) {
+        var nonTerminalNode = selectorNode, tokenTypeNode = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+            var tokenTypeNode = null;
+            var nonTerminalNode = firstChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameTokenTypeRuleName = ruleName === _ruleNames.TOKEN_TYPE_RULE_NAME;
+            if (ruleNameTokenTypeRuleName) {
+                tokenTypeNode = nonTerminalNode; ///
+            }
+            return tokenTypeNode;
+        });
+        if (tokenTypeNode !== null) {
+            tokenTypeNodes.push(tokenTypeNode);
+        }
+        return tokenTypeNodes;
+    }, []), tokenTypes = tokenTypeNodes.map(function(tokenTypeNode) {
+        var nonTerminalNode = tokenTypeNode, tokenType = fromThirdChildNode(nonTerminalNode, function(thirdChildNode) {
+            var terminalNode = thirdChildNode, content = terminalNode.getContent(), tokenType = content; ///
+            return tokenType;
+        });
+        return tokenType;
+    });
+    return tokenTypes;
+}
+function selectorNodesFromPathNode(pathNode) {
+    var nonTerminalNode;
+    nonTerminalNode = pathNode; ///
+    var selectorsNode = fromLastChildNode(nonTerminalNode, function(lastChildNode) {
+        var selectorsNode = lastChildNode; ///
+        return selectorsNode;
+    });
+    nonTerminalNode = selectorsNode; ///
+    var selectorNodes = nonTerminalNode.filterChildNode(function(childNode) {
+        var childNodeNonTerminalNode = childNode.isNonTerminalNode();
+        if (childNodeNonTerminalNode) {
+            return true;
+        }
+    });
+    return selectorNodes;
+}
+function infiniteDescentFromPathNode(pathNode) {
+    var nonTerminalNode = pathNode, infiniteDescent = fromSecondChildNode(nonTerminalNode, function(secondChildNode) {
+        var nonTerminalNode = secondChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameInfiniteDescentRuleName = ruleName === _ruleNames.INFINITE_DESCENT_RULE_NAME, infiniteDescent = ruleNameInfiniteDescentRuleName; ///
+        return infiniteDescent;
+    }) || false;
+    return infiniteDescent;
+}
+function uniqueFromSpreadNode(spreadNode) {
+    var nonTerminalNode = spreadNode, unique = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+        var unique = false;
+        var firstChildNodeNonTerminalNode = firstChildNode.isNonTerminalNode();
+        if (firstChildNodeNonTerminalNode) {
+            var nonTerminalNode = firstChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameUniqueRuleName = ruleName === _ruleNames.UNIQUE_RULE_NAME;
+            if (ruleNameUniqueRuleName) {
+                unique = true;
+            }
+        }
+        return unique;
+    });
+    return unique;
+}
+function indexFromSpreadNode(spreadNode) {
+    var index = null;
+    var nonTerminalNode = spreadNode, indexNode = nonTerminalNode.findChildNode(function(childNode) {
+        var childNodeNonTerminalNode = childNode.isNonTerminalNode();
+        if (childNodeNonTerminalNode) {
+            var nonTerminalNode = childNode, ruleName = nonTerminalNode.getRuleName(), ruleNameIndexRuleName = ruleName === _ruleNames.INDEX_RULE_NAME;
+            if (ruleNameIndexRuleName) {
+                return true;
+            }
+        }
+    }) || null;
+    if (indexNode !== null) {
+        index = indexFromIndexNode(indexNode);
+    }
+    return index;
+}
+function endIndexFromSpreadNode(spreadNode) {
+    var endIndex = Infinity;
+    var nonTerminalNode = spreadNode, endIndexNode = nonTerminalNode.findChildNode(function(childNode) {
+        var childNodeNonTerminalNode = childNode.isNonTerminalNode();
+        if (childNodeNonTerminalNode) {
+            var nonTerminalNode = childNode, ruleName = nonTerminalNode.getRuleName(), ruleNameEndIndexRuleName = ruleName === _ruleNames.END_INDEX_RULE_NAME;
+            if (ruleNameEndIndexRuleName) {
+                return true;
+            }
+        }
+    }) || null;
+    if (endIndexNode !== null) {
+        endIndex = indexFromIndexNode(endIndexNode);
+    }
+    return endIndex;
+}
+function startIndexFromSpreadNode(spreadNode) {
+    var startIndex = 0;
+    var nonTerminalNode = spreadNode, startIndexNode = nonTerminalNode.findChildNode(function(childNode) {
+        var childNodeNonTerminalNode = childNode.isNonTerminalNode();
+        if (childNodeNonTerminalNode) {
+            var nonTerminalNode = childNode, ruleName = nonTerminalNode.getRuleName(), ruleNameStartIndexRuleName = ruleName === _ruleNames.START_INDEX_RULE_NAME;
+            if (ruleNameStartIndexRuleName) {
+                return true;
+            }
+        }
+    }) || null;
+    if (startIndexNode !== null) {
+        startIndex = indexFromIndexNode(startIndexNode);
+    }
+    return startIndex;
+}
+function pathNodeFromExpressionNode(expressionNode) {
+    var nonTerminalNode = expressionNode, pathNode = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+        var pathNode = firstChildNode; ///
+        return pathNode;
+    });
+    return pathNode;
+}
+function spreadNodeFromExpressionNode(expressionNode) {
+    var nonTerminalNode = expressionNode, spreadNode = fromSecondChildNode(nonTerminalNode, function(secondChildNode) {
+        var spreadNode = null;
+        var nonTerminalNode = secondChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameSpreadRuleName = ruleName === _ruleNames.SPREAD_RULE_NAME;
+        if (ruleNameSpreadRuleName) {
+            spreadNode = secondChildNode; ///
+        }
+        return spreadNode;
+    }) || null;
+    return spreadNode;
+}
+function errorNodesFromExpressionNode(expressionNode) {
+    var nonTerminalNode = expressionNode, errorNodes = nonTerminalNode.reduceChildNode(function(errorNodes, childNode) {
+        var childNodeNonTerminalNode = childNode.isNonTerminalNode();
+        if (childNodeNonTerminalNode) {
+            var nonTerminalNode = childNode, ruleName = nonTerminalNode.getRuleName(), ruleNameErrorRuleName = ruleName === _ruleNames.ERROR_RULE_NAME;
+            if (ruleNameErrorRuleName) {
+                var errorNode = nonTerminalNode; ///
+                errorNodes.push(errorNode);
+            }
+        }
+        return errorNodes;
+    }, []);
+    return errorNodes;
+}
+function subExpressionNodeFromExpressionNode(expressionNode) {
+    var subExpressionNode = null;
+    var nonTerminalNode = expressionNode, multiplicity = nonTerminalNode.getMultiplicity();
+    if (multiplicity > 1) {
+        subExpressionNode = fromLastChildNode(nonTerminalNode, function(lastChildNode) {
+            var subExpressionNode = null;
+            var nonTerminalNode = lastChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameSubExpressionRuleName = ruleName === _ruleNames.SUB_EXPRESSION_RULE_NAME;
+            if (ruleNameSubExpressionRuleName) {
+                subExpressionNode = lastChildNode; ///
+            }
+            return subExpressionNode;
+        });
+    }
+    return subExpressionNode;
+}
+function pathNodeFromSubExpressionNode(subExpressionNode) {
+    var nonTerminalNode = subExpressionNode, pathNode = fromFirstChildNode(nonTerminalNode, function(firstChildNode) {
+        var pathNode = firstChildNode; ///
+        return pathNode;
+    });
+    return pathNode;
+}
+function spreadNodeFromSubExpressionNode(subExpressionNode) {
+    var spreadNode = null;
+    var nonTerminalNode = subExpressionNode, multiplicity = nonTerminalNode.getMultiplicity();
+    if (multiplicity > 1) {
+        spreadNode = fromSecondChildNode(nonTerminalNode, function(secondChildNode) {
+            var spreadNode = null;
+            var nonTerminalNode = secondChildNode, ruleName = nonTerminalNode.getRuleName(), ruleNameSpreadRuleName = ruleName === _ruleNames.SPREAD_RULE_NAME;
+            if (ruleNameSpreadRuleName) {
+                spreadNode = secondChildNode; ///
+            }
+            return spreadNode;
+        }) || null;
+    }
+    return spreadNode;
+}
+function subExpressionNodeFromSubExpressionNode(subExpressionNode) {
+    var nonTerminalNode = subExpressionNode; ///
+    subExpressionNode = null;
+    var multiplicity = nonTerminalNode.getMultiplicity();
+    if (multiplicity > 1) {
+        subExpressionNode = fromLastChildNode(nonTerminalNode, function(lastChildNode) {
+            var _$subExpressionNode = null;
+            var nonTerminalNoe = lastChildNode, ruleName = nonTerminalNoe.getRuleName(), ruleNameSubExpressionRuleName = ruleName === _ruleNames.SUB_EXPRESSION_RULE_NAME;
+            if (ruleNameSubExpressionRuleName) {
+                _$subExpressionNode = lastChildNode; ///
+            }
+            return _$subExpressionNode;
+        });
+    }
+    return subExpressionNode;
+}
+function fromFirstChildNode(nonTerminalNode, callback) {
+    var result;
+    var firstIndex = 0;
+    nonTerminalNode.forwardsSomeChildNode(function(childNode, index) {
+        if (index === firstIndex) {
+            var firstChildNode = childNode; ///
+            result = callback(firstChildNode);
+            return true;
+        }
+    });
+    return result;
+}
+function fromSecondChildNode(nonTerminalNode, callback) {
+    var result;
+    var secondIndex = 1;
+    nonTerminalNode.forwardsSomeChildNode(function(childNode, index) {
+        if (index === secondIndex) {
+            var firstChildNode = childNode; ///
+            result = callback(firstChildNode);
+            return true;
+        }
+    });
+    return result;
+}
+function fromThirdChildNode(nonTerminalNode, callback) {
+    var result;
+    var thirdIndex = 2;
+    nonTerminalNode.forwardsSomeChildNode(function(childNode, index) {
+        if (index === thirdIndex) {
+            var thirdChildNode = childNode; ///
+            result = callback(thirdChildNode);
+            return true;
+        }
+    });
+    return result;
+}
+function fromLastChildNode(nonTerminalNode, callback) {
+    var result;
+    var multiplicity = nonTerminalNode.getMultiplicity(), lastIndex = multiplicity - 1;
+    nonTerminalNode.backwardsSomeChildNode(function(childNode, index) {
+        if (index === lastIndex) {
+            var thirdChildNode = childNode; ///
+            result = callback(thirdChildNode);
+            return true;
+        }
+    });
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/node.js"],"sourcesContent":["\"use strict\";\n\nimport { ERROR_RULE_NAME,\n         INDEX_RULE_NAME,\n         UNIQUE_RULE_NAME,\n         SPREAD_RULE_NAME,\n         END_INDEX_RULE_NAME,\n         RULE_NAME_RULE_NAME,\n         TOKEN_TYPE_RULE_NAME,\n         START_INDEX_RULE_NAME,\n         SUB_EXPRESSION_RULE_NAME,\n         INFINITE_DESCENT_RULE_NAME } from \"../ruleNames\";\n\nexport function indexFromIndexNode(indexNode) {\n  const nonTerminalNode = indexNode, ///\n        index = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n          const terminalNode = firstChildNode,  ///\n                content = terminalNode.getContent(),\n                index = Number(content);\n\n          return index;\n        });\n\n  return index;\n}\n\nexport function ruleNamesFromPathNode(pathNode) {\n  const selectorNodes = selectorNodesFromPathNode(pathNode),\n        ruleNameNodes = selectorNodes.reduce((ruleNameNodes, selectorNode) => {\n          const nonTerminalNode = selectorNode, ///\n                ruleNameNode = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n                  let ruleNameNode = null;\n\n                  const nonTerminalNode = firstChildNode, ///\n                        ruleName = nonTerminalNode.getRuleName(),\n                        ruleNameRuleNameRuleName = (ruleName === RULE_NAME_RULE_NAME);\n\n                  if (ruleNameRuleNameRuleName) {\n                    ruleNameNode = nonTerminalNode; ///\n                  }\n\n                  return ruleNameNode;\n                });\n\n          if (ruleNameNode !== null) {\n            ruleNameNodes.push(ruleNameNode);\n          }\n\n          return ruleNameNodes;\n        }, []),\n        ruleNames = ruleNameNodes.map((ruleNameNode) => {\n          const nonTerminalNode = ruleNameNode, ///\n                ruleName = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n                  const terminalNode = firstChildNode,  ///\n                        content = terminalNode.getContent(),\n                        ruleName = content; ///\n\n                  return ruleName;\n                });\n\n          return ruleName;\n        });\n\n  return ruleNames;\n}\n\nexport function tokenTypesFromPathNode(pathNode) {\n  const selectorNodes = selectorNodesFromPathNode(pathNode),\n        tokenTypeNodes = selectorNodes.reduce((tokenTypeNodes, selectorNode) => {\n          const nonTerminalNode = selectorNode, ///\n                tokenTypeNode = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n                  let tokenTypeNode = null;\n\n                  const nonTerminalNode = firstChildNode, ///\n                        ruleName = nonTerminalNode.getRuleName(),\n                        ruleNameTokenTypeRuleName = (ruleName === TOKEN_TYPE_RULE_NAME);\n\n                  if (ruleNameTokenTypeRuleName) {\n                    tokenTypeNode = nonTerminalNode; ///\n                  }\n\n                  return tokenTypeNode;\n                });\n\n          if (tokenTypeNode !== null) {\n            tokenTypeNodes.push(tokenTypeNode);\n          }\n\n          return tokenTypeNodes;\n        }, []),\n        tokenTypes = tokenTypeNodes.map((tokenTypeNode) => {\n          const nonTerminalNode = tokenTypeNode,  ///\n                tokenType = fromThirdChildNode(nonTerminalNode, (thirdChildNode) => {\n                  const terminalNode = thirdChildNode,  ///\n                        content = terminalNode.getContent(),\n                        tokenType = content;  ///\n\n                  return tokenType;\n                });\n\n          return tokenType;\n        });\n\n  return tokenTypes;\n}\n\nexport function selectorNodesFromPathNode(pathNode) {\n  let nonTerminalNode;\n\n  nonTerminalNode = pathNode; ///\n\n  const selectorsNode = fromLastChildNode(nonTerminalNode, (lastChildNode) => {\n    const selectorsNode = lastChildNode;  ///\n\n    return selectorsNode;\n  });\n\n  nonTerminalNode = selectorsNode;  ///\n\n  const selectorNodes = nonTerminalNode.filterChildNode((childNode) => {\n    const childNodeNonTerminalNode = childNode.isNonTerminalNode();\n\n    if (childNodeNonTerminalNode) {\n      return true;\n    }\n  });\n\n  return selectorNodes;\n}\n\nexport function infiniteDescentFromPathNode(pathNode) {\n  const nonTerminalNode = pathNode, ///\n        infiniteDescent = fromSecondChildNode(nonTerminalNode, (secondChildNode) => {\n          const nonTerminalNode = secondChildNode,  ///\n                ruleName = nonTerminalNode.getRuleName(),\n                ruleNameInfiniteDescentRuleName = (ruleName === INFINITE_DESCENT_RULE_NAME),\n                infiniteDescent = ruleNameInfiniteDescentRuleName;  ///\n\n          return infiniteDescent;\n        }) || false;\n\n  return infiniteDescent;\n}\n\nexport function uniqueFromSpreadNode(spreadNode) {\n  const nonTerminalNode = spreadNode,\n        unique = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n          let unique = false;\n\n          const firstChildNodeNonTerminalNode = firstChildNode.isNonTerminalNode();\n\n          if (firstChildNodeNonTerminalNode) {\n            const nonTerminalNode = firstChildNode, ///\n                  ruleName = nonTerminalNode.getRuleName(),\n                  ruleNameUniqueRuleName = (ruleName === UNIQUE_RULE_NAME);\n\n            if (ruleNameUniqueRuleName) {\n              unique = true;\n            }\n          }\n\n          return unique;\n        });\n\n  return unique;\n}\n\nexport function indexFromSpreadNode(spreadNode) {\n  let index = null;\n\n  const nonTerminalNode = spreadNode, ///\n        indexNode = nonTerminalNode.findChildNode((childNode) => {\n          const childNodeNonTerminalNode = childNode.isNonTerminalNode();\n\n          if (childNodeNonTerminalNode) {\n            const nonTerminalNode = childNode,  ///\n                  ruleName = nonTerminalNode.getRuleName(),\n                  ruleNameIndexRuleName = (ruleName === INDEX_RULE_NAME);\n\n            if (ruleNameIndexRuleName) {\n              return true;\n            }\n          }\n        }) || null;\n\n  if (indexNode !== null) {\n    index = indexFromIndexNode(indexNode);\n  }\n\n  return index;\n}\n\nexport function endIndexFromSpreadNode(spreadNode) {\n  let endIndex = Infinity;\n\n  const nonTerminalNode = spreadNode, ///\n        endIndexNode = nonTerminalNode.findChildNode((childNode) => {\n          const childNodeNonTerminalNode = childNode.isNonTerminalNode();\n\n          if (childNodeNonTerminalNode) {\n            const nonTerminalNode = childNode,  ///\n                  ruleName = nonTerminalNode.getRuleName(),\n                  ruleNameEndIndexRuleName = (ruleName === END_INDEX_RULE_NAME);\n\n            if (ruleNameEndIndexRuleName) {\n              return true;\n            }\n          }\n        }) || null;\n\n  if (endIndexNode !== null) {\n    endIndex = indexFromIndexNode(endIndexNode);\n  }\n\n  return endIndex;\n}\n\nexport function startIndexFromSpreadNode(spreadNode) {\n  let startIndex = 0;\n\n  const nonTerminalNode = spreadNode, ///\n        startIndexNode = nonTerminalNode.findChildNode((childNode) => {\n          const childNodeNonTerminalNode = childNode.isNonTerminalNode();\n\n          if (childNodeNonTerminalNode) {\n            const nonTerminalNode = childNode,  ///\n                  ruleName = nonTerminalNode.getRuleName(),\n                  ruleNameStartIndexRuleName = (ruleName === START_INDEX_RULE_NAME);\n\n            if (ruleNameStartIndexRuleName) {\n              return true;\n            }\n          }\n        }) || null;\n\n  if (startIndexNode !== null) {\n    startIndex = indexFromIndexNode(startIndexNode);\n  }\n\n  return startIndex;\n}\n\nexport function pathNodeFromExpressionNode(expressionNode) {\n  const nonTerminalNode = expressionNode, ///\n        pathNode = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n          const pathNode = firstChildNode;  ///\n\n          return pathNode;\n        });\n\n  return pathNode;\n}\n\nexport function spreadNodeFromExpressionNode(expressionNode) {\n  const nonTerminalNode = expressionNode, ///\n        spreadNode = fromSecondChildNode(nonTerminalNode, (secondChildNode) => {\n          let spreadNode = null;\n\n          const nonTerminalNode = secondChildNode,  ///\n                ruleName = nonTerminalNode.getRuleName(),\n                ruleNameSpreadRuleName = (ruleName === SPREAD_RULE_NAME);\n\n          if (ruleNameSpreadRuleName) {\n            spreadNode = secondChildNode;  ///\n          }\n\n          return spreadNode;\n        }) || null;\n\n  return spreadNode;\n}\n\nexport function errorNodesFromExpressionNode(expressionNode) {\n  const nonTerminalNode = expressionNode, ///\n        errorNodes = nonTerminalNode.reduceChildNode((errorNodes, childNode) => {\n          const childNodeNonTerminalNode = childNode.isNonTerminalNode();\n\n          if (childNodeNonTerminalNode) {\n            const nonTerminalNode = childNode,  ///\n                  ruleName = nonTerminalNode.getRuleName(),\n                  ruleNameErrorRuleName = (ruleName === ERROR_RULE_NAME);\n\n            if (ruleNameErrorRuleName) {\n              const errorNode = nonTerminalNode;  ///\n\n              errorNodes.push(errorNode);\n            }\n          }\n\n          return errorNodes;\n        }, []);\n\n  return errorNodes;\n}\n\nexport function subExpressionNodeFromExpressionNode(expressionNode) {\n  let subExpressionNode = null;\n\n  const nonTerminalNode = expressionNode, ///\n        multiplicity = nonTerminalNode.getMultiplicity();\n\n  if (multiplicity > 1) {\n    subExpressionNode = fromLastChildNode(nonTerminalNode, (lastChildNode) => {\n      let subExpressionNode = null;\n\n      const nonTerminalNode = lastChildNode,  ///\n            ruleName = nonTerminalNode.getRuleName(),\n            ruleNameSubExpressionRuleName = (ruleName === SUB_EXPRESSION_RULE_NAME);\n\n      if (ruleNameSubExpressionRuleName) {\n        subExpressionNode = lastChildNode;  ///\n      }\n\n      return subExpressionNode;\n    });\n  }\n\n  return subExpressionNode;\n}\n\nexport function pathNodeFromSubExpressionNode(subExpressionNode) {\n  const nonTerminalNode = subExpressionNode, ///\n        pathNode = fromFirstChildNode(nonTerminalNode, (firstChildNode) => {\n          const pathNode = firstChildNode;  ///\n\n          return pathNode;\n        })\n\n  return pathNode;\n}\n\nexport function spreadNodeFromSubExpressionNode(subExpressionNode) {\n  let spreadNode = null;\n\n  const nonTerminalNode = subExpressionNode, ///\n        multiplicity = nonTerminalNode.getMultiplicity();\n\n  if (multiplicity > 1) {\n    spreadNode = fromSecondChildNode(nonTerminalNode, (secondChildNode) => {\n      let spreadNode = null;\n\n      const nonTerminalNode = secondChildNode,  ///\n            ruleName = nonTerminalNode.getRuleName(),\n            ruleNameSpreadRuleName = (ruleName === SPREAD_RULE_NAME);\n\n      if (ruleNameSpreadRuleName) {\n        spreadNode = secondChildNode;  ///\n      }\n\n      return spreadNode;\n    }) || null;\n  }\n\n  return spreadNode;\n}\n\nexport function subExpressionNodeFromSubExpressionNode(subExpressionNode) {\n  const nonTerminalNode = subExpressionNode; ///\n\n  subExpressionNode = null;\n\n  const multiplicity = nonTerminalNode.getMultiplicity();\n\n  if (multiplicity > 1) {\n    subExpressionNode = fromLastChildNode(nonTerminalNode, (lastChildNode) => {\n      let subExpressionNode = null;\n\n      const nonTerminalNoe = lastChildNode, ///\n            ruleName = nonTerminalNoe.getRuleName(),\n            ruleNameSubExpressionRuleName = (ruleName === SUB_EXPRESSION_RULE_NAME);\n\n      if (ruleNameSubExpressionRuleName) {\n        subExpressionNode = lastChildNode;  ///\n      }\n\n      return subExpressionNode;\n    });\n  }\n\n  return subExpressionNode;\n}\n\nfunction fromFirstChildNode(nonTerminalNode, callback) {\n  let result;\n\n  const firstIndex = 0;\n\n  nonTerminalNode.forwardsSomeChildNode((childNode, index) => {\n    if (index === firstIndex) {\n      const firstChildNode = childNode; ///\n\n      result = callback(firstChildNode);\n\n      return true;\n    }\n  });\n\n  return result;\n}\n\nfunction fromSecondChildNode(nonTerminalNode, callback) {\n  let result;\n\n  const secondIndex = 1;\n\n  nonTerminalNode.forwardsSomeChildNode((childNode, index) => {\n    if (index === secondIndex) {\n      const firstChildNode = childNode; ///\n\n      result = callback(firstChildNode);\n\n      return true;\n    }\n  });\n\n  return result;\n}\n\nfunction fromThirdChildNode(nonTerminalNode, callback) {\n  let result;\n\n  const thirdIndex = 2;\n\n  nonTerminalNode.forwardsSomeChildNode((childNode, index) => {\n    if (index === thirdIndex) {\n      const thirdChildNode = childNode; ///\n\n      result = callback(thirdChildNode);\n\n      return true;\n    }\n  });\n\n  return result;\n}\n\nfunction fromLastChildNode(nonTerminalNode, callback) {\n  let result;\n\n  const multiplicity = nonTerminalNode.getMultiplicity(),\n        lastIndex = multiplicity - 1;\n\n  nonTerminalNode.backwardsSomeChildNode((childNode, index) => {\n    if (index === lastIndex) {\n      const thirdChildNode = childNode; ///\n\n      result = callback(thirdChildNode);\n\n      return true;\n    }\n  });\n\n  return result;\n}\n"],"names":["endIndexFromSpreadNode","errorNodesFromExpressionNode","indexFromIndexNode","indexFromSpreadNode","infiniteDescentFromPathNode","pathNodeFromExpressionNode","pathNodeFromSubExpressionNode","ruleNamesFromPathNode","selectorNodesFromPathNode","spreadNodeFromExpressionNode","spreadNodeFromSubExpressionNode","startIndexFromSpreadNode","subExpressionNodeFromExpressionNode","subExpressionNodeFromSubExpressionNode","tokenTypesFromPathNode","uniqueFromSpreadNode","indexNode","nonTerminalNode","index","fromFirstChildNode","firstChildNode","terminalNode","content","getContent","Number","pathNode","selectorNodes","ruleNameNodes","reduce","selectorNode","ruleNameNode","ruleName","getRuleName","ruleNameRuleNameRuleName","RULE_NAME_RULE_NAME","push","ruleNames","map","tokenTypeNodes","tokenTypeNode","ruleNameTokenTypeRuleName","TOKEN_TYPE_RULE_NAME","tokenTypes","tokenType","fromThirdChildNode","thirdChildNode","selectorsNode","fromLastChildNode","lastChildNode","filterChildNode","childNode","childNodeNonTerminalNode","isNonTerminalNode","infiniteDescent","fromSecondChildNode","secondChildNode","ruleNameInfiniteDescentRuleName","INFINITE_DESCENT_RULE_NAME","spreadNode","unique","firstChildNodeNonTerminalNode","ruleNameUniqueRuleName","UNIQUE_RULE_NAME","findChildNode","ruleNameIndexRuleName","INDEX_RULE_NAME","endIndex","Infinity","endIndexNode","ruleNameEndIndexRuleName","END_INDEX_RULE_NAME","startIndex","startIndexNode","ruleNameStartIndexRuleName","START_INDEX_RULE_NAME","expressionNode","ruleNameSpreadRuleName","SPREAD_RULE_NAME","errorNodes","reduceChildNode","ruleNameErrorRuleName","ERROR_RULE_NAME","errorNode","subExpressionNode","multiplicity","getMultiplicity","ruleNameSubExpressionRuleName","SUB_EXPRESSION_RULE_NAME","nonTerminalNoe","callback","result","firstIndex","forwardsSomeChildNode","secondIndex","thirdIndex","lastIndex","backwardsSomeChildNode"],"mappings":"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"}

package/lib/utilities/query.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return _default;
+    },
+    queryByExpressionString: function() {
+        return queryByExpressionString;
+    }
+});
+var _query = /*#__PURE__*/ _interop_require_default(require("../query"));
+var _expression = /*#__PURE__*/ _interop_require_default(require("../expression"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function queryByExpressionString(node, expressionString, maximumDepth) {
+    var nodes = null;
+    var expression = _expression.default.fromExpressionString(expressionString);
+    if (expression !== null) {
+        var query = _query.default.fromExpression(expression, maximumDepth);
+        nodes = query.execute(node);
+    }
+    return nodes;
+}
+var _default = {
+    queryByExpressionString: queryByExpressionString
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvcXVlcnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBRdWVyeSBmcm9tIFwiLi4vcXVlcnlcIjtcbmltcG9ydCBFeHByZXNzaW9uIGZyb20gXCIuLi9leHByZXNzaW9uXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBxdWVyeUJ5RXhwcmVzc2lvblN0cmluZyhub2RlLCBleHByZXNzaW9uU3RyaW5nLCBtYXhpbXVtRGVwdGgpIHtcbiAgbGV0IG5vZGVzID0gbnVsbDtcblxuICBjb25zdCBleHByZXNzaW9uID0gRXhwcmVzc2lvbi5mcm9tRXhwcmVzc2lvblN0cmluZyhleHByZXNzaW9uU3RyaW5nKTtcblxuICBpZiAoZXhwcmVzc2lvbiAhPT0gbnVsbCkge1xuICAgIGNvbnN0IHF1ZXJ5ID0gUXVlcnkuZnJvbUV4cHJlc3Npb24oZXhwcmVzc2lvbiwgbWF4aW11bURlcHRoKTtcblxuICAgIG5vZGVzID0gcXVlcnkuZXhlY3V0ZShub2RlKTtcbiAgfVxuXG4gIHJldHVybiBub2Rlcztcbn1cblxuZXhwb3J0IGRlZmF1bHQge1xuICBxdWVyeUJ5RXhwcmVzc2lvblN0cmluZ1xufTtcbiJdLCJuYW1lcyI6WyJxdWVyeUJ5RXhwcmVzc2lvblN0cmluZyIsIm5vZGUiLCJleHByZXNzaW9uU3RyaW5nIiwibWF4aW11bURlcHRoIiwibm9kZXMiLCJleHByZXNzaW9uIiwiRXhwcmVzc2lvbiIsImZyb21FeHByZXNzaW9uU3RyaW5nIiwicXVlcnkiLCJRdWVyeSIsImZyb21FeHByZXNzaW9uIiwiZXhlY3V0ZSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O0lBbUJBLE9BRUU7ZUFGRjs7SUFkZ0JBLHVCQUF1QjtlQUF2QkE7Ozs0REFIRTtpRUFDSzs7Ozs7O0FBRWhCLFNBQVNBLHdCQUF3QkMsSUFBSSxFQUFFQyxnQkFBZ0IsRUFBRUMsWUFBWTtJQUMxRSxJQUFJQyxRQUFRO0lBRVosSUFBTUMsYUFBYUMsbUJBQVUsQ0FBQ0Msb0JBQW9CLENBQUNMO0lBRW5ELElBQUlHLGVBQWUsTUFBTTtRQUN2QixJQUFNRyxRQUFRQyxjQUFLLENBQUNDLGNBQWMsQ0FBQ0wsWUFBWUY7UUFFL0NDLFFBQVFJLE1BQU1HLE9BQU8sQ0FBQ1Y7SUFDeEI7SUFFQSxPQUFPRztBQUNUO0lBRUEsV0FBZTtJQUNiSix5QkFBQUE7QUFDRiJ9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-dom",
   "author": "James Smith",
-  "version": "4.0.16",
+  "version": "5.0.0",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-dom",
   "description": "Occam's DOM related functionality.",

package/src/constants.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export const EMPTY_STRING = "";

package/src/example/utilities/token.js

@@ -0,0 +1,19 @@
+"use strict";
+
+export function tokenIndexFromTerminalNodeAndTokens(terminalNode, tokens) {
+  const significantToken = terminalNode.getSignificantToken(),
+        significantTokenIndex = tokens.indexOf(significantToken),
+        tokenIndex = `(${significantTokenIndex})`;
+
+  return tokenIndex;
+}
+
+export function tokenIndexesFromNonTerminalNodeAndTokens(nonTerminalNode, tokens) {
+  const firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens),
+        tokenIndexes = (firstSignificantTokenIndex !== lastSignificantTokenIndex) ?
+                        `(${firstSignificantTokenIndex}-${lastSignificantTokenIndex})` :
+                          `(${firstSignificantTokenIndex})`;
+
+  return tokenIndexes;
+}

package/src/example/view/div/sizeable.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { SizeableDiv } from "easy-layout";
+
+export default withStyle(SizeableDiv)`
+
+  width: 64rem;
+  min-width: 24rem;
+  
+`;

package/src/example/view/input/expressionString.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import Input from "../input";
+
+export default class ExpressionStringInput extends Input {
+  getExpressionString() {
+    const value = this.getValue(),
+          expression = value; ///
+
+    return expression;
+  }
+
+  setExpressionString(expressionString) {
+    const value = expressionString; ///
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const getExpressionString = this.getExpressionString.bind(this),
+          setExpressionString = this.setExpressionString.bind(this); ///;
+
+    return ({
+      getExpressionString,
+      setExpressionString
+    });
+  }
+
+  static defaultProperties = {
+    className: "expression-string",
+    spellCheck: "false"
+  };
+}

package/src/example/view/input/maximumDepth.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import Input from "../input";
+
+export default class MaximumDepthInput extends Input {
+  getMaximumDepth() {
+    const value = this.getValue(),
+          maximumDepth = Number(value);
+
+    return maximumDepth;
+  }
+
+  setMaximumDepth(maximumDepth) {
+    const value = maximumDepth; ///
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const getMaximumDepth = this.getMaximumDepth.bind(this),
+          setMaximumDepth = this.setMaximumDepth.bind(this),
+          setMaximumDepthReadOnly = this.setReadOnly.bind(this); ///;
+
+    return ({
+      getMaximumDepth,
+      setMaximumDepth,
+      setMaximumDepthReadOnly
+    });
+  }
+
+  static defaultProperties = {
+    className: "maximum-depth",
+    spellCheck: "false"
+  };
+}

package/src/example/view/input.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+import { Input } from "easy";
+
+export default withStyle(Input)`
+
+  border: 1px solid darkgrey;
+  padding: 0.25rem;
+  font-size: 1.2rem;
+  font-family: monospace;
+
+`;

package/src/example/view/subHeading.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import withStyle from "easy-with-style";  ///
+
+const SubHeading = withStyle.h2`
+
+  margin: 1rem 0 0.5rem 0;
+  font-size: 2rem;
+  
+  :first-of-type {
+    margin-top: 0;
+  }
+
+`;
+
+export default SubHeading;

package/src/example/view/textarea/content.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import Textarea from "../textarea";
+
+export default class ContentTextarea extends Textarea {
+  getContent() {
+    const value = this.getValue(),
+          content = value; ///
+
+    return content;
+  }
+
+  setContent(content) {
+    const value = content;
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const getContent = this.getContent.bind(this),
+          setContent = this.setContent.bind(this);
+
+    return ({
+      getContent,
+      setContent
+    });
+  }
+
+  static defaultProperties = {
+    className: "content",
+    spellCheck: "false"
+  };
+}

package/src/example/view/textarea/nodes.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import Textarea from "../textarea";
+
+import { EMPTY_STRING } from "../../../constants";
+import { tokenIndexFromTerminalNodeAndTokens, tokenIndexesFromNonTerminalNodeAndTokens } from "../../utilities/token"
+
+export default class NodesTextarea extends Textarea {
+  setNodes(nodes, tokens) { ///
+    const value = nodes.reduce((value, node) => {
+      const nodeTerminalNode = node.isTerminalNode();
+
+      if (nodeTerminalNode) {
+        const terminalNode = node,  ///
+              significantToken = terminalNode.getSignificantToken(),
+              significantTokenType = significantToken.getType(),
+              tokenIndex = tokenIndexFromTerminalNodeAndTokens(terminalNode, tokens);
+
+        value = `${value}[${significantTokenType}]${tokenIndex}\n`;
+      } else {
+        const nonTerminalNode = node, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              tokenIndexes = tokenIndexesFromNonTerminalNodeAndTokens(nonTerminalNode, tokens);
+
+        value = `${value}${ruleName}${tokenIndexes}\n`;
+      }
+
+      return value;
+    }, EMPTY_STRING);
+
+    this.setValue(value);
+  }
+
+  clearNodes() {
+    const value = EMPTY_STRING;
+
+    this.setValue(value);
+  }
+
+  parentContext() {
+    const setNodes = this.setNodes.bind(this),
+          clearNodes = this.clearNodes.bind(this);
+
+    return ({
+      setNodes,
+      clearNodes
+    });
+  }
+
+  static defaultProperties = {
+    className: "nodes",
+    spellCheck: "false",
+    readOnly: true
+  };
+}