diff --git a/src/Parser.js b/src/Parser.js
index e43a8a2a..541a2b5d 100644
--- a/src/Parser.js
+++ b/src/Parser.js
@@ -240,13 +240,13 @@ export default class Parser {
             if (numerBody.length === 1 && numerBody[0].type === "ordgroup") {
                 numerNode = numerBody[0];
             } else {
-                numerNode = {type: "ordgroup", mode: this.mode, value: numerBody};
+                numerNode = {type: "ordgroup", mode: this.mode, body: numerBody};
             }
 
             if (denomBody.length === 1 && denomBody[0].type === "ordgroup") {
                 denomNode = denomBody[0];
             } else {
-                denomNode = {type: "ordgroup", mode: this.mode, value: denomBody};
+                denomNode = {type: "ordgroup", mode: this.mode, body: denomBody};
             }
 
             let node;
@@ -404,7 +404,7 @@ export default class Parser {
                     primes.push(this.handleSupSubscript("superscript"));
                 }
                 // Put everything into an ordgroup as the superscript
-                superscript = {type: "ordgroup", mode: this.mode, value: primes};
+                superscript = {type: "ordgroup", mode: this.mode, body: primes};
             } else {
                 // If it wasn't ^, _, or ', stop parsing super/subscripts
                 break;
@@ -832,7 +832,7 @@ export default class Parser {
                 type: "ordgroup",
                 mode: this.mode,
                 loc: SourceLocation.range(firstToken, lastToken),
-                value: expression,
+                body: expression,
             }, firstToken.range(lastToken, firstToken.text));
         } else {
             // Otherwise, just return a nucleus, or nothing for an optional group
diff --git a/src/defineFunction.js b/src/defineFunction.js
index 65d8f269..58fb4985 100644
--- a/src/defineFunction.js
+++ b/src/defineFunction.js
@@ -241,5 +241,5 @@ export function defineFunctionBuilders<NODETYPE: NodeType>({
 // list of elements, we normalize for different kinds of arguments
 export const ordargument = function(arg: AnyParseNode): AnyParseNode[] {
     const node = checkNodeType(arg, "ordgroup");
-    return node ? node.value : [arg];
+    return node ? node.body : [arg];
 };
diff --git a/src/environments/array.js b/src/environments/array.js
index 7aed466f..43ff075c 100644
--- a/src/environments/array.js
+++ b/src/environments/array.js
@@ -87,7 +87,7 @@ function parseArray(
         cell = {
             type: "ordgroup",
             mode: parser.mode,
-            value: cell,
+            body: cell,
         };
         if (style) {
             cell = {
@@ -106,7 +106,7 @@ function parseArray(
             // the last line is empty.
             // NOTE: Currently, `cell` is the last item added into `row`.
             if (row.length === 1 && cell.type === "styling" &&
-                cell.body[0].value.length === 0) {
+                cell.body[0].body.length === 0) {
                 body.pop();
             }
             if (hLinesBeforeRow.length < body.length + 1) {
@@ -400,13 +400,13 @@ const alignedHandler = function(context, args) {
     const emptyGroup = {
         type: "ordgroup",
         mode: context.mode,
-        value: [],
+        body: [],
     };
     const ordgroup = checkNodeType(args[0], "ordgroup");
     if (ordgroup) {
         let arg0 = "";
-        for (let i = 0; i < ordgroup.value.length; i++) {
-            const textord = assertNodeType(ordgroup.value[i], "textord");
+        for (let i = 0; i < ordgroup.body.length; i++) {
+            const textord = assertNodeType(ordgroup.body[i], "textord");
             arg0 += textord.text;
         }
         numMaths = Number(arg0);
@@ -418,7 +418,7 @@ const alignedHandler = function(context, args) {
             // Modify ordgroup node within styling node
             const styling = assertNodeType(row[i], "styling");
             const ordgroup = assertNodeType(styling.body[0], "ordgroup");
-            ordgroup.value.unshift(emptyGroup);
+            ordgroup.body.unshift(emptyGroup);
         }
         if (!isAligned) { // Case 1
             const curMaths = row.length / 2;
@@ -471,7 +471,7 @@ defineEnvironment({
         // - The argument is a bare symbol node.
         const symNode = checkSymbolNodeType(args[0]);
         const colalign: AnyParseNode[] =
-            symNode ? [args[0]] : assertNodeType(args[0], "ordgroup").value;
+            symNode ? [args[0]] : assertNodeType(args[0], "ordgroup").body;
         const cols = colalign.map(function(nde) {
             const node = assertSymbolNodeType(nde);
             const ca = node.text;
diff --git a/src/functions/char.js b/src/functions/char.js
index 3cd610fd..ed1e413b 100644
--- a/src/functions/char.js
+++ b/src/functions/char.js
@@ -15,7 +15,7 @@ defineFunction({
     },
     handler({parser}, args) {
         const arg = assertNodeType(args[0], "ordgroup");
-        const group = arg.value;
+        const group = arg.body;
         let number = "";
         for (let i = 0; i < group.length; i++) {
             const node = assertNodeType(group[i], "textord");
diff --git a/src/functions/environment.js b/src/functions/environment.js
index e9b09e1e..fdfbd3d9 100644
--- a/src/functions/environment.js
+++ b/src/functions/environment.js
@@ -18,8 +18,8 @@ defineFunction({
             throw new ParseError("Invalid environment name", nameGroup);
         }
         let name = "";
-        for (let i = 0; i < nameGroup.value.length; ++i) {
-            name += assertNodeType(nameGroup.value[i], "textord").text;
+        for (let i = 0; i < nameGroup.body.length; ++i) {
+            name += assertNodeType(nameGroup.body[i], "textord").text;
         }
         return {
             type: "environment",
diff --git a/src/functions/font.js b/src/functions/font.js
index 6de010e4..2ffe0b99 100644
--- a/src/functions/font.js
+++ b/src/functions/font.js
@@ -110,7 +110,7 @@ defineFunction({
             body: {
                 type: "ordgroup",
                 mode: parser.mode,
-                value: body,
+                body,
             },
         };
     },
diff --git a/src/functions/genfrac.js b/src/functions/genfrac.js
index 6a1e6d46..05142624 100644
--- a/src/functions/genfrac.js
+++ b/src/functions/genfrac.js
@@ -365,7 +365,7 @@ defineFunction({
         // Look into the parse nodes to get the desired delimiters.
         let leftNode = checkNodeType(args[0], "ordgroup");
         if (leftNode) {
-            leftNode = assertAtomFamily(leftNode.value[0], "open");
+            leftNode = assertAtomFamily(leftNode.body[0], "open");
         } else {
             leftNode = assertAtomFamily(args[0], "open");
         }
@@ -373,7 +373,7 @@ defineFunction({
 
         let rightNode = checkNodeType(args[1], "ordgroup");
         if (rightNode) {
-            rightNode = assertAtomFamily(rightNode.value[0], "close");
+            rightNode = assertAtomFamily(rightNode.body[0], "close");
         } else {
             rightNode = assertAtomFamily(args[1], "close");
         }
@@ -396,8 +396,8 @@ defineFunction({
         let size = "auto";
         let styl = checkNodeType(args[3], "ordgroup");
         if (styl) {
-            if (styl.value.length > 0) {
-                const textOrd = assertNodeType(styl.value[0], "textord");
+            if (styl.body.length > 0) {
+                const textOrd = assertNodeType(styl.body[0], "textord");
                 size = stylArray[Number(textOrd.text)];
             }
         } else {
diff --git a/src/functions/mclass.js b/src/functions/mclass.js
index 04fe4436..4f42d01b 100644
--- a/src/functions/mclass.js
+++ b/src/functions/mclass.js
@@ -49,7 +49,7 @@ export const binrelClass = (arg: AnyParseNode): string => {
     // (by rendering separately and with {}s before and after, and measuring
     // the change in spacing).  We'll do roughly the same by detecting the
     // atom type directly.
-    const atom = (arg.type === "ordgroup" && arg.value.length ? arg.value[0] : arg);
+    const atom = (arg.type === "ordgroup" && arg.body.length ? arg.body[0] : arg);
     if (atom.type === "atom" && (atom.family === "bin" || atom.family === "rel")) {
         return "m" + atom.family;
     } else {
diff --git a/src/functions/ordgroup.js b/src/functions/ordgroup.js
index 08942e95..ce56dd0d 100644
--- a/src/functions/ordgroup.js
+++ b/src/functions/ordgroup.js
@@ -9,10 +9,10 @@ defineFunctionBuilders({
     type: "ordgroup",
     htmlBuilder(group, options) {
         return buildCommon.makeSpan(
-            ["mord"], html.buildExpression(group.value, options, true), options);
+            ["mord"], html.buildExpression(group.body, options, true), options);
     },
     mathmlBuilder(group, options) {
-        return mml.buildExpressionRow(group.value, options);
+        return mml.buildExpressionRow(group.body, options);
     },
 });
 
diff --git a/src/functions/smash.js b/src/functions/smash.js
index ac112cd8..ae85d166 100644
--- a/src/functions/smash.js
+++ b/src/functions/smash.js
@@ -25,8 +25,8 @@ defineFunction({
             // ref: amsmath: \renewcommand{\smash}[1][tb]{%
             //               def\mb@t{\ht}\def\mb@b{\dp}\def\mb@tb{\ht\z@\z@\dp}%
             let letter = "";
-            for (let i = 0; i < tbArg.value.length; ++i) {
-                const node = tbArg.value[i];
+            for (let i = 0; i < tbArg.body.length; ++i) {
+                const node = tbArg.body[i];
                 // $FlowFixMe: Not every node type has a `text` property.
                 letter = node.text;
                 if (letter === "t") {
diff --git a/src/parseNode.js b/src/parseNode.js
index 2809c80a..684999d0 100644
--- a/src/parseNode.js
+++ b/src/parseNode.js
@@ -78,7 +78,7 @@ type ParseNodeTypes = {
         type: "ordgroup",
         mode: Mode,
         loc?: ?SourceLocation,
-        value: AnyParseNode[],
+        body: AnyParseNode[],
     |},
     "size": {|
         type: "size",
diff --git a/src/stretchy.js b/src/stretchy.js
index 94063bc0..7d16122b 100644
--- a/src/stretchy.js
+++ b/src/stretchy.js
@@ -162,7 +162,7 @@ const katexImagesData: {
 
 const groupLength = function(arg: AnyParseNode): number {
     if (arg.type === "ordgroup") {
-        return arg.value.length;
+        return arg.body.length;
     } else {
         return 1;
     }
diff --git a/src/utils.js b/src/utils.js
index cc4edfae..015345ba 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -98,8 +98,8 @@ function clearNode(node: Node) {
  */
 const getBaseElem = function(group: AnyParseNode): AnyParseNode {
     if (group.type === "ordgroup") {
-        if (group.value.length === 1) {
-            return getBaseElem(group.value[0]);
+        if (group.body.length === 1) {
+            return getBaseElem(group.body[0]);
         } else {
             return group;
         }
diff --git a/test/__snapshots__/katex-spec.js.snap b/test/__snapshots__/katex-spec.js.snap
index 3855200a..7a4197cc 100755
--- a/test/__snapshots__/katex-spec.js.snap
+++ b/test/__snapshots__/katex-spec.js.snap
@@ -12,8 +12,7 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
           "body": [
             {
               "type": "ordgroup",
-              "mode": "math",
-              "value": [
+              "body": [
                 {
                   "type": "mathord",
                   "loc": {
@@ -27,7 +26,8 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
                   "mode": "math",
                   "text": "a"
                 }
-              ]
+              ],
+              "mode": "math"
             }
           ],
           "mode": "math",
@@ -38,8 +38,7 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
           "body": [
             {
               "type": "ordgroup",
-              "mode": "math",
-              "value": [
+              "body": [
                 {
                   "type": "mathord",
                   "loc": {
@@ -53,7 +52,8 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
                   "mode": "math",
                   "text": "b"
                 }
-              ]
+              ],
+              "mode": "math"
             }
           ],
           "mode": "math",
@@ -66,8 +66,7 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
           "body": [
             {
               "type": "ordgroup",
-              "mode": "math",
-              "value": [
+              "body": [
                 {
                   "type": "mathord",
                   "loc": {
@@ -81,7 +80,8 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
                   "mode": "math",
                   "text": "c"
                 }
-              ]
+              ],
+              "mode": "math"
             }
           ],
           "mode": "math",
@@ -92,8 +92,7 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
           "body": [
             {
               "type": "ordgroup",
-              "mode": "math",
-              "value": [
+              "body": [
                 {
                   "type": "mathord",
                   "loc": {
@@ -107,7 +106,8 @@ exports[`A begin/end parser should grab \\arraystretch 1`] = `
                   "mode": "math",
                   "text": "d"
                 }
-              ]
+              ],
+              "mode": "math"
             }
           ],
           "mode": "math",
@@ -630,19 +630,18 @@ exports[`An implicit group parser within optional groups should work style comma
     "type": "sqrt",
     "body": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "mathord",
           "mode": "math",
           "text": "x"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "index": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "styling",
           "body": [
@@ -655,7 +654,8 @@ exports[`An implicit group parser within optional groups should work style comma
           "mode": "math",
           "style": "text"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "mode": "math"
   }
@@ -668,19 +668,18 @@ exports[`An implicit group parser within optional groups should work with \\colo
     "type": "sqrt",
     "body": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "mathord",
           "mode": "math",
           "text": "x"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "index": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "color",
           "body": [
@@ -693,7 +692,8 @@ exports[`An implicit group parser within optional groups should work with \\colo
           "color": "red",
           "mode": "math"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "mode": "math"
   }
@@ -706,36 +706,36 @@ exports[`An implicit group parser within optional groups should work with old fo
     "type": "sqrt",
     "body": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "mathord",
           "mode": "math",
           "text": "x"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "index": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "font",
           "body": {
             "type": "ordgroup",
-            "mode": "math",
-            "value": [
+            "body": [
               {
                 "type": "textord",
                 "mode": "math",
                 "text": "3"
               }
-            ]
+            ],
+            "mode": "math"
           },
           "font": "mathtt",
           "mode": "math"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "mode": "math"
   }
@@ -748,19 +748,18 @@ exports[`An implicit group parser within optional groups should work with sizing
     "type": "sqrt",
     "body": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "mathord",
           "mode": "math",
           "text": "x"
         }
-      ]
+      ],
+      "mode": "math"
     },
     "index": {
       "type": "ordgroup",
-      "mode": "math",
-      "value": [
+      "body": [
         {
           "type": "sizing",
           "body": [
@@ -773,7 +772,8 @@ exports[`An implicit group parser within optional groups should work with sizing
           "mode": "math",
           "size": 5
         }
-      ]
+      ],
+      "mode": "math"
     },
     "mode": "math"
   }
diff --git a/test/katex-spec.js b/test/katex-spec.js
index 1037cbf4..ffe4117c 100644
--- a/test/katex-spec.js
+++ b/test/katex-spec.js
@@ -325,7 +325,7 @@ describe("A group parser", function() {
         const ord = parse[0];
 
         expect(ord.type).toMatch("ord");
-        expect(ord.value).toBeTruthy();
+        expect(ord.body).toBeTruthy();
     });
 });
 
@@ -362,7 +362,7 @@ describe("An implicit group parser", function() {
         const parse = getParsed`a { b \Large c } d`;
 
         const group = parse[1];
-        const sizing = group.value[1];
+        const sizing = group.body[1];
 
         expect(sizing.type).toEqual("sizing");
         expect(sizing.body).toHaveLength(1);
@@ -552,14 +552,14 @@ describe("An over/brace/brack parser", function() {
         const parse = getParsed(complexOver)[0];
 
         const numer = parse.numer;
-        expect(numer.value).toHaveLength(4);
+        expect(numer.body).toHaveLength(4);
     });
 
     it("should create a demonimator from the atoms after \\over", function() {
         const parse = getParsed(complexOver)[0];
 
         const denom = parse.numer;
-        expect(denom.value).toHaveLength(4);
+        expect(denom.body).toHaveLength(4);
     });
 
     it("should handle empty numerators", function() {
@@ -582,7 +582,7 @@ describe("An over/brace/brack parser", function() {
         const displaystyleExpression = r`\displaystyle 1 \over 2`;
         const parse = getParsed(displaystyleExpression)[0];
         expect(parse.type).toEqual("genfrac");
-        expect(parse.numer.value[0].type).toEqual("styling");
+        expect(parse.numer.body[0].type).toEqual("styling");
         expect(parse.denom).toBeDefined();
     });
 
@@ -595,11 +595,11 @@ describe("An over/brace/brack parser", function() {
         const nestedOverExpression = r`{1 \over 2} \over 3`;
         const parse = getParsed(nestedOverExpression)[0];
         expect(parse.type).toEqual("genfrac");
-        expect(parse.numer.value[0].type).toEqual("genfrac");
-        expect(parse.numer.value[0].numer.value[0].text).toEqual("1");
-        expect(parse.numer.value[0].denom.value[0].text).toEqual("2");
+        expect(parse.numer.body[0].type).toEqual("genfrac");
+        expect(parse.numer.body[0].numer.body[0].text).toEqual("1");
+        expect(parse.numer.body[0].denom.body[0].text).toEqual("2");
         expect(parse.denom).toBeDefined();
-        expect(parse.denom.value[0].text).toEqual("3");
+        expect(parse.denom.body[0].text).toEqual("3");
     });
 
     it("should fail with multiple overs in the same group", function() {
@@ -1467,7 +1467,7 @@ describe("A style change parser", function() {
         const text = r`a b { c d \displaystyle e f } g h`;
         const parse = getParsed(text);
 
-        const displayNode = parse[2].value[2];
+        const displayNode = parse[2].body[2];
 
         expect(displayNode.type).toEqual("styling");
 
@@ -1520,7 +1520,7 @@ describe("A font parser", function() {
         expect(nestedParse.font).toEqual("mathbb");
         expect(nestedParse.type).toEqual("font");
 
-        const bbBody = nestedParse.body.value;
+        const bbBody = nestedParse.body.body;
         expect(bbBody).toHaveLength(3);
         expect(bbBody[0].type).toEqual("mathord");
         expect(bbBody[2].type).toEqual("font");
@@ -1546,11 +1546,11 @@ describe("A font parser", function() {
         const bf = getParsed`\mathbf{a\mathrm{b}c}`[0];
         expect(bf.type).toEqual("font");
         expect(bf.font).toEqual("mathbf");
-        expect(bf.body.value).toHaveLength(3);
-        expect(bf.body.value[0].text).toEqual("a");
-        expect(bf.body.value[1].type).toEqual("font");
-        expect(bf.body.value[1].font).toEqual("mathrm");
-        expect(bf.body.value[2].text).toEqual("c");
+        expect(bf.body.body).toHaveLength(3);
+        expect(bf.body.body[0].text).toEqual("a");
+        expect(bf.body.body[1].type).toEqual("font");
+        expect(bf.body.body[1].font).toEqual("mathrm");
+        expect(bf.body.body[2].text).toEqual("c");
     });
 
     it("should have the correct greediness", function() {