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

package/src/browser/compile/index.ts

@@ -151,16 +151,17 @@ export interface Value {
   component: ComponentLike;
 }
 
-export function buildCompiler(markdownText: Input | (() => Input)): Value;
-export function buildCompiler(markdownText: Input | (() => Input), options?: Format): Value;
-export function buildCompiler(markdownText: Input | (() => Input), options?: () => Format): Value;
-export function buildCompiler(markdownText: Input | (() => Input), options?: ExtraOptions): Value;
-export function buildCompiler(
-  markdownText: Input | (() => Input),
-  options?: () => ExtraOptions
-): Value;
+export function Compiled(markdownText: Input | (() => Input)): Value;
+export function Compiled(markdownText: Input | (() => Input), options?: Format): Value;
+export function Compiled(markdownText: Input | (() => Input), options?: () => Format): Value;
+export function Compiled(markdownText: Input | (() => Input), options?: ExtraOptions): Value;
+export function Compiled(markdownText: Input | (() => Input), options?: () => ExtraOptions): Value;
 
-export function buildCompiler(
+/**
+ * By default, this compiles to `glimdown`. A Markdown format which
+ * extracts `live` tagged code snippets and compiles them to components.
+ */
+export function Compiled(
   markdownText: Input | (() => Input),
   maybeOptions?: Format | (() => Format) | ExtraOptions | (() => ExtraOptions)
 ): Value {
@@ -202,8 +203,4 @@ export function buildCompiler(
   });
 }
 
-/**
- * By default, this compiles to `glimdown`. A Markdown format which
- * extracts `live` tagged code snippets and compiles them to components.
- */
-export const Compiled = resourceFactory(buildCompiler) as typeof buildCompiler;
+resourceFactory(Compiled);

package/src/browser/esm/index.ts

@@ -65,7 +65,7 @@ async function evalSnippet(code: string) {
 }
 
 async function compileGJS({ code: input, name }: Info) {
-  let preprocessed = preprocess(input, name);
+  let preprocessed = await preprocess(input, name);
   let result = await transform(preprocessed, name, {
     modules: false,
   });

package/src/browser/gjs.ts

@@ -2,25 +2,25 @@ import { importSync } from '@embroider/macros';
 
 import babelPluginEmberTemplateCompilation from 'babel-plugin-ember-template-compilation';
 
-// TODO: use real packages, and not these copied files from ember-template-imports
-import babelPluginIntermediateGJS from './eti/babel-plugin.ts';
-import { preprocessEmbeddedTemplates } from './eti/preprocess.ts';
-import { TEMPLATE_TAG_NAME, TEMPLATE_TAG_PLACEHOLDER } from './eti/util.ts';
-
 import type { Babel } from './types.ts';
 
 const compiler = importSync('ember-source/dist/ember-template-compiler.js');
 
-export function preprocess(input: string, name: string) {
-  let preprocessed = preprocessEmbeddedTemplates(input, {
-    relativePath: `${name}.js`,
-    includeSourceMaps: false,
-    includeTemplateTokens: true,
-    templateTag: TEMPLATE_TAG_NAME,
-    templateTagReplacement: TEMPLATE_TAG_PLACEHOLDER,
-  });
+let processor: any;
+let fetchingPromise: Promise<any>;
+
+export async function preprocess(input: string, name: string): Promise<string> {
+  if (!fetchingPromise) {
+    fetchingPromise = import('content-tag');
+  }
+
+  if (!processor) {
+    let { Preprocessor } = await fetchingPromise;
+
+    processor = new Preprocessor();
+  }
 
-  return preprocessed.output;
+  return processor.process(input, `${name}.js`);
 }
 
 export async function transform(
@@ -33,7 +33,7 @@ export async function transform(
   return babel.transform(intermediate, {
     filename: `${name}.js`,
     plugins: [
-      [babelPluginIntermediateGJS],
+      // [babelPluginIntermediateGJS],
       [
         babelPluginEmberTemplateCompilation,
         {

package/src/browser/known-modules.ts

@@ -7,24 +7,27 @@ import * as _tracking from '@glimmer/tracking';
 import * as _application from '@ember/application';
 import * as _array from '@ember/array';
 import * as _EmberComponent from '@ember/component';
+import * as _EmberComponentHelper from '@ember/component/helper';
 import _TO from '@ember/component/template-only';
 import * as _debug from '@ember/debug';
 import * as _destroyable from '@ember/destroyable';
 import * as _helpers from '@ember/helper';
 import * as _modifier from '@ember/modifier';
 import * as _object from '@ember/object';
+import * as _owner from '@ember/owner';
 import * as _runloop from '@ember/runloop';
 import * as _service from '@ember/service';
+import * as _template from '@ember/template';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { createTemplateFactory } from '@ember/template-factory';
 import * as _utils from '@ember/utils';
-// import * as _owner from '@ember/owner';
 
 export const modules = {
   '@ember/application': _application,
   '@ember/array': _array,
   '@ember/component': _EmberComponent,
+  '@ember/component/helper': _EmberComponentHelper,
   '@ember/component/template-only': _TO,
   '@ember/debug': _debug,
   '@ember/destroyable': _destroyable,
@@ -35,7 +38,8 @@ export const modules = {
   '@ember/service': _service,
   '@ember/template-factory': { createTemplateFactory },
   '@ember/utils': _utils,
-  // '@ember/owner': _owner,
+  '@ember/template': _template,
+  '@ember/owner': _owner,
 
   '@glimmer/component': _GlimmerComponent,
   '@glimmer/tracking': _tracking,

package/declarations/browser/eti/babel-plugin.d.ts

@@ -1,54 +0,0 @@
-/**
- * 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): {
-    visitor: any;
-};
-//# sourceMappingURL=babel-plugin.d.ts.map

package/declarations/browser/eti/babel-plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"babel-plugin.d.ts","sourceRoot":"","sources":["../../../src/browser/eti/babel-plugin.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,CAAC,OAAO,WAAW,KAAK,EAAE,GAAG;;EA8ClC"}

package/declarations/browser/eti/debug.d.ts

@@ -1,2 +0,0 @@
-export declare function expect<T>(value: T | null | undefined, message: string): T;
-//# sourceMappingURL=debug.d.ts.map

package/declarations/browser/eti/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../src/browser/eti/debug.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAMzE"}

package/declarations/browser/eti/parse-templates.d.ts

@@ -1,56 +0,0 @@
-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;
-}
-export declare const DEFAULT_PARSE_TEMPLATES_OPTIONS: {
-    templateTag: string;
-};
-/**
- * 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 declare function parseTemplates(template: string, relativePath: string, options?: ParseTemplatesOptions): TemplateMatch[];
-//# sourceMappingURL=parse-templates.d.ts.map

package/declarations/browser/eti/parse-templates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-templates.d.ts","sourceRoot":"","sources":["../../../src/browser/eti/parse-templates.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,aAAa,GAAG,gBAAgB,CAAC;AAE7C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,gBAAgB,CAAC;IACxB,GAAG,EAAE,gBAAgB,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA8BD,eAAO,MAAM,+BAA+B;;CAE3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,qBAAuD,GAC/D,aAAa,EAAE,CA6LjB"}

package/declarations/browser/eti/preprocess.d.ts

@@ -1,58 +0,0 @@
-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;
-}
-/**
- * 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 declare function preprocessEmbeddedTemplates(template: string, options: PreprocessOptions): PreprocessedOutput;
-export {};
-//# sourceMappingURL=preprocess.d.ts.map

package/declarations/browser/eti/preprocess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preprocess.d.ts","sourceRoot":"","sources":["../../../src/browser/eti/preprocess.ts"],"names":[],"mappings":"AAcA,UAAU,sBAAsB;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,UAAU,qBAAqB;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,KAAK,iBAAiB,GAAG,qBAAqB,GAAG,sBAAsB,CAAC;AAExE,UAAU,kBAAkB;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAoED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,iBAAiB,GACzB,kBAAkB,CAgCpB"}

package/declarations/browser/eti/template-tag-transform.d.ts

@@ -1,15 +0,0 @@
-/**
- * Supports the following syntaxes:
- *
- * const Foo = [GLIMMER_TEMPLATE('hello')];
- *
- * export const Foo = [GLIMMER_TEMPLATE('hello')];
- *
- * export default [GLIMMER_TEMPLATE('hello')];
- *
- * class Foo {
- *   [GLIMMER_TEMPLATE('hello')];
- * }
- */
-export declare const transformTemplateTag: (t: any, templatePath: any, state: any) => void;
-//# sourceMappingURL=template-tag-transform.d.ts.map

package/declarations/browser/eti/template-tag-transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"template-tag-transform.d.ts","sourceRoot":"","sources":["../../../src/browser/eti/template-tag-transform.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,MAAgB,GAAG,gBAAgB,GAAG,SAAS,GAAG,SAgFlF,CAAC"}

package/declarations/browser/eti/util.d.ts

@@ -1,14 +0,0 @@
-import type { TemplateMatch } from './parse-templates.ts';
-import type { NodePath } from '@babel/traverse';
-import type { CallExpression } from '@babel/types';
-import type { ImportUtil } from 'babel-import-util';
-export declare const TEMPLATE_TAG_NAME = "template";
-export declare const TEMPLATE_TAG_PLACEHOLDER = "__GLIMMER_TEMPLATE";
-export declare function isTemplateTag(callExpressionPath: NodePath<CallExpression>): boolean;
-export declare function buildPrecompileTemplateCall(t: any, callExpressionPath: NodePath<CallExpression>, state: {
-    importUtil: ImportUtil;
-}): CallExpression;
-export declare function registerRefs(newPath: string | string[], getRefPaths: (path: string) => NodePath[]): void;
-export declare function isSupportedScriptFileExtension(filePath: string): boolean;
-export declare function isStrictMode(templateInfo: TemplateMatch): boolean;
-//# sourceMappingURL=util.d.ts.map

package/declarations/browser/eti/util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/browser/eti/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAC5C,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D,wBAAgB,aAAa,CAAC,kBAAkB,EAAE,QAAQ,CAAC,cAAc,CAAC,WAMzE;AAED,wBAAgB,2BAA2B,CACzC,CAAC,EAAE,GAAG,EACN,kBAAkB,EAAE,QAAQ,CAAC,cAAc,CAAC,EAC5C,KAAK,EAAE;IACL,UAAU,EAAE,UAAU,CAAC;CACxB,GACA,cAAc,CAOhB;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,EAAE,QA2B1C;AAID,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,WAE9D;AAED,wBAAgB,YAAY,CAAC,YAAY,EAAE,aAAa,GAAG,OAAO,CAEjE"}

package/dist/browser/eti/babel-plugin.js

@@ -1,95 +0,0 @@
-import { ImportUtil } from 'babel-import-util';
-import { transformTemplateTag } from './template-tag-transform.js';
-import { isTemplateTag } from './util.js';
-
-/**
- * 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);
- * ```
- */
-function babelPluginIntermediateGJS (babel) {
-  let t = babel.types;
-  let visitor = {
-    Program: {
-      enter(path, state) {
-        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, state) {
-      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, state) {
-      if (isTemplateTag(path)) {
-        transformTemplateTag(t, path, state);
-      }
-    }
-  };
-  return {
-    visitor
-  };
-}
-
-export { babelPluginIntermediateGJS as default };
-//# sourceMappingURL=babel-plugin.js.map

package/dist/browser/eti/babel-plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"babel-plugin.js","sources":["../../../src/browser/eti/babel-plugin.ts"],"sourcesContent":["import { ImportUtil } from 'babel-import-util';\n\nimport { transformTemplateTag } from './template-tag-transform.ts';\nimport * as util from './util.ts';\n\nimport type { NodePath } from '@babel/traverse';\nimport type { CallExpression, Class, Program } from '@babel/types';\n\n/**\n * This Babel plugin takes parseable code emitted by the string-based\n * preprocessor plugin in this package and converts it into calls to\n * the standardized `precompileTemplate` macro from `@ember/template-compilation`.\n *\n * Its goal is to convert code like this:\n *\n * ```js\n * import { hbs } from 'ember-template-imports';\n *\n * const A = hbs(`A`, {...});\n * const B = [__GLIMMER_TEMPLATE(`B`, {...})];\n * class C {\n *   template = hbs(`C`, {...});\n * }\n *\n * [__GLIMMER_TEMPLATE(`default`, {...})];\n *\n * class D {\n *   [__GLIMMER_TEMPLATE(`D`, {...})]\n * }\n * ```\n *\n * Into this:\n *\n * ```js\n * import { precompileTemplate } from '@ember/template-compilation';\n * import { setComponentTemplate } from '@ember/component';\n * import templateOnlyComponent from '@ember/component/template-only';\n *\n * const A = setComponentTemplate(\n *   precompileTemplate(`A`, {...}),\n *   templateOnlyComponent('this-module.js', 'A')\n * );\n * const B = setComponentTemplate(\n *   precompileTemplate(`B`, {...}),\n *   templateOnlyComponent('this-module.js', 'B')\n * );\n * class C {}\n * setComponentTemplate(precompileTemplate(`C`, {...}), C);\n *\n * export default setComponentTemplate(\n *   precompileTemplate(`default`, {...}),\n *   templateOnlyComponent('this-module.js', '_thisModule')\n * );\n *\n * class D {}\n * setComponentTemplate(precompileTemplate(`D`, {...}), D);\n * ```\n */\nexport default function (babel: any) {\n  let t = babel.types;\n\n  let visitor: any = {\n    Program: {\n      enter(path: NodePath<Program>, state: any) {\n        state.importUtil = new ImportUtil(t, path);\n      },\n    },\n\n    // Process class bodies before things like class properties get transformed\n    // into imperative constructor code that we can't recognize. Taken directly\n    // from babel-plugin-htmlbars-inline-precompile https://git.io/JMi1G\n    Class(path: NodePath<Class>, state: any) {\n      let bodyPath = path.get('body.body');\n\n      if (!Array.isArray(bodyPath)) return;\n\n      bodyPath.forEach((path) => {\n        if (path.type !== 'ClassProperty') return;\n\n        let keyPath = path.get('key');\n        let valuePath = path.get('value');\n\n        if (Array.isArray(keyPath)) return;\n\n        if (keyPath && visitor[keyPath.type]) {\n          visitor[keyPath.type](keyPath, state);\n        }\n\n        if (Array.isArray(valuePath)) return;\n\n        if (valuePath && visitor[valuePath.type]) {\n          visitor[valuePath.type](valuePath, state);\n        }\n      });\n    },\n\n    CallExpression(path: NodePath<CallExpression>, state: any) {\n      if (util.isTemplateTag(path)) {\n        transformTemplateTag(t, path, state);\n      }\n    },\n  };\n\n  return { visitor };\n}\n"],"names":["babel","t","types","visitor","Program","enter","path","state","importUtil","ImportUtil","Class","bodyPath","get","Array","isArray","forEach","type","keyPath","valuePath","CallExpression","util","transformTemplateTag"],"mappings":";;;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,mCAAA,EAAUA,KAAU,EAAE;AACnC,EAAA,IAAIC,CAAC,GAAGD,KAAK,CAACE,KAAK,CAAA;AAEnB,EAAA,IAAIC,OAAY,GAAG;AACjBC,IAAAA,OAAO,EAAE;AACPC,MAAAA,KAAKA,CAACC,IAAuB,EAAEC,KAAU,EAAE;QACzCA,KAAK,CAACC,UAAU,GAAG,IAAIC,UAAU,CAACR,CAAC,EAAEK,IAAI,CAAC,CAAA;AAC5C,OAAA;KACD;AAED;AACA;AACA;AACAI,IAAAA,KAAKA,CAACJ,IAAqB,EAAEC,KAAU,EAAE;AACvC,MAAA,IAAII,QAAQ,GAAGL,IAAI,CAACM,GAAG,CAAC,WAAW,CAAC,CAAA;AAEpC,MAAA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACH,QAAQ,CAAC,EAAE,OAAA;AAE9BA,MAAAA,QAAQ,CAACI,OAAO,CAAET,IAAI,IAAK;AACzB,QAAA,IAAIA,IAAI,CAACU,IAAI,KAAK,eAAe,EAAE,OAAA;AAEnC,QAAA,IAAIC,OAAO,GAAGX,IAAI,CAACM,GAAG,CAAC,KAAK,CAAC,CAAA;AAC7B,QAAA,IAAIM,SAAS,GAAGZ,IAAI,CAACM,GAAG,CAAC,OAAO,CAAC,CAAA;AAEjC,QAAA,IAAIC,KAAK,CAACC,OAAO,CAACG,OAAO,CAAC,EAAE,OAAA;QAE5B,IAAIA,OAAO,IAAId,OAAO,CAACc,OAAO,CAACD,IAAI,CAAC,EAAE;UACpCb,OAAO,CAACc,OAAO,CAACD,IAAI,CAAC,CAACC,OAAO,EAAEV,KAAK,CAAC,CAAA;AACvC,SAAA;AAEA,QAAA,IAAIM,KAAK,CAACC,OAAO,CAACI,SAAS,CAAC,EAAE,OAAA;QAE9B,IAAIA,SAAS,IAAIf,OAAO,CAACe,SAAS,CAACF,IAAI,CAAC,EAAE;UACxCb,OAAO,CAACe,SAAS,CAACF,IAAI,CAAC,CAACE,SAAS,EAAEX,KAAK,CAAC,CAAA;AAC3C,SAAA;AACF,OAAC,CAAC,CAAA;KACH;AAEDY,IAAAA,cAAcA,CAACb,IAA8B,EAAEC,KAAU,EAAE;AACzD,MAAA,IAAIa,aAAkB,CAACd,IAAI,CAAC,EAAE;AAC5Be,QAAAA,oBAAoB,CAACpB,CAAC,EAAEK,IAAI,EAAEC,KAAK,CAAC,CAAA;AACtC,OAAA;AACF,KAAA;GACD,CAAA;EAED,OAAO;AAAEJ,IAAAA,OAAAA;GAAS,CAAA;AACpB;;;;"}

package/dist/browser/eti/debug.js

@@ -1,9 +0,0 @@
-function expect(value, message) {
-  if (value === undefined || value === null) {
-    throw new Error(`LIBRARY BUG: ${message}`);
-  }
-  return value;
-}
-
-export { expect };
-//# sourceMappingURL=debug.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"debug.js","sources":["../../../src/browser/eti/debug.ts"],"sourcesContent":["export function expect<T>(value: T | null | undefined, message: string): T {\n  if (value === undefined || value === null) {\n    throw new Error(`LIBRARY BUG: ${message}`);\n  }\n\n  return value;\n}\n"],"names":["expect","value","message","undefined","Error"],"mappings":"AAAO,SAASA,MAAMA,CAAIC,KAA2B,EAAEC,OAAe,EAAK;AACzE,EAAA,IAAID,KAAK,KAAKE,SAAS,IAAIF,KAAK,KAAK,IAAI,EAAE;AACzC,IAAA,MAAM,IAAIG,KAAK,CAAE,CAAeF,aAAAA,EAAAA,OAAQ,EAAC,CAAC,CAAA;AAC5C,GAAA;AAEA,EAAA,OAAOD,KAAK,CAAA;AACd;;;;"}