6064

     *   $event->replace = true; 
     *   // Now do something with the information you have, for example
     *   // you might want to populate a value to $event->return if 
     *   // you want the unknown method to return a value. 
     * }); 
     * ~~~~~
     * 
     * #pw-hooker
     * 
     * @param string $method Requested method name
     * @param array $arguments Arguments provided
     * @return null|mixed Return value of method (if applicable)
     * @throws WireException
     * 
     */
    protected function ___callUnknown($method, $arguments) {
        if($arguments) {} // intentional to avoid unused argument notice
        $config = $this->wire()->config;
        if($config && $config->disableUnknownMethodException) return null;
        throw new WireException("Method " . $this->className() . "::$method does not exist or is not callable in this context"); 
    }
 
    /**
     * Provides the implementation for calling hooks in ProcessWire
     *
     * Unlike __call, this method won't trigger an Exception if the hook and method don't exist. 
     * Instead it returns a result array containing information about the call. 
     * 
     * #pw-internal
     *
     * @param string $method Method or property to run hooks for.
     * @param array $arguments Arguments passed to the method and hook. 
     * @param string|array $type May be either 'method', 'property' or array of hooks (from getHooks) to run. Default is 'method'.
     * @return array Returns an array with the following information: 
     *     [return] => The value returned from the hook or NULL if no value returned or hook didn't exist. 
     *    [numHooksRun] => The number of hooks that were actually run. 
     *    [methodExists] => Did the hook method exist as a real method in the class? (i.e. with 3 underscores ___method).
     *    [replace] => Set by the hook at runtime if it wants to prevent execution of the original hooked method.
     *
     */

     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal
     * 
     * @param string $method Method name, without leading "___"
     * @param array $arguments
     * @return mixed
     * 
     */

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */
    protected function _callWireAPI($method, $arguments) {
        $var = $this->_wire ? $this->_wire->fuel()->$method : null;
        if(!$var) return false;

 
        if ($ignoreStrictCheck || !$env->isStrictVariables()) {
            return;
        }
 
        throw new RuntimeError(sprintf('Neither the property "%1$s" nor one of the methods "%1$s()", "get%1$s()"/"is%1$s()"/"has%1$s()" or "__call()" exist and have public access in class "%2$s".', $item, $class), $lineno, $source);
    }
 
    if ($isDefinedTest) {
        return true;
    }
 
    if ($sandboxed) {
        $env->getExtension(SandboxExtension::class)->checkMethodAllowed($object, $method, $lineno, $source);
    }
 
    // Some objects throw exceptions when they have __call, and the method we try
    // to call is not supported. If ignoreStrictCheck is true, we should return null.
    try {
        $ret = $object->$method(...$arguments);
    } catch (\BadMethodCallException $e) {
        if ($call && ($ignoreStrictCheck || !$env->isStrictVariables())) {
            return;
        }
        throw $e;
    }
 
    return $ret;
}
 
/**
 * Returns the values from a single column in the input array.
 *
 * <pre>
 *  {% set items = [{ 'fruit' : 'apple'}, {'fruit' : 'orange' }] %}
 *
 *  {% set fruits = items|column('fruit') %}
 *
 *  {# fruits now contains ['apple', 'orange'] #}
 * </pre>

    private $source;
    private $macros = [];
 
    public function __construct(Environment $env)
    {
        parent::__construct($env);
 
        $this->source = $this->getSourceContext();
 
        $this->parent = false;
 
        $this->blocks = [
        ];
    }
 
    protected function doDisplay(array $context, array $blocks = [])
    {
        $macros = $this->macros;
        // line 1
        $context["brand"] = twig_get_attribute($this->env, $this->source, ($context["pages"] ?? null), "get", [0 => ("template=brand,code=" . twig_get_attribute($this->env, $this->source, twig_get_attribute($this->env, $this->source, ($context["page"] ?? null), "partdata", [], "any", false, false, false, 1), "brandcode", [], "any", false, false, false, 1))], "method", false, false, false, 1);
        // line 2
        echo "
 
<div class=\"bar\">
\t<!-- LEFT COLUMN _________________________________________________________-->
 
\t<p class=\"lead\">
\t\t";
        // line 8
        echo twig_get_attribute($this->env, $this->source, twig_get_attribute($this->env, $this->source, ($context["page"] ?? null), "item", [], "any", false, false, false, 8), "description", [], "any", false, false, false, 8);
        echo "
\t\t";
        // line 9
        if (twig_get_attribute($this->env, $this->source, twig_get_attribute($this->env, $this->source, ($context["page"] ?? null), "item", [], "any", false, false, false, 9), "description2", [], "any", false, false, false, 9)) {
            // line 10
            echo "\t\t\t<br> ";
            echo twig_escape_filter($this->env, twig_get_attribute($this->env, $this->source, twig_get_attribute($this->env, $this->source, ($context["page"] ?? null), "item", [], "any", false, false, false, 10), "description2", [], "any", false, false, false, 10), "html", null, true);
            echo "
\t\t";
        }

        } else {
            ob_start(function () { return ''; });
        }
        try {
            $this->display($context);
        } catch (\Throwable $e) {
            while (ob_get_level() > $level) {
                ob_end_clean();
            }
 
            throw $e;
        }
 
        return ob_get_clean();
    }
 
    protected function displayWithErrorHandling(array $context, array $blocks = [])
    {
        try {
            $this->doDisplay($context, $blocks);
        } catch (Error $e) {
            if (!$e->getSourceContext()) {
                $e->setSourceContext($this->getSourceContext());
            }
 
            // this is mostly useful for \Twig\Error\LoaderError exceptions
            // see \Twig\Error\LoaderError
            if (-1 === $e->getTemplateLine()) {
                $e->guess();
            }
 
            throw $e;
        } catch (\Exception $e) {
            $e = new RuntimeError(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $this->getSourceContext(), $e);
            $e->guess();
 
            throw $e;
        }
    }
 

    {
        return $this;
    }
 
    /**
     * Returns all blocks.
     *
     * This method is for internal use only and should never be called
     * directly.
     *
     * @return array An array of blocks
     */
    public function getBlocks()
    {
        return $this->blocks;
    }
 
    public function display(array $context, array $blocks = [])
    {
        $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks));
    }
 
    public function render(array $context)
    {
        $level = ob_get_level();
        if ($this->env->isDebug()) {
            ob_start();
        } else {
            ob_start(function () { return ''; });
        }
        try {
            $this->display($context);
        } catch (\Throwable $e) {
            while (ob_get_level() > $level) {
                ob_end_clean();
            }
 
            throw $e;
        }
 

    public function getBlocks()
    {
        return $this->blocks;
    }
 
    public function display(array $context, array $blocks = [])
    {
        $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks));
    }
 
    public function render(array $context)
    {
        $level = ob_get_level();
        if ($this->env->isDebug()) {
            ob_start();
        } else {
            ob_start(function () { return ''; });
        }
        try {
            $this->display($context);
        } catch (\Throwable $e) {
            while (ob_get_level() > $level) {
                ob_end_clean();
            }
 
            throw $e;
        }
 
        return ob_get_clean();
    }
 
    protected function displayWithErrorHandling(array $context, array $blocks = [])
    {
        try {
            $this->doDisplay($context, $blocks);
        } catch (Error $e) {
            if (!$e->getSourceContext()) {
                $e->setSourceContext($this->getSourceContext());
            }
 

     * directly (use Twig\Environment::load() instead).
     *
     * @internal
     */
    public function __construct(Environment $env, Template $template)
    {
        $this->env = $env;
        $this->template = $template;
    }
 
    /**
     * Renders the template.
     *
     * @param array $context An array of parameters to pass to the template
     */
    public function render(array $context = []): string
    {
        // using func_get_args() allows to not expose the blocks argument
        // as it should only be used by internal code
        return $this->template->render($context, \func_get_args()[1] ?? []);
    }
 
    /**
     * Displays the template.
     *
     * @param array $context An array of parameters to pass to the template
     */
    public function display(array $context = [])
    {
        // using func_get_args() allows to not expose the blocks argument
        // as it should only be used by internal code
        $this->template->display($context, \func_get_args()[1] ?? []);
    }
 
    /**
     * Checks if a block is defined.
     *
     * @param string $name    The block name
     * @param array  $context An array of parameters to pass to the template
     */

        $key = $this->getLoader()->getCacheKey($name).$this->optionsHash;
 
        return $this->templateClassPrefix.hash('sha256', $key).(null === $index ? '' : '___'.$index);
    }
 
    /**
     * Renders a template.
     *
     * @param string|TemplateWrapper $name    The template name
     * @param array                  $context An array of parameters to pass to the template
     *
     * @return string The rendered template
     *
     * @throws LoaderError  When the template cannot be found
     * @throws SyntaxError  When an error occurred during compilation
     * @throws RuntimeError When an error occurred during rendering
     */
    public function render($name, array $context = [])
    {
        return $this->load($name)->render($context);
    }
 
    /**
     * Displays a template.
     *
     * @param string|TemplateWrapper $name    The template name
     * @param array                  $context An array of parameters to pass to the template
     *
     * @throws LoaderError  When the template cannot be found
     * @throws SyntaxError  When an error occurred during compilation
     * @throws RuntimeError When an error occurred during rendering
     */
    public function display($name, array $context = [])
    {
        $this->load($name)->display($context);
    }
 
    /**
     * Loads a template.
     *

        }
        Parts::requestPrice($page->itemid);
 
        $page->partdata = $CACHE->fetch($page->itemid);
 
        if ($page->partdata === false) {
            $CACHE->cachePage($page);
            $page->partdata = $CACHE->fetch($page);
        }
 
        if (self::pw('user')->isLoggedIn() && empty($page->partdata->substitutes) === false && sizeof($page->partdata->substitutes)) {
            $itemids   = $page->partdata->substitutes;
            $itemids[] = $page->itemid;
            Parts::requestPriceMultiple($itemids);
            self::requestPartPagesBuild($itemids);
        }
 
        // PartsImages::instance()->addDocmImageToPage($page);
        $page->breadcrumbs = $config->twig->render('parts/part/bread-crumbs.twig');
        return $config->twig->render('parts/part/page.twig', ['catalog' => PartsCatalog::instance()]);
    }
 
    private static function requestPartPagesBuild($itemIDs) {
        $pages = PartsPagesRepo::instance();
        $list = [];
 
        foreach ($itemIDs as $itemID) {
            if ($pages->exists($itemID) === false) {
                $list[] = $itemID;
            }
        }
        if (empty($list)) {
            return true;
        }
        return BuildPartPagesCache::instance()->cacheItemids($list);
    }
 
    public static function init() {
        $m = self::pw('modules')->get('Fowler');
 

        $class = $handler[0];
 
        if (class_exists($class) == false) {
            throw new Exception("Class $class does not exist");
        }
 
        $methodName = strtoupper($handler[1]);
 
        if (method_exists($class, $methodName) === false) {
            throw new Exception("Class Method $class::$methodName does not exist");
        }
 
        $vars = (object) $routeInfo[2];
        $vars = array_merge((array) $this->params(), (array) $vars);
 
        // convert array to object:
        // $vars = json_decode(json_encode($vars));
        $data = new WireData();
        $data->setArray($vars);
        return $class::$methodName($data);
    }
 
    public function params($index = null, $default = null, $source = null) {
        // check for php://input and merge with $_REQUEST
        if ((isset($_SERVER['CONTENT_TYPE']) &&
            stripos($_SERVER['CONTENT_TYPE'], 'application/json') !== false) ||
            (isset($_SERVER['HTTP_CONTENT_TYPE']) &&
        stripos($_SERVER['HTTP_CONTENT_TYPE'], 'application/json') !== false) // PHP build in Webserver !?
        ) {
            if ($json = json_decode(@file_get_contents('php://input'), true)) {
                $_REQUEST = array_merge($_REQUEST, $json);
            }
        }
 
        $src = $source ? $source : $_REQUEST;
 
        return $this->fetch_from_array($src, $index, $default);
    }
 
    public function fetch_from_array(&$array, $index = null, $default = null) {

 
        if (array_key_exists(2, $this->routeInfo)) {
            $params = $this->routeInfo[2];
            if (array_key_exists('pagenbr', $params)) {
                $input->setPageNum(intval($params['pagenbr']));
            }
        }
        return $this->handleRoute($this->routeInfo);
    }
 
    /**
     * Try Calling the Handler Function, catch errors if needed
     * @param  array $routeInfo
     * @return strings
     */
    protected function handleRoute() {
        $response = '';
 
        try {
            $response = $this->handle($this->routeInfo);
        } catch (Wire404Exception $e) {
            $this->error = true;
            throw $e;
        } catch (Exception $e) {
            $this->error = true;
            $response = $this->handleException($e);
        }
        return $response;
    }
 
    /**
     * Return Response after Handling Exception
     * @param  Exception $e
     * @return string
     */
    protected function handleException(Exception $e) {
        $whoops = new Whoops();
        $whoops->allowQuit(false);
        $whoops->writeToOutput(false);
        $whoops->pushHandler($this->getWhoopsEmailPageHandler());

    public function setRoutePrefix($prefix = '') {
        $this->routeprefix = $prefix;
    }
 
    /**
     * Return Route Handler Call
     * @return mixed
     */
    public function route() {
        $input = $this->wire('input');
        $dispatcher = $this->dispatcher();
        $this->routeInfo  = $dispatcher->dispatch($input->requestMethod(), $input->url());
 
        if (array_key_exists(2, $this->routeInfo)) {
            $params = $this->routeInfo[2];
            if (array_key_exists('pagenbr', $params)) {
                $input->setPageNum(intval($params['pagenbr']));
            }
        }
        return $this->handleRoute($this->routeInfo);
    }
 
    /**
     * Try Calling the Handler Function, catch errors if needed
     * @param  array $routeInfo
     * @return strings
     */
    protected function handleRoute() {
        $response = '';
 
        try {
            $response = $this->handle($this->routeInfo);
        } catch (Wire404Exception $e) {
            $this->error = true;
            throw $e;
        } catch (Exception $e) {
            $this->error = true;
            $response = $this->handleException($e);
        }
        return $response;

<?php
    use Controllers\Part;
    use Controllers\Category;
 
    Part::init();
    Category::init();
 
    $routes = [
        ['GET',  '', Part::class, 'index'],
    ];
    $router = new Mvc\Routers\Router();
    $router->setRoutes($routes);
    $router->setRoutePrefix($page->url);
    $page->html = $router->route();
 
 include(\ProcessWire\wire('files')->compile(\ProcessWire\wire("config")->paths->root . 'site/templates/basic-page.php',array('includes'=>true,'namespace'=>true,'modules'=>true,'skipIfNamespace'=>true)));
 

        try {
            // include prepend files
            foreach($this->prependFilename as $_filename) {
                if($this->halt) break;
                $this->fileReady($_filename);
                require($_filename);
                $this->fileFinished();
            }
        } catch(\Exception $e) {
            if($this->fileFailed($this->currentFilename, $e)) throw $this->renderFailed($e);
        }
        
        if($this->halt) {
            // if prepend file indicates we should halt, then do not render next file
            $this->returnValue = 0;
        } else {
            // include main file to render
            try {
                $this->fileReady($this->filename);
                $this->returnValue = require($this->filename);
                $this->fileFinished();
            } catch(\Exception $e) {
                if($this->fileFailed($this->filename, $e)) throw $this->renderFailed($e);
            }
        }
    
        try {
            // include append files
            foreach($this->appendFilename as $_filename) {
                if($this->halt) break;
                $this->fileReady($_filename);
                require($_filename);
                $this->fileFinished();
            }
        } catch(\Exception $e) {
            if($this->fileFailed($this->currentFilename, $e)) throw $this->renderFailed($e);
        }
        
        $out = ob_get_contents();
        ob_end_clean();

    public function setLocalHooks(array $hooks) {
        $this->localHooks = $hooks;
    }
 
    /**
     * Call a method in this object, for use by WireHooks
     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

                } else {
                    throw new WireException("Invalid output file location or specified file does not exist. $setFilename"); 
                }
            } else {
                if($compiler) {
                    $options['filename'] = $compiler->compile($template->filename);
                    $output->setFilename($options['filename']);
                    $output->setChdir(dirname($template->filename));
                } else {
                    $options['filename'] = $template->filename;
                }
            }
 
            // pass along the $options as a local variable to the template so that one can provide their 
            // own additional variables in it if they want to
            $output->set('options', $options);
 
            $profiler = $this->wire('profiler');
            $profilerEvent = $profiler ? $profiler->start($page->path, $this, array('page' => $page)) : null;
            $data = $output->render();
            if($profilerEvent) $profiler->stop($profilerEvent);
            if(!strlen($data) && $page->template->name === 'admin' && !is_readable($options['filename'])) {
                throw new WireException('Missing or non-readable template file: ' . basename($options['filename']));
            }
        }
 
        if($this->wire('config')->useMarkupRegions) {
            $contentType = $template->contentType; 
            if(empty($contentType) || stripos($contentType, 'html') !== false) {
                $this->populateMarkupRegions($data);
            }
        }
 
        if($data && $cacheAllowed && $cacheFile) {
            $data = $this->saveCacheFileReady($page, $data);
            $cacheFile->save($data);
        }
        
        $event->return = $data; 
 

 
    /**
     * Call a method in this object, for use by WireHooks
     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal
     * 
     * @param string $method Method name, without leading "___"
     * @param array $arguments

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

                    if(!$toMethodCallable && strpos($toMethod, "\\") === false && __NAMESPACE__) {
                        $_toMethod = $toMethod;
                        $toMethod = "\\" . __NAMESPACE__ . "\\$toMethod";
                        $toMethodCallable = is_callable($toMethod);
                        if(!$toMethodCallable) {
                            $toMethod = "\\$_toMethod";
                            $toMethodCallable = is_callable($toMethod);
                        }
                    }
                    if($toMethodCallable) {
                        $returnValue = $toMethod($event);
                    } else {
                        // hook fail, not callable
                        $returnValue = null;
                    }
                } else {
                    /** @var Wire $toObject */
                    if($hook['toPublic']) {
                        // public
                        $returnValue = $toObject->$toMethod($event);
                    } else {
                        // protected or private
                        $returnValue = $toObject->_callMethod($toMethod, array($event));
                    }
                    $toMethodCallable = true; 
                }
 
                if($returnValue !== null) {
                    // hook method/func had an explicit 'return $value;' statement 
                    // we can optionally use this rather than $event->return. Can be useful
                    // in cases where a return value doesn’t need to be passed around to
                    // more than one hook
                    if($useHookReturnValue) {
                        $event->return = $returnValue;
                    }
                }
                
                if($profilerEvent) $profiler->stop($profilerEvent);
                
                if(!$toMethodCallable) continue;

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

        if($this->delayRedirects) {
            $this->checkProtocol($page);
            if($this->redirectURL) $this->redirect($this->redirectURL);
        }
 
        try {
 
            if($this->requestFile) {
 
                $this->responseType = self::responseTypeFile;
                $this->wire()->setStatus(ProcessWire::statusDownload, array('downloadFile' => $this->requestFile));
                $this->sendFile($page, $this->requestFile);
 
            } else {
 
                $contentType = $this->contentTypeHeader($page, true);
                $this->wire()->setStatus(ProcessWire::statusRender, array('contentType' => $contentType));
                if($config->ajax) $this->responseType = self::responseTypeAjax;
                
                return $page->render();
            }
 
        } catch(Wire404Exception $e) {
            // 404 exception
            TemplateFile::clearAll();
            return $this->renderNoPage(array(
                'reason404' => '404 thrown during page render',
                'exception404' => $e, 
                'page' => $page, 
                'ready' => true, // let it know ready state already executed
            ));
 
        } catch(\Exception $e) {
            // other exception (re-throw non 404 exceptions)
            $this->responseType = self::responseTypeError;
            $this->failed($e, "Thrown during page render", $page);
            throw $e; 
        }
 
        return '';

      *
     */
    public function ___execute($internal = true) {
    
        if(!$internal) return $this->executeExternal();
 
        $this->responseType = self::responseTypeNormal;
        $config = $this->wire()->config; 
        $timerKey = $config->debug ? 'ProcessPageView.getPage()' : ''; 
        if($config->usePoweredBy !== null) header('X-Powered-By:' . ($config->usePoweredBy ? ' ProcessWire CMS' : ''));
        
        $this->wire()->pages->setOutputFormatting(true); 
        
        if($timerKey) Debug::timer($timerKey); 
        $page = $this->getPage();
        if($timerKey) Debug::saveTimer($timerKey, ($page && $page->id ? $page->path : '')); 
        
        if(!$page || !$page->id) return $this->renderNoPage();
        
        return $this->renderPage($page);
    }
 
    /**
     * Render Page
     * 
     * @param Page $page
     * @return bool|mixed|string
     * @throws WireException
     * @since 3.0.173
     * 
     */
    protected function renderPage(Page $page) {
        
        $config = $this->wire()->config;
        $page->setOutputFormatting(true);
        $_page = $page;
        
        $page = $this->checkAccess($page);
 
        if(!$page || $_page->id == $config->http404PageID) {

 
    /**
     * Call a method in this object, for use by WireHooks
     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal
     * 
     * @param string $method Method name, without leading "___"
     * @param array $arguments

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

    // If ProcessWire is not installed, go to the installer
    if(is_file("./install.php") && strtolower($_SERVER['REQUEST_URI']) == strtolower($config->urls->root)) {
        require("./install.php");
        exit(0);
    } else {
        header("HTTP/1.1 404 Page Not Found");
        echo "404 page not found (no site configuration or install.php available)";
        exit(0);
    }
}
 
$process = null;
$wire = null;
 
try { 
    // Bootstrap ProcessWire's core and make the API available with $wire
    $wire = new ProcessWire($config);
    $process = $wire->modules->get('ProcessPageView'); /** @var ProcessPageView $process */
    $wire->wire('process', $process); 
    echo $process->execute($config->internal);
    $config->internal ? $process->finished() : extract($wire->wire('all')->getArray());
    
} catch(\Exception $e) {
    // Formulate error message and send to the error handler
    if($process) $process->failed($e);
    $wire ? $wire->trackException($e) : $config->trackException($e);
    $errorMessage = "Exception: " . $e->getMessage() . " (in " . $e->getFile() . " line " . $e->getLine() . ")";
    if($config->debug || ($wire && $wire->user && $wire->user->isSuperuser())) $errorMessage .= "\n\n" . $e->getTraceAsString();
    trigger_error($errorMessage, E_USER_ERROR);
}