From f19dbba5e21202e674fc05e54ee6cafca3452204 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Thu, 30 Mar 2023 19:24:03 -0400
Subject: [PATCH] Remove all traces of hbs

Update snapshots since data has been removed

Commit lockfile changes due to package.json change

Fix case where <template> could be within a template string (found in REPL)

Add failing test for situation brought up on limber.glimdown.com

Add fix for reported issue on limber.glimdown.com

Fix comment in babel-plugin.js
---
 README.md                                     |   1 -
 __tests__/parse-templates.test.ts             | 578 ------------------
 .../preprocess-embedded-templates.test.ts     | 100 ++-
 package.json                                  |   1 -
 src/babel-plugin.js                           |  26 +-
 src/parse-templates.ts                        | 207 +------
 src/preprocess-embedded-templates.ts          |  44 +-
 src/preprocessor-plugin.js                    |  48 +-
 src/template-literal-transform.js             | 123 ----
 src/util.ts                                   |  28 +-
 tests/dummy/app/components/hbs-test.js        |  13 -
 tests/dummy/app/templates/application.hbs     |   7 +-
 tests/integration/.gitkeep                    |   0
 tests/integration/hbs-test.js                 |  54 --
 14 files changed, 60 insertions(+), 1170 deletions(-)
 delete mode 100644 src/template-literal-transform.js
 delete mode 100644 tests/dummy/app/components/hbs-test.js
 delete mode 100644 tests/integration/.gitkeep
 delete mode 100644 tests/integration/hbs-test.js

diff --git a/README.md b/README.md
index ce1f386..e963684 100644
--- a/README.md
+++ b/README.md
@@ -253,7 +253,6 @@ export default class Hello extends Component {
 }
 ```
 
-
 ## Reference: built-in helpers, modifiers, components
 
 As implemented as part of the [Strict Mode Templates RFC][rfc-496], the built in
diff --git a/__tests__/parse-templates.test.ts b/__tests__/parse-templates.test.ts
index 49228d0..e5acaf1 100644
--- a/__tests__/parse-templates.test.ts
+++ b/__tests__/parse-templates.test.ts
@@ -1,7 +1,6 @@
 import {
   parseTemplates as _parseTemplates,
   ParseTemplatesOptions,
-  DEFAULT_PARSE_TEMPLATES_OPTIONS,
 } from '../src/parse-templates';
 
 describe('parseTemplates', function () {
@@ -151,581 +150,4 @@ describe('parseTemplates', function () {
       ]
     `);
   });
-
-  it('hbs`Hello!` when only matching <template>', function () {
-    const input = 'hbs`Hello!`';
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-    });
-
-    expect(templates).toMatchInlineSnapshot(`Array []`);
-  });
-
-  it('hbs`Hello!` with imports ember-cli-htmlbars', function () {
-    const input = "import { hbs } from 'ember-cli-htmlbars'; hbs`Hello!`";
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-cli-htmlbars',
-          importIdentifier: 'hbs',
-        },
-      ],
-    });
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Hello!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 52,
-            "input": "import { hbs } from 'ember-cli-htmlbars'; hbs\`Hello!\`",
-          },
-          "importIdentifier": "hbs",
-          "importPath": "ember-cli-htmlbars",
-          "start": Object {
-            "0": "hbs\`",
-            "1": "hbs",
-            "groups": undefined,
-            "index": 42,
-            "input": "import { hbs } from 'ember-cli-htmlbars'; hbs\`Hello!\`",
-          },
-          "tagName": "hbs",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('hbs`Hello!` with imports @ember/template-compilation', function () {
-    const input =
-      "import { hbs } from '@ember/template-compilation'; hbs`Hello!`";
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: '@ember/template-compilation',
-          importIdentifier: 'precompileTemplate',
-        },
-        {
-          importPath: '@ember/template-compilation',
-          importIdentifier: 'hbs',
-        },
-      ],
-    });
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Hello!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 61,
-            "input": "import { hbs } from '@ember/template-compilation'; hbs\`Hello!\`",
-          },
-          "importIdentifier": "hbs",
-          "importPath": "@ember/template-compilation",
-          "start": Object {
-            "0": "hbs\`",
-            "1": "hbs",
-            "groups": undefined,
-            "index": 51,
-            "input": "import { hbs } from '@ember/template-compilation'; hbs\`Hello!\`",
-          },
-          "tagName": "hbs",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('hbs`Hello!` with imports ember-template-imports', function () {
-    const input = "import { hbs } from 'ember-template-imports'; hbs`Hello!`";
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-template-imports',
-          importIdentifier: 'hbs',
-        },
-      ],
-    });
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Hello!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 56,
-            "input": "import { hbs } from 'ember-template-imports'; hbs\`Hello!\`",
-          },
-          "importIdentifier": "hbs",
-          "importPath": "ember-template-imports",
-          "start": Object {
-            "0": "hbs\`",
-            "1": "hbs",
-            "groups": undefined,
-            "index": 46,
-            "input": "import { hbs } from 'ember-template-imports'; hbs\`Hello!\`",
-          },
-          "tagName": "hbs",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('renamed hbs`Hello!` with (default) import ember-cli-htmlbars-inline-precompile', function () {
-    const input =
-      "import theHbs from 'ember-cli-htmlbars-inline-precompile'; theHbs`Hello!`";
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-cli-htmlbars-inline-precompile',
-          importIdentifier: 'default',
-        },
-      ],
-    });
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Hello!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 72,
-            "input": "import theHbs from 'ember-cli-htmlbars-inline-precompile'; theHbs\`Hello!\`",
-          },
-          "importIdentifier": "default",
-          "importPath": "ember-cli-htmlbars-inline-precompile",
-          "start": Object {
-            "0": "theHbs\`",
-            "1": "theHbs",
-            "groups": undefined,
-            "index": 59,
-            "input": "import theHbs from 'ember-cli-htmlbars-inline-precompile'; theHbs\`Hello!\`",
-          },
-          "tagName": "theHbs",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('hbs`Hello!` with (default) import htmlbars-inline-precompile', function () {
-    const input = "import hbs from 'htmlbars-inline-precompile'; hbs`Hello!`";
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'htmlbars-inline-precompile',
-          importIdentifier: 'default',
-        },
-      ],
-    });
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Hello!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 56,
-            "input": "import hbs from 'htmlbars-inline-precompile'; hbs\`Hello!\`",
-          },
-          "importIdentifier": "default",
-          "importPath": "htmlbars-inline-precompile",
-          "start": Object {
-            "0": "hbs\`",
-            "1": "hbs",
-            "groups": undefined,
-            "index": 46,
-            "input": "import hbs from 'htmlbars-inline-precompile'; hbs\`Hello!\`",
-          },
-          "tagName": "hbs",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('precompileTemplate`Hello!` with import @ember/template-compilation', function () {
-    const input =
-      "import { precompileTemplate } from '@ember/template-compilation'; precompileTemplate`Hello!`";
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: '@ember/template-compilation',
-          importIdentifier: 'hbs',
-        },
-        {
-          importPath: '@ember/template-compilation',
-          importIdentifier: 'precompileTemplate',
-        },
-      ],
-    });
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Hello!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 91,
-            "input": "import { precompileTemplate } from '@ember/template-compilation'; precompileTemplate\`Hello!\`",
-          },
-          "importIdentifier": "precompileTemplate",
-          "importPath": "@ember/template-compilation",
-          "start": Object {
-            "0": "precompileTemplate\`",
-            "1": "precompileTemplate",
-            "groups": undefined,
-            "index": 66,
-            "input": "import { precompileTemplate } from '@ember/template-compilation'; precompileTemplate\`Hello!\`",
-          },
-          "tagName": "precompileTemplate",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('hbs`Hello!` with imports alias', function () {
-    const input =
-      "import { hbs as someHbs } from 'ember-cli-htmlbars';\n" +
-      "import theHbs from 'htmlbars-inline-precompile';\n" +
-      "import { hbs } from 'not-the-hbs-you-want';\n" +
-      'hbs`Hello!`\n' +
-      'someHbs`Howdy!`\n' +
-      'theHbs`Hi!`';
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-cli-htmlbars',
-          importIdentifier: 'hbs',
-        },
-        {
-          importPath: 'htmlbars-inline-precompile',
-          importIdentifier: 'default',
-        },
-      ],
-    });
-
-    const expected = [
-      {
-        contents: 'Howdy!',
-        end: {
-          0: '`',
-          1: undefined,
-          groups: undefined,
-          index: 172,
-          input,
-        },
-        importIdentifier: 'hbs',
-        importPath: 'ember-cli-htmlbars',
-        start: {
-          0: 'someHbs`',
-          1: 'someHbs',
-          groups: undefined,
-          index: 158,
-          input,
-        },
-        tagName: 'someHbs',
-        type: 'template-literal',
-      },
-      {
-        contents: 'Hi!',
-        end: {
-          0: '`',
-          1: undefined,
-          groups: undefined,
-          index: 184,
-          input,
-        },
-        importIdentifier: 'default',
-        importPath: 'htmlbars-inline-precompile',
-        start: {
-          0: 'theHbs`',
-          1: 'theHbs',
-          groups: undefined,
-          index: 174,
-          input,
-        },
-        tagName: 'theHbs',
-        type: 'template-literal',
-      },
-    ];
-
-    expect(templates).toEqual(expected);
-  });
-
-  it('with multiple identifiers for the same import path', function () {
-    const input =
-      "import someDefaultHbs, { hbs as someHbs } from 'ember-cli-htmlbars';\n" +
-      "import theHbs from 'htmlbars-inline-precompile';\n" +
-      "import { hbs } from 'not-the-hbs-you-want';\n" +
-      'hbs`Hello!`\n' +
-      'someDefaultHbs`Hello!`\n' +
-      'someHbs`Howdy!`\n' +
-      'theHbs`Hi!`';
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-cli-htmlbars',
-          importIdentifier: 'hbs',
-        },
-        {
-          importPath: 'ember-cli-htmlbars',
-          importIdentifier: 'default',
-        },
-        {
-          importPath: 'htmlbars-inline-precompile',
-          importIdentifier: 'default',
-        },
-      ],
-    });
-
-    const expected = [
-      {
-        contents: 'Hello!',
-        end: {
-          0: '`',
-          1: undefined,
-          groups: undefined,
-          index: 195,
-          input,
-        },
-        importIdentifier: 'default',
-        importPath: 'ember-cli-htmlbars',
-        start: {
-          0: 'someDefaultHbs`',
-          1: 'someDefaultHbs',
-          groups: undefined,
-          index: 174,
-          input,
-        },
-        tagName: 'someDefaultHbs',
-        type: 'template-literal',
-      },
-      {
-        contents: 'Howdy!',
-        end: {
-          0: '`',
-          1: undefined,
-          groups: undefined,
-          index: 211,
-          input,
-        },
-        importIdentifier: 'hbs',
-        importPath: 'ember-cli-htmlbars',
-        start: {
-          0: 'someHbs`',
-          1: 'someHbs',
-          groups: undefined,
-          index: 197,
-          input,
-        },
-        tagName: 'someHbs',
-        type: 'template-literal',
-      },
-      {
-        contents: 'Hi!',
-        end: {
-          0: '`',
-          1: undefined,
-          groups: undefined,
-          index: 223,
-          input,
-        },
-        importIdentifier: 'default',
-        importPath: 'htmlbars-inline-precompile',
-        start: {
-          0: 'theHbs`',
-          1: 'theHbs',
-          groups: undefined,
-          index: 213,
-          input,
-        },
-        tagName: 'theHbs',
-        type: 'template-literal',
-      },
-    ];
-
-    expect(templates).toEqual(expected);
-  });
-
-  it('with multiple identifiers for the same import path with DEFAULT_PARSE_TEMPLATES_OPTIONS', function () {
-    const input =
-      "import someDefaultHbs, { hbs as someHbs } from 'ember-cli-htmlbars';\n" +
-      "import theHbs from 'htmlbars-inline-precompile';\n" +
-      "import { hbs } from 'not-the-hbs-you-want';\n" +
-      'hbs`Hello!`\n' +
-      'someDefaultHbs`Hello!`\n' +
-      'someHbs`Howdy!`\n' +
-      'theHbs`Hi!`';
-
-    const templates = parseTemplates(
-      input,
-      'foo.js',
-      DEFAULT_PARSE_TEMPLATES_OPTIONS
-    );
-
-    expect(templates).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "contents": "Howdy!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 211,
-            "input": "import someDefaultHbs, { hbs as someHbs } from 'ember-cli-htmlbars';
-      import theHbs from 'htmlbars-inline-precompile';
-      import { hbs } from 'not-the-hbs-you-want';
-      hbs\`Hello!\`
-      someDefaultHbs\`Hello!\`
-      someHbs\`Howdy!\`
-      theHbs\`Hi!\`",
-          },
-          "importIdentifier": "hbs",
-          "importPath": "ember-cli-htmlbars",
-          "start": Object {
-            "0": "someHbs\`",
-            "1": "someHbs",
-            "groups": undefined,
-            "index": 197,
-            "input": "import someDefaultHbs, { hbs as someHbs } from 'ember-cli-htmlbars';
-      import theHbs from 'htmlbars-inline-precompile';
-      import { hbs } from 'not-the-hbs-you-want';
-      hbs\`Hello!\`
-      someDefaultHbs\`Hello!\`
-      someHbs\`Howdy!\`
-      theHbs\`Hi!\`",
-          },
-          "tagName": "someHbs",
-          "type": "template-literal",
-        },
-        Object {
-          "contents": "Hi!",
-          "end": Object {
-            "0": "\`",
-            "1": undefined,
-            "groups": undefined,
-            "index": 223,
-            "input": "import someDefaultHbs, { hbs as someHbs } from 'ember-cli-htmlbars';
-      import theHbs from 'htmlbars-inline-precompile';
-      import { hbs } from 'not-the-hbs-you-want';
-      hbs\`Hello!\`
-      someDefaultHbs\`Hello!\`
-      someHbs\`Howdy!\`
-      theHbs\`Hi!\`",
-          },
-          "importIdentifier": "default",
-          "importPath": "htmlbars-inline-precompile",
-          "start": Object {
-            "0": "theHbs\`",
-            "1": "theHbs",
-            "groups": undefined,
-            "index": 213,
-            "input": "import someDefaultHbs, { hbs as someHbs } from 'ember-cli-htmlbars';
-      import theHbs from 'htmlbars-inline-precompile';
-      import { hbs } from 'not-the-hbs-you-want';
-      hbs\`Hello!\`
-      someDefaultHbs\`Hello!\`
-      someHbs\`Howdy!\`
-      theHbs\`Hi!\`",
-          },
-          "tagName": "theHbs",
-          "type": "template-literal",
-        },
-      ]
-    `);
-  });
-
-  it('hbs`Hello!` with multiple imports and alias', function () {
-    const input =
-      "import { hbs as someHbs } from 'ember-cli-htmlbars';\n" +
-      "import { hbs } from 'not-the-hbs-you-want';\n" +
-      'hbs`Hello!`\n' +
-      'someHbs`Howdy!`';
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-cli-htmlbars',
-          importIdentifier: 'hbs',
-        },
-      ],
-    });
-
-    const expected = [
-      {
-        contents: 'Howdy!',
-        end: {
-          0: '`',
-          1: undefined,
-          groups: undefined,
-          index: 123,
-          input,
-        },
-        importIdentifier: 'hbs',
-        importPath: 'ember-cli-htmlbars',
-        start: {
-          0: 'someHbs`',
-          1: 'someHbs',
-          groups: undefined,
-          index: 109,
-          input,
-        },
-        tagName: 'someHbs',
-        type: 'template-literal',
-      },
-    ];
-
-    expect(templates).toEqual(expected);
-  });
-
-  it('lol`hahahaha` with options', function () {
-    const input = 'lol`hahaha`';
-
-    const templates = parseTemplates(input, 'foo.js', {
-      templateTag: 'template',
-      templateLiteral: [
-        {
-          importPath: 'ember-cli-htmlbars',
-          importIdentifier: 'hbs',
-        },
-      ],
-    });
-
-    expect(templates).toEqual([]);
-  });
 });
diff --git a/__tests__/preprocess-embedded-templates.test.ts b/__tests__/preprocess-embedded-templates.test.ts
index a8e7999..4d2b39c 100644
--- a/__tests__/preprocess-embedded-templates.test.ts
+++ b/__tests__/preprocess-embedded-templates.test.ts
@@ -39,8 +39,8 @@ describe('preprocessEmbeddedTemplates', function () {
     expect(templates).toEqual(expected);
   });
 
-  it('<template></template> with backticks in content', function () {
-    const input = '<template>Hello `world`!</template>';
+  it('<template></template> with no content', function () {
+    const input = '<template></template>';
     const templates = preprocessEmbeddedTemplates(input, {
       getTemplateLocals,
       relativePath: 'foo.gjs',
@@ -51,8 +51,7 @@ describe('preprocessEmbeddedTemplates', function () {
     });
 
     const expected = {
-      output:
-        '[__GLIMMER_TEMPLATE(`Hello \\`world\\`!`, { strictMode: true })]',
+      output: '[__GLIMMER_TEMPLATE(``, { strictMode: true })]',
       replacements: [
         {
           type: 'start',
@@ -64,10 +63,10 @@ describe('preprocessEmbeddedTemplates', function () {
         },
         {
           type: 'end',
-          index: 24,
+          index: 10,
           oldLength: 11,
           newLength: 25,
-          originalCol: 25,
+          originalCol: 11,
           originalLine: 1,
         },
       ],
@@ -76,82 +75,36 @@ describe('preprocessEmbeddedTemplates', function () {
     expect(templates).toEqual(expected);
   });
 
-  it('hbs`Hello`', function () {
-    const input = `hbs\`Hello!\``;
-    const templates = preprocessEmbeddedTemplates(input, {
-      getTemplateLocals,
-      relativePath: 'foo.gjs',
-      templateTag: util.TEMPLATE_TAG_NAME,
-      templateTagReplacement: util.TEMPLATE_TAG_PLACEHOLDER,
-      importIdentifier: util.TEMPLATE_LITERAL_IDENTIFIER,
-      importPath: util.TEMPLATE_LITERAL_MODULE_SPECIFIER,
-      includeSourceMaps: false,
-      includeTemplateTokens: false,
-    });
-
-    const expected = {
-      output: input,
-      replacements: [],
-    };
-
-    expect(templates).toEqual(expected);
-  });
-
-  it('hbs`Hello \\`world\\``', function () {
-    const input = `hbs\`Hello \\\`world\\\`!\``; // template tag with escaped backticks in content
-    const templates = preprocessEmbeddedTemplates(input, {
-      getTemplateLocals,
-      relativePath: 'foo.gjs',
-      templateTag: util.TEMPLATE_TAG_NAME,
-      templateTagReplacement: util.TEMPLATE_TAG_PLACEHOLDER,
-      importIdentifier: util.TEMPLATE_LITERAL_IDENTIFIER,
-      importPath: util.TEMPLATE_LITERAL_MODULE_SPECIFIER,
-      includeSourceMaps: false,
-      includeTemplateTokens: false,
-    });
-
-    const expected = {
-      output: input,
-      replacements: [],
-    };
-
-    expect(templates).toEqual(expected);
-  });
-
-  it('hbs`Hello` with import statement', function () {
-    const input =
-      `import { hbs } from 'ember-template-imports'\n` +
-      'const Greeting = hbs`Hello!`\n';
+  it('<template></template> with backticks in content', function () {
+    const input = '<template>Hello `world`!</template>';
     const templates = preprocessEmbeddedTemplates(input, {
       getTemplateLocals,
       relativePath: 'foo.gjs',
       templateTag: util.TEMPLATE_TAG_NAME,
       templateTagReplacement: util.TEMPLATE_TAG_PLACEHOLDER,
-      importIdentifier: util.TEMPLATE_LITERAL_IDENTIFIER,
-      importPath: util.TEMPLATE_LITERAL_MODULE_SPECIFIER,
       includeSourceMaps: false,
       includeTemplateTokens: false,
     });
 
     const expected = {
       output:
-        "import { hbs } from 'ember-template-imports'\nconst Greeting = hbs(`Hello!`, { strictMode: true })\n",
+        '[__GLIMMER_TEMPLATE(`Hello \\`world\\`!`, { strictMode: true })]',
       replacements: [
         {
           type: 'start',
-          index: 62,
-          oldLength: 4,
-          newLength: 5,
-          originalCol: 18,
-          originalLine: 2,
+          index: 0,
+          oldLength: 10,
+          newLength: 21,
+          originalCol: 1,
+          originalLine: 1,
         },
         {
           type: 'end',
-          index: 72,
-          oldLength: 1,
-          newLength: 24,
-          originalCol: 28,
-          originalLine: 2,
+          index: 24,
+          oldLength: 11,
+          newLength: 25,
+          originalCol: 25,
+          originalLine: 1,
         },
       ],
     };
@@ -185,4 +138,21 @@ describe('preprocessEmbeddedTemplates', function () {
 
     expect(templates.output).not.toContain('//# sourceMappingURL');
   });
+
+  it('does not parse <template> within template-literals', function () {
+    const input = `
+      const DEMO = \`<template>Hi there</template>\`;
+    `;
+
+    const templates = preprocessEmbeddedTemplates(input, {
+      getTemplateLocals,
+      relativePath: 'foo.gjs',
+      templateTag: util.TEMPLATE_TAG_NAME,
+      templateTagReplacement: util.TEMPLATE_TAG_PLACEHOLDER,
+      includeSourceMaps: true,
+      includeTemplateTokens: false,
+    });
+
+    expect(templates.output).not.toContain(util.TEMPLATE_TAG_PLACEHOLDER);
+  });
 });
diff --git a/package.json b/package.json
index fd713d6..1153e7e 100644
--- a/package.json
+++ b/package.json
@@ -37,7 +37,6 @@
     "ember-cli-version-checker": "^5.1.2",
     "line-column": "^1.0.2",
     "magic-string": "^0.25.7",
-    "parse-static-imports": "^1.1.0",
     "string.prototype.matchall": "^4.0.6",
     "validate-peer-dependencies": "^1.1.0"
   },
diff --git a/src/babel-plugin.js b/src/babel-plugin.js
index 892d955..6b924fd 100644
--- a/src/babel-plugin.js
+++ b/src/babel-plugin.js
@@ -1,6 +1,5 @@
 const { ImportUtil } = require('babel-import-util');
 const util = require('../lib/util');
-const { transformTemplateLiteral } = require('./template-literal-transform');
 const { transformTemplateTag } = require('./template-tag-transform');
 
 /**
@@ -11,13 +10,7 @@ const { transformTemplateTag } = require('./template-tag-transform');
  * Its goal is to convert code like this:
  *
  * ```js
- * import { hbs } from 'ember-template-imports';
- *
- * const A = hbs(`A`, {...});
  * const B = [__GLIMMER_TEMPLATE(`B`, {...})];
- * class C {
- *   template = hbs(`C`, {...});
- * }
  *
  * [__GLIMMER_TEMPLATE(`default`, {...})];
  *
@@ -33,16 +26,10 @@ const { transformTemplateTag } = require('./template-tag-transform');
  * import { setComponentTemplate } from '@ember/component';
  * import templateOnlyComponent from '@ember/component/template-only';
  *
- * const A = setComponentTemplate(
- *   precompileTemplate(`A`, {...}),
- *   templateOnlyComponent('this-module.js', 'A')
- * );
  * const B = setComponentTemplate(
  *   precompileTemplate(`B`, {...}),
  *   templateOnlyComponent('this-module.js', 'B')
  * );
- * class C {}
- * setComponentTemplate(precompileTemplate(`C`, {...}), C);
  *
  * export default setComponentTemplate(
  *   precompileTemplate(`default`, {...}),
@@ -60,14 +47,6 @@ module.exports = function (babel) {
       enter(path, state) {
         state.importUtil = new ImportUtil(t, path);
       },
-      exit(path, state) {
-        if (state.hadTaggedTemplate) {
-          state.importUtil.removeImport(
-            util.TEMPLATE_LITERAL_MODULE_SPECIFIER,
-            util.TEMPLATE_LITERAL_IDENTIFIER
-          );
-        }
-      },
     },
 
     // Process class bodies before things like class properties get transformed
@@ -91,10 +70,7 @@ module.exports = function (babel) {
     },
 
     CallExpression(path, state) {
-      if (util.isTemplateLiteral(path)) {
-        state.hadTaggedTemplate = true;
-        transformTemplateLiteral(t, path, state);
-      } else if (util.isTemplateTag(path)) {
+      if (util.isTemplateTag(path)) {
         transformTemplateTag(t, path, state);
       }
     },
diff --git a/src/parse-templates.ts b/src/parse-templates.ts
index 183dea4..b74936f 100644
--- a/src/parse-templates.ts
+++ b/src/parse-templates.ts
@@ -1,14 +1,9 @@
 import matchAll from 'string.prototype.matchall';
-import parseStaticImports from 'parse-static-imports';
 
-import {
-  TEMPLATE_TAG_NAME,
-  TEMPLATE_LITERAL_MODULE_SPECIFIER,
-  TEMPLATE_LITERAL_IDENTIFIER,
-} from './util';
+import { TEMPLATE_TAG_NAME } from './util';
 import { expect } from './debug';
 
-export type TemplateMatch = TemplateTagMatch | TemplateLiteralMatch;
+export type TemplateMatch = TemplateTagMatch;
 
 export interface TemplateTagMatch {
   type: 'template-tag';
@@ -18,49 +13,14 @@ export interface TemplateTagMatch {
   contents: string;
 }
 
-export interface TemplateLiteralMatch {
-  type: 'template-literal';
-  tagName: string;
-  contents: string;
-  start: RegExpMatchArray;
-  end: RegExpMatchArray;
-  importPath: string;
-  importIdentifier: string;
-}
-
-export function isTemplateLiteralMatch(
-  template: TemplateTagMatch | TemplateLiteralMatch
-): template is TemplateLiteralMatch {
-  return template.type === 'template-literal';
-}
-
-/**
- * Represents a static import of a template literal.
- */
-export interface StaticImportConfig {
-  /**
-   * The path to the package from which we want to import the template literal
-   * (e.g.: 'ember-cli-htmlbars')
-   */
-  importPath: string;
-  /**
-   * The name of the template literal (e.g.: 'hbs') or 'default' if this package
-   * exports a default function
-   */
-  importIdentifier: string;
-}
-
 /**
  * The input options to instruct parseTemplates on how to parse the input.
  *
  * @param templateTag
- * @param templateLiteral
  */
 export interface ParseTemplatesOptions {
   /** Tag to use, if parsing template tags is enabled. */
   templateTag?: string;
-  /** Which static imports are expected in this template. */
-  templateLiteral?: StaticImportConfig[];
 }
 
 const escapeChar = '\\';
@@ -93,41 +53,11 @@ function isEscaped(template: string, _offset: number | undefined) {
 
 export const DEFAULT_PARSE_TEMPLATES_OPTIONS = {
   templateTag: TEMPLATE_TAG_NAME,
-  templateLiteral: [
-    {
-      importPath: 'ember-cli-htmlbars',
-      importIdentifier: 'hbs',
-    },
-    {
-      importPath: '@ember/template-compilation',
-      importIdentifier: 'hbs',
-    },
-    {
-      importPath: TEMPLATE_LITERAL_MODULE_SPECIFIER,
-      importIdentifier: TEMPLATE_LITERAL_IDENTIFIER,
-    },
-    {
-      importPath: 'ember-cli-htmlbars-inline-precompile',
-      importIdentifier: 'default',
-    },
-    {
-      importPath: 'htmlbars-inline-precompile',
-      importIdentifier: 'default',
-    },
-    {
-      importPath: '@ember/template-compilation',
-      importIdentifier: 'precompileTemplate',
-    },
-  ],
 };
 
 /**
  * Parses a template to find all possible valid matches for an embedded template.
- * Supported syntaxes are template literals:
- *
- *   hbs`Hello, world!`
- *
- * And template tags
+ * Template tags are the only supported syntax
  *
  *   <template></template>
  *
@@ -147,17 +77,11 @@ export function parseTemplates(
 ): TemplateMatch[] {
   const results: TemplateMatch[] = [];
   const templateTag = options?.templateTag;
-  const templateLiteralConfig = options?.templateLiteral;
 
   const templateTagStart = new RegExp(`<${templateTag}[^<]*>`);
   const templateTagEnd = new RegExp(`</${templateTag}>`);
   const argumentsMatchRegex = new RegExp(`<${templateTag}[^<]*\\S[^<]*>`);
 
-  let importedNames = new Map<string, StaticImportConfig>();
-  if (templateLiteralConfig) {
-    importedNames = findImportedNames(template, templateLiteralConfig);
-  }
-
   const allTokens = new RegExp(
     [
       singleLineCommentStart.source,
@@ -200,14 +124,7 @@ export function parseTemplates(
     } else if (token[0].match(singleLineCommentStart)) {
       parseSingleLineComment(results, template, token, tokens);
     } else if (token[0].match(templateLiteralStart)) {
-      parseTemplateLiteral(
-        results,
-        template,
-        token,
-        tokens,
-        isTopLevel,
-        importedNames
-      );
+      parseTemplateLiteral(template, tokens);
     } else if (
       isTopLevel &&
       templateTag !== undefined &&
@@ -286,89 +203,13 @@ export function parseTemplates(
    * literal is top level (e.g. not nested within a dynamic segment) and has a
    * tag, pushes it into the list of results.
    */
-  function parseTemplateLiteral(
-    results: TemplateMatch[],
-    template: string,
-    startToken: RegExpMatchArray,
-    tokens: RegExpMatchArray[],
-    isTopLevel = false,
-    importedNames: Map<string, StaticImportConfig>
-  ) {
-    let hasDynamicSegment = false;
-
-    while (tokens.length > 0) {
-      let currentToken = expect(tokens.shift(), 'expected token');
-
-      if (isEscaped(template, currentToken.index)) continue;
-
-      if (currentToken[0].match(dynamicSegmentStart)) {
-        hasDynamicSegment = true;
-
-        parseDynamicSegment(results, template, currentToken, tokens);
-      } else if (currentToken[0].match(templateLiteralEnd)) {
-        if (isTopLevel && !hasDynamicSegment && startToken[1]?.length > 0) {
-          // Handle the case where a tag-like was matched, e.g. hbs`hello`
-          if (currentToken[0].length > 1) {
-            const tokenStr = currentToken[0];
-            const index = expect(currentToken.index, 'expected index');
-
-            currentToken = ['`'];
-            currentToken.index = index + tokenStr.length - 1;
-          }
-          const tagName = startToken[1];
-          const importConfig = importedNames.get(tagName);
-
-          if (importConfig !== undefined) {
-            let contents = '';
-
-            if (startToken.index !== undefined) {
-              const templateStart = startToken.index + startToken[0].length;
-
-              contents = template.slice(templateStart, currentToken.index);
-            }
-
-            results.push({
-              type: 'template-literal',
-              tagName,
-              contents: contents,
-              start: startToken,
-              end: currentToken,
-              importPath: importConfig.importPath,
-              importIdentifier: importConfig.importIdentifier,
-            });
-          }
-        }
-
-        return;
-      }
-    }
-  }
-
-  /**
-   * Parses a dynamic segment within a template literal. Continues parsing until
-   * the dynamic segment has been exited, ignoring all tokens within it.
-   * Accounts for nested block statements, strings, and template literals.
-   */
-  function parseDynamicSegment(
-    results: TemplateMatch[],
-    template: string,
-    _startToken: RegExpMatchArray,
-    tokens: RegExpMatchArray[]
-  ) {
-    let stack = 1;
-
+  function parseTemplateLiteral(template: string, tokens: RegExpMatchArray[]) {
     while (tokens.length > 0) {
       const currentToken = expect(tokens.shift(), 'expected token');
 
-      if (currentToken[0].match(blockStart)) {
-        stack++;
-      } else if (currentToken[0].match(dynamicSegmentEnd)) {
-        stack--;
-      } else {
-        parseToken(results, template, currentToken, tokens);
-      }
+      if (isEscaped(template, currentToken.index)) continue;
 
-      if (stack === 0) {
+      if (currentToken[0].match(templateLiteralEnd)) {
         return;
       }
     }
@@ -426,37 +267,3 @@ export function parseTemplates(
 
   return results;
 }
-
-function findImportedNames(
-  template: string,
-  importConfig: StaticImportConfig[]
-): Map<string, StaticImportConfig> {
-  const importedNames = new Map<string, StaticImportConfig>();
-
-  for (const $import of parseStaticImports(template)) {
-    for (const $config of findImportConfigByImportPath(
-      importConfig,
-      $import.moduleName
-    )) {
-      if ($import.defaultImport && $config.importIdentifier === 'default') {
-        importedNames.set($import.defaultImport, $config);
-      }
-      const match = $import.namedImports.find(
-        ({ name }) => $config.importIdentifier === name
-      );
-      if (match) {
-        const localName = match.alias || match.name;
-        importedNames.set(localName, $config);
-      }
-    }
-  }
-
-  return importedNames;
-}
-
-function findImportConfigByImportPath(
-  importConfig: StaticImportConfig[],
-  importPath: string
-): StaticImportConfig[] {
-  return importConfig.filter((config) => config.importPath === importPath);
-}
diff --git a/src/preprocess-embedded-templates.ts b/src/preprocess-embedded-templates.ts
index c00974d..1250a57 100644
--- a/src/preprocess-embedded-templates.ts
+++ b/src/preprocess-embedded-templates.ts
@@ -11,8 +11,6 @@ import {
 interface PreprocessOptionsEager {
   getTemplateLocals: GetTemplateLocals;
 
-  importIdentifier?: string;
-  importPath?: string;
   templateTag?: string;
   templateTagReplacement?: string;
 
@@ -25,8 +23,6 @@ interface PreprocessOptionsLazy {
   getTemplateLocalsRequirePath: string;
   getTemplateLocalsExportPath: string;
 
-  importIdentifier?: string;
-  importPath?: string;
   templateTag?: string;
   templateTagReplacement?: string;
 
@@ -167,16 +163,6 @@ function replaceMatch(
  * Output:
  *
  *   [GLIMMER_TEMPLATE(`<MyComponent/>`, { scope() { return {MyComponent}; } })];
- *
- * It can also be used with template literals to provide the in scope values:
- *
- * Input:
- *
- *   hbs`<MyComponent/>`;
- *
- * Output
- *
- *   hbs(`<MyComponent/>`, { scope() { return {MyComponent}; } });
  */
 export function preprocessEmbeddedTemplates(
   template: string,
@@ -185,7 +171,6 @@ export function preprocessEmbeddedTemplates(
   let getTemplateLocals: GetTemplateLocals;
 
   const {
-    importPath,
     templateTag,
     templateTagReplacement,
     includeSourceMaps,
@@ -193,8 +178,6 @@ export function preprocessEmbeddedTemplates(
     relativePath,
   } = options;
 
-  const { importIdentifier } = options;
-
   if ('getTemplateLocals' in options) {
     getTemplateLocals = options.getTemplateLocals;
   } else {
@@ -208,36 +191,12 @@ export function preprocessEmbeddedTemplates(
     templateTag,
   };
 
-  if (importPath && importIdentifier) {
-    parseTemplatesOptions.templateLiteral = [
-      {
-        importPath,
-        importIdentifier,
-      },
-    ];
-  }
-
   const matches = parseTemplates(template, relativePath, parseTemplatesOptions);
   const replacements: Replacement[] = [];
   const s = new MagicString(template);
 
   for (const match of matches) {
-    if (
-      match.type === 'template-literal' &&
-      match.tagName === importIdentifier
-    ) {
-      replacements.push(
-        ...replaceMatch(
-          s,
-          match,
-          `${match.tagName}(`,
-          ')',
-          template,
-          getTemplateLocals,
-          includeTemplateTokens
-        )
-      );
-    } else if (match.type === 'template-tag') {
+    if (match.type === 'template-tag') {
       replacements.push(
         ...replaceMatch(
           s,
@@ -275,6 +234,7 @@ export function preprocessEmbeddedTemplates(
 }
 
 function ensureBackticksEscaped(s: MagicString, start: number, end: number) {
+  if (start >= end) return;
   let content = s.slice(start, end);
   content = content.replace(/(?<!\\)`/g, '\\`');
   s.overwrite(start, end, content, false);
diff --git a/src/preprocessor-plugin.js b/src/preprocessor-plugin.js
index fa6060c..bd7eebd 100644
--- a/src/preprocessor-plugin.js
+++ b/src/preprocessor-plugin.js
@@ -9,12 +9,6 @@ const {
  * tagged template strings and embedded `<template>` tags like these:
  *
  * ```js
- * import { hbs } from 'ember-template-imports';
- *
- * const ComponentA = hbs`
- *   <Greeting />, World!
- * `;
- *
  * const ComponentB = <template>
  *   <Greeting />, World!
  * </template>;
@@ -30,12 +24,6 @@ const {
  * processed in our Babel plugin.
  *
  * ```js
- * import { hbs } from 'ember-template-imports';
- *
- * const ComponentA = hbs(`
- *   <Greeting />, World!
- * `, { strictMode: true, scope: () => ({ Greeting }) });
- *
  * const ComponentB = [__GLIMMER_TEMPLATE(`
  *   <Greeting />, World!
  * `, { strictMode: true, scope: () => ({ Greeting }) })];
@@ -61,37 +49,21 @@ module.exports = class TemplateImportPreprocessor {
       includeSourceMaps: true,
       includeTemplateTokens: true,
     };
-
-    this.templateLiteralConfig = {
-      getTemplateLocalsExportPath: '_GlimmerSyntax.getTemplateLocals',
-
-      importIdentifier: util.TEMPLATE_LITERAL_IDENTIFIER,
-      importPath: util.TEMPLATE_LITERAL_MODULE_SPECIFIER,
-
-      includeSourceMaps: true,
-      includeTemplateTokens: true,
-    };
   }
 
   toTree(tree) {
-    let compiled = stew.map(
-      tree,
-      `**/*.{js,gjs,ts,gts}`,
-      (string, relativePath) => {
-        let config = {
-          relativePath,
-          getTemplateLocalsRequirePath: this.getTemplateCompilerPath(),
-        };
-
-        if (relativePath.match(/\.(gjs|gts)$/)) {
-          Object.assign(config, this.templateTagConfig);
-        } else {
-          Object.assign(config, this.templateLiteralConfig);
-        }
+    let compiled = stew.map(tree, `**/*.{gjs,gts}`, (string, relativePath) => {
+      let config = {
+        relativePath,
+        getTemplateLocalsRequirePath: this.getTemplateCompilerPath(),
+      };
 
-        return preprocessEmbeddedTemplates(string, config).output;
+      if (relativePath.match(/\.(gjs|gts)$/)) {
+        Object.assign(config, this.templateTagConfig);
       }
-    );
+
+      return preprocessEmbeddedTemplates(string, config).output;
+    });
 
     return stew.rename(compiled, (name) => {
       return name.replace(/\.gjs$/, '.js').replace(/\.gts$/, '.ts');
diff --git a/src/template-literal-transform.js b/src/template-literal-transform.js
deleted file mode 100644
index 5e3bdc2..0000000
--- a/src/template-literal-transform.js
+++ /dev/null
@@ -1,123 +0,0 @@
-const filePath = require('path');
-const {
-  registerRefs,
-  TEMPLATE_LITERAL_IDENTIFIER,
-  buildPrecompileTemplateCall,
-} = require('../lib/util');
-
-module.exports.transformTemplateLiteral = function (t, path, state) {
-  let { parentPath } = path;
-  let compiled = buildPrecompileTemplateCall(t, path, state);
-  let filename = filePath.parse(state.file.opts.filename).name;
-
-  if (parentPath.node.type === 'ClassProperty') {
-    if (parentPath.node.static !== true) {
-      throw path.buildCodeFrameError(
-        `Attempted to use \`${TEMPLATE_LITERAL_IDENTIFIER}\` with a non-static class field. Templates declared with this helper must be assigned to the \`static template\` class field`
-      );
-    }
-
-    if (parentPath.node.key.name !== 'template') {
-      throw path.buildCodeFrameError(
-        `Attempted to use \`${TEMPLATE_LITERAL_IDENTIFIER}\` with the ${parentPath.node.key.name} class property. Templates declared with this helper must be assigned to the \`static template\` class field`
-      );
-    }
-
-    let classPath = parentPath.parentPath.parentPath;
-
-    if (classPath.node.type === 'ClassDeclaration') {
-      if (classPath.node.id === null) {
-        registerRefs(
-          classPath.replaceWith(
-            buildClassExpression(t, state, classPath, compiled)
-          ),
-          (newPath) => [newPath.parentPath.get('declaration')]
-        );
-      } else {
-        registerRefs(
-          classPath.insertAfter(
-            t.expressionStatement(
-              t.callExpression(buildSetComponentTemplate(classPath, state), [
-                compiled,
-                classPath.node.id,
-              ])
-            )
-          ),
-          (newPath) => [
-            newPath.get('expression.callee'),
-            newPath.get('expression.arguments.0.callee'),
-          ]
-        );
-      }
-    } else {
-      registerRefs(
-        classPath.replaceWith(
-          t.expressionStatement(
-            t.callExpression(buildSetComponentTemplate(classPath, state), [
-              compiled,
-              classPath.node,
-            ])
-          )
-        ),
-        (newPath) => [
-          newPath.parentPath.get('callee'),
-          newPath.parentPath.get('arguments.0.callee'),
-        ]
-      );
-    }
-
-    parentPath.remove();
-  } else {
-    let varId =
-      parentPath.node.id || path.scope.generateUidIdentifier(filename);
-
-    registerRefs(
-      path.replaceWith(
-        t.callExpression(buildSetComponentTemplate(path, state), [
-          compiled,
-          t.callExpression(
-            state.importUtil.import(
-              path,
-              '@ember/component/template-only',
-              'default',
-              'templateOnly'
-            ),
-            [t.stringLiteral(filename), t.stringLiteral(varId.name)]
-          ),
-        ])
-      ),
-      (newPath) => [
-        newPath.get('callee'),
-        newPath.get('arguments.0.callee'),
-        newPath.get('arguments.1.callee'),
-      ]
-    );
-  }
-};
-
-function buildSetComponentTemplate(path, state) {
-  return state.importUtil.import(
-    path,
-    '@ember/component',
-    'setComponentTemplate'
-  );
-}
-
-function buildClassExpression(t, state, classPath, compiled) {
-  return t.callExpression(
-    state.importUtil.import(
-      classPath,
-      '@ember/component',
-      'setComponentTemplate'
-    ),
-    [
-      compiled,
-      t.classExpression(
-        classPath.node.id,
-        classPath.node.superClass,
-        classPath.node.body,
-        classPath.node.decorators
-      ),
-    ]
-  );
-}
diff --git a/src/util.ts b/src/util.ts
index 7eb8fc6..904ac67 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -2,26 +2,7 @@ import type { ImportUtil } from 'babel-import-util';
 
 import type { NodePath } from '@babel/traverse';
 import type * as babelTypes from '@babel/types';
-import { isTemplateLiteralMatch, TemplateMatch } from './parse-templates';
-
-// import { hbs } from 'ember-template-imports';
-// const Greeting = hbs`Hello!`;
-export const TEMPLATE_LITERAL_IDENTIFIER = 'hbs';
-export const TEMPLATE_LITERAL_MODULE_SPECIFIER = 'ember-template-imports';
-
-export function isTemplateLiteral(
-  callExpressionPath: NodePath<babelTypes.CallExpression>
-) {
-  const callee = callExpressionPath.get('callee');
-
-  return (
-    callee.isIdentifier() &&
-    callee.referencesImport(
-      exports.TEMPLATE_LITERAL_MODULE_SPECIFIER,
-      exports.TEMPLATE_LITERAL_IDENTIFIER
-    )
-  );
-}
+import { TemplateMatch } from './parse-templates';
 
 // const Greeting = <template>Hello</template>
 export const TEMPLATE_TAG_NAME = 'template';
@@ -94,10 +75,5 @@ export function isSupportedScriptFileExtension(filePath: string) {
 }
 
 export function isStrictMode(templateInfo: TemplateMatch): boolean {
-  return (
-    (isTemplateLiteralMatch(templateInfo) &&
-      templateInfo.importIdentifier === TEMPLATE_LITERAL_IDENTIFIER &&
-      templateInfo.importPath === TEMPLATE_LITERAL_MODULE_SPECIFIER) ||
-    templateInfo.type === 'template-tag'
-  );
+  return templateInfo.type === 'template-tag';
 }
diff --git a/tests/dummy/app/components/hbs-test.js b/tests/dummy/app/components/hbs-test.js
deleted file mode 100644
index fa66eab..0000000
--- a/tests/dummy/app/components/hbs-test.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import { hbs } from 'ember-template-imports';
-import Component from '@glimmer/component';
-
-// eslint-disable-next-line no-unused-vars
-const First = hbs`Hello`;
-
-// eslint-disable-next-line no-unused-vars
-class Second extends Component {
-  static template = hbs`world`;
-}
-
-// eslint-disable-next-line ember/no-test-import-export
-export default hbs`<First/>, <Second/>!`;
diff --git a/tests/dummy/app/templates/application.hbs b/tests/dummy/app/templates/application.hbs
index b4aed8b..a1a6d95 100644
--- a/tests/dummy/app/templates/application.hbs
+++ b/tests/dummy/app/templates/application.hbs
@@ -1,6 +1,5 @@
-{{page-title "Dummy"}}
+{{page-title 'Dummy'}}
 
-<h2 id="title">Welcome to Ember</h2>
+<h2 id='title'>Welcome to Ember</h2>
 
-<GjsTest/>
-<HbsTest/>
+<GjsTest />
diff --git a/tests/integration/.gitkeep b/tests/integration/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/integration/hbs-test.js b/tests/integration/hbs-test.js
deleted file mode 100644
index 9f28cef..0000000
--- a/tests/integration/hbs-test.js
+++ /dev/null
@@ -1,54 +0,0 @@
-import { module, test } from 'qunit';
-import { setupRenderingTest } from 'ember-qunit';
-import { render } from '@ember/test-helpers';
-import { precompileTemplate } from '@ember/template-compilation';
-import Component from '@glimmer/component';
-
-import { hbs } from 'ember-template-imports';
-// eslint-disable-next-line ember/no-test-import-export
-import HbsTest from 'dummy/components/hbs-test';
-
-module('tests/integration/components/hbs', function (hooks) {
-  setupRenderingTest(hooks);
-
-  test('it works', async function (assert) {
-    const Foo = hbs`Hello, {{@name}}!`;
-
-    await render(
-      precompileTemplate(`<Foo @name="world" />`, {
-        strictMode: true,
-        scope: () => ({ Foo }),
-      })
-    );
-
-    assert.equal(this.element.textContent.trim(), 'Hello, world!');
-  });
-
-  test('it works with classes', async function (assert) {
-    class Foo extends Component {
-      greeting = 'Hello';
-
-      static template = hbs`{{this.greeting}}, {{@name}}!`;
-    }
-
-    await render(
-      precompileTemplate(`<Foo @name="world" />`, {
-        strictMode: true,
-        scope: () => ({ Foo }),
-      })
-    );
-
-    assert.equal(this.element.textContent.trim(), 'Hello, world!');
-  });
-
-  test('it works with a component that is a top-level default export', async function (assert) {
-    await render(
-      precompileTemplate(`<HbsTest />`, {
-        strictMode: true,
-        scope: () => ({ HbsTest }),
-      })
-    );
-
-    assert.equal(this.element.textContent.trim(), 'Hello, world!');
-  });
-});