Delays registering partials to the engine
because there is no add partial method...

@param string $name The name of the partial
@param string $partial
@return Handlebars
15757
public function registerPartial(string $name, string $partial): Handlebars
    {
        $this->runtime->addPartial($name, $partial);
        return $this;
    }
145606
protected function isLegalProp($name)
	{
		/**
		* @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Reserved_Words
		* @link http://www.crockford.com/javascript/survey.html
		*/
		$reserved = ['abstract', 'boolean', 'break', 'byte', 'case', 'catch', 'char', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'double', 'else', 'enum', 'export', 'extends', 'false', 'final', 'finally', 'float', 'for', 'function', 'goto', 'if', 'implements', 'import', 'in', 'instanceof', 'int', 'interface', 'let', 'long', 'native', 'new', 'null', 'package', 'private', 'protected', 'public', 'return', 'short', 'static', 'super', 'switch', 'synchronized', 'this', 'throw', 'throws', 'transient', 'true', 'try', 'typeof', 'var', 'void', 'volatile', 'while', 'with'];

		if (in_array($name, $reserved, true))
		{
			return false;
		}

		return (bool) preg_match('#^(?![0-9])[$_\\pL][$_\\pL\\pNl]+$#Du', $name);
	}
1313029
public function partial($name, array $data = [])
    {
        $templatePath = $this->manager->pathByName($name);

        // Use special variable names here to avoid conflict when extracting data
        if (is_array($data)) {
            extract($data, EXTR_PREFIX_SAME, 'data_');
        }

        ob_start();
        include $templatePath;
        return ob_get_clean();
    }
1210361
public static function unregisterPartial($name)
    {
        //Argument 1 must be a string
        Argument::i()->test(1, 'string');

        if (isset(self::$partials[$name])) {
            unset(self::$partials[$name]);
        }
    }
957954
public function render(string $name, string $presenter = null, array $bindings = [], bool $specialSidebar = false): ?string
    {
        if ($this->has($name)) {
            $instance = $this->instance($name);

            $this->callbacks->get($name)->each(function ($callback) use ($instance) {
                $reflectionParams = collect((new ReflectionFunction($callback))->getParameters());
                $reflectionParams->shift();

                collect($reflectionParams)->each(function ($param) use (&$params) {
                    $params[] = Route::current()->hasParameter($param->getName()) ? Route::current()->parameter($param->getName())
                        : (class_exists($param->getClass()->getName()) ? app($param->getClass()->getName()) : null);
                });

                $params ? $callback($instance, ...$params) : $callback($instance);
            });

            return $instance->setBindings($bindings)->render($presenter, $specialSidebar);
        }

        return null;
    }
545629
public static function add($method, $target, $handler, $name = null)
    {
        array_push(static::$prefixRoutes, [
            'method'  => $method, 'target' => $target,
            'handler' => $handler, 'name' => $name,
        ]);
    }
353186
public function renderContent($name, $parameters = [])
    {
        /**
         * @event cms.page.beforeRenderContent
         * Provides an oportunity to manipulate the name of the content file being rendered before it renders
         *
         * Example usage:
         *
         *     Event::listen('cms.page.beforeRenderContent', function ((\Cms\Classes\Controller) $controller, (string) $contentName) {
         *         return "path/to/overriding/location/" . $contentName;
         *     });
         *
         * Or
         *
         *     $CmsController->bindEvent('page.beforeRenderContent', function ((string) $contentName) {
         *         return "path/to/overriding/location/" . $contentName;
         *     });
         *
         */
        if ($event = $this->fireSystemEvent('cms.page.beforeRenderContent', [$name])) {
            $content = $event;
        }
        /*
         * Load content from theme
         */
        elseif (($content = Content::loadCached($this->theme, $name)) === null) {
            throw new CmsException(Lang::get('cms::lang.content.not_found_name', ['name'=>$name]));
        }

        $fileContent = $content->parsedMarkup;

        /*
         * Inject global view variables
         */
        $globalVars = ViewHelper::getGlobalVars();
        if (!empty($globalVars)) {
            $parameters = (array) $parameters + $globalVars;
        }

        /*
         * Parse basic template variables
         */
        if (!empty($parameters)) {
            $fileContent = TextParser::parse($fileContent, $parameters);
        }

        /**
         * @event cms.page.renderContent
         * Provides an oportunity to manipulate the output of a content file after being rendered
         *
         * Example usage:
         *
         *     Event::listen('cms.page.renderContent', function ((\Cms\Classes\Controller) $controller, (string) $contentName, (string) &$fileContent) {
         *         return "Overriding content";
         *     });
         *
         * Or
         *
         *     $CmsController->bindEvent('page.renderContent', function ((string) $contentName, (string) &$fileContent) {
         *         return "Overriding content";
         *     });
         *
         */
        if ($event = $this->fireSystemEvent('cms.page.renderContent', [$name, &$fileContent])) {
            return $event;
        }

        return $fileContent;
    }
1344776
protected function renderBlock($name, $parameters)
    {
        /** @var Twig_TemplateInterface $template */
        foreach ($this->getTemplates() as $template) {
            if ($template->hasBlock($name)) {

                $context = array_merge(
                    $template->getEnvironment()->getGlobals(),
                    $parameters
                );

                return $template->renderBlock($name, $context);
            }
        }

        throw new \InvalidArgumentException(sprintf('Block "%s" doesn\'t exist in grid template.', $name));
    }
209019
public function addPartials($_partials)
    {
        foreach ($_partials as $partial => $value) {

            $this->_partials[$partial] = $value;
        }
    }
957034
private function enablePragma($name)
    {
        $this->pragmas[$name] = true;

        switch ($name) {
            case Mustache_Engine::PRAGMA_BLOCKS:
                $this->pragmaBlocks = true;
                break;

            case Mustache_Engine::PRAGMA_FILTERS:
                $this->pragmaFilters = true;
                break;
        }
    }
210475
public function addActionCallback($key, $name, $callback = null)
	{
		$this->addActionCheck($key);

		$params = ['__id' => $this->primary_key];

		$this->actions[$key] = $action = new Column\ActionCallback($this, $key, $name, $params);

		if ($callback) {
			if (!is_callable($callback)) {
				throw new DataGridException('ActionCallback callback has to be callable.');
			}

			$action->onClick[] = $callback;
		}

		return $action;
	}
181
public function setPartial($partial)
    {
        if (null === $partial || is_string($partial) || is_array($partial)) {
            $this->partial = $partial;
        }

        return $this;
    }
814899
public function partial($partial)
    {
        if ($this->partialExists($partial)) return $this->_partials[$partial];

        throw new PartialNotFoundException($partial . ' partial does not exist');
    }
962408
private function findPartialFile($name)
    {
        foreach ($this->partialDirs as $dir) {
            $file = $this->createPartialPath($dir, $name);

            if (is_file($file)) {
                return $file;
            }
        }

        return false;
    }
490457
def bind_partial(self, *args, **kwargs):
        
        return self._bind(args, kwargs, partial=True)
971542
protected static function register($name/* , ... $ctors */) {
			$key = get_called_class();

			if (static::isDone())
				throw new BadMethodCallException(sprintf('Registration has been halted for %s; cannot add %s to the enum list.',
					$key, $name));

			if (!array_key_exists($key, self::$types))
				self::$types[$key] = array();

			$ctors = func_get_args();
			array_shift($ctors);

			$refl = new ReflectionClass($key);
			$ctor = $refl->getConstructor();
			$ctor->setAccessible(true);

			/** @var Enum $inst */
			$inst = $refl->newInstanceWithoutConstructor();

			$ctor->invokeArgs($inst, $ctors);
			$ctor->setAccessible(false);

			$inst->setName($name);
			$inst->setOrdinal(sizeof(self::$types[$key]));

			self::$types[$key][$name] = $inst;
		}
1143914
public static function getPartial($name)
    {
        //Argument 1 must be a string
        Argument::i()->test(1, 'string');
        
        if (isset(self::$partials[$name])) {
            return self::$partials[$name];
        }
        
        return null;
    }