diff --git a/demo/test-cases.html b/demo/test-cases.html
index 244e2a3..2f9f02a 100644
--- a/demo/test-cases.html
+++ b/demo/test-cases.html
@@ -174,7 +174,7 @@ <h2>Standard Functions</h2>
           det(A) = |(a, b; c, d)| = ad - cd
         </test-case>
 
-        <test-case>a^(p-1) == 1   (mod p)</test-case>
+        <test-case display="block">a^(p-1) == 1  (mod p)</test-case>
       </section>
 
       <!-- prettier-ignore -->
diff --git a/docs/index.html b/docs/index.html
index d0ef629..1cd5717 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1470,6 +1470,13 @@ <h3>Spaces</h3>
             the height of the <i>‘x’</i> character in your font.
           </p>
 
+          <p>
+            In addition <code>(mod p)</code> will add 1.65 <span class="unit"
+              >ex</span
+            >
+            of space to the left of the open parenthesis.
+          </p>
+
           <aside class="examples">
             <ul>
               <li>
@@ -1479,6 +1486,11 @@ <h3>Spaces</h3>
                 </use-example>
               </li>
 
+              <li>
+                <!-- prettier-ignore -->
+                <use-example>a^(p-1) == 1  (mod p)</use-example>
+              </li>
+
               <li>
                 <!-- prettier-ignore -->
                 <use-example>
@@ -1635,10 +1647,10 @@ <h3>Sub and superscripts</h3>
           <h3>Fenced Groups</h3>
 
           <p>
-            We can use parentesis to group terms together. An any unicode open
+            We can use parenthesis to group terms together. An any unicode open
             parenthesis (unicode category <code>Ps</code>) starts a fence, and
             any closing parenthesis (category <code>Pe</code>) closes it. Note
-            that parentesis don’t have to match, but they do have to come in
+            that parenthesis don’t have to match, but they do have to come in
             open/close pairs.
           </p>
 
diff --git a/eslint.config.js b/eslint.config.js
index cd77496..bc15c45 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -106,6 +106,7 @@ export default [
       "no-throw-literal": "error",
       "no-unmodified-loop-condition": "error",
       "no-unused-expressions": "error",
+      "no-unused-vars": ["error", { varsIgnorePattern: "^_" }],
       "no-useless-backreference": "error",
       "no-useless-concat": "error",
       "no-useless-return": "error",
diff --git a/src/compiler/parser/handlers/group.js b/src/compiler/parser/handlers/group.js
index 4856e6e..1ac6447 100644
--- a/src/compiler/parser/handlers/group.js
+++ b/src/compiler/parser/handlers/group.js
@@ -3,11 +3,22 @@ import { addZeroLSpaceToOperator } from "../utils.js";
 import expr from "./expr.js";
 
 /**
+ * @typedef {import("../../tokenizer/index.js").Token} Token
  * @typedef {import("../index.js").Node} Node
  * @typedef {import("../index.js").FencedGroup} FencedGroup
  * @typedef {import("../index.js").MatrixGroup} MatrixGroup
  */
 
+/**
+ * @param {Token} token
+ * @returns {Omit<Token, "type">}
+ */
+function omitType(token) {
+  const { type: _type, ...rest } = token;
+
+  return rest;
+}
+
 /**
  * @param {import("../parse.js").State} state
  * @returns {{ node: FencedGroup | MatrixGroup, end: number }}
@@ -108,8 +119,8 @@ export default function group(state) {
   const close = token && token.type === "paren.close" ? token : null;
 
   const attrs = {
-    open: open.value,
-    close: (close && token.value) || "",
+    open: omitType(open),
+    close: close ? omitType(close) : null,
     seps,
   };
 
diff --git a/src/compiler/parser/handlers/group.test.js b/src/compiler/parser/handlers/group.test.js
index b570831..496043d 100644
--- a/src/compiler/parser/handlers/group.test.js
+++ b/src/compiler/parser/handlers/group.test.js
@@ -15,8 +15,8 @@ test("empty unfenced group", (t) => {
     type: "FencedGroup",
     items: [],
     attrs: {
-      open: "",
-      close: "",
+      open: { value: "" },
+      close: { value: "" },
       seps: [],
     },
   });
@@ -35,8 +35,8 @@ test("empty fenced group", (t) => {
     type: "FencedGroup",
     items: [],
     attrs: {
-      open: "(",
-      close: ")",
+      open: { value: "(" },
+      close: { value: ")" },
       seps: [],
     },
   });
@@ -52,8 +52,8 @@ test("empty unclosed group", (t) => {
     type: "FencedGroup",
     items: [],
     attrs: {
-      open: "",
-      close: "",
+      open: { value: "" },
+      close: null,
       seps: [],
     },
   });
@@ -74,8 +74,50 @@ test("group with one sep", (t) => {
     items: [[]],
     attrs: {
       seps: [","],
-      open: "",
-      close: "",
+      open: { value: "" },
+      close: { value: "" },
+    },
+  });
+});
+
+test("group with open attrs", (t) => {
+  const tokens = [
+    { type: "paren.open", value: "(", attrs: { foo: "bar" } },
+    { type: "sep.col", value: "," },
+    { type: "paren.close", value: "" },
+  ];
+
+  const { end, node } = group({ start: 0, tokens });
+
+  t.is(end, 3);
+  t.deepEqual(node, {
+    type: "FencedGroup",
+    items: [[]],
+    attrs: {
+      seps: [","],
+      open: { value: "(", attrs: { foo: "bar" } },
+      close: { value: "" },
+    },
+  });
+});
+
+test("group with close attrs", (t) => {
+  const tokens = [
+    { type: "paren.open", value: "" },
+    { type: "sep.col", value: "," },
+    { type: "paren.close", value: ")", attrs: { foo: "bar" } },
+  ];
+
+  const { end, node } = group({ start: 0, tokens });
+
+  t.is(end, 3);
+  t.deepEqual(node, {
+    type: "FencedGroup",
+    items: [[]],
+    attrs: {
+      seps: [","],
+      open: { value: "" },
+      close: { value: ")", attrs: { foo: "bar" } },
     },
   });
 });
@@ -94,8 +136,8 @@ test("unclosed group with one sep", (t) => {
     items: [[]],
     attrs: {
       seps: [","],
-      open: "foo",
-      close: "",
+      open: { value: "foo" },
+      close: null,
     },
   });
 });
@@ -117,8 +159,8 @@ test("group with multiple seps", (t) => {
   t.is(node.items[0].length, 0);
   t.is(node.items[1].length, 0);
   t.true(node.items[2].length > 0);
-  t.is(node.attrs.open, "");
-  t.is(node.attrs.close, "");
+  t.deepEqual(node.attrs.open, { value: "" });
+  t.deepEqual(node.attrs.close, { value: "" });
   t.deepEqual(node.attrs.seps, [",", ","]);
 });
 
@@ -138,8 +180,8 @@ test("unclosed group with multiple seps", (t) => {
   t.is(node.items[0].length, 0);
   t.is(node.items[1].length, 0);
   t.true(node.items[2].length > 0);
-  t.is(node.attrs.open, "");
-  t.is(node.attrs.close, "");
+  t.deepEqual(node.attrs.open, { value: "" });
+  t.is(node.attrs.close, null);
   t.deepEqual(node.attrs.seps, [",", ","]);
 });
 
@@ -160,8 +202,8 @@ test("ignores leading spaces", (t) => {
     items: [[]],
     attrs: {
       seps: [","],
-      open: "",
-      close: "",
+      open: { value: "" },
+      close: { value: "" },
     },
   });
 });
@@ -177,8 +219,8 @@ test("matrix groups", (t) => {
 
   t.is(end, 3);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "(");
-  t.is(node.attrs.close, ")");
+  t.deepEqual(node.attrs.open, { value: "(" });
+  t.deepEqual(node.attrs.close, { value: ")" });
   t.deepEqual(node.items, [[[]]]);
 });
 
@@ -199,8 +241,8 @@ test("matrix groups with items", (t) => {
 
   t.is(end, 9);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "(");
-  t.is(node.attrs.close, ")");
+  t.deepEqual(node.attrs.open, { value: "(" });
+  t.deepEqual(node.attrs.close, { value: ")" });
   t.is(node.items.length, 2);
   t.is(node.items[0].length, 2);
   t.is(node.items[1].length, 2);
@@ -220,8 +262,8 @@ test("unclosed matrix with one sep", (t) => {
 
   t.true(end >= 2);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "foo");
-  t.is(node.attrs.close, "");
+  t.deepEqual(node.attrs.open, { value: "foo" });
+  t.is(node.attrs.close, null);
   t.deepEqual(node.items, [[[]]]);
 });
 
@@ -240,8 +282,8 @@ test("sparce matrix groups", (t) => {
 
   t.is(end, 7);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "(");
-  t.is(node.attrs.close, ")");
+  t.deepEqual(node.attrs.open, { value: "(" });
+  t.deepEqual(node.attrs.close, { value: ")" });
   t.is(node.items.length, 2);
   t.is(node.items[0].length, 2);
   t.is(node.items[1].length, 1);
@@ -264,8 +306,8 @@ test("single line matrix groups", (t) => {
 
   t.is(end, 6);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "(");
-  t.is(node.attrs.close, ")");
+  t.deepEqual(node.attrs.open, { value: "(" });
+  t.deepEqual(node.attrs.close, { value: ")" });
   t.is(node.items.length, 1);
   t.is(node.items[0].length, 2);
   t.true(node.items[0][0].length > 0);
@@ -285,8 +327,8 @@ test("unclosed matrix groups", (t) => {
 
   t.true(end >= 5);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "(");
-  t.is(node.attrs.close, "");
+  t.deepEqual(node.attrs.open, { value: "(" });
+  t.is(node.attrs.close, null);
   t.is(node.items.length, 1);
   t.is(node.items[0].length, 2);
   t.true(node.items[0][0].length > 0);
@@ -308,7 +350,7 @@ test("ignores leading spaces in matrix groups", (t) => {
 
   t.is(end, 7);
   t.is(node.type, "MatrixGroup");
-  t.is(node.attrs.open, "");
-  t.is(node.attrs.close, "");
+  t.deepEqual(node.attrs.open, { value: "" });
+  t.deepEqual(node.attrs.close, { value: "" });
   t.deepEqual(node.items, [[[], []]]);
 });
diff --git a/src/compiler/parser/handlers/infix.test.js b/src/compiler/parser/handlers/infix.test.js
index 5852aed..a1a8a62 100644
--- a/src/compiler/parser/handlers/infix.test.js
+++ b/src/compiler/parser/handlers/infix.test.js
@@ -534,8 +534,8 @@ test("but keeps a singleton exponent in fences", (t) => {
   t.is(node.items.length, 2);
   t.is(node.items[0].value, "a");
   t.is(node.items[1].type, "FencedGroup");
-  t.is(node.items[1].attrs.open, "(");
-  t.is(node.items[1].attrs.close, ")");
+  t.is(node.items[1].attrs.open.value, "(");
+  t.is(node.items[1].attrs.close.value, ")");
 });
 
 test("but keeps multi-celled in fences", (t) => {
@@ -559,8 +559,8 @@ test("but keeps multi-celled in fences", (t) => {
   t.is(node.items.length, 2);
   t.is(node.items[0].value, "a");
   t.is(node.items[1].type, "FencedGroup");
-  t.is(node.items[1].attrs.open, "(");
-  t.is(node.items[1].attrs.close, ")");
+  t.is(node.items[1].attrs.open.value, "(");
+  t.is(node.items[1].attrs.close.value, ")");
 });
 
 test("chains sub sup into subsup ternary", (t) => {
diff --git a/src/compiler/parser/index.js b/src/compiler/parser/index.js
index 96ad6e8..230102a 100644
--- a/src/compiler/parser/index.js
+++ b/src/compiler/parser/index.js
@@ -1,12 +1,12 @@
 /**
- * @typedef {object} GroupAttrs
- * @property {string} open
- * @property {string} close
- * @property {string[]} seps
+ * @typedef {Record<string, string | boolean | number | null | undefined>} LiteralAttrs
  */
 
 /**
- * @typedef {Record<string, string | boolean | number | null | undefined>} LiteralAttrs
+ * @typedef {object} GroupAttrs
+ * @property {{ value: string, attrs?: LiteralAttrs }} open
+ * @property {{ value: string, attrs?: LiteralAttrs } | null} close
+ * @property {string[]} seps
  */
 
 /**
diff --git a/src/compiler/tokenizer/index.js b/src/compiler/tokenizer/index.js
index de2e25a..ab2b6d4 100644
--- a/src/compiler/tokenizer/index.js
+++ b/src/compiler/tokenizer/index.js
@@ -23,6 +23,7 @@ import scanners, { unhandled } from "./scanners/index.js";
  * @property {string} [name]
  * @property {boolean} [split]
  * @property {Record<string, string | number | boolean | null | undefined>} [attrs]
+ * @property {Token[]} [extraTokensAfter]
  *
  * @typedef {object} State
  * @property {number} start
@@ -67,10 +68,13 @@ export default function createTokenizer(options) {
     let nestLevel = 0;
 
     while (pos < input.length) {
-      const { type, value, end, split, ...attrs } = nextToken(input, {
-        start: pos,
-        grouping: nestLevel > 0,
-      });
+      const { type, value, end, split, extraTokensAfter, ...attrs } = nextToken(
+        input,
+        {
+          start: pos,
+          grouping: nestLevel > 0,
+        },
+      );
 
       if (split) {
         let char = "";
@@ -104,6 +108,12 @@ export default function createTokenizer(options) {
         };
       }
 
+      if (extraTokensAfter) {
+        for (const token of extraTokensAfter) {
+          yield token;
+        }
+      }
+
       pos = end;
 
       if (type === "paren.open") {
diff --git a/src/compiler/tokenizer/index.test.js b/src/compiler/tokenizer/index.test.js
index c784566..721d515 100644
--- a/src/compiler/tokenizer/index.test.js
+++ b/src/compiler/tokenizer/index.test.js
@@ -65,3 +65,22 @@ test("operators", (t) => {
     ],
   );
 });
+
+test("extra tokens after", (t) => {
+  const tokenize = tokenizer(options);
+  const tokens = tokenize("(mod");
+
+  t.deepEqual(tokens.next().value, {
+    type: "paren.open",
+    value: "(",
+    attrs: { lspace: "1.65ex" },
+  });
+
+  t.deepEqual(tokens.next().value, {
+    type: "operator",
+    value: "mod",
+    attrs: { lspace: 0 },
+  });
+
+  t.is(tokens.next().done, true);
+});
diff --git a/src/compiler/tokenizer/lexemes.js b/src/compiler/tokenizer/lexemes.js
index 17b35ae..3360e7f 100644
--- a/src/compiler/tokenizer/lexemes.js
+++ b/src/compiler/tokenizer/lexemes.js
@@ -1,4 +1,7 @@
-/** @typedef {(char: string) => boolean} LeximeTest */
+/**
+ * @typedef {import("./index.js").Token} Token
+ * @typedef {(char: string) => boolean} LeximeTest
+ */
 
 const LETTER_RE = /^\p{L}/u;
 
@@ -248,6 +251,7 @@ export const KNOWN_OPS = new Map([
   ["~~", { value: "≈" }],
 ]);
 
+/** @type {Map<string, Omit<Token, "type">>} */
 export const KNOWN_PARENS_OPEN = new Map([
   ["(:", { value: "⟨" }],
   ["<<", { value: "⟨" }],
@@ -256,6 +260,16 @@ export const KNOWN_PARENS_OPEN = new Map([
   ["|__", { value: "⌊" }],
   ["||(", { value: "‖" }],
   ["|~", { value: "⌈" }],
+  [
+    "(mod",
+    {
+      value: "(",
+      attrs: { lspace: "1.65ex" },
+      extraTokensAfter: [
+        { type: "operator", value: "mod", attrs: { lspace: 0 } },
+      ],
+    },
+  ],
 ]);
 
 export const KNOWN_PARENS_CLOSE = new Map([
diff --git a/src/compiler/tokenizer/scanners/paren-open.js b/src/compiler/tokenizer/scanners/paren-open.js
index cca4679..12a704b 100644
--- a/src/compiler/tokenizer/scanners/paren-open.js
+++ b/src/compiler/tokenizer/scanners/paren-open.js
@@ -42,8 +42,8 @@ export default function parenOpenScanner(char, input, { start }) {
 
   if (known) {
     return {
+      ...known,
       type: "paren.open",
-      value: known.value,
       end: start + value.length,
     };
   }
@@ -51,7 +51,7 @@ export default function parenOpenScanner(char, input, { start }) {
   if (isPunctOpen(char)) {
     return {
       type: "paren.open",
-      value,
+      value: char,
       end: start + char.length,
     };
   }
diff --git a/src/compiler/tokenizer/scanners/paren-open.test.js b/src/compiler/tokenizer/scanners/paren-open.test.js
index 1b3a36c..1639297 100644
--- a/src/compiler/tokenizer/scanners/paren-open.test.js
+++ b/src/compiler/tokenizer/scanners/paren-open.test.js
@@ -43,3 +43,23 @@ test("paren open is also an operator", (t) => {
 test("paren close is also an operator", (t) => {
   t.is(parenOpen(">", ">>>", { start: 0 }), null);
 });
+
+test("modulus operator", (t) => {
+  t.deepEqual(parenOpen("(", "(mod", { start: 0 }), {
+    type: "paren.open",
+    value: "(",
+    attrs: { lspace: "1.65ex" },
+    extraTokensAfter: [
+      { type: "operator", value: "mod", attrs: { lspace: 0 } },
+    ],
+    end: 4,
+  });
+});
+
+test("almost modulus operator", (t) => {
+  t.deepEqual(parenOpen("(", "(mo d", { start: 0 }), {
+    type: "paren.open",
+    value: "(",
+    end: 1,
+  });
+});
diff --git a/src/compiler/transformer/transforms/fenced-group.js b/src/compiler/transformer/transforms/fenced-group.js
index c16dfc7..3180a83 100644
--- a/src/compiler/transformer/transforms/fenced-group.js
+++ b/src/compiler/transformer/transforms/fenced-group.js
@@ -44,17 +44,18 @@ export default function fencedGroup(node, transform) {
 
   const { open, close } = node.attrs;
 
-  if (cols && !open && !close) {
+  if (cols && !open.value && !close?.value) {
     return cols;
   }
 
   const childNodes = [];
 
-  if (open) {
+  if (open.value) {
     childNodes.push({
       tag: "mo",
-      textContent: open,
+      textContent: open.value,
       attrs: {
+        ...open.attrs,
         fence: "true",
       },
     });
@@ -66,11 +67,12 @@ export default function fencedGroup(node, transform) {
     childNodes.push(cols);
   }
 
-  if (node.attrs.close) {
+  if (close?.value) {
     childNodes.push({
       tag: "mo",
-      textContent: node.attrs.close,
+      textContent: close.value,
       attrs: {
+        ...close.attrs,
         fence: "true",
       },
     });
diff --git a/src/compiler/transformer/transforms/matrix-group.js b/src/compiler/transformer/transforms/matrix-group.js
index 1356948..2d1a17f 100644
--- a/src/compiler/transformer/transforms/matrix-group.js
+++ b/src/compiler/transformer/transforms/matrix-group.js
@@ -21,16 +21,19 @@ export default function matrixGroup(node, transform) {
     0,
   );
 
+  const { open, close } = node.attrs;
+
   // auto start-align tables with no close param.
-  const aligns = !node.attrs.close
+  const aligns = !close?.value
     ? Array.from({ length: colCount }).fill("start")
     : [];
 
-  if (node.attrs.open) {
+  if (open.value) {
     childNodes.push({
       tag: "mo",
-      textContent: node.attrs.open,
+      textContent: open.value,
       attrs: {
+        ...open.attrs,
         fence: "true",
       },
     });
@@ -48,11 +51,12 @@ export default function matrixGroup(node, transform) {
     })),
   });
 
-  if (node.attrs.close) {
+  if (close?.value) {
     childNodes.push({
       tag: "mo",
-      textContent: node.attrs.close,
+      textContent: close.value,
       attrs: {
+        ...close.attrs,
         fence: "true",
       },
     });
diff --git a/test/snapshots/standard-functions.js.md b/test/snapshots/standard-functions.js.md
index b61e62f..f75154e 100644
--- a/test/snapshots/standard-functions.js.md
+++ b/test/snapshots/standard-functions.js.md
@@ -44,4 +44,4 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    '<math><msup><mi>a</mi><mrow><mi>p</mi><mo>−</mo><mn>1</mn></mrow></msup><mo>≡</mo><mn>1</mn><mspace width="0.7ex" /><mrow><mo fence="true">(</mo><mrow><mo lspace="0">mod</mo><mi>p</mi></mrow><mo fence="true">)</mo></mrow></math>'
+    '<math><msup><mi>a</mi><mrow><mi>p</mi><mo>−</mo><mn>1</mn></mrow></msup><mo>≡</mo><mn>1</mn><mspace width="0.35ex" /><mrow><mo lspace="1.65ex" fence="true">(</mo><mrow><mo lspace="0">mod</mo><mi>p</mi></mrow><mo fence="true">)</mo></mrow></math>'
diff --git a/test/snapshots/standard-functions.js.snap b/test/snapshots/standard-functions.js.snap
index 3728b4d..f47e030 100644
Binary files a/test/snapshots/standard-functions.js.snap and b/test/snapshots/standard-functions.js.snap differ
diff --git a/test/standard-functions.js b/test/standard-functions.js
index 993caa5..f1258da 100644
--- a/test/standard-functions.js
+++ b/test/standard-functions.js
@@ -41,5 +41,5 @@ test("2×2 determinants", (t) => {
 });
 
 test("Fermats little theorem", (t) => {
-  t.snapshot(render("a^ p-1 == 1   (mod p)"));
+  t.snapshot(render("a^(p-1) == 1  (mod p)"));
 });