ember-repl 3.0.0-beta.6 → 3.0.0-beta.7

package/dist/browser/eti/util.js

@@ -1,39 +0,0 @@
-// const Greeting = <template>Hello</template>
-const TEMPLATE_TAG_NAME = 'template';
-const TEMPLATE_TAG_PLACEHOLDER = '__GLIMMER_TEMPLATE';
-function isTemplateTag(callExpressionPath) {
-  const callee = callExpressionPath.get('callee');
-  return !Array.isArray(callee) && callee.isIdentifier() && callee.node.name === TEMPLATE_TAG_PLACEHOLDER;
-}
-function buildPrecompileTemplateCall(t, callExpressionPath, state) {
-  const callee = callExpressionPath.get('callee');
-  return t.callExpression(state.importUtil.import(callee, '@ember/template-compilation', 'precompileTemplate'), callExpressionPath.node.arguments);
-}
-function registerRefs(newPath, getRefPaths) {
-  if (Array.isArray(newPath)) {
-    if (newPath.length > 1) {
-      throw new Error('registerRefs is only meant to handle single node transformations. Received more than one path node.');
-    }
-    newPath = newPath[0];
-  }
-  const refPaths = getRefPaths(newPath);
-  for (const ref of refPaths) {
-    if (!ref.isIdentifier()) {
-      throw new Error('ember-template-imports internal assumption that refPath should of type identifier. Please open an issue.');
-    }
-    const binding = ref.scope.getBinding(ref.node.name);
-    if (binding !== undefined) {
-      binding.reference(ref);
-    }
-  }
-}
-const SUPPORTED_EXTENSIONS = ['.js', '.ts', '.gjs', '.gts'];
-function isSupportedScriptFileExtension(filePath) {
-  return SUPPORTED_EXTENSIONS.some(ext => filePath.endsWith(ext));
-}
-function isStrictMode(templateInfo) {
-  return templateInfo.type === 'template-tag';
-}
-
-export { TEMPLATE_TAG_NAME, TEMPLATE_TAG_PLACEHOLDER, buildPrecompileTemplateCall, isStrictMode, isSupportedScriptFileExtension, isTemplateTag, registerRefs };
-//# sourceMappingURL=util.js.map

package/dist/browser/eti/util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.js","sources":["../../../src/browser/eti/util.ts"],"sourcesContent":["import type { TemplateMatch } from './parse-templates.ts';\nimport type { NodePath } from '@babel/traverse';\nimport type { CallExpression } from '@babel/types';\nimport type { ImportUtil } from 'babel-import-util';\n\n// const Greeting = <template>Hello</template>\nexport const TEMPLATE_TAG_NAME = 'template';\nexport const TEMPLATE_TAG_PLACEHOLDER = '__GLIMMER_TEMPLATE';\n\nexport function isTemplateTag(callExpressionPath: NodePath<CallExpression>) {\n  const callee = callExpressionPath.get('callee');\n\n  return (\n    !Array.isArray(callee) && callee.isIdentifier() && callee.node.name === TEMPLATE_TAG_PLACEHOLDER\n  );\n}\n\nexport function buildPrecompileTemplateCall(\n  t: any,\n  callExpressionPath: NodePath<CallExpression>,\n  state: {\n    importUtil: ImportUtil;\n  }\n): CallExpression {\n  const callee = callExpressionPath.get('callee');\n\n  return t.callExpression(\n    state.importUtil.import(callee, '@ember/template-compilation', 'precompileTemplate'),\n    callExpressionPath.node.arguments\n  );\n}\n\nexport function registerRefs(\n  newPath: string | string[],\n  getRefPaths: (path: string) => NodePath[]\n) {\n  if (Array.isArray(newPath)) {\n    if (newPath.length > 1) {\n      throw new Error(\n        'registerRefs is only meant to handle single node transformations. Received more than one path node.'\n      );\n    }\n\n    newPath = newPath[0] as string;\n  }\n\n  const refPaths = getRefPaths(newPath);\n\n  for (const ref of refPaths) {\n    if (!ref.isIdentifier()) {\n      throw new Error(\n        'ember-template-imports internal assumption that refPath should of type identifier. Please open an issue.'\n      );\n    }\n\n    const binding = ref.scope.getBinding(ref.node.name);\n\n    if (binding !== undefined) {\n      binding.reference(ref);\n    }\n  }\n}\n\nconst SUPPORTED_EXTENSIONS = ['.js', '.ts', '.gjs', '.gts'];\n\nexport function isSupportedScriptFileExtension(filePath: string) {\n  return SUPPORTED_EXTENSIONS.some((ext) => filePath.endsWith(ext));\n}\n\nexport function isStrictMode(templateInfo: TemplateMatch): boolean {\n  return templateInfo.type === 'template-tag';\n}\n"],"names":["TEMPLATE_TAG_NAME","TEMPLATE_TAG_PLACEHOLDER","isTemplateTag","callExpressionPath","callee","get","Array","isArray","isIdentifier","node","name","buildPrecompileTemplateCall","t","state","callExpression","importUtil","import","arguments","registerRefs","newPath","getRefPaths","length","Error","refPaths","ref","binding","scope","getBinding","undefined","reference","SUPPORTED_EXTENSIONS","isSupportedScriptFileExtension","filePath","some","ext","endsWith","isStrictMode","templateInfo","type"],"mappings":"AAKA;AACO,MAAMA,iBAAiB,GAAG,WAAU;AACpC,MAAMC,wBAAwB,GAAG,qBAAoB;AAErD,SAASC,aAAaA,CAACC,kBAA4C,EAAE;AAC1E,EAAA,MAAMC,MAAM,GAAGD,kBAAkB,CAACE,GAAG,CAAC,QAAQ,CAAC,CAAA;EAE/C,OACE,CAACC,KAAK,CAACC,OAAO,CAACH,MAAM,CAAC,IAAIA,MAAM,CAACI,YAAY,EAAE,IAAIJ,MAAM,CAACK,IAAI,CAACC,IAAI,KAAKT,wBAAwB,CAAA;AAEpG,CAAA;AAEO,SAASU,2BAA2BA,CACzCC,CAAM,EACNT,kBAA4C,EAC5CU,KAEC,EACe;AAChB,EAAA,MAAMT,MAAM,GAAGD,kBAAkB,CAACE,GAAG,CAAC,QAAQ,CAAC,CAAA;EAE/C,OAAOO,CAAC,CAACE,cAAc,CACrBD,KAAK,CAACE,UAAU,CAACC,MAAM,CAACZ,MAAM,EAAE,6BAA6B,EAAE,oBAAoB,CAAC,EACpFD,kBAAkB,CAACM,IAAI,CAACQ,SAC1B,CAAC,CAAA;AACH,CAAA;AAEO,SAASC,YAAYA,CAC1BC,OAA0B,EAC1BC,WAAyC,EACzC;AACA,EAAA,IAAId,KAAK,CAACC,OAAO,CAACY,OAAO,CAAC,EAAE;AAC1B,IAAA,IAAIA,OAAO,CAACE,MAAM,GAAG,CAAC,EAAE;AACtB,MAAA,MAAM,IAAIC,KAAK,CACb,qGACF,CAAC,CAAA;AACH,KAAA;AAEAH,IAAAA,OAAO,GAAGA,OAAO,CAAC,CAAC,CAAW,CAAA;AAChC,GAAA;AAEA,EAAA,MAAMI,QAAQ,GAAGH,WAAW,CAACD,OAAO,CAAC,CAAA;AAErC,EAAA,KAAK,MAAMK,GAAG,IAAID,QAAQ,EAAE;AAC1B,IAAA,IAAI,CAACC,GAAG,CAAChB,YAAY,EAAE,EAAE;AACvB,MAAA,MAAM,IAAIc,KAAK,CACb,0GACF,CAAC,CAAA;AACH,KAAA;AAEA,IAAA,MAAMG,OAAO,GAAGD,GAAG,CAACE,KAAK,CAACC,UAAU,CAACH,GAAG,CAACf,IAAI,CAACC,IAAI,CAAC,CAAA;IAEnD,IAAIe,OAAO,KAAKG,SAAS,EAAE;AACzBH,MAAAA,OAAO,CAACI,SAAS,CAACL,GAAG,CAAC,CAAA;AACxB,KAAA;AACF,GAAA;AACF,CAAA;AAEA,MAAMM,oBAAoB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpD,SAASC,8BAA8BA,CAACC,QAAgB,EAAE;AAC/D,EAAA,OAAOF,oBAAoB,CAACG,IAAI,CAAEC,GAAG,IAAKF,QAAQ,CAACG,QAAQ,CAACD,GAAG,CAAC,CAAC,CAAA;AACnE,CAAA;AAEO,SAASE,YAAYA,CAACC,YAA2B,EAAW;AACjE,EAAA,OAAOA,YAAY,CAACC,IAAI,KAAK,cAAc,CAAA;AAC7C;;;;"}

package/src/browser/eti/babel-plugin.ts

@@ -1,105 +0,0 @@
-import { ImportUtil } from 'babel-import-util';
-
-import { transformTemplateTag } from './template-tag-transform.ts';
-import * as util from './util.ts';
-
-import type { NodePath } from '@babel/traverse';
-import type { CallExpression, Class, Program } from '@babel/types';
-
-/**
- * This Babel plugin takes parseable code emitted by the string-based
- * preprocessor plugin in this package and converts it into calls to
- * the standardized `precompileTemplate` macro from `@ember/template-compilation`.
- *
- * 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`, {...})];
- *
- * class D {
- *   [__GLIMMER_TEMPLATE(`D`, {...})]
- * }
- * ```
- *
- * Into this:
- *
- * ```js
- * import { precompileTemplate } from '@ember/template-compilation';
- * 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`, {...}),
- *   templateOnlyComponent('this-module.js', '_thisModule')
- * );
- *
- * class D {}
- * setComponentTemplate(precompileTemplate(`D`, {...}), D);
- * ```
- */
-export default function (babel: any) {
-  let t = babel.types;
-
-  let visitor: any = {
-    Program: {
-      enter(path: NodePath<Program>, state: any) {
-        state.importUtil = new ImportUtil(t, path);
-      },
-    },
-
-    // Process class bodies before things like class properties get transformed
-    // into imperative constructor code that we can't recognize. Taken directly
-    // from babel-plugin-htmlbars-inline-precompile https://git.io/JMi1G
-    Class(path: NodePath<Class>, state: any) {
-      let bodyPath = path.get('body.body');
-
-      if (!Array.isArray(bodyPath)) return;
-
-      bodyPath.forEach((path) => {
-        if (path.type !== 'ClassProperty') return;
-
-        let keyPath = path.get('key');
-        let valuePath = path.get('value');
-
-        if (Array.isArray(keyPath)) return;
-
-        if (keyPath && visitor[keyPath.type]) {
-          visitor[keyPath.type](keyPath, state);
-        }
-
-        if (Array.isArray(valuePath)) return;
-
-        if (valuePath && visitor[valuePath.type]) {
-          visitor[valuePath.type](valuePath, state);
-        }
-      });
-    },
-
-    CallExpression(path: NodePath<CallExpression>, state: any) {
-      if (util.isTemplateTag(path)) {
-        transformTemplateTag(t, path, state);
-      }
-    },
-  };
-
-  return { visitor };
-}

package/src/browser/eti/debug.ts

@@ -1,7 +0,0 @@
-export function expect<T>(value: T | null | undefined, message: string): T {
-  if (value === undefined || value === null) {
-    throw new Error(`LIBRARY BUG: ${message}`);
-  }
-
-  return value;
-}

package/src/browser/eti/parse-templates.ts

@@ -1,284 +0,0 @@
-import { expect } from './debug.ts';
-import { TEMPLATE_TAG_NAME } from './util.ts';
-
-export type TemplateMatch = TemplateTagMatch;
-
-export interface TemplateTagMatch {
-  type: 'template-tag';
-  tagName: string;
-  start: RegExpMatchArray;
-  end: RegExpMatchArray;
-  contents: string;
-}
-
-/**
- * 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
- */
-export interface ParseTemplatesOptions {
-  /** Tag to use, if parsing template tags is enabled. */
-  templateTag?: string;
-}
-
-const escapeChar = '\\';
-const stringDelimiter = /['"]/;
-
-const singleLineCommentStart = /\/\//;
-const newLine = /\n/;
-const multiLineCommentStart = /\/\*/;
-const multiLineCommentEnd = /\*\//;
-
-const templateLiteralStart = /([$a-zA-Z_][0-9a-zA-Z_$]*)?`/;
-const templateLiteralEnd = /`/;
-
-const dynamicSegmentStart = /\${/;
-const blockStart = /{/;
-const dynamicSegmentEnd = /}/;
-
-function isEscaped(template: string, _offset: number | undefined) {
-  let offset = expect(_offset, 'Expected an index to check escaping');
-
-  let count = 0;
-
-  while (template[offset - 1] === escapeChar) {
-    count++;
-    offset--;
-  }
-
-  return count % 2 === 1;
-}
-
-export const DEFAULT_PARSE_TEMPLATES_OPTIONS = {
-  templateTag: TEMPLATE_TAG_NAME,
-};
-
-/**
- * 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></template>
- *
- * The parser excludes any values found within strings recursively, and also
- * excludes any string literals with dynamic segments (e.g `${}`) since these
- * cannot be valid templates.
- *
- * @param template The template to parse
- * @param relativePath Relative file path for the template (for errors)
- * @param options optional configuration options for how to parse templates
- * @returns
- */
-export function parseTemplates(
-  template: string,
-  relativePath: string,
-  options: ParseTemplatesOptions = DEFAULT_PARSE_TEMPLATES_OPTIONS
-): TemplateMatch[] {
-  const results: TemplateMatch[] = [];
-  const templateTag = options?.templateTag;
-
-  const templateTagStart = new RegExp(`<${templateTag}[^<]*>`);
-  const templateTagEnd = new RegExp(`</${templateTag}>`);
-  const argumentsMatchRegex = new RegExp(`<${templateTag}[^<]*\\S[^<]*>`);
-
-  const allTokens = new RegExp(
-    [
-      singleLineCommentStart.source,
-      newLine.source,
-      multiLineCommentStart.source,
-      multiLineCommentEnd.source,
-      stringDelimiter.source,
-      templateLiteralStart.source,
-      templateLiteralEnd.source,
-      dynamicSegmentStart.source,
-      dynamicSegmentEnd.source,
-      blockStart.source,
-      templateTagStart.source,
-      templateTagEnd.source,
-    ].join('|'),
-    'g'
-  );
-
-  const tokens = Array.from(template.matchAll(allTokens));
-
-  while (tokens.length > 0) {
-    const currentToken = tokens.shift()!; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-
-    parseToken(results, template, currentToken, tokens, true);
-  }
-
-  /**
-   * Parse the current token. If top level, then template tags can be parsed.
-   * Else, we are nested within a dynamic segment, which is currently unsupported.
-   */
-  function parseToken(
-    results: TemplateMatch[],
-    template: string,
-    token: RegExpMatchArray,
-    tokens: RegExpMatchArray[],
-    isTopLevel = false
-  ) {
-    if (token[0].match(multiLineCommentStart)) {
-      parseMultiLineComment(results, template, token, tokens);
-    } else if (token[0].match(singleLineCommentStart)) {
-      parseSingleLineComment(results, template, token, tokens);
-    } else if (token[0].match(templateLiteralStart)) {
-      parseTemplateLiteral(template, tokens);
-    } else if (
-      isTopLevel &&
-      templateTag !== undefined &&
-      templateTagStart &&
-      token[0].match(templateTagStart)
-    ) {
-      parseTemplateTag(results, template, token, tokens, templateTag);
-    } else if (token[0].match(stringDelimiter)) {
-      parseString(results, template, token, tokens);
-    }
-  }
-
-  /**
-   * Parse a template literal. If a dynamic segment is found, enters the dynamic
-   * segment and parses it recursively. If no dynamic segments are found and the
-   * 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(template: string, tokens: RegExpMatchArray[]) {
-    while (tokens.length > 0) {
-      let currentToken = expect(tokens.shift(), 'expected token');
-
-      if (isEscaped(template, currentToken.index)) continue;
-
-      if (currentToken[0].match(templateLiteralEnd)) {
-        return;
-      }
-    }
-  }
-
-  /**
-   * Parse a string. All tokens within a string are ignored
-   * since there are no dynamic segments within these.
-   */
-  function parseString(
-    _results: TemplateMatch[],
-    template: string,
-    startToken: RegExpMatchArray,
-    tokens: RegExpMatchArray[]
-  ) {
-    while (tokens.length > 0) {
-      const currentToken = expect(tokens.shift(), 'expected token');
-
-      if (currentToken[0] === startToken[0] && !isEscaped(template, currentToken.index)) {
-        return;
-      }
-    }
-  }
-
-  /**
-   * Parse a single-line comment. All tokens within a single-line comment are ignored
-   * since there are no dynamic segments within them.
-   */
-  function parseSingleLineComment(
-    _results: TemplateMatch[],
-    _template: string,
-    _startToken: RegExpMatchArray,
-    tokens: RegExpMatchArray[]
-  ) {
-    while (tokens.length > 0) {
-      const currentToken = expect(tokens.shift(), 'expected token');
-
-      if (currentToken[0] === '\n') {
-        return;
-      }
-    }
-  }
-
-  /**
-   * Parse a multi-line comment. All tokens within a multi-line comment are ignored
-   * since there are no dynamic segments within them.
-   */
-  function parseMultiLineComment(
-    _results: TemplateMatch[],
-    _template: string,
-    _startToken: RegExpMatchArray,
-    tokens: RegExpMatchArray[]
-  ) {
-    while (tokens.length > 0) {
-      const currentToken = expect(tokens.shift(), 'expected token');
-
-      if (currentToken[0] === '*/') {
-        return;
-      }
-    }
-  }
-
-  /**
-   * Parses a template tag. Continues parsing until the template tag has closed,
-   * accounting for nested template tags.
-   */
-  function parseTemplateTag(
-    results: TemplateMatch[],
-    _template: string,
-    startToken: RegExpMatchArray,
-    tokens: RegExpMatchArray[],
-    templateTag: string
-  ) {
-    let stack = 1;
-
-    if (argumentsMatchRegex && startToken[0].match(argumentsMatchRegex)) {
-      throw new Error(
-        `embedded template preprocessing currently does not support passing arguments, found args in: ${relativePath}`
-      );
-    }
-
-    while (tokens.length > 0) {
-      const currentToken = expect(tokens.shift(), 'expected token');
-
-      if (currentToken[0].match(templateTagStart)) {
-        stack++;
-      } else if (currentToken[0].match(templateTagEnd)) {
-        stack--;
-      }
-
-      if (stack === 0) {
-        let contents = '';
-
-        if (startToken.index !== undefined) {
-          const templateStart = startToken.index + startToken[0].length;
-
-          contents = template.slice(templateStart, currentToken.index);
-        }
-
-        results.push({
-          type: 'template-tag',
-          tagName: templateTag,
-          contents: contents,
-          start: startToken,
-          end: currentToken,
-        });
-
-        return;
-      }
-    }
-  }
-
-  return results;
-}

package/src/browser/eti/preprocess.ts

@@ -1,187 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import { getTemplateLocals } from '@glimmer/syntax';
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import lineColumn from 'line-column';
-import MagicString from 'magic-string';
-
-import { expect } from './debug.ts';
-import { parseTemplates } from './parse-templates.ts';
-
-import type { ParseTemplatesOptions, TemplateMatch } from './parse-templates.ts';
-
-interface PreprocessOptionsEager {
-  importIdentifier?: string;
-  importPath?: string;
-  templateTag?: string;
-  templateTagReplacement?: string;
-
-  relativePath: string;
-  includeSourceMaps: boolean;
-  includeTemplateTokens: boolean;
-}
-
-interface PreprocessOptionsLazy {
-  importIdentifier?: string;
-  importPath?: string;
-  templateTag?: string;
-  templateTagReplacement?: string;
-
-  relativePath: string;
-  includeSourceMaps: boolean;
-  includeTemplateTokens: boolean;
-}
-
-type PreprocessOptions = PreprocessOptionsLazy | PreprocessOptionsEager;
-
-interface PreprocessedOutput {
-  output: string;
-  replacements: Replacement[];
-}
-
-interface Replacement {
-  type: 'start' | 'end';
-  index: number;
-  oldLength: number;
-  newLength: number;
-  originalLine: number;
-  originalCol: number;
-}
-
-function getMatchStartAndEnd(match: RegExpMatchArray) {
-  return {
-    start: expect(match.index, 'Expected regular expression match to have an index'),
-    end:
-      expect(match.index, 'Expected regular expression match to have an index') + match[0].length,
-  };
-}
-
-function replacementFrom(
-  template: string,
-  index: number,
-  oldLength: number,
-  newLength: number,
-  type: 'start' | 'end'
-): Replacement {
-  const loc = expect(
-    lineColumn(template).fromIndex(index),
-    'BUG: expected to find a line/column based on index'
-  );
-
-  return {
-    type,
-    index,
-    oldLength,
-    newLength,
-    originalCol: loc.col,
-    originalLine: loc.line,
-  };
-}
-
-function replaceMatch(
-  s: MagicString,
-  match: TemplateMatch,
-  startReplacement: string,
-  endReplacement: string,
-  template: string,
-  includeTemplateTokens: boolean
-): Replacement[] {
-  const { start: openStart, end: openEnd } = getMatchStartAndEnd(match.start);
-  const { start: closeStart, end: closeEnd } = getMatchStartAndEnd(match.end);
-
-  let options = '';
-
-  if (includeTemplateTokens) {
-    const tokensString = getTemplateLocals(template.slice(openEnd, closeStart))
-      .filter((local: string) => local.match(/^[$A-Z_][0-9A-Z_$]*$/i))
-      .join(',');
-
-    if (tokensString.length > 0) {
-      options = `, scope: () => ({${tokensString}})`;
-    }
-  }
-
-  const newStart = `${startReplacement}\``;
-  const newEnd = `\`, { strictMode: true${options} }${endReplacement}`;
-
-  s.overwrite(openStart, openEnd, newStart);
-  s.overwrite(closeStart, closeEnd, newEnd);
-  ensureBackticksEscaped(s, openEnd + 1, closeStart - 1);
-
-  return [
-    replacementFrom(template, openStart, openEnd - openStart, newStart.length, 'start'),
-    replacementFrom(template, closeStart, closeEnd - closeStart, newEnd.length, 'end'),
-  ];
-}
-
-/**
- * Preprocesses all embedded templates within a JavaScript or TypeScript file.
- * This function replaces all embedded templates that match our template syntax
- * with valid, parseable JS. Optionally, it can also include a source map, and
- * it can also include all possible values used within the template.
- *
- * Input:
- *
- *   <template><MyComponent/><template>
- *
- * 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,
-  options: PreprocessOptions
-): PreprocessedOutput {
-  const { templateTag, templateTagReplacement, includeTemplateTokens, relativePath } = options;
-
-  const parseTemplatesOptions: ParseTemplatesOptions = {
-    templateTag,
-  };
-
-  const matches = parseTemplates(template, relativePath, parseTemplatesOptions);
-  const replacements: Replacement[] = [];
-  const s = new MagicString(template);
-
-  for (const match of matches) {
-    if (match.type === 'template-tag') {
-      replacements.push(
-        ...replaceMatch(
-          s,
-          match,
-          `[${templateTagReplacement}(`,
-          ')]',
-          template,
-          includeTemplateTokens
-        )
-      );
-    }
-  }
-
-  let output = s.toString();
-
-  return {
-    output,
-    replacements,
-  };
-}
-
-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);
-}