From 2f764a11d00a36792488db0ee90be4785fc441b0 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Wed, 18 Mar 2026 18:05:31 -0400
Subject: [PATCH 1/2] Extract rule: template-no-whitespace-within-word

---
 README.md                                     |   1 +
 .../template-no-whitespace-within-word.md     |  49 ++++++
 .../template-no-whitespace-within-word.js     | 117 ++++++++++++++
 .../template-no-whitespace-within-word.js     | 144 ++++++++++++++++++
 4 files changed, 311 insertions(+)
 create mode 100644 docs/rules/template-no-whitespace-within-word.md
 create mode 100644 lib/rules/template-no-whitespace-within-word.js
 create mode 100644 tests/lib/rules/template-no-whitespace-within-word.js

diff --git a/README.md b/README.md
index 33484c4067..c00551fdda 100644
--- a/README.md
+++ b/README.md
@@ -197,6 +197,7 @@ rules in templates can be disabled with eslint directives with mustache or html
 | [template-no-nested-interactive](docs/rules/template-no-nested-interactive.md)                                   | disallow nested interactive elements                                             |    |    |    |
 | [template-no-nested-landmark](docs/rules/template-no-nested-landmark.md)                                         | disallow nested landmark elements                                                |    |    |    |
 | [template-no-pointer-down-event-binding](docs/rules/template-no-pointer-down-event-binding.md)                   | disallow pointer down event bindings                                             |    |    |    |
+| [template-no-whitespace-within-word](docs/rules/template-no-whitespace-within-word.md)                           | disallow excess whitespace within words (e.g. "W e l c o m e")                   |    |    |    |
 | [template-require-aria-activedescendant-tabindex](docs/rules/template-require-aria-activedescendant-tabindex.md) | require non-interactive elements with aria-activedescendant to have tabindex     |    | 🔧 |    |
 | [template-require-iframe-title](docs/rules/template-require-iframe-title.md)                                     | require iframe elements to have a title attribute                                |    |    |    |
 | [template-require-input-label](docs/rules/template-require-input-label.md)                                       | require label for form input elements                                            |    |    |    |
diff --git a/docs/rules/template-no-whitespace-within-word.md b/docs/rules/template-no-whitespace-within-word.md
new file mode 100644
index 0000000000..f75405146e
--- /dev/null
+++ b/docs/rules/template-no-whitespace-within-word.md
@@ -0,0 +1,49 @@
+# ember/template-no-whitespace-within-word
+
+<!-- end auto-generated rule header -->
+
+Disallow excess whitespace within words (e.g. "W e l c o m e").
+
+## Rule Details
+
+This rule detects text content where letters are separated by whitespace or whitespace HTML entities, producing a "spaced out" word effect like `W e l c o m e`. This pattern is an accessibility concern because screen readers will read each letter individually instead of reading the word.
+
+The rule checks `GlimmerTextNode` content (excluding text inside attributes and `<style>` elements) for patterns matching alternating whitespace and letter characters.
+
+## Examples
+
+Examples of **incorrect** code for this rule:
+
+```gjs
+<template>
+  <span>W e l c o m e</span>
+</template>
+```
+
+```gjs
+<template>
+  <h1>H&nbsp;E&nbsp;L&nbsp;L&nbsp;O</h1>
+</template>
+```
+
+Examples of **correct** code for this rule:
+
+```gjs
+<template>
+  <span>Welcome</span>
+</template>
+```
+
+```gjs
+<template>
+  <h1>Hello World</h1>
+</template>
+```
+
+## Migration
+
+Use CSS to add letter-spacing to a word.
+
+## References
+
+- [WCAG - Meaningful Sequence](https://www.w3.org/WAI/WCAG21/Understanding/meaningful-sequence.html)
diff --git a/lib/rules/template-no-whitespace-within-word.js b/lib/rules/template-no-whitespace-within-word.js
new file mode 100644
index 0000000000..81b28c2fea
--- /dev/null
+++ b/lib/rules/template-no-whitespace-within-word.js
@@ -0,0 +1,117 @@
+const WHITESPACE_ENTITY_LIST = [
+  '&#32;',
+  '&#160;',
+  '&nbsp;',
+  '&NonBreakingSpace;',
+  '&#8194;',
+  '&ensp;',
+  '&#8195;',
+  '&emsp;',
+  '&#8196;',
+  '&emsp13;',
+  '&#8197;',
+  '&emsp14;',
+  '&#8199;',
+  '&numsp;',
+  '&#8200;',
+  '&puncsp;',
+  '&#8201;',
+  '&thinsp;',
+  '&ThinSpace;',
+  '&#8202;',
+  '&hairsp;',
+  '&VeryThinSpace;',
+  '&ThickSpace;',
+  '&#8203;',
+  '&ZeroWidthSpace;',
+  '&NegativeVeryThinSpace;',
+  '&NegativeThinSpace;',
+  '&NegativeMediumSpace;',
+  '&NegativeThickSpace;',
+  '&#8204;',
+  '&zwnj;',
+  '&#8205;',
+  '&zwj;',
+  '&#8206;',
+  '&lrm;',
+  '&#8207;',
+  '&rlm;',
+  '&#8287;',
+  '&MediumSpace;',
+  '&ThickSpace;',
+  '&#8288;',
+  '&NoBreak;',
+  '&#8289;',
+  '&ApplyFunction;',
+  '&af;',
+  '&#8290;',
+  '&InvisibleTimes;',
+  '&it;',
+  '&#8291;',
+  '&InvisibleComma;',
+  '&ic;',
+];
+
+const CHARACTER_REGEX = '[a-zA-Z]';
+
+// Build a regex that catches alternating non-whitespace/whitespace characters,
+// for example, 'W e l c o m e'. The pattern requires 5 alternations to avoid
+// false positives: (whitespace)(char)(whitespace)(char)(whitespace)
+const whitespaceOrEntityRegex = `(?:\\s|${WHITESPACE_ENTITY_LIST.map(
+  (entity) => `\\${entity}`
+).join('|')})+`;
+const WHITESPACE_WITHIN_WORD_REGEX = new RegExp(
+  `${whitespaceOrEntityRegex}${CHARACTER_REGEX}${whitespaceOrEntityRegex}${CHARACTER_REGEX}${whitespaceOrEntityRegex}`
+);
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'disallow excess whitespace within words (e.g. "W e l c o m e")',
+      category: 'Accessibility',
+      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-no-whitespace-within-word.md',
+      templateMode: 'both',
+    },
+    schema: [],
+    messages: {
+      excessWhitespace: 'Excess whitespace in layout detected.',
+    },
+    originallyFrom: {
+      name: 'ember-template-lint',
+      rule: 'lib/rules/no-whitespace-within-word.js',
+      docs: 'docs/rule/no-whitespace-within-word.md',
+      tests: 'test/unit/rules/no-whitespace-within-word-test.js',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    return {
+      GlimmerTextNode(node) {
+        // Skip text inside attributes
+        let parent = node.parent;
+        while (parent) {
+          if (parent.type === 'GlimmerAttrNode') {
+            return;
+          }
+          // Skip text inside <style> elements
+          if (parent.type === 'GlimmerElementNode' && parent.tag === 'style') {
+            return;
+          }
+          parent = parent.parent;
+        }
+
+        const text = sourceCode.getText(node);
+        if (WHITESPACE_WITHIN_WORD_REGEX.test(text)) {
+          context.report({
+            node,
+            messageId: 'excessWhitespace',
+          });
+        }
+      },
+    };
+  },
+};
diff --git a/tests/lib/rules/template-no-whitespace-within-word.js b/tests/lib/rules/template-no-whitespace-within-word.js
new file mode 100644
index 0000000000..fd6e347367
--- /dev/null
+++ b/tests/lib/rules/template-no-whitespace-within-word.js
@@ -0,0 +1,144 @@
+const eslint = require('eslint');
+const rule = require('../../../lib/rules/template-no-whitespace-within-word');
+
+const { RuleTester } = eslint;
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+ruleTester.run('template-no-whitespace-within-word', rule, {
+  valid: [
+    // No whitespace
+    '<template>{{value}}</template>',
+    '<template>{{this.property}}</template>',
+    '<template>{{@arg}}</template>',
+    '<template>{{#if condition}}content{{/if}}</template>',
+
+    '<template>Welcome</template>',
+    '<template>Hey - I like this!</template>',
+    '<template>Expected: 5-10 guests</template>',
+    '<template>Expected: 5 - 10 guests</template>',
+    '<template>It is possible to get some examples of in-word emph a sis past this rule.</template>',
+    '<template>However, I do not want a rule that flags annoying false positives for correctly-used single-character words.</template>',
+    '<template><div>Welcome</div></template>',
+    '<template><div enable-background="a b c d e f g h i j k l m">We want to ignore values of HTML attributes</div></template>',
+    `<template><style>
+  .my-custom-class > * {
+    border: 2px dotted red;
+  }
+</style></template>`,
+  ],
+  invalid: [
+    {
+      code: '<template><div>W e l c o m e</div></template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template><span>H e l l o</span></template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template><p>C l i c k</p></template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+
+    {
+      code: '<template>W e l c o m e</template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template>W&nbsp;e&nbsp;l&nbsp;c&nbsp;o&nbsp;m&nbsp;e</template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template>Wel c o me</template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template>Wel&nbsp;c&emsp;o&nbsp;me</template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template><div>Wel c o me</div></template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+    {
+      code: '<template>A  B&nbsp;&nbsp; C </template>',
+      output: null,
+      errors: [{ messageId: 'excessWhitespace' }],
+    },
+  ],
+});
+
+const hbsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser/hbs'),
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+  },
+});
+
+hbsRuleTester.run('template-no-whitespace-within-word', rule, {
+  valid: [
+    'Welcome',
+    'Hey - I like this!',
+    'Expected: 5-10 guests',
+    'Expected: 5 - 10 guests',
+    'It is possible to get some examples of in-word emph a sis past this rule.',
+    'However, I do not want a rule that flags annoying false positives for correctly-used single-character words.',
+    '<div>Welcome</div>',
+    '<div enable-background="a b c d e f g h i j k l m">We want to ignore values of HTML attributes</div>',
+    `<style>
+  .my-custom-class > * {
+    border: 2px dotted red;
+  }
+</style>`,
+  ],
+  invalid: [
+    {
+      code: 'W e l c o m e',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+    {
+      code: 'W&nbsp;e&nbsp;l&nbsp;c&nbsp;o&nbsp;m&nbsp;e',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+    {
+      code: 'Wel c o me',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+    {
+      code: 'Wel&nbsp;c&emsp;o&nbsp;me',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+    {
+      code: '<div>W e l c o m e</div>',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+    {
+      code: '<div>Wel c o me</div>',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+    {
+      code: 'A  B&nbsp;&nbsp; C ',
+      output: null,
+      errors: [{ message: 'Excess whitespace in layout detected.' }],
+    },
+  ],
+});

From ce53f5c7b047d0b1d1b6f34733cbe18a53277be4 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 20 Mar 2026 20:13:35 -0400
Subject: [PATCH 2/2] Sync with template-lint

---
 .../template-no-whitespace-within-word.md     |  46 +++--
 .../template-no-whitespace-within-word.js     | 195 +++++++-----------
 2 files changed, 102 insertions(+), 139 deletions(-)

diff --git a/docs/rules/template-no-whitespace-within-word.md b/docs/rules/template-no-whitespace-within-word.md
index f75405146e..1a8e6c0c41 100644
--- a/docs/rules/template-no-whitespace-within-word.md
+++ b/docs/rules/template-no-whitespace-within-word.md
@@ -2,48 +2,62 @@
 
 <!-- end auto-generated rule header -->
 
-Disallow excess whitespace within words (e.g. "W e l c o m e").
+In practice, the predominant issue raised by inline whitespace styling is that the resultant text "formatting" is entirely visual in nature; the ability to discern the correct manner in which to read the text, and therefore, to correctly comprehend its meaning, is restricted to sighted users.
 
-## Rule Details
+Using in-line whitespace word formatting produces results that are explicitly mentioned in [WCAG's list of common sources of web accessibility failures](https://www.w3.org/TR/WCAG20-TECHS/failures.html). Specifically, this common whitespace-within-word-induced web accessibility issue fails to successfully achieve [WCAG Success Criterion 1.3.2: Meaningful Sequence](https://www.w3.org/TR/UNDERSTANDING-WCAG20/content-structure-separation-sequence.html).
 
-This rule detects text content where letters are separated by whitespace or whitespace HTML entities, producing a "spaced out" word effect like `W e l c o m e`. This pattern is an accessibility concern because screen readers will read each letter individually instead of reading the word.
-
-The rule checks `GlimmerTextNode` content (excluding text inside attributes and `<style>` elements) for patterns matching alternating whitespace and letter characters.
+The `template-no-whitespace-within-word` rule operates on the assumption that artificially-spaced English words in rendered text content contain, at a minimum, two word characters fencepost-delimited by three whitespace characters (`space-char-space-char-space`) so it should be avoided.
 
 ## Examples
 
-Examples of **incorrect** code for this rule:
+This rule **forbids** the following:
 
 ```gjs
 <template>
-  <span>W e l c o m e</span>
+  W e l c o m e
 </template>
 ```
 
-```gjs
-<template>
-  <h1>H&nbsp;E&nbsp;L&nbsp;L&nbsp;O</h1>
-</template>
-```
+`W`**`&nbsp;`**`e`**`&nbsp;`**`l`**`&nbsp;`**`c`**`&nbsp;`**`o`**`&nbsp;`**`m`**`&nbsp;`**`e`
+
+`Wel c o me`
 
-Examples of **correct** code for this rule:
+`Wel`**`&nbsp;`**`c`**`&emsp;`**`o`**`&nbsp;`**`me`
 
 ```gjs
 <template>
-  <span>Welcome</span>
+  <div>W e l c o m e</div>
+
+  <div>Wel c o me</div>
 </template>
 ```
 
+This rule **allows** the following:
+
+`Welcome`
+
+`Yes`**`&nbsp;`**`I`**`&nbsp;`**`am`
+
+`It is possible to get some examples of in-word emph a sis past this rule.`
+
+`However, I do not want a rule that flags annoying false positives for correctly-used single-character words.`
+
 ```gjs
 <template>
-  <h1>Hello World</h1>
+  <div>Welcome</div>
+
+  <div>Yes&nbsp;I am.</div>
 </template>
 ```
 
+This rule uses the heuristic of letter, whitespace character, letter, whitespace character, letter which makes it a good candidate for most use cases, but not ideal for some languages (such as Japanese).
+
 ## Migration
 
 Use CSS to add letter-spacing to a word.
 
 ## References
 
-- [WCAG - Meaningful Sequence](https://www.w3.org/WAI/WCAG21/Understanding/meaningful-sequence.html)
+- [F32: Using white space characters to create multiple columns in plain text content](https://www.w3.org/TR/WCAG20-TECHS/failures.html#F32)
+- [WCAG Success Criterion 1.3.2: Meaningful Sequence](https://www.w3.org/TR/UNDERSTANDING-WCAG20/content-structure-separation-sequence.html)
+- [C8: Using CSS letter-spacing to control spacing within a word](https://www.w3.org/WAI/WCAG21/Techniques/css/C8)
diff --git a/tests/lib/rules/template-no-whitespace-within-word.js b/tests/lib/rules/template-no-whitespace-within-word.js
index fd6e347367..0ca6f5e9e0 100644
--- a/tests/lib/rules/template-no-whitespace-within-word.js
+++ b/tests/lib/rules/template-no-whitespace-within-word.js
@@ -3,81 +3,80 @@ const rule = require('../../../lib/rules/template-no-whitespace-within-word');
 
 const { RuleTester } = eslint;
 
-const ruleTester = new RuleTester({
-  parser: require.resolve('ember-eslint-parser'),
-  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
-});
-
-ruleTester.run('template-no-whitespace-within-word', rule, {
-  valid: [
-    // No whitespace
-    '<template>{{value}}</template>',
-    '<template>{{this.property}}</template>',
-    '<template>{{@arg}}</template>',
-    '<template>{{#if condition}}content{{/if}}</template>',
-
-    '<template>Welcome</template>',
-    '<template>Hey - I like this!</template>',
-    '<template>Expected: 5-10 guests</template>',
-    '<template>Expected: 5 - 10 guests</template>',
-    '<template>It is possible to get some examples of in-word emph a sis past this rule.</template>',
-    '<template>However, I do not want a rule that flags annoying false positives for correctly-used single-character words.</template>',
-    '<template><div>Welcome</div></template>',
-    '<template><div enable-background="a b c d e f g h i j k l m">We want to ignore values of HTML attributes</div></template>',
-    `<template><style>
+const validHbs = [
+  'Welcome',
+  'Hey - I like this!',
+  'Expected: 5-10 guests',
+  'Expected: 5 - 10 guests',
+  'It is possible to get some examples of in-word emph a sis past this rule.',
+  'However, I do not want a rule that flags annoying false positives for correctly-used single-character words.',
+  '<div>Welcome</div>',
+  '<div enable-background="a b c d e f g h i j k l m">We want to ignore values of HTML attributes</div>',
+  `<style>
   .my-custom-class > * {
     border: 2px dotted red;
   }
-</style></template>`,
-  ],
-  invalid: [
-    {
-      code: '<template><div>W e l c o m e</div></template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template><span>H e l l o</span></template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template><p>C l i c k</p></template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
+</style>`,
+];
 
-    {
-      code: '<template>W e l c o m e</template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template>W&nbsp;e&nbsp;l&nbsp;c&nbsp;o&nbsp;m&nbsp;e</template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template>Wel c o me</template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template>Wel&nbsp;c&emsp;o&nbsp;me</template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template><div>Wel c o me</div></template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-    {
-      code: '<template>A  B&nbsp;&nbsp; C </template>',
-      output: null,
-      errors: [{ messageId: 'excessWhitespace' }],
-    },
-  ],
+const invalidHbs = [
+  {
+    code: 'W e l c o m e',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+  {
+    code: 'W&nbsp;e&nbsp;l&nbsp;c&nbsp;o&nbsp;m&nbsp;e',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+  {
+    code: 'Wel c o me',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+  {
+    code: 'Wel&nbsp;c&emsp;o&nbsp;me',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+  {
+    code: '<div>W e l c o m e</div>',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+  {
+    code: '<div>Wel c o me</div>',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+  {
+    code: 'A  B&nbsp;&nbsp; C ',
+    output: null,
+    errors: [{ message: 'Excess whitespace in layout detected.' }],
+  },
+];
+
+function wrapTemplate(entry) {
+  if (typeof entry === 'string') {
+    return `<template>${entry}</template>`;
+  }
+
+  return {
+    ...entry,
+    code: `<template>${entry.code}</template>`,
+    output: entry.output ? `<template>${entry.output}</template>` : entry.output,
+  };
+}
+
+const gjsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+gjsRuleTester.run('template-no-whitespace-within-word', rule, {
+  valid: validHbs.map(wrapTemplate),
+  invalid: invalidHbs.map(wrapTemplate),
 });
 
 const hbsRuleTester = new RuleTester({
@@ -89,56 +88,6 @@ const hbsRuleTester = new RuleTester({
 });
 
 hbsRuleTester.run('template-no-whitespace-within-word', rule, {
-  valid: [
-    'Welcome',
-    'Hey - I like this!',
-    'Expected: 5-10 guests',
-    'Expected: 5 - 10 guests',
-    'It is possible to get some examples of in-word emph a sis past this rule.',
-    'However, I do not want a rule that flags annoying false positives for correctly-used single-character words.',
-    '<div>Welcome</div>',
-    '<div enable-background="a b c d e f g h i j k l m">We want to ignore values of HTML attributes</div>',
-    `<style>
-  .my-custom-class > * {
-    border: 2px dotted red;
-  }
-</style>`,
-  ],
-  invalid: [
-    {
-      code: 'W e l c o m e',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-    {
-      code: 'W&nbsp;e&nbsp;l&nbsp;c&nbsp;o&nbsp;m&nbsp;e',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-    {
-      code: 'Wel c o me',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-    {
-      code: 'Wel&nbsp;c&emsp;o&nbsp;me',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-    {
-      code: '<div>W e l c o m e</div>',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-    {
-      code: '<div>Wel c o me</div>',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-    {
-      code: 'A  B&nbsp;&nbsp; C ',
-      output: null,
-      errors: [{ message: 'Excess whitespace in layout detected.' }],
-    },
-  ],
+  valid: validHbs,
+  invalid: invalidHbs,
 });