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

@param *string $name    The name of the helper
@param *string $partial The helper handler
188131
public static function registerPartial($name, $partial)
    {
        Argument::i()
            //Argument 1 must be a string
            ->test(1, 'string')
            //Argument 2 must be a string
            ->test(2, 'string');

        self::$partials[$name] = $partial;
    }
680176
public function supportParameter($name)
    {
        if (in_array($name, QueryModifiers)) {
            throw new \DomainException("parameter $name not allowed");
        }
        $this->supportedParameters[$name] = $name;
        asort($this->supportedParameters);
    }
1197805
public function hidden(string $name, $callback = null): void
    {
        $value = \data_get($this->data, $name);

        $field = new Fluent([
            'name' => $name,
            'value' => $value ?: '',
            'attributes' => [],
        ]);

        if ($callback instanceof Closure) {
            $callback($field);
        }

        $this->hiddens[$name] = $this->app->make('form')->hidden($name, $field->get('value'), $field->get('attributes'));
    }
1179
public function registerHelper($name, $helper = false)
    {
        if (is_array($name)) {
            foreach ($name as $n => $helper) {
                $this->registerHelper($n, $helper);
            }
        } elseif (is_object($name)) {
            $this->registerJavascriptObject('helper', $this->wrapHelperObject($name));
        } elseif ($helper === false) {
            $this->registerJavascriptObject('helper', $name);
        } elseif (is_callable($helper)) {
            $this->registerJavascriptFunction('helper', $name, $this->wrapHelperCallable($name, $helper));
        } else {
            $this->registerJavascriptFunction('helper', $name, $helper);
        }
    }
438894
public static function read(&$context, $name) {
        $isPB = ($name === '@partial-block');
        $context['usedFeature']['partial']++;

        if (isset($context['usedPartial'][$name])) {
            return;
        }

        $cnt = static::resolve($context, $name);

        if ($cnt !== null) {
            $context['usedPartial'][$name] = SafeString::escapeTemplate($cnt);
            return static::compileDynamic($context, $name);
        }

        if (!$context['flags']['skippartial'] && !$isPB) {
            $context['error'][] = "Can not find partial for '$name', you should provide partials or partialresolver in options";
        }
    }
528683
public function getPartialFile($name)
    {
        $file = $this->findPartialFile($name);

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

        } else if ($this->hasStaticPartial($name)) {
            return $this->getStaticFile($name);

        } else {
            throw new LogicException(sprintf('Could not find a registered partial called %s', $name));
        }
    }
326602
function include(partial, cb) {
    cb((params.partials && params.partials[partial]) ?
      params.partials[partial] :
      '[error] partial ' + partial + ' does not exist');
  }
676592
public function delete($name)
	{
		$templates = $this->getTemplates();
		$templates->delete($name, $this->plugin->name);
	}
844816
protected function addMatched(string $name)
    {
        if (! isset($this->matched[$name])) {
            $this->matched[$name] = $this->newMiddleware($name);
        }
    }
485093
public function push(string $name, string $handler)
    {
        if (! isset($this->handlers[$name])) {
            $this->handlers[$name] = [];
        }

        if (! in_array($handler, $this->handlers[$name])) {
            $this->handlers[$name][] = $handler;
        }
    }
1269605
public function appendInit(callable $middleware, $name = null)
    {
        $this->add(self::INIT, $name, $middleware);
    }
1231995
public function load($name) {
		
		if (!isset($this->templates[$name])) {
			try {
				$this->templates[$name] = $this->loadFile($name);
			} catch (Exception $e) {
				print "The partial, ".$name.", wasn't found so a pattern failed to build.\n";
			}
		}
		
		return (isset($this->templates[$name])) ? $this->templates[$name] : false;
		
	}
814899
public function partial($partial)
    {
        if ($this->partialExists($partial)) return $this->_partials[$partial];

        throw new PartialNotFoundException($partial . ' partial does not exist');
    }
498363
protected function setTagItem(string $name): void
    {
        if (!empty($this->tag)) {
            foreach ($this->tag as $tag) {
                $tagName = $this->getTagKey($tag);
                $this->handler->sAdd($tagName, $name);
            }

            $this->tag = null;
        }
    }
1147100
public function addPart(PartInterface $part, $name = null)
    {
        if ($name == null) {
            $name = $part->getName();
        }
        $this->parts[$name] = $part;
    }
1083842
public function partial( $partial, $child = '', $context = [] ) {
		if ( is_array( $child ) ) {
			// Optional argument $child not specified, flip input around.
			$context = $child;
			$child = '';
		}

		$templates = [];

		if ( $child ) {
			$templates[] = "partials/${partial}-${child}.php";
		}

		$templates[] = "partials/${partial}.php";

		app_render( $templates, $context );
	}
1075078
private function addHelper(string $name, string $path): void
    {
        $class = static::class;

        // create store of helpers for this class
        if (!isset(static::$helpers[$class])) {
            static::$helpers[$class] = [];
        }

        $helper = include $path;

        if (\is_callable($helper)) {
            static::$helpers[$class][$name] = $helper;
        } else {
            throw new CommonException("Helper `$name` not found in file `$path`");
        }
    }