How to use the @glimmer/bundle-compiler.BundleCompiler function in @glimmer/bundle-compiler

function getBundleCompiler(
  registry: AotCompilerRegistry
): { compiler: BundleCompiler; constants: DebugConstants } {
  let delegate: AotCompilerDelegate = new AotCompilerDelegate(registry);
  let constants = new DebugConstants();
  let compiler = new BundleCompiler(delegate, {
    macros: new TestMacros(),
    constants,
  });
  return { constants, compiler };
}

protected buildBytecodeLoader(resolver: Resolver) {
    let delegate = new CompilerDelegate(resolver);
    let compiler = new BundleCompiler(delegate);

    let mainLocator = locatorFor('template:mainTemplate', 'default');
    mainLocator.meta.module = 'template:mainTemplate';

    let block = JSON.parse(mainTemplate.block);
    let compilableTemplate = compilable({
      block,
      referrer: mainLocator.meta,
    });

    compiler.addCompilableTemplate(mainLocator, compilableTemplate);

    for (let module in this.templates) {
      compiler.addTemplateSource(locatorFor(module, 'default'), this.templates[module]);
    }

renderTemplate(template: string, context: Dict, element: HTMLElement): RenderResult {
    let macros = new TestMacros();
    let delegate: BundlingDelegate = new BundlingDelegate(this.components, this.modules, this.compileTimeModules, specifier => {
      return compiler.compileSpecifier(specifier);
    });
    let program = new WriteOnlyProgram(new DebugConstants());
    let compiler = new BundleCompiler(delegate, { macros, program });

    let spec = specifierFor('ui/components/main', 'default');
    compiler.add(spec, template);

    let { components, modules, compileTimeModules } = this;
    Object.keys(components).forEach(key => {
      assert(key.indexOf('ui/components') !== -1, `Expected component key to start with ui/components, got ${key}.`);

      let component = components[key];
      let spec = specifierFor(key, 'default');

      let block;
      let symbolTable;

      if (component.type === "Curly" || component.type === "Dynamic") {
        let block = compiler.preprocess(spec, component.template);

if (options.mode && options.mode === 'module-unification') {
      delegate = this.delegate = new MUCompilerDelegate({
        projectPath,
        outputFiles,
        builtins,
      });
    } else if (options.delegate) {
      delegate = this.delegate = new options.delegate({
        projectPath,
        outputFiles,
        builtins,
      });
    }

    this.compiler = new BundleCompiler(delegate, options.bundleCompiler);
  }