export function registerAttribute(this: ICustomAttributeType, container: IContainer): void {
  const description = this.description;
  const resourceKey = this.kind.keyFrom(description.name);
  const aliases = description.aliases;

  container.register(Registration.transient(resourceKey, this));

  for (let i = 0, ii = aliases.length; i < ii; ++i) {
    const aliasKey = this.kind.keyFrom(aliases[i]);
    container.register(Registration.alias(resourceKey, aliasKey));
  }
}

describe(`@bindingBehavior('foo')`, function () {
  let container: IContainer;

  beforeEach(function () {
    container = DI.createContainer();
  });

  // @ts-ignore
  @bindingBehavior('foo')
  class FooBindingBehavior { }

  it(`should define the binding behavior`, function () {
    expect(FooBindingBehavior['kind']).to.equal(BindingBehaviorResource);
    expect(FooBindingBehavior['description'].name).to.equal('foo');
    FooBindingBehavior['register'](container);
    const instance = container.get(BindingBehaviorResource.keyFrom('foo'));
    expect(instance).to.be.instanceof(FooBindingBehavior);
  });

});

export function register(container: IContainer): void {
  container.registerTransformer(ISVGAnalyzer, analyzer => {
    return {
      ...analyzer,
      isStandardSvgAttribute(node: INode, attributeName: string): boolean {
        // Using very HTML-specific code here since you won't install this module
        // unless you are actually running in a browser, using HTML,
        // and dealing with browser inconsistencies.

        if (!(node instanceof SVGElement)) {
          return false;
        }

        const nodeName = node.nodeName;

        return svgPresentationElements[nodeName] !== undefined && svgPresentationAttributes[attributeName] !== undefined
          || svgElements[nodeName] !== undefined && svgElements[nodeName].indexOf(attributeName) !== -1;
      }
    };
  });
}

export function registerElement(this: ICustomElementType, container: IContainer): void {
  const resourceKey = this.kind.keyFrom(this.description.name);
  container.register(Registration.transient(resourceKey, this));
}

function register(this: IBindingBehaviorType, container: IContainer): void {
  const resourceKey = BindingBehaviorResource.keyFrom(this.description.name);
  container.register(Registration.singleton(resourceKey, this));
}

function register(this: IValueConverterType, container: IContainer): void {
  const resourceKey = this.kind.keyFrom(this.description.name);
  container.register(Registration.singleton(resourceKey, this));
}

 it(`should define the binding behavior`, function () {
   expect(FooBindingBehavior['kind']).to.equal(BindingBehaviorResource);
   expect(FooBindingBehavior['description'].name).to.equal('foo');
   FooBindingBehavior['register'](container);
   const instance = container.get(BindingBehaviorResource.keyFrom('foo'));
   expect(instance).to.be.instanceof(FooBindingBehavior);
 });

 it(`should define the value converter`, function () {
   expect(FooValueConverter['kind']).to.equal(ValueConverterResource);
   expect(FooValueConverter['description'].name).to.equal('foo');
   FooValueConverter['register'](container);
   const instance = container.get(ValueConverterResource.keyFrom('foo'));
   expect(instance).to.be.instanceof(FooValueConverter);
 });

  public app(config: ISinglePageApp): this {
    const host = config.host as INode & {$au?: Aurelia | null};

    const domInitializer = this.container.get(IDOMInitializer);
    domInitializer.initialize(config);
    Registration.instance(INode, host).register(this.container);

    const startFlags = LifecycleFlags.fromStartTask | config.strategy;
    const stopFlags = LifecycleFlags.fromStopTask | config.strategy;

    let component: ICustomElement;
    const componentOrType = config.component as ICustomElement | ICustomElementType;
    if (CustomElementResource.isType(componentOrType as ICustomElementType)) {
      this.container.register(componentOrType as ICustomElementType);
      component = this.container.get<ICustomElement>(CustomElementResource.keyFrom((componentOrType as ICustomElementType).description.name));
    } else {
      component = componentOrType as ICustomElement;
    }
    component = ProxyObserver.getRawIfProxy(component);

    const startTask = () => {
      host.$au = this;
      if (!this.components.includes(component)) {
        this._root = component;
        this.components.push(component);
        component.$hydrate(startFlags, this.container as ExposedContext, host);
      }

      component.$bind(startFlags | LifecycleFlags.fromBind, null);
      component.$attach(startFlags | LifecycleFlags.fromAttach);
    };

    this.startTasks.push(startTask);

    this.stopTasks.push(() => {
      component.$detach(stopFlags | LifecycleFlags.fromDetach);
      component.$unbind(stopFlags | LifecycleFlags.fromUnbind);
      host.$au = null;
    });

    if (this.isStarted) {
      startTask();
    }

    return this;
  }

 public register(...params: (IRegistry | Record<string, Partial<IRegistry>>)[]): this {
   this.container.register(...params);
   return this;
 }