<vue-component name="HelloComponent" v-props="person"></vue-component>

@param $injector
@returns {{restrict: string, link: (function(*=, *=, *=))}}
555594
function ngVueComponentDirective ($injector) {
  return {
    restrict: 'E',
    link (scope, elem, attrs) {
      const componentName = attrs.name
      ngVueLinker(componentName, elem, attrs, scope, $injector)
    }
  }
}
994806
private List<ParameterConverter> findConverters(Injector injector) {
        List<Binding<ParameterConverter>> bindingsByType = injector
                .findBindingsByType(new TypeLiteral<ParameterConverter>() {
                });
        if (bindingsByType.isEmpty() && injector.getParent() != null) {
            return findConverters(injector.getParent());
        }
        List<ParameterConverter> converters = new ArrayList<>();
        for (Binding<ParameterConverter> binding : bindingsByType) {
            converters.add(binding.getProvider().get());
        }
        return converters;
    }
446596
public function injectRenderer($helper)
    {
        $renderer = $this->getRenderer();
        if (null === $renderer) {
            return;
        }

        $helper->setView($renderer);
    }
34107
function getReactComponent( name, $injector ) {
    // if name is a function assume it is component and return it
    if (angular.isFunction(name)) {
      return name;
    }

    // a React component name must be specified
    if (!name) {
      throw new Error('ReactComponent name attribute must be specified');
    }

    // ensure the specified React component is accessible, and fail fast if it's not
    var reactComponent;
    try {
      reactComponent = $injector.get(name);
    } catch(e) { }

    if (!reactComponent) {
      try {
        reactComponent = name.split('.').reduce(function(current, namePart) {
          return current[namePart];
        }, window);
      } catch (e) { }
    }

    if (!reactComponent) {
      throw Error('Cannot find react component ' + name);
    }

    return reactComponent;
  }
951346
public function injectTranslator($helper)
    {
        if (!$helper instanceof TranslatorAwareInterface) {
            return;
        }

        $locator = $this->getServiceLocator();

        if (!$locator) {
            return;
        }

        if ($locator->has('MvcTranslator')) {
            $helper->setTranslator($locator->get('MvcTranslator'));
            return;
        }

        if ($locator->has(TranslatorInterface::class)) {
            $helper->setTranslator($locator->get(TranslatorInterface::class));
            return;
        }

        if ($locator->has('Translator')) {
            $helper->setTranslator($locator->get('Translator'));
            return;
        }
    }
435515
public function render($renderer=null)
	{
		if (!$renderer)
		{
			$renderer = php_sapi_name() === 'cli' ? 'console' : 'html';
		}

		return $this->setRenderer($renderer)
					->getRenderer()
					->render($this->messages());
	}
1127216
public static function query(DiInterface $dependencyInjector = null)
    {
        $class = '\\' . get_called_class() . 'Criteria';
        if (class_exists($class)) {
            /** @var \Frogg\Model\Criteria $criteria */
            $criteria = new $class();
            $criteria->setDI($dependencyInjector ?: Di::getDefault());
            $criteria->setModelName(get_called_class());
        } else {
            $criteria = (new Criteria())->setModelName(get_called_class())->setAlias(get_called_class());
        }

        return $criteria;
    }
977606
public function getInstance(Injector $injector, $name = null)
    {
        if (null !== $this->instance) {
            return $this->instance;
        }

        if (is_string($this->impl)) {
            $this->impl = new \ReflectionClass($this->impl);
        }

        if (null === $this->scope) {
            if (annotationsOf($this->impl)->contain('Singleton')) {
                $this->scope = $this->scopes->singleton();
            }
        }

        if (null === $this->provider) {
            if (null != $this->providerClass) {
                $provider = $injector->getInstance($this->providerClass);
                if (!($provider instanceof InjectionProvider)) {
                    throw new BindingException('Configured provider class ' . $this->providerClass . ' for type ' . $this->type . ' is not an instance of stubbles\ioc\InjectionProvider.');
                }

                $this->provider = $provider;
            } else {
                $this->provider = new DefaultInjectionProvider($injector, $this->impl);
            }
        }

        if (null !== $this->scope) {
            return $this->scope->getInstance($this->impl, $this->provider);
        }

        return $this->provider->get($name);
    }
1029586
static function _ (Component $parent, array $props = null, array $bindings = null)
  {
    return (string)static::create ($parent, $props, $bindings);
  }
579287
protected function initExtensionType()
    {
        // We have to get the class of our injector
        $class = '';
        if (!class_exists($class = $this->extensionType) &&
            !class_exists($class = strstr($this->extensionType, '(', true))) {
            throw new \Exception('Unknown injector class ' . $class);
        }

        // We also have to get the parameter
        $parameters = array();
        preg_match('`\((.+)\)`', $this->getExtensionType(), $parameters);

        // Clean them up and separate them
        $parameterString = str_replace(array(' ', '\''), array(''), $parameters[1]);
        $clearParameters = explode(',', $parameterString);

        // Instantiate the injector and  init it
        $this->injector = new $class($clearParameters[0], $clearParameters[1], $clearParameters[2]);
        $this->injector->init();
    }
732220
function AdapterFactory(injector) {
    if (!injector.adapters) { return; }
    var me = this;

    this.adapterMap = {};
    _.each(injector.adapterMap, function (adapterName, adapterType) {
        var adapter = injector.adapters[adapterName];
        if (adapter) {
            me.adapterMap[adapterType + 'adapter'] = adapter;
        }
    });
}
294758
function Link(props) {
  const { activeClassName, router, className: classNameProps, naked, ...other } = props;

  const className = clsx(classNameProps, {
    [activeClassName]: router.pathname === props.href && activeClassName,
  });

  if (naked) {
    return <NextComposed className={className} {...other} />;
  }

  return <MuiLink component={NextComposed} className={className} {...other} />;
}
1181108
function controllerProviderDecorator($controllerProvider, $controllerIntrospectorProvider) {
  var register = $controllerProvider.register;
  $controllerProvider.register = function (name, ctrl) {
    $controllerIntrospectorProvider.register(name, ctrl);
    return register.apply(this, arguments);
  };
}
102088
public static function injectInstance(Resolver $resolver)
    {
        $sub = $resolver->getResolver('assets');
        return $sub !== null ? new static($sub) : null;
    }
1136483
function injectTemplate(template) {
  let js = [
    '',
    'var __vue__options__ = (module.exports.__esModule) ?',
    'module.exports.default : module.exports;',
    '__vue__options__.template = ' + JSON.stringify(template) + ';',
    '',
  ];

  return js.join(os.EOL);
}
406063
private boolean findBinding(Injector injector, Class<?> type) {
        boolean found = false;
        for (Key<?> key : injector.getBindings().keySet()) {
            if (key.getTypeLiteral().getRawType().equals(type)) {
                found = true;
                break;
            }
        }
        if (!found && injector.getParent() != null) {
            return findBinding(injector.getParent(), type);
        }

        return found;
    }
1318582
public function init($parts, $parser = LinkUtil::class)
    {

        if (is_string($parts) && filter_var($parts, FILTER_VALIDATE_URL)) {
            $parts = $parser::parse($parts);
        }

        /**@var $Property \ReflectionProperty */
        foreach((new \ReflectionObject($this))->getProperties(\ReflectionProperty::IS_PUBLIC) as $Property) {
            if ((!$Property->getValue($this)) && isset($parts[$Property->getName()])) {
                $Property->setValue($this, $parts[$Property->getName()]);
            }
        }

        return $this;
    }