occam-verify-cli 1.0.184 → 1.0.192

package/src/node/declaration/metavariable.js

@@ -1,7 +1,40 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class MetavariableDeclarationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeMetaTypeNode, isNodeMetavariableNode } from "../../utilities/node";
+
+export default class MetavariableDeclarationNode extends NonTerminalNode {
+  getTypeNode() {
+    const metavariableNode = this.getMetavariableNode(),
+          typeNode = metavariableNode.getTypeNode();
+
+    return typeNode;
+  }
+
+  getMetaTypeNode() {
+    const metaTypeNode = this.findChildNode((childNode) => {
+      const childNodeMetaTypeNode = isNodeMetaTypeNode(childNode);
+
+      if (childNodeMetaTypeNode) {
+        return true;
+      }
+    }) || null;
+
+    return metaTypeNode
+  }
+
+  getMetavariableNode() {
+    const metavariableNode = this.findChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    }) || null;
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/property.js

@@ -1,36 +1,40 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
-import { isNodePropertyNode } from "../../utilities/node";
+import { isNodeTypeNode, isNodePropertyNode } from "../../utilities/node";
 
-export default class PropertyDeclarationNode extends Node {
+export default class PropertyDeclarationNode extends NonTerminalNode {
   getTypeNode() {
-    const typeNode = this.fromSecondLastChildNode((secondLastChildNode) => {
-      const typeNode = secondLastChildNode;; ///
+    const typeNode = this.findChildNode((childNode) => {
+      const childNodeTypeNode = isNodeTypeNode(childNode);
 
-      return typeNode;
-    });
+      if (childNodeTypeNode) {
+        return true;
+      }
+    }) || null;
 
     return typeNode;
   }
 
-  getPropertyNames() {
-    const propertyNames = this.reduceChildNode((propertyNames, childNode) => {
+  getPropertyNode() {
+    const propertyNode = this.findChildNode((childNode) => {
       const childNodePropertyNode = isNodePropertyNode(childNode);
 
       if (childNodePropertyNode) {
-        const propertyNode = childNode, ///
-              propertyName = propertyNode.getPropertyName();
-
-        propertyNames.push(propertyName);
+        return true;
       }
+    }) || null;
+
+    return propertyNode;
+  }
 
-      return propertyNames;
-    }, []);
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
 
-    return propertyNames;
+    return propertyName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/type.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
 import { PROVISIONAL } from "../../constants";
 import { isNodeTypeNode } from "../../utilities/node";
 
-export default class TypeDeclarationNode extends Node {
+export default class TypeDeclarationNode extends NonTerminalNode {
   getTypeName() {
-    let typeName;
+    let typeName = null;
 
     this.someChildNode((childNode) => {
       const childNodeTypeNode = isNodeTypeNode(childNode);
@@ -25,30 +25,35 @@ export default class TypeDeclarationNode extends Node {
   }
 
   isProvisional() {
-    const provisional = this.fromFirstChildNode((firstChildNode) => {
-      const terminalNode = firstChildNode,  ///
-            content = terminalNode.getContent(),
-            contentProvisional = (content === PROVISIONAL),
-            provisional = contentProvisional; ///
+    let provisional = false;
 
-      return provisional;
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent(),
+              contentProvisional = (content === PROVISIONAL);
+
+        if (contentProvisional) {
+          provisional = true;
+
+          return true;
+        }
+      }
     });
 
     return provisional;
   }
 
   getSuperTypeNodes() {
-    const typeNodes = this.reduceChildNode((typeNodes, childNode) => {
+    const typeNodes = this.filterChildNode((childNode) => {
       const childNodeTypeNode = isNodeTypeNode(childNode);
 
       if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
-
-        typeNodes.push(typeNode);
+        return true;
       }
-
-      return typeNodes;
-    }, []);
+    });
 
     typeNodes.pop();
 
@@ -57,6 +62,6 @@ export default class TypeDeclarationNode extends Node {
     return superTypeNodes;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }
 

package/src/node/declaration/variable.js

@@ -1,61 +1,53 @@
 "use strict";
 
-import Node from "../../node";
+import { NonTerminalNode } from "occam-parsers";
 
 import { PROVISIONALLY } from "../../constants";
 import { isNodeTypeNode, isNodeVariableNode } from "../../utilities/node";
 
-export default class VariableDeclarationNode extends Node {
-  getTypeNode() {
-    let typeNode;
-
-    this.someChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        typeNode = childNode; ///
-
-        return true;
-      }
-    });
-
-    return typeNode;
-  }
-
+export default class VariableDeclarationNode extends NonTerminalNode {
   isProvisional() {
-    const provisional = this.fromSecondLastChildNode((secondLastChildNode) => {
-      let provisional = false;
+    let provisional = false;
 
-      const secondLastChildNodeTerminalNode = secondLastChildNode.isTerminalNode();
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
 
-      if (secondLastChildNodeTerminalNode) {
-        const terminalNode = secondLastChildNode, ///
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
               content = terminalNode.getContent(),
               contentProvisionally = (content === PROVISIONALLY);
 
         if (contentProvisionally) {
           provisional = true;
+
+          return true;
         }
       }
-
-      return provisional;
     });
 
     return provisional;
   }
 
-  getVariableNode() {
-    let variableNode;
+  getTypeNode() {
+    const typeNode = this.findChildNode((childNode) => {
+      const childNodeTypeNode = isNodeTypeNode(childNode);
 
-    this.someChildNode((childNode) => {
+      if (childNodeTypeNode) {
+        return true;
+      }
+    }) || null;
+
+    return typeNode;
+  }
+
+  getVariableNode() {
+    const variableNode = this.findChildNode((childNode) => {
       const childNodeVariableNode = isNodeVariableNode(childNode);
 
       if (childNodeVariableNode) {
-        variableNode = childNode; ///
-
         return true;
       }
-    });
+    }) || null;
 
     return variableNode;
   }
@@ -67,5 +59,5 @@ export default class VariableDeclarationNode extends Node {
     return variableName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(VariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class DeclarationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DeclarationNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode, isNodeMetavariableNode } from "../utilities/node";
+
+export default class DeclarationNode extends NonTerminalNode {
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  getMetavariableNode() {
+    const metavariableNode = this.findChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    }) || null;
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/deduction.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class DeductionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DeductionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode } from "../utilities/node";
+
+export default class DeductionNode extends NonTerminalNode {
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DeductionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/derivation.js

@@ -1,7 +1,22 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class DerivationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DerivationNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStepNode, isNodeSubproofNode } from "../utilities/node";
+
+export default class DerivationNode extends NonTerminalNode {
+  getStepOrSubproofNodes() {
+    const stepOrSubproofNodes = this.filterChildNode((childNode) => {
+      const childNodeStepNode = isNodeStepNode(childNode),
+            childNodeSubproofNode = isNodeSubproofNode(childNode);
+
+      if (childNodeStepNode || childNodeSubproofNode) {
+        return true;
+      }
+    });
+
+    return stepOrSubproofNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DerivationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/equality.js

@@ -1,7 +1,35 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class EqualityNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(EqualityNode, ruleName, childNodes, opacity, precedence); }
+export default class EqualityNode extends NonTerminalNode {
+  getLeftTermNode() {
+    let leftTermNode;
+
+    this.someChildNode((childNode, index) => {
+      if (index === 0) {
+        leftTermNode = childNode; ///
+
+        return true;
+      }
+    });
+
+    return leftTermNode;
+  }
+
+  getRightTermNode() {
+    let rightTermNode;
+
+    this.someChildNode((childNode, index) => {
+      if (index === 2) {
+        rightTermNode = childNode; ///
+
+        return true;
+      }
+    });
+
+    return rightTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(EqualityNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/error.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ErrorNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ErrorNode, ruleName, childNodes, opacity, precedence); }
+export default class ErrorNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ErrorNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/frame.js

@@ -1,7 +1,57 @@
 "use strict";
 
-import Node from "../node";
+import { arrayUtilities } from "necessary";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class FrameNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(FrameNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeDeclarationNode, isNodeMetavariableNode } from "../utilities/node";
+
+const { first } = arrayUtilities;
+
+export default class FrameNode extends NonTerminalNode {
+  getDeclarationNodes() {
+    const declarationNodes = this.filterChildNode((childNode) => {
+      const childNodeDeclarationNode = isNodeDeclarationNode(childNode);
+
+      if (childNodeDeclarationNode) {
+        return true;
+      }
+    });
+
+    return declarationNodes;
+  }
+
+  getMetavariableNodes() {
+    const metavariableNodes = this.filterChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    });
+
+    return metavariableNodes;
+  }
+
+  getSingularMetavariableNode() {
+    let singularMetavariableNode = null;
+
+    const metavariableNodes = this.filterChildNode((childNode) => {
+            const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+            if (!childNodeMetavariableNode) {
+              return true;
+            }
+          }),
+          metavariableNodesLength = metavariableNodes.length;
+
+    if (metavariableNodesLength === 1) {
+      const firstMetavariableNode = first(metavariableNodes);
+
+      singularMetavariableNode = firstMetavariableNode; ///
+    }
+
+    return singularMetavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/judgement.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class JudgementNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(JudgementNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeFrameNode, isNodeDeclarationNode } from "../utilities/node";
+
+export default class JudgementNode extends NonTerminalNode {
+  getFrameNode() {
+    const frameNode = this.findChildNode((childNode) => {
+      const childNodeFrameNode = isNodeFrameNode(childNode);
+
+      if (childNodeFrameNode) {
+        return true;
+      }
+    }) || null;
+
+    return frameNode;
+  }
+
+  getDeclarationNode() {
+    const declarationNode = this.findChildNode((childNode) => {
+      const childNodeDeclarationNode = isNodeDeclarationNode(childNode);
+
+      if (childNodeDeclarationNode) {
+        return true;
+      }
+    }) || null;
+
+    return declarationNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(JudgementNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/label.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class LabelNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(LabelNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeMetavariableNode } from "../utilities/node";
+
+export default class LabelNode extends NonTerminalNode {
+  getMetavariableNode() {
+    const metavariableNode = this.findChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    }) || null;
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LabelNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/labels.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-parsers";
+
+import { isNodeLabelNode } from "../utilities/node";
+
+export default class LabelsNode extends NonTerminalNode {
+  getLabelNodes() {
+    const labelNodes = this.filterChildNode((childNode) => {
+      const childNodeLabelNode = isNodeLabelNode(childNode);
+
+      if (childNodeLabelNode) {
+        return true;
+      }
+    });
+
+    return labelNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LabelsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/lemma.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
-export default class LemmaNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
+export default class LemmaNode extends TopLevelAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metaLemma.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
-export default class MetaLemmaNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
+export default class MetaLemmaNode extends TopLevelMetaAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metaType.js

@@ -1,19 +1,30 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
+
+export default class MetaTypeNode extends NonTerminalNode {
+  getTypeNode() {
+
+  }
 
-export default class MetaTypeNode extends Node {
   getMetaTypeName() {
-    const metaTypeName = this.fromFirstChildNode((firstChildNode) => {
-      const metaTypeTerminalNode = firstChildNode,  ///
-            content = metaTypeTerminalNode.getContent(),
-            metaTypeName = content; ///
+    let metaTypeName;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent();
+
+        metaTypeName = content; ///
 
-      return metaTypeName;
+        return true;
+      }
     });
 
     return metaTypeName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetaTypeNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaTypeNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metatheorem.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
-export default class MetatheoremNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
+export default class MetatheoremNode extends TopLevelMetaAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
 }