diff --git a/test/index.js b/test/index.js
index 06b8404..7d2357f 100644
--- a/test/index.js
+++ b/test/index.js
@@ -7,7 +7,7 @@ import '../x-template.js';
 
 // Set a high bar for code coverage!
 coverage(new URL('../x-element.js', import.meta.url).href, 100);
-coverage(new URL('../x-parser.js', import.meta.url).href, 97); // TODO: Get back to 100%!
+coverage(new URL('../x-parser.js', import.meta.url).href, 100);
 coverage(new URL('../x-template.js', import.meta.url).href, 100);
 
 test('./test-parser.html');
diff --git a/test/test-parser.js b/test/test-parser.js
index ea048be..ab175a2 100644
--- a/test/test-parser.js
+++ b/test/test-parser.js
@@ -699,93 +699,69 @@ describe('odds and ends', () => {
 });
 
 describe('errors', () => {
-  it('throws when initial markup cannot be parsed', () => {
-    const callback = () => htmlol`<`;
-    const expectedMessage = '[#100]';
-    assertThrows(callback, expectedMessage, { startsWith: true });
-  });
-
-  it('throws when markup after text cannot be parsed', () => {
-    const callback = () => htmlol`text<`;
-    const expectedMessage = '[#101]';
-    assertThrows(callback, expectedMessage, { startsWith: true });
-  });
-
-  it('throws when markup after comment cannot be parsed', () => {
-    const callback = () => htmlol`<!--comment--><`;
-    const expectedMessage = '[#102]';
-    assertThrows(callback, expectedMessage, { startsWith: true });
-  });
-
-  it('throws when markup after content interpolation cannot be parsed', () => {
-    const callback = () => htmlol`${VALUE}<`;
-    const expectedMessage = '[#103]';
-    assertThrows(callback, expectedMessage, { startsWith: true });
-  });
-
-  it('throws when markup after start tag cannot be parsed', () => {
-    const callback = () => htmlol`<div><`;
-    const expectedMessage = '[#106]';
-    assertThrows(callback, expectedMessage, { startsWith: true });
-  });
-
   it('throws when markup after end tag cannot be parsed', () => {
     const callback = () => htmlol`<div></div><`;
-    const expectedMessage = '[#114]';
+    const expectedMessage = '[#110]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws when attempting non-trivial interpolation of a textarea tag (preceding space)', () => {
     const callback = () => html`<textarea id="target"> ${VALUE}</textarea>`;
-    const expectedMessage = '[#156]';
+    const expectedMessage = '[#155]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws when attempting non-trivial interpolation of a textarea tag (succeeding space)', () => {
     const callback = () => html`<textarea id="target">${VALUE} </textarea>`;
-    const expectedMessage = '[#156]';
+    const expectedMessage = '[#155]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws when attempting non-trivial interpolation of a textarea tag', () => {
     const callback = () => html`<textarea id="target">please ${VALUE} no</textarea>`;
-    const expectedMessage = '[#156]';
+    const expectedMessage = '[#155]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws when attempting non-trivial interpolation of a textarea tag via nesting', () => {
     const callback = () => html`<textarea id="target"><b>please ${VALUE} no</b></textarea>`;
-    const expectedMessage = '[#156]';
+    const expectedMessage = '[#155]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws when attempting non-trivial interpolation of a textarea tag via nesting', () => {
     const callback = () => html`<textarea><b>please ${VALUE} no</b></textarea>`;
-    const expectedMessage = '[#156]';
+    const expectedMessage = '[#155]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when interpolation of a textarea is at the end of the template', () => {
+    const callback = () => html`<textarea>${VALUE}`;
+    const expectedMessage = '[#155]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws for unquoted attributes', () => {
     const callback = () => html`<div id="target" not-ok=${VALUE}>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#128]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws for single-quoted attributes', () => {
     const callback = () => html`<div id="target" not-ok='${VALUE}'>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#128]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws for unquoted properties', () => {
     const callback = () => html`<div id="target" .notOk=${VALUE}>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#129]';
+    const expectedMessage = '[#126]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws for single-quoted properties', () => {
     const callback = () => html`<div id="target" .notOk='${VALUE}'>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#129]';
+    const expectedMessage = '[#126]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
@@ -896,7 +872,7 @@ describe('errors', () => {
 
   it('throws if an open tag has a slash before the ">" character', () => {
     const callback = () => html`<input foo/>`;
-    const expectedMessage = '[#105]';
+    const expectedMessage = '[#104]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
@@ -999,163 +975,187 @@ describe('errors', () => {
 
   it('throws if an unbound attribute starts with a hyphen', () => {
     const callback = () => html`<div -what="no"></div>`;
-    const expectedMessage = '[#125]';
+    const expectedMessage = '[#124]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if an unbound attribute starts with a number', () => {
     const callback = () => html`<div 5what="no"></div>`;
-    const expectedMessage = '[#125]';
+    const expectedMessage = '[#124]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if an unbound attribute has an uppercase letter', () => {
     const callback = () => html`<div wHat="no"></div>`;
-    const expectedMessage = '[#125]';
+    const expectedMessage = '[#124]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if an unbound attribute ends with a hyphen', () => {
     const callback = () => html`<div what-="no"></div>`;
-    const expectedMessage = '[#125]';
+    const expectedMessage = '[#124]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute starts with a hyphen', () => {
     const callback = () => html`<div ?-what="${VALUE}"></div>`;
-    const expectedMessage = '[#126]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute starts with a number', () => {
     const callback = () => html`<div ?3what="${VALUE}"></div>`;
-    const expectedMessage = '[#126]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute has an uppercase letter', () => {
     const callback = () => html`<div ?wHat="${VALUE}"></div>`;
-    const expectedMessage = '[#126]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute ends with a hyphen', () => {
     const callback = () => html`<div ?what-="${VALUE}"></div>`;
-    const expectedMessage = '[#126]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute has a malformed dangling quote', () => {
     const callback = () => html`<div ?what="${VALUE} "></div>`;
-    const expectedMessage = '[#130]';
+    const expectedMessage = '[#127]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute ends with a hyphen', () => {
     const callback = () => html`<div ?what-="${VALUE}"></div>`;
-    const expectedMessage = '[#126]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound boolean attribute has a malformed dangling quote', () => {
     const callback = () => html`<div ?what="${VALUE} "></div>`;
-    const expectedMessage = '[#130]';
+    const expectedMessage = '[#127]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws if a bound boolean attribute is at the end of the template', () => {
+    const callback = () => htmlol`<div ?bool="${VALUE}`;
+    const expectedMessage = '[#157]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound defined attribute starts with a hyphen', () => {
     const callback = () => html`<div ??-what="${VALUE}"></div>`;
-    const expectedMessage = '[#127]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound defined attribute starts with a number', () => {
     const callback = () => html`<div ??3what="${VALUE}"></div>`;
-    const expectedMessage = '[#127]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound defined attribute has an uppercase letter', () => {
     const callback = () => html`<div ??wHat="${VALUE}"></div>`;
-    const expectedMessage = '[#127]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound defined attribute ends with a hyphen', () => {
     const callback = () => html`<div ??what-="${VALUE}"></div>`;
-    const expectedMessage = '[#127]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound defined attribute has a malformed dangling quote', () => {
     const callback = () => html`<div ??what="${VALUE} "></div>`;
-    const expectedMessage = '[#130]';
+    const expectedMessage = '[#127]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws if a bound defined attribute is at the end of the template', () => {
+    const callback = () => htmlol`<div ??what="${VALUE}`;
+    const expectedMessage = '[#157]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound attribute starts with a hyphen', () => {
     const callback = () => html`<div -what="${VALUE}"></div>`;
-    const expectedMessage = '[#128]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound attribute starts with a number', () => {
     const callback = () => html`<div 3what="${VALUE}"></div>`;
-    const expectedMessage = '[#128]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound attribute has an uppercase letter', () => {
     const callback = () => html`<div wHat="${VALUE}"></div>`;
-    const expectedMessage = '[#128]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound attribute ends with a hyphen', () => {
     const callback = () => html`<div what-="${VALUE}"></div>`;
-    const expectedMessage = '[#128]';
+    const expectedMessage = '[#125]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound attribute has a malformed dangling quote', () => {
     const callback = () => html`<div what="${VALUE} "></div>`;
-    const expectedMessage = '[#130]';
+    const expectedMessage = '[#127]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws if a bound attribute is at the end of the template', () => {
+    const callback = () => htmlol`<div what="${VALUE}`;
+    const expectedMessage = '[#157]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws for misuse of a bound property prefix with a literal value', () => {
     const callback = () => html`<div .literal="property"></div>`;
-    const expectedMessage = '[#105]';
+    const expectedMessage = '[#104]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound property starts with an underscore', () => {
     const callback = () => html`<div ._what="${VALUE}"></div>`;
-    const expectedMessage = '[#129]';
+    const expectedMessage = '[#126]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound property starts with a number', () => {
     const callback = () => html`<div .3what="${VALUE}"></div>`;
-    const expectedMessage = '[#129]';
+    const expectedMessage = '[#126]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound property starts with a capital letter', () => {
     const callback = () => html`<div .Yak="${VALUE}"></div>`;
-    const expectedMessage = '[#129]';
+    const expectedMessage = '[#126]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound property ends with an underscore', () => {
     const callback = () => html`<div .what_="${VALUE}"></div>`;
-    const expectedMessage = '[#129]';
+    const expectedMessage = '[#126]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
   it('throws if a bound property has a malformed dangling quote', () => {
     const callback = () => html`<div .what="${VALUE} "></div>`;
-    const expectedMessage = '[#130]';
+    const expectedMessage = '[#127]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws if a bound property is at the end of the template', () => {
+    const callback = () => htmlol`<div .what="${VALUE}`;
+    const expectedMessage = '[#157]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
@@ -1173,7 +1173,7 @@ describe('errors', () => {
 
   it('throws if you mismatch a close a tag', () => {
     const callback = () => html`<div></span>`;
-    const expectedMessage = '[#155]';
+    const expectedMessage = '[#154]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
 
@@ -1419,6 +1419,181 @@ describe('errors', () => {
 
   it('throws for declarative shadow roots', () => {
     const callback = () => html`<template shadowrootmode="open"></template>`;
+    const expectedMessage = '[#156]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+});
+
+// Sanity check to make sure we’re able to hit all our errors.
+describe('errors coverage', () => {
+
+  it('throws when initial markup cannot be parsed', () => {
+    const callback = () => htmlol`<`;
+    const expectedMessage = '[#100]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after text cannot be parsed', () => {
+    const callback = () => htmlol`text<`;
+    const expectedMessage = '[#101]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after comment cannot be parsed', () => {
+    const callback = () => htmlol`<!--comment--><`;
+    const expectedMessage = '[#102]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after content interpolation cannot be parsed', () => {
+    const callback = () => htmlol`${VALUE}<`;
+    const expectedMessage = '[#103]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after start tag space cannot be parsed', () => {
+    const callback = () => htmlol`<input !>`;
+    const expectedMessage = '[#104]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after start tag cannot be parsed', () => {
+    const callback = () => htmlol`<div><`;
+    const expectedMessage = '[#105]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after bound boolean cannot be parsed', () => {
+    const callback = () => htmlol`<div ?boolean="${VALUE}!`;
+    const expectedMessage = '[#106]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after bound defined cannot be parsed', () => {
+    const callback = () => htmlol`<div ??defined="${VALUE}!`;
+    const expectedMessage = '[#107]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after bound attribute cannot be parsed', () => {
+    const callback = () => htmlol`<div attribute="${VALUE}!`;
+    const expectedMessage = '[#108]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after bound property cannot be parsed', () => {
+    const callback = () => htmlol`<div .property="${VALUE}!`;
+    const expectedMessage = '[#109]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when markup after end tag cannot be parsed', () => {
+    const callback = () => htmlol`<div></div><`;
+    const expectedMessage = '[#110]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  it('throws when start tag is invalid', () => {
+    const callback = () => htmlol`<dIv>`;
+    const expectedMessage = '[#120]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when start tag space is invalid', () => {
+    // There is a literal tab character here.
+    const callback = () => htmlol`<div	>`;
+    const expectedMessage = '[#121]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when start tag close is invalid', () => {
+    const callback = () => htmlol`<div foo />`;
+    const expectedMessage = '[#122]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when end tag is invalid', () => {
+    const callback = () => htmlol`<div></ div>`;
+    const expectedMessage = '[#123]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when attribute name is invalid', () => {
+    const callback = () => htmlol`<div Boolean>`;
+    const expectedMessage = '[#124]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when bound attribute name is invalid', () => {
+    const callback = () => htmlol`<div ?Boolean="${VALUE}">`;
+    const expectedMessage = '[#125]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when bound property name is invalid', () => {
+    const callback = () => htmlol`<div .Property="${VALUE}">`;
+    const expectedMessage = '[#126]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when bound closing quote is invalid', () => {
+    const callback = () => htmlol`<div attribute="${VALUE}'>`;
+    const expectedMessage = '[#127]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when cdata exists', () => {
+    const callback = () => htmlol`<![CDATA[<]]>`;
+    const expectedMessage = '[#140]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when escapes are used', () => {
+    const callback = () => htmlol`\n`;
+    const expectedMessage = '[#150]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when ambiguous ampersands are used', () => {
+    const callback = () => htmlol`&a`;
+    const expectedMessage = '[#151]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws when comments are invalid', () => {
+    const callback = () => htmlol`<!-- -- -->`;
+    const expectedMessage = '[#152]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws for unsupported (or unknown) native tags', () => {
+    const callback = () => htmlol`<style>`;
+    const expectedMessage = '[#153]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws for wrong or missing end tag', () => {
+    const callback = () => htmlol`<div>`;
+    const expectedMessage = '[#154]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws for textarea abuse', () => {
+    const callback = () => htmlol`<textarea> -- ${VALUE} -- </textarea>`;
+    const expectedMessage = '[#155]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws for declarative shadow root / shadowrootmode', () => {
+    const callback = () => htmlol`<template shadowrootmode>`;
+    const expectedMessage = '[#156]';
+    assertThrows(callback, expectedMessage, { startsWith: true });
+  });
+
+  it('throws for missing closing quote at end of template', () => {
+    const callback = () => htmlol`<template foo="${VALUE}`;
     const expectedMessage = '[#157]';
     assertThrows(callback, expectedMessage, { startsWith: true });
   });
@@ -1427,14 +1602,14 @@ describe('errors', () => {
 describe('html error formatting', () => {
   it('single line template', () => {
     const callback = () => html`<div id="target" not-ok=${VALUE}>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#128] Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).\nSee substring `not-ok=`.\nYour HTML was parsed through: `<div id="target" `.';
+    const expectedMessage = '[#125] Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).\nSee substring `not-ok=`.\nYour HTML was parsed through: `<div id="target" `.';
     assertThrows(callback, expectedMessage);
   });
 
   it('template with two lines', () => {
     const callback = () => html`
       <div id="target" not-ok='${VALUE}'>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#128] Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).\nSee substring `not-ok=\'`.\nYour HTML was parsed through: `\n      <div id="target" `.';
+    const expectedMessage = '[#125] Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).\nSee substring `not-ok=\'`.\nYour HTML was parsed through: `\n      <div id="target" `.';
     assertThrows(callback, expectedMessage);
   });
 
@@ -1443,7 +1618,7 @@ describe('html error formatting', () => {
       
       
       <div id="target" .notOk=${VALUE}>Gotta double-quote those.</div>`;
-    const expectedMessage = '[#129] Invalid tag property interpolation (must use kebab-case names and double-quoted values).\nSee substring `.notOk=`.\nYour HTML was parsed through: `\n      \n      \n      <div id="target" `.';
+    const expectedMessage = '[#126] Invalid tag property interpolation (must use kebab-case names and double-quoted values).\nSee substring `.notOk=`.\nYour HTML was parsed through: `\n      \n      \n      <div id="target" `.';
     assertThrows(callback, expectedMessage);
   });
 });
diff --git a/ts/x-parser.d.ts b/ts/x-parser.d.ts
index 1bffa4b..a416659 100644
--- a/ts/x-parser.d.ts
+++ b/ts/x-parser.d.ts
@@ -36,9 +36,9 @@ export class XParser {
     static "__#1@#boundAttributeMalformed": RegExp;
     static "__#1@#boundPropertyMalformed": RegExp;
     static "__#1@#danglingQuoteMalformed": RegExp;
-    static "__#1@#getErrorMessage"(key: any): "Could not parse template markup (at template start)." | "Could not parse template markup (after text content)." | "Could not parse template markup (after a comment)." | "Could not parse template markup (after interpolated content)." | "Could not parse template markup (after a start tag name)." | "Could not parse template markup (after a spacing within start tag)." | "Could not parse template markup (after a start tag)." | "Could not parse template markup (after a boolean attribute in a start tag)." | "Could not parse template markup (after an attribute in a start tag)." | "Could not parse template markup (after a boolean attribute interpolation in a start tag)." | "Could not parse template markup (after a defined attribute interpolation in a start tag)." | "Could not parse template markup (after an attribute interpolation in a start tag)." | "Could not parse template markup (after a property interpolation in a start tag)." | "Could not parse template markup (after the closing quote of an interpolated attribute or property in a start tag)." | "Could not parse template markup (after an end tag)." | "Invalid tag name - refer to https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define#valid_custom_element_names)." | "Invalid tag whitespace (extraneous whitespace in start tag)." | "Invalid start tag (extraneous whitespace at close of start tag)." | "Invalid end tag." | "Invalid tag attribute (must use kebab-case names and double-quoted values)." | "Invalid tag attribute interpolation (must use kebab-case names and double-quoted values)." | "Invalid tag property interpolation (must use kebab-case names and double-quoted values)." | "Invalid closing quote on tag attribute or property." | "CDATA sections are not supported. Use character references instead: https://developer.mozilla.org/en-US/docs/Glossary/Character_reference." | "Bad escape in tagged template string. Use “&bsol;” for “\\”, “&dollar;” for “\\$”, and “&grave;” for “\\`”. All character references are supported: https://developer.mozilla.org/en-US/docs/Glossary/Character_reference." | "Ambiguous ampersand character or invalid hexadecimal character reference." | "Invalid comment. Comments cannot start with “>” or “->” characters, they cannot include a set of “--” characters, and they cannot end with a “-” character." | "Unsupported native tag - supported native tags are listed here: https://github.com/Netflix/x-element/blob/main/doc/TEMPLATES.md#supported-native-tags." | "Invalid closing tag (all non-void start tags much have matching end tags)." | "Unsupported <textarea> interpolation. Interpolation must be exact (<textarea>${…}</textarea>)." | "Unsupported declarative shadow root on <template>. The “shadowrootmode” attribute is not supported.";
-    static "__#1@#getErrorMessageKeyFromValue"(value: any): "#100" | "#101" | "#102" | "#103" | "#104" | "#105" | "#106" | "#107" | "#108" | "#109" | "#110" | "#111" | "#112" | "#113" | "#114";
-    static "__#1@#getErrorMessageKeyFromValueMalformed"(valueMalformed: any): "#120" | "#121" | "#122" | "#123" | "#124" | "#125" | "#126" | "#127" | "#128" | "#129" | "#130";
+    static "__#1@#getErrorMessage"(key: any): "Could not parse template markup (at template start)." | "Could not parse template markup (after text content)." | "Could not parse template markup (after a comment)." | "Could not parse template markup (after interpolated content)." | "Could not parse template markup (after a spacing within start tag)." | "Could not parse template markup (after a start tag)." | "Could not parse template markup (after a boolean attribute interpolation in a start tag)." | "Could not parse template markup (after a defined attribute interpolation in a start tag)." | "Could not parse template markup (after an attribute interpolation in a start tag)." | "Could not parse template markup (after a property interpolation in a start tag)." | "Could not parse template markup (after an end tag)." | "Invalid tag name - refer to https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define#valid_custom_element_names)." | "Invalid tag whitespace (extraneous whitespace in start tag)." | "Invalid start tag (extraneous whitespace at close of start tag)." | "Invalid end tag." | "Invalid tag attribute (must use kebab-case names and double-quoted values)." | "Invalid tag attribute interpolation (must use kebab-case names and double-quoted values)." | "Invalid tag property interpolation (must use kebab-case names and double-quoted values)." | "Invalid closing quote on tag attribute or property." | "CDATA sections are not supported. Use character references instead: https://developer.mozilla.org/en-US/docs/Glossary/Character_reference." | "Bad escape in tagged template string. Use “&bsol;” for “\\”, “&dollar;” for “\\$”, and “&grave;” for “\\`”. All character references are supported: https://developer.mozilla.org/en-US/docs/Glossary/Character_reference." | "Ambiguous ampersand character or invalid hexadecimal character reference." | "Invalid comment. Comments cannot start with “>” or “->” characters, they cannot include a set of “--” characters, and they cannot end with a “-” character." | "Unsupported native tag - supported native tags are listed here: https://github.com/Netflix/x-element/blob/main/doc/TEMPLATES.md#supported-native-tags." | "Invalid end tag (all non-void start tags much have matching end tags)." | "Unsupported <textarea> interpolation. Interpolation must be exact (<textarea>${…}</textarea>)." | "Unsupported declarative shadow root on <template>. The “shadowrootmode” attribute is not supported." | "Missing closing quote on bound attribute or property.";
+    static "__#1@#getErrorMessageKeyFromValue"(value: any): "#100" | "#101" | "#102" | "#103" | "#104" | "#105" | "#106" | "#107" | "#108" | "#109" | "#110";
+    static "__#1@#getErrorMessageKeyFromValueMalformed"(valueMalformed: any): "#120" | "#121" | "#122" | "#123" | "#124" | "#125" | "#126" | "#127";
     static "__#1@#getErrorMessageKeyFromValueForbidden"(valueForbidden: any): string;
     static "__#1@#getErrorMessageKeyFromErrorName"(errorName: any): "#150" | "#151" | "#152" | "#153" | "#154" | "#155" | "#156" | "#157";
     static "__#1@#try"(string: any, stringIndex: any, ...values: any[]): any;
@@ -51,7 +51,7 @@ export class XParser {
     };
     static "__#1@#throwTransitionError"(strings: any, stringsIndex: any, string: any, stringIndex: any, value: any): void;
     static "__#1@#validateRawString"(rawString: any): void;
-    static "__#1@#validateExit"(tagName: any): void;
+    static "__#1@#validateExit"(value: any, tagName: any): void;
     static "__#1@#sendInnerTextTokens"(onToken: any, string: any, index: any, start: any, end: any, plaintextType: any, referenceType: any): void;
     static "__#1@#validateTagName"(tagName: any): void;
     static "__#1@#validateNoDeclarativeShadowRoots"(tagName: any, attributeName: any): void;
diff --git a/ts/x-parser.d.ts.map b/ts/x-parser.d.ts.map
index ef5c305..d7b07f2 100644
--- a/ts/x-parser.d.ts.map
+++ b/ts/x-parser.d.ts.map
@@ -1 +1 @@
-{"version":3,"file":"x-parser.d.ts","sourceRoot":"","sources":["../x-parser.js"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D;IAEE,uCAAmC;IAGnC,iCAAgC;IAOhC,6CAGG;IAEH,yCAyCG;IACH,+CAMG;IACH,gDAA4F;IAa5F,+BAA0C;IAC1C,oCAA0C;IAI1C,4BAA2C;IAI3C,+BAAiD;IAYjD,oCAA8E;IAC9E,8BAAoE;IACpE,qCAAqD;IAYrD,qCAA2E;IAgB3E,+BAA+E;IAC/E,iCAAuF;IACvF,oCAAuE;IACvE,oCAAuE;IACvE,sCAAuE;IAevE,qCAA2E;IAO3E,qCAAiD;IAWjD,uCAAsD;IAgBtD,8BAA4C;IAC5C,uCAAqD;IAarD,kCAAiD;IAQjD,6CAA4D;IAC5D,8CAA8C;IAC9C,8CAAkD;IAClD,uCAA2E;IAI3E,wCAAmE;IACnE,0CAAwF;IACxF,6CAAkE;IAClE,6CAAkE;IAClE,+CAAkE;IAIlE,8CAAgE;IAGhE,8CAAmD;IAWnD,6vFAyCC;IAGD,6LAkBC;IAGD,2KAcC;IAGD,iFAIC;IAGD,sIAWC;IAOD,yEAOC;IAID,mFASC;IAGD,iFAsCC;IAID,+EAiGC;IAID;;;MAgBC;IAMD,sHAcC;IAcD,uDASC;IAID,gDAOC;IAUD,8IAwCC;IAKD,mDAUC;IAID,wFAMC;IAMD,wIAWC;IAID,4GAEC;IAGD,0HAIC;IAMD,6HAaC;IAGD,iIAOC;IAGD,mIAGC;IAGD,mIAEC;IAGD,2IAKC;IAID,6IAeC;IAID,kIAWC;IAID,kIAWC;IAID,oIASC;IAID,mIAWC;IAID,oHAIC;IAKD,gIAoBC;IAGD,sHAEC;IAGD,wJAeC;IAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8CE;IAEF;;;;;;OAMG;IAEH;;;;OAIG;IACH,8BAHW,KAAK,GACH;eARC,MAAM;eACN,MAAM;aACN,MAAM;QAMM,IAAI,CAI7B;IAED;;;;;;;;OAQG;IAEH;;;;;OAKG;IACH,sBAHW,GAAC,kBAVD,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,aACN,MAAM,gBAuIhB;CACF"}
\ No newline at end of file
+{"version":3,"file":"x-parser.d.ts","sourceRoot":"","sources":["../x-parser.js"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D;IAEE,uCAAmC;IAGnC,iCAAgC;IAOhC,6CAGG;IAEH,yCAyCG;IACH,+CAMG;IACH,gDAA4F;IAa5F,+BAA0C;IAC1C,oCAA0C;IAI1C,4BAA2C;IAI3C,+BAAiD;IAYjD,oCAA4E;IAC5E,8BAAoE;IACpE,qCAAiD;IAUjD,qCAA4C;IAgB5C,+BAA6E;IAC7E,iCAAqF;IACrF,oCAAuE;IACvE,oCAAuE;IACvE,sCAAuE;IAevE,qCAA2E;IAO3E,qCAAgD;IAWhD,uCAAsD;IAgBtD,8BAA4C;IAC5C,uCAAmD;IAanD,kCAAiD;IAQjD,6CAAwD;IACxD,8CAA0C;IAC1C,8CAA8C;IAC9C,uCAAmE;IAInE,wCAAiE;IACjE,0CAAsF;IACtF,6CAAkE;IAClE,6CAAkE;IAClE,+CAAkE;IAIlE,8CAAgE;IAGhE,8CAAiD;IAWjD,q+EAkCC;IAGD,yJAqBC;IAGD,gJAcC;IAGD,iFAIC;IAGD,sIAYC;IAOD,yEAOC;IAID,mFASC;IAGD,iFAuCC;IAID,+EAiGC;IAID;;;MAgBC;IAMD,sHAcC;IAcD,uDASC;IAID,4DAkBC;IAUD,8IAwCC;IAKD,mDAUC;IAID,wFAMC;IAMD,wIAWC;IAID,4GAEC;IAGD,0HAIC;IAMD,6HAaC;IAGD,iIAOC;IAGD,mIAGC;IAGD,mIAEC;IAGD,2IAKC;IAID,6IAeC;IAID,kIAWC;IAID,kIAWC;IAID,oIASC;IAID,mIAWC;IAID,oHAIC;IAKD,gIAoBC;IAGD,sHAEC;IAGD,wJAeC;IAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8CE;IAEF;;;;;;OAMG;IAEH;;;;OAIG;IACH,8BAHW,KAAK,GACH;eARC,MAAM;eACN,MAAM;aACN,MAAM;QAMM,IAAI,CAI7B;IAED;;;;;;;;OAQG;IAEH;;;;;OAKG;IACH,sBAHW,GAAC,kBAVD,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,aACN,MAAM,gBAuIhB;CACF"}
\ No newline at end of file
diff --git a/x-parser.js b/x-parser.js
index e891ce7..1b4a2dc 100644
--- a/x-parser.js
+++ b/x-parser.js
@@ -99,12 +99,10 @@ export class XParser {
   // Examples:
   //  - ok: <h6>, <my-element-1>
   //  - not ok: <-div>, <1-my-element>
-  static #startTagOpen            =   /<(?![0-9-])[a-z0-9-]+(?<!-)(?=[\s\n>])/y;
+  static #startTagOpen            =   /<(?![0-9-])[a-z0-9-]+(?<!-)(?=[\s>])/y;
   static #endTag                  = /<\/(?![0-9-])[a-z0-9-]+(?<!-)>/y;
-  static #startTagClose           =    /(?<![\s\n])>/y;
+  static #startTagClose           =    /(?<!\s)>/y;
 
-  // TODO: Check on performance for this pattern. We want to do a positive
-  //  lookahead so that we report the correct failure on fail.
   // Our space-delimiter rules more restrictive than the “space” spec.
   //  https://w3c.github.io/html-reference/terminology.html#space
   // Spaces must either be singular — or, a single newline followed by spaces
@@ -113,7 +111,7 @@ export class XParser {
   // Examples:
   //  - ok: <div foo bar>, <div\n  foo\n  bar>
   //  - not ok: <div foo  bar>, <div\n\n  foo\n\n  bar>, <div\tfoo\tbar>
-  static #startTagSpace           = / (?! )|\n *(?!\n)(?=[-_.?a-zA-Z0-9>])/y;
+  static #startTagSpace           = / |\n */y;
 
   // Our attribute rules are more restrictive than the “attribute” spec.
   //  https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
@@ -129,8 +127,8 @@ export class XParser {
   // Full attribute examples:
   //  - ok: foo, foo="bar", ?foo="${'bar'}", ??foo="${'bar'}", foo="${'bar'}"
   //  - not ok: foo='bar', ?foo, foo=${'bar'}
-  static #boolean                 =     /(?![0-9-])[a-z0-9-]+(?<!-)(?=[\s\n>])/y;
-  static #attribute               =     /(?![0-9-])[a-z0-9-]+(?<!-)="[^"]*"(?=[\s\n>])/y;
+  static #boolean                 =     /(?![0-9-])[a-z0-9-]+(?<!-)(?=[\s>])/y;
+  static #attribute               =     /(?![0-9-])[a-z0-9-]+(?<!-)="[^"]*"(?=[\s>])/y;
   static #boundBoolean            =   /\?(?![0-9-])[a-z0-9-]+(?<!-)="$/y;
   static #boundDefined            = /\?\?(?![0-9-])[a-z0-9-]+(?<!-)="$/y;
   static #boundAttribute          =     /(?![0-9-])[a-z0-9-]+(?<!-)="$/y;
@@ -155,7 +153,7 @@ export class XParser {
   //  “strings”, we need to check that the _next_ string begins with a
   //  double-quote. Note that it must precede a space, a newline, or the closing
   //  angle bracket of the opening tag.
-  static #danglingQuote           = /"(?=[ \n>])/y;
+  static #danglingQuote           = /"(?=[\s>])/y;
 
   //////////////////////////////////////////////////////////////////////////////
   // Special Tag Patterns //////////////////////////////////////////////////////
@@ -183,7 +181,7 @@ export class XParser {
   //  rely on setHTMLUnsafe to decode.
   // https://w3c.github.io/html-reference/syntax.html#character-encoding
   static #entity                  = /&.*?;/ys;
-  static #htmlEntityStart         = /[^&]*&[^&\s\n<]/y;
+  static #htmlEntityStart         = /[^&]*&[^&\s<]/y;
 
   //////////////////////////////////////////////////////////////////////////////
   // CDATA /////////////////////////////////////////////////////////////////////
@@ -204,15 +202,15 @@ export class XParser {
 
   // See if weird spaces were added or if incorrect characters were used in
   //  open or close tags.
-  static #startTagOpenMalformed   = /<[\s\n]*[a-zA-Z0-9_-]+/y;
-  static #startTagSpaceMalformed  =  /[\s\n]+/y;
-  static #startTagCloseMalformed  =  /[\s\n]*\/?>/y;
-  static #endTagMalformed         = /<[\s\n]*\/[\s\n]*[a-zA-Z0-9_-]+[^>]*>/y;
+  static #startTagOpenMalformed   = /<\s*[a-zA-Z0-9_-]+/y;
+  static #startTagSpaceMalformed  =  /\s+/y;
+  static #startTagCloseMalformed  =  /\s*\/?>/y;
+  static #endTagMalformed         = /<\s*\/\s*[a-zA-Z0-9_-]+[^>]*>/y;
 
   // See if incorrect characters, wrong quotes, or no quotes were used with
   //  either normal or bound attributes.
-  static #booleanMalformed        =     /[a-zA-Z0-9-_]+(?=[\s\n>])/y;
-  static #attributeMalformed      =     /[a-zA-Z0-9-_]+=(?:"[^"]*"|'[^']*')?(?=[\s\n>])/y;
+  static #booleanMalformed        =     /[a-zA-Z0-9-_]+(?=[\s>])/y;
+  static #attributeMalformed      =     /[a-zA-Z0-9-_]+=(?:"[^"]*"|'[^']*')?(?=[\s>])/y;
   static #boundBooleanMalformed   =   /\?[a-zA-Z0-9-_]+=(?:"|')?$/y;
   static #boundDefinedMalformed   = /\?\?[a-zA-Z0-9-_]+=(?:"|')?$/y;
   static #boundAttributeMalformed =     /[a-zA-Z0-9-_]+=(?:"|')?$/y;
@@ -222,7 +220,7 @@ export class XParser {
   static #boundPropertyMalformed  = /\.[a-zA-Z0-9-_]+=(?:"|')?$/y;
 
   // See if the quote pair was malformed or missing.
-  static #danglingQuoteMalformed  = /'?(?=[\s\n>])/y;
+  static #danglingQuoteMalformed  = /'?(?=[\s>])/y;
 
   //////////////////////////////////////////////////////////////////////////////
   // Errors ////////////////////////////////////////////////////////////////////
@@ -239,29 +237,22 @@ export class XParser {
       case '#101': return 'Could not parse template markup (after text content).';
       case '#102': return 'Could not parse template markup (after a comment).';
       case '#103': return 'Could not parse template markup (after interpolated content).';
-      case '#104': return 'Could not parse template markup (after a start tag name).';
-      case '#105': return 'Could not parse template markup (after a spacing within start tag).';
-      case '#106': return 'Could not parse template markup (after a start tag).';
-      case '#107': return 'Could not parse template markup (after a boolean attribute in a start tag).';
-      case '#108': return 'Could not parse template markup (after an attribute in a start tag).';
-      case '#109': return 'Could not parse template markup (after a boolean attribute interpolation in a start tag).';
-      case '#110': return 'Could not parse template markup (after a defined attribute interpolation in a start tag).';
-      case '#111': return 'Could not parse template markup (after an attribute interpolation in a start tag).';
-      case '#112': return 'Could not parse template markup (after a property interpolation in a start tag).';
-      case '#113': return 'Could not parse template markup (after the closing quote of an interpolated attribute or property in a start tag).';
-      case '#114': return 'Could not parse template markup (after an end tag).';
+      case '#104': return 'Could not parse template markup (after a spacing within start tag).';
+      case '#105': return 'Could not parse template markup (after a start tag).';
+      case '#106': return 'Could not parse template markup (after a boolean attribute interpolation in a start tag).';
+      case '#107': return 'Could not parse template markup (after a defined attribute interpolation in a start tag).';
+      case '#108': return 'Could not parse template markup (after an attribute interpolation in a start tag).';
+      case '#109': return 'Could not parse template markup (after a property interpolation in a start tag).';
+      case '#110': return 'Could not parse template markup (after an end tag).';
 
       case '#120': return 'Invalid tag name - refer to https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define#valid_custom_element_names).';
       case '#121': return 'Invalid tag whitespace (extraneous whitespace in start tag).';
       case '#122': return 'Invalid start tag (extraneous whitespace at close of start tag).';
       case '#123': return 'Invalid end tag.';
       case '#124': return 'Invalid tag attribute (must use kebab-case names and double-quoted values).';
-      case '#125': return 'Invalid tag attribute (must use kebab-case names and double-quoted values).';
-      case '#126': return 'Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).';
-      case '#127': return 'Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).';
-      case '#128': return 'Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).';
-      case '#129': return 'Invalid tag property interpolation (must use kebab-case names and double-quoted values).';
-      case '#130': return 'Invalid closing quote on tag attribute or property.';
+      case '#125': return 'Invalid tag attribute interpolation (must use kebab-case names and double-quoted values).';
+      case '#126': return 'Invalid tag property interpolation (must use kebab-case names and double-quoted values).';
+      case '#127': return 'Invalid closing quote on tag attribute or property.';
 
       case '#140': return 'CDATA sections are not supported. Use character references instead: https://developer.mozilla.org/en-US/docs/Glossary/Character_reference.';
 
@@ -269,31 +260,34 @@ export class XParser {
       case '#151': return 'Ambiguous ampersand character or invalid hexadecimal character reference.';
       case '#152': return 'Invalid comment. Comments cannot start with “>” or “->” characters, they cannot include a set of “--” characters, and they cannot end with a “-” character.';
       case '#153': return 'Unsupported native tag - supported native tags are listed here: https://github.com/Netflix/x-element/blob/main/doc/TEMPLATES.md#supported-native-tags.';
-      case '#154':
-      case '#155': return 'Invalid closing tag (all non-void start tags much have matching end tags).';
-      case '#156': return 'Unsupported <textarea> interpolation. Interpolation must be exact (<textarea>${…}</textarea>).';
-      case '#157': return 'Unsupported declarative shadow root on <template>. The “shadowrootmode” attribute is not supported.';
+      case '#154': return 'Invalid end tag (all non-void start tags much have matching end tags).';
+      case '#155': return 'Unsupported <textarea> interpolation. Interpolation must be exact (<textarea>${…}</textarea>).';
+      case '#156': return 'Unsupported declarative shadow root on <template>. The “shadowrootmode” attribute is not supported.';
+      case '#157': return 'Missing closing quote on bound attribute or property.';
     }
   }
 
   // Block #100-#119 — Invalid transition errors.
   static #getErrorMessageKeyFromValue(value) {
+    // Note that the following states _never_ have their own generic errors. The
+    //  main reason is because they all encode a lookahead which is a subset of
+    //  a related “*Malformed” pattern.
+    // - XParser.#startTagOpen  (caught by XParser.#startTagSpaceMalformed)
+    // - XParser.#boolean       (caught by XParser.#startTagSpaceMalformed)
+    // - XParser.#attribute     (caught by XParser.#startTagSpaceMalformed)
+    // - XParser.#danglingQuote (caught by XParser.#startTagSpaceMalformed)
     switch (value) {
       case XParser.#initial:                  return '#100';
       case XParser.#text:                     return '#101';
       case XParser.#comment:                  return '#102';
       case XParser.#boundContent:             return '#103';
-      case XParser.#startTagOpen:             return '#104';
-      case XParser.#startTagSpace:            return '#105';
-      case XParser.#startTagClose:            return '#106';
-      case XParser.#boolean:                  return '#107';
-      case XParser.#attribute:                return '#108';
-      case XParser.#boundBoolean:             return '#109';
-      case XParser.#boundDefined:             return '#110';
-      case XParser.#boundAttribute:           return '#111';
-      case XParser.#boundProperty:            return '#112';
-      case XParser.#danglingQuote:            return '#113';
-      case XParser.#endTag:                   return '#114';
+      case XParser.#startTagSpace:            return '#104';
+      case XParser.#startTagClose:            return '#105';
+      case XParser.#boundBoolean:             return '#106';
+      case XParser.#boundDefined:             return '#107';
+      case XParser.#boundAttribute:           return '#108';
+      case XParser.#boundProperty:            return '#109';
+      case XParser.#endTag:                   return '#110';
     }
   }
 
@@ -305,12 +299,12 @@ export class XParser {
       case XParser.#startTagCloseMalformed:   return '#122';
       case XParser.#endTagMalformed:          return '#123';
       case XParser.#booleanMalformed:         return '#124';
-      case XParser.#attributeMalformed:       return '#125';
-      case XParser.#boundBooleanMalformed:    return '#126';
-      case XParser.#boundDefinedMalformed:    return '#127';
-      case XParser.#boundAttributeMalformed:  return '#128';
-      case XParser.#boundPropertyMalformed:   return '#129';
-      case XParser.#danglingQuoteMalformed:   return '#130';
+      case XParser.#attributeMalformed:       return '#124';
+      case XParser.#boundBooleanMalformed:    return '#125';
+      case XParser.#boundDefinedMalformed:    return '#125';
+      case XParser.#boundAttributeMalformed:  return '#125';
+      case XParser.#boundPropertyMalformed:   return '#126';
+      case XParser.#danglingQuoteMalformed:   return '#127';
     }
   }
 
@@ -328,10 +322,11 @@ export class XParser {
       case 'malformed-html-entity':           return '#151';
       case 'malformed-comment':               return '#152';
       case 'forbidden-html-element':          return '#153';
-      case 'missing-closing-tag':             return '#154';
-      case 'mismatched-closing-tag':          return '#155';
-      case 'complex-textarea-interpolation':  return '#156';
-      case 'declarative-shadow-root':         return '#157';
+      case 'missing-end-tag':                 return '#154';
+      case 'mismatched-end-tag':              return '#154';
+      case 'complex-textarea-interpolation':  return '#155';
+      case 'declarative-shadow-root':         return '#156';
+      case 'missing-closing-quote':           return '#157';
     }
   }
 
@@ -382,6 +377,7 @@ export class XParser {
       case XParser.#danglingQuote: return XParser.#try(string, stringIndex,
         XParser.#startTagSpaceMalformed);
       case XParser.#startTagSpace: return XParser.#try(string, stringIndex,
+        XParser.#startTagSpaceMalformed,
         XParser.#booleanMalformed,
         XParser.#attributeMalformed,
         XParser.#boundBooleanMalformed,
@@ -569,9 +565,20 @@ export class XParser {
 
   // Before a successful exit, the parser ensures that all non-void opening tags
   //  have been matched successfully to prevent any unexpected behavior.
-  static #validateExit(tagName) {
+  static #validateExit(value, tagName) {
+    switch (value) {
+      case XParser.#boundBoolean:
+      case XParser.#boundDefined:
+      case XParser.#boundAttribute:
+      case XParser.#boundProperty: {
+        const errorMessageKey = XParser.#getErrorMessageKeyFromErrorName('missing-closing-quote');
+        const errorMessage = XParser.#getErrorMessage(errorMessageKey);
+        const substringMessage = `Missing closing double-quote.`;
+        throw new Error(`[${errorMessageKey}] ${errorMessage}\n${substringMessage}`);
+      }
+    }
     if (tagName) {
-      const errorMessageKey = XParser.#getErrorMessageKeyFromErrorName('missing-closing-tag');
+      const errorMessageKey = XParser.#getErrorMessageKeyFromErrorName('missing-end-tag');
       const errorMessage = XParser.#getErrorMessage(errorMessageKey);
       const substringMessage = `Missing a closing </${tagName}>.`;
       throw new Error(`[${errorMessageKey}] ${errorMessage}\n${substringMessage}`);
@@ -853,7 +860,7 @@ export class XParser {
     const endTagName = string.slice(endTagNameStart, endTagNameEnd);
     if (endTagName !== tagName) {
       const { parsed } = XParser.#getErrorInfo(strings, stringsIndex, string, stringIndex);
-      const errorMessageKey = XParser.#getErrorMessageKeyFromErrorName('mismatched-closing-tag');
+      const errorMessageKey = XParser.#getErrorMessageKeyFromErrorName('mismatched-end-tag');
       const errorMessage = XParser.#getErrorMessage(errorMessageKey);
       const substringMessage = `The closing tag </${endTagName}> does not match <${tagName}>.`;
       const parsedThroughMessage = `Your HTML was parsed through: \`${parsed}\`.`;
@@ -1068,7 +1075,7 @@ export class XParser {
         stringsIndex++;
       }
 
-      XParser.#validateExit(tagName);
+      XParser.#validateExit(value, tagName);
     } catch (error) {
       // Roughly match the conventions for “onToken”.
       const index = stringsIndex;