diff --git a/blocks/classes/output/block_contents.php b/blocks/classes/output/block_contents.php
new file mode 100644
index 00000000000..a18800bbe1b
--- /dev/null
+++ b/blocks/classes/output/block_contents.php
@@ -0,0 +1,161 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This class represents how a block appears on a page.
+ *
+ * During output, each block instance is asked to return a block_contents object,
+ * those are then passed to the $OUTPUT->block function for display.
+ *
+ * contents should probably be generated using a moodle_block_..._renderer.
+ *
+ * Other block-like things that need to appear on the page, for example the
+ * add new block UI, are also represented as block_contents objects.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class block_contents {
+
+    /** Used when the block cannot be collapsed **/
+    const NOT_HIDEABLE = 0;
+
+    /** Used when the block can be collapsed but currently is not **/
+    const VISIBLE = 1;
+
+    /** Used when the block has been collapsed **/
+    const HIDDEN = 2;
+
+    /**
+     * @var int Used to set $skipid.
+     */
+    protected static $idcounter = 1;
+
+    /**
+     * @var int All the blocks (or things that look like blocks) printed on
+     * a page are given a unique number that can be used to construct id="" attributes.
+     * This is set automatically be the {@link prepare()} method.
+     * Do not try to set it manually.
+     */
+    public $skipid;
+
+    /**
+     * @var int If this is the contents of a real block, this should be set
+     * to the block_instance.id. Otherwise this should be set to 0.
+     */
+    public $blockinstanceid = 0;
+
+    /**
+     * @var int If this is a real block instance, and there is a corresponding
+     * block_position.id for the block on this page, this should be set to that id.
+     * Otherwise it should be 0.
+     */
+    public $blockpositionid = 0;
+
+    /**
+     * @var array An array of attribute => value pairs that are put on the outer div of this
+     * block. {@link $id} and {@link $classes} attributes should be set separately.
+     */
+    public $attributes;
+
+    /**
+     * @var string The title of this block. If this came from user input, it should already
+     * have had format_string() processing done on it. This will be output inside
+     * <h2> tags. Please do not cause invalid XHTML.
+     */
+    public $title = '';
+
+    /**
+     * @var string The label to use when the block does not, or will not have a visible title.
+     * You should never set this as well as title... it will just be ignored.
+     */
+    public $arialabel = '';
+
+    /**
+     * @var string HTML for the content
+     */
+    public $content = '';
+
+    /**
+     * @var array An alternative to $content, it you want a list of things with optional icons.
+     */
+    public $footer = '';
+
+    /**
+     * @var string Any small print that should appear under the block to explain
+     * to the teacher about the block, for example 'This is a sticky block that was
+     * added in the system context.'
+     */
+    public $annotation = '';
+
+    /**
+     * @var int One of the constants NOT_HIDEABLE, VISIBLE, HIDDEN. Whether
+     * the user can toggle whether this block is visible.
+     */
+    public $collapsible = self::NOT_HIDEABLE;
+
+    /**
+     * Set this to true if the block is dockable.
+     * @var bool
+     */
+    public $dockable = false;
+
+    /**
+     * @var array A (possibly empty) array of editing controls. Each element of
+     * this array should be an array('url' => $url, 'icon' => $icon, 'caption' => $caption).
+     * $icon is the icon name. Fed to $OUTPUT->image_url.
+     */
+    public $controls = array();
+
+
+    /**
+     * Create new instance of block content
+     * @param array $attributes
+     */
+    public function __construct(array $attributes = null) {
+        $this->skipid = self::$idcounter;
+        self::$idcounter += 1;
+
+        if ($attributes) {
+            // standard block
+            $this->attributes = $attributes;
+        } else {
+            // simple "fake" blocks used in some modules and "Add new block" block
+            $this->attributes = array('class'=>'block');
+        }
+    }
+
+    /**
+     * Add html class to block
+     *
+     * @param string $class
+     */
+    public function add_class($class) {
+        $this->attributes['class'] .= ' '.$class;
+    }
+
+    /**
+     * Check if the block is a fake block.
+     *
+     * @return boolean
+     */
+    public function is_fake() {
+        return isset($this->attributes['data-block']) && $this->attributes['data-block'] == '_fake';
+    }
+}
diff --git a/blocks/classes/output/block_move_target.php b/blocks/classes/output/block_move_target.php
new file mode 100644
index 00000000000..c0312747b8b
--- /dev/null
+++ b/blocks/classes/output/block_move_target.php
@@ -0,0 +1,44 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This class represents a target for where a block can go when it is being moved.
+ *
+ * This needs to be rendered as a form with the given hidden from fields, and
+ * clicking anywhere in the form should submit it. The form action should be
+ * $PAGE->url.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class block_move_target {
+
+    /**
+     * @var moodle_url Move url
+     */
+    public $url;
+
+    /**
+     * Constructor
+     * @param moodle_url $url
+     */
+    public function __construct(moodle_url $url) {
+        $this->url  = $url;
+    }
+}
diff --git a/lib/classes/component.php b/lib/classes/component.php
index 26b83933d71..50a5be5f4c3 100644
--- a/lib/classes/component.php
+++ b/lib/classes/component.php
@@ -390,6 +390,7 @@ class core_component {
         $keyclasses = [
             \core\exception\moodle_exception::class,
             \core\output\bootstrap_renderer::class,
+            \renderable::class,
         ];
         foreach ($keyclasses as $classname) {
             if (!array_key_exists($classname, $cache['classmap'])) {
diff --git a/lib/classes/output/action_link.php b/lib/classes/output/action_link.php
new file mode 100644
index 00000000000..ae006adfe27
--- /dev/null
+++ b/lib/classes/output/action_link.php
@@ -0,0 +1,156 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure describing html link with special action attached.
+ *
+ * @copyright 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class action_link implements renderable {
+
+    /**
+     * @var moodle_url Href url
+     */
+    public $url;
+
+    /**
+     * @var string Link text HTML fragment
+     */
+    public $text;
+
+    /**
+     * @var array HTML attributes
+     */
+    public $attributes;
+
+    /**
+     * @var array List of actions attached to link
+     */
+    public $actions;
+
+    /**
+     * @var pix_icon Optional pix icon to render with the link
+     */
+    public $icon;
+
+    /**
+     * Constructor
+     * @param moodle_url $url
+     * @param string $text HTML fragment
+     * @param component_action $action
+     * @param array $attributes associative array of html link attributes + disabled
+     * @param pix_icon $icon optional pix_icon to render with the link text
+     */
+    public function __construct(moodle_url $url,
+        $text,
+        component_action $action=null,
+        array $attributes=null,
+        pix_icon $icon=null) {
+        $this->url = clone($url);
+        $this->text = $text;
+        if (empty($attributes['id'])) {
+            $attributes['id'] = html_writer::random_id('action_link');
+        }
+        $this->attributes = (array)$attributes;
+        if ($action) {
+            $this->add_action($action);
+        }
+        $this->icon = $icon;
+    }
+
+    /**
+     * Add action to the link.
+     *
+     * @param component_action $action
+     */
+    public function add_action(component_action $action) {
+        $this->actions[] = $action;
+    }
+
+    /**
+     * Adds a CSS class to this action link object
+     * @param string $class
+     */
+    public function add_class($class) {
+        if (empty($this->attributes['class'])) {
+            $this->attributes['class'] = $class;
+        } else {
+            $this->attributes['class'] .= ' ' . $class;
+        }
+    }
+
+    /**
+     * Returns true if the specified class has been added to this link.
+     * @param string $class
+     * @return bool
+     */
+    public function has_class($class) {
+        return strpos(' ' . $this->attributes['class'] . ' ', ' ' . $class . ' ') !== false;
+    }
+
+    /**
+     * Return the rendered HTML for the icon. Useful for rendering action links in a template.
+     * @return string
+     */
+    public function get_icon_html() {
+        global $OUTPUT;
+        if (!$this->icon) {
+            return '';
+        }
+        return $OUTPUT->render($this->icon);
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output The renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $data = new stdClass();
+        $attributes = $this->attributes;
+
+        $data->id = $attributes['id'];
+        unset($attributes['id']);
+
+        $data->disabled = !empty($attributes['disabled']);
+        unset($attributes['disabled']);
+
+        $data->text = $this->text instanceof renderable ? $output->render($this->text) : (string) $this->text;
+        $data->url = $this->url ? $this->url->out(false) : '';
+        $data->icon = $this->icon ? $this->icon->export_for_pix() : null;
+        $data->classes = isset($attributes['class']) ? $attributes['class'] : '';
+        unset($attributes['class']);
+
+        $data->attributes = array_map(function($key, $value) {
+            return [
+                'name' => $key,
+                'value' => $value
+            ];
+        }, array_keys($attributes), $attributes);
+
+        $data->actions = array_map(function($action) use ($output) {
+            return $action->export_for_template($output);
+        }, !empty($this->actions) ? $this->actions : []);
+        $data->hasactions = !empty($this->actions);
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/action_menu.php b/lib/classes/output/action_menu.php
new file mode 100644
index 00000000000..2906f1c86fa
--- /dev/null
+++ b/lib/classes/output/action_menu.php
@@ -0,0 +1,666 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+use core\output\local\action_menu\subpanel;
+
+/**
+ * An action menu.
+ *
+ * This action menu component takes a series of primary and secondary actions.
+ * The primary actions are displayed permanently and the secondary attributes are displayed within a drop
+ * down menu.
+ *
+ * @package core
+ * @category output
+ * @copyright 2013 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class action_menu implements renderable, templatable {
+
+    /**
+     * Top right alignment.
+     */
+    const TL = 1;
+
+    /**
+     * Top right alignment.
+     */
+    const TR = 2;
+
+    /**
+     * Top right alignment.
+     */
+    const BL = 3;
+
+    /**
+     * Top right alignment.
+     */
+    const BR = 4;
+
+    /**
+     * The instance number. This is unique to this instance of the action menu.
+     * @var int
+     */
+    protected $instance = 0;
+
+    /**
+     * An array of primary actions. Please use {@link action_menu::add_primary_action()} to add actions.
+     * @var array
+     */
+    protected $primaryactions = array();
+
+    /**
+     * An array of secondary actions. Please use {@link action_menu::add_secondary_action()} to add actions.
+     * @var array
+     */
+    protected $secondaryactions = array();
+
+    /**
+     * An array of attributes added to the container of the action menu.
+     * Initialised with defaults during construction.
+     * @var array
+     */
+    public $attributes = array();
+    /**
+     * An array of attributes added to the container of the primary actions.
+     * Initialised with defaults during construction.
+     * @var array
+     */
+    public $attributesprimary = array();
+    /**
+     * An array of attributes added to the container of the secondary actions.
+     * Initialised with defaults during construction.
+     * @var array
+     */
+    public $attributessecondary = array();
+
+    /**
+     * The string to use next to the icon for the action icon relating to the secondary (dropdown) menu.
+     * @var array
+     */
+    public $actiontext = null;
+
+    /**
+     * The string to use for the accessible label for the menu.
+     * @var array
+     */
+    public $actionlabel = null;
+
+    /**
+     * An icon to use for the toggling the secondary menu (dropdown).
+     * @var pix_icon
+     */
+    public $actionicon;
+
+    /**
+     * Any text to use for the toggling the secondary menu (dropdown).
+     * @var string
+     */
+    public $menutrigger = '';
+
+    /**
+     * An array of attributes added to the trigger element of the secondary menu.
+     * @var array
+     */
+    public $triggerattributes = [];
+
+    /**
+     * Any extra classes for toggling to the secondary menu.
+     * @var string
+     */
+    public $triggerextraclasses = '';
+
+    /**
+     * Place the action menu before all other actions.
+     * @var bool
+     */
+    public $prioritise = false;
+
+    /**
+     * Dropdown menu alignment class.
+     * @var string
+     */
+    public $dropdownalignment = '';
+
+    /**
+     * Constructs the action menu with the given items.
+     *
+     * @param array $actions An array of actions (action_menu_link|pix_icon|string).
+     */
+    public function __construct(array $actions = array()) {
+        static $initialised = 0;
+        $this->instance = $initialised;
+        $initialised++;
+
+        $this->attributes = array(
+            'id' => 'action-menu-'.$this->instance,
+            'class' => 'moodle-actionmenu',
+            'data-enhance' => 'moodle-core-actionmenu'
+        );
+        $this->attributesprimary = array(
+            'id' => 'action-menu-'.$this->instance.'-menubar',
+            'class' => 'menubar',
+        );
+        $this->attributessecondary = array(
+            'id' => 'action-menu-'.$this->instance.'-menu',
+            'class' => 'menu',
+            'data-rel' => 'menu-content',
+            'aria-labelledby' => 'action-menu-toggle-'.$this->instance,
+            'role' => 'menu'
+        );
+        $this->dropdownalignment = 'dropdown-menu-right';
+        foreach ($actions as $action) {
+            $this->add($action);
+        }
+    }
+
+    /**
+     * Sets the label for the menu trigger.
+     *
+     * @param string $label The text
+     */
+    public function set_action_label($label) {
+        $this->actionlabel = $label;
+    }
+
+    /**
+     * Sets the menu trigger text.
+     *
+     * @param string $trigger The text
+     * @param string $extraclasses Extra classes to style the secondary menu toggle.
+     */
+    public function set_menu_trigger($trigger, $extraclasses = '') {
+        $this->menutrigger = $trigger;
+        $this->triggerextraclasses = $extraclasses;
+    }
+
+    /**
+     * Classes for the trigger menu
+     */
+    const DEFAULT_KEBAB_TRIGGER_CLASSES = 'btn btn-icon d-flex align-items-center justify-content-center no-caret';
+
+    /**
+     * Setup trigger as in the kebab menu.
+     *
+     * @param string|null $triggername
+     * @param core_renderer|null $output
+     * @param string|null $extraclasses extra classes for the trigger {@see self::set_menu_trigger()}
+     * @throws coding_exception
+     */
+    public function set_kebab_trigger(?string $triggername = null, ?core_renderer $output = null,
+        ?string $extraclasses = '') {
+        global $OUTPUT;
+        if (empty($output)) {
+            $output = $OUTPUT;
+        }
+        $label = $triggername ?? get_string('actions');
+        $triggerclasses = self::DEFAULT_KEBAB_TRIGGER_CLASSES . ' ' . $extraclasses;
+        $icon = $output->pix_icon('i/menu', $label);
+        $this->set_menu_trigger($icon, $triggerclasses);
+    }
+
+    /**
+     * Return true if there is at least one visible link in the menu.
+     *
+     * @return bool
+     */
+    public function is_empty() {
+        return !count($this->primaryactions) && !count($this->secondaryactions);
+    }
+
+    /**
+     * Initialises JS required fore the action menu.
+     * The JS is only required once as it manages all action menu's on the page.
+     *
+     * @param moodle_page $page
+     */
+    public function initialise_js(moodle_page $page) {
+        static $initialised = false;
+        if (!$initialised) {
+            $page->requires->yui_module('moodle-core-actionmenu', 'M.core.actionmenu.init');
+            $initialised = true;
+        }
+    }
+
+    /**
+     * Adds an action to this action menu.
+     *
+     * @param action_link|pix_icon|subpanel|string $action
+     */
+    public function add($action) {
+
+        if ($action instanceof subpanel) {
+            $this->add_secondary_subpanel($action);
+        } else if ($action instanceof action_link) {
+            if ($action->primary) {
+                $this->add_primary_action($action);
+            } else {
+                $this->add_secondary_action($action);
+            }
+        } else if ($action instanceof pix_icon) {
+            $this->add_primary_action($action);
+        } else {
+            $this->add_secondary_action($action);
+        }
+    }
+
+    /**
+     * Adds a secondary subpanel.
+     * @param subpanel $subpanel
+     */
+    public function add_secondary_subpanel(subpanel $subpanel) {
+        $this->secondaryactions[] = $subpanel;
+    }
+
+    /**
+     * Adds a primary action to the action menu.
+     *
+     * @param action_menu_link|action_link|pix_icon|string $action
+     */
+    public function add_primary_action($action) {
+        if ($action instanceof action_link || $action instanceof pix_icon) {
+            $action->attributes['role'] = 'menuitem';
+            $action->attributes['tabindex'] = '-1';
+            if ($action instanceof action_menu_link) {
+                $action->actionmenu = $this;
+            }
+        }
+        $this->primaryactions[] = $action;
+    }
+
+    /**
+     * Adds a secondary action to the action menu.
+     *
+     * @param action_link|pix_icon|string $action
+     */
+    public function add_secondary_action($action) {
+        if ($action instanceof action_link || $action instanceof pix_icon) {
+            $action->attributes['role'] = 'menuitem';
+            $action->attributes['tabindex'] = '-1';
+            if ($action instanceof action_menu_link) {
+                $action->actionmenu = $this;
+            }
+        }
+        $this->secondaryactions[] = $action;
+    }
+
+    /**
+     * Returns the primary actions ready to be rendered.
+     *
+     * @param core_renderer $output The renderer to use for getting icons.
+     * @return array
+     */
+    public function get_primary_actions(core_renderer $output = null) {
+        global $OUTPUT;
+        if ($output === null) {
+            $output = $OUTPUT;
+        }
+        $pixicon = $this->actionicon;
+        $linkclasses = array('toggle-display');
+
+        $title = '';
+        if (!empty($this->menutrigger)) {
+            $pixicon = '<b class="caret"></b>';
+            $linkclasses[] = 'textmenu';
+        } else {
+            $title = new lang_string('actionsmenu', 'moodle');
+            $this->actionicon = new pix_icon(
+                't/edit_menu',
+                '',
+                'moodle',
+                array('class' => 'iconsmall actionmenu', 'title' => '')
+            );
+            $pixicon = $this->actionicon;
+        }
+        if ($pixicon instanceof renderable) {
+            $pixicon = $output->render($pixicon);
+            if ($pixicon instanceof pix_icon && isset($pixicon->attributes['alt'])) {
+                $title = $pixicon->attributes['alt'];
+            }
+        }
+        $string = '';
+        if ($this->actiontext) {
+            $string = $this->actiontext;
+        }
+        $label = '';
+        if ($this->actionlabel) {
+            $label = $this->actionlabel;
+        } else {
+            $label = $title;
+        }
+        $actions = $this->primaryactions;
+        $attributes = array(
+            'class' => implode(' ', $linkclasses),
+            'title' => $title,
+            'aria-label' => $label,
+            'id' => 'action-menu-toggle-'.$this->instance,
+            'role' => 'menuitem',
+            'tabindex' => '-1',
+        );
+        $link = html_writer::link('#', $string . $this->menutrigger . $pixicon, $attributes);
+        if ($this->prioritise) {
+            array_unshift($actions, $link);
+        } else {
+            $actions[] = $link;
+        }
+        return $actions;
+    }
+
+    /**
+     * Returns the secondary actions ready to be rendered.
+     * @return array
+     */
+    public function get_secondary_actions() {
+        return $this->secondaryactions;
+    }
+
+    /**
+     * Sets the selector that should be used to find the owning node of this menu.
+     * @param string $selector A CSS/YUI selector to identify the owner of the menu.
+     */
+    public function set_owner_selector($selector) {
+        $this->attributes['data-owner'] = $selector;
+    }
+
+    /**
+     * Sets the alignment of the dialogue in relation to button used to toggle it.
+     *
+     * @deprecated since Moodle 4.0
+     *
+     * @param int $dialogue One of action_menu::TL, action_menu::TR, action_menu::BL, action_menu::BR.
+     * @param int $button One of action_menu::TL, action_menu::TR, action_menu::BL, action_menu::BR.
+     */
+    public function set_alignment($dialogue, $button) {
+        debugging('The method action_menu::set_alignment() is deprecated, use action_menu::set_menu_left()', DEBUG_DEVELOPER);
+        if (isset($this->attributessecondary['data-align'])) {
+            // We've already got one set, lets remove the old class so as to avoid troubles.
+            $class = $this->attributessecondary['class'];
+            $search = 'align-'.$this->attributessecondary['data-align'];
+            $this->attributessecondary['class'] = str_replace($search, '', $class);
+        }
+        $align = $this->get_align_string($dialogue) . '-' . $this->get_align_string($button);
+        $this->attributessecondary['data-align'] = $align;
+        $this->attributessecondary['class'] .= ' align-'.$align;
+    }
+
+    /**
+     * Returns a string to describe the alignment.
+     *
+     * @param int $align One of action_menu::TL, action_menu::TR, action_menu::BL, action_menu::BR.
+     * @return string
+     */
+    protected function get_align_string($align) {
+        switch ($align) {
+            case self::TL :
+                return 'tl';
+            case self::TR :
+                return 'tr';
+            case self::BL :
+                return 'bl';
+            case self::BR :
+                return 'br';
+            default :
+                return 'tl';
+        }
+    }
+
+    /**
+     * Aligns the left corner of the dropdown.
+     *
+     */
+    public function set_menu_left() {
+        $this->dropdownalignment = 'dropdown-menu-left';
+    }
+
+    /**
+     * Sets a constraint for the dialogue.
+     *
+     * The constraint is applied when the dialogue is shown and limits the display of the dialogue to within the
+     * element the constraint identifies.
+     *
+     * This is required whenever the action menu is displayed inside any CSS element with the .no-overflow class
+     * (flexible_table and any of it's child classes are a likely candidate).
+     *
+     * @deprecated since Moodle 4.3
+     * @param string $ancestorselector A snippet of CSS used to identify the ancestor to contrain the dialogue to.
+     */
+    public function set_constraint($ancestorselector) {
+        debugging('The method set_constraint() is deprecated. Please use the set_boundary() method instead.', DEBUG_DEVELOPER);
+        $this->set_boundary('window');
+    }
+
+    /**
+     * Set the overflow constraint boundary of the dropdown menu.
+     * @see https://getbootstrap.com/docs/4.6/components/dropdowns/#options The 'boundary' option in the Bootstrap documentation
+     *
+     * @param string $boundary Accepts the values of 'viewport', 'window', or 'scrollParent'.
+     * @throws coding_exception
+     */
+    public function set_boundary(string $boundary) {
+        if (!in_array($boundary, ['viewport', 'window', 'scrollParent'])) {
+            throw new coding_exception("HTMLElement reference boundaries are not supported." .
+                "Accepted boundaries are 'viewport', 'window', or 'scrollParent'.", DEBUG_DEVELOPER);
+        }
+
+        $this->triggerattributes['data-boundary'] = $boundary;
+    }
+
+    /**
+     * If you call this method the action menu will be displayed but will not be enhanced.
+     *
+     * By not displaying the menu enhanced all items will be displayed in a single row.
+     *
+     * @deprecated since Moodle 3.2
+     */
+    public function do_not_enhance() {
+        debugging('The method action_menu::do_not_enhance() is deprecated, use a list of action_icon instead.', DEBUG_DEVELOPER);
+    }
+
+    /**
+     * Returns true if this action menu will be enhanced.
+     *
+     * @return bool
+     */
+    public function will_be_enhanced() {
+        return isset($this->attributes['data-enhance']);
+    }
+
+    /**
+     * Sets nowrap on items. If true menu items should not wrap lines if they are longer than the available space.
+     *
+     * This property can be useful when the action menu is displayed within a parent element that is either floated
+     * or relatively positioned.
+     * In that situation the width of the menu is determined by the width of the parent element which may not be large
+     * enough for the menu items without them wrapping.
+     * This disables the wrapping so that the menu takes on the width of the longest item.
+     *
+     * @param bool $value If true nowrap gets set, if false it gets removed. Defaults to true.
+     */
+    public function set_nowrap_on_items($value = true) {
+        $class = 'nowrap-items';
+        if (!empty($this->attributes['class'])) {
+            $pos = strpos($this->attributes['class'], $class);
+            if ($value === true && $pos === false) {
+                // The value is true and the class has not been set yet. Add it.
+                $this->attributes['class'] .= ' '.$class;
+            } else if ($value === false && $pos !== false) {
+                // The value is false and the class has been set. Remove it.
+                $this->attributes['class'] = substr($this->attributes['class'], $pos, strlen($class));
+            }
+        } else if ($value) {
+            // The value is true and the class has not been set yet. Add it.
+            $this->attributes['class'] = $class;
+        }
+    }
+
+    /**
+     * Add classes to the action menu for an easier styling.
+     *
+     * @param string $class The class to add to attributes.
+     */
+    public function set_additional_classes(string $class = '') {
+        if (!empty($this->attributes['class'])) {
+            $this->attributes['class'] .= " ".$class;
+        } else {
+            $this->attributes['class'] = $class;
+        }
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output The renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $data = new stdClass();
+        // Assign a role of menubar to this action menu when:
+        // - it contains 2 or more primary actions; or
+        // - if it contains a primary action and secondary actions.
+        if (count($this->primaryactions) > 1 || (!empty($this->primaryactions) && !empty($this->secondaryactions))) {
+            $this->attributes['role'] = 'menubar';
+        }
+        $attributes = $this->attributes;
+
+        $data->instance = $this->instance;
+
+        $data->classes = isset($attributes['class']) ? $attributes['class'] : '';
+        unset($attributes['class']);
+
+        $data->attributes = array_map(function($key, $value) {
+            return [ 'name' => $key, 'value' => $value ];
+        }, array_keys($attributes), $attributes);
+
+        $data->primary = $this->export_primary_actions_for_template($output);
+        $data->secondary = $this->export_secondary_actions_for_template($output);
+        $data->dropdownalignment = $this->dropdownalignment;
+
+        return $data;
+    }
+
+    /**
+     * Export the primary actions for the template.
+     * @param renderer_base $output
+     * @return stdClass
+     */
+    protected function export_primary_actions_for_template(renderer_base $output): stdClass {
+        $attributes = $this->attributes;
+        $attributesprimary = $this->attributesprimary;
+
+        $primary = new stdClass();
+        $primary->title = '';
+        $primary->prioritise = $this->prioritise;
+
+        $primary->classes = isset($attributesprimary['class']) ? $attributesprimary['class'] : '';
+        unset($attributesprimary['class']);
+
+        $primary->attributes = array_map(function ($key, $value) {
+            return ['name' => $key, 'value' => $value];
+        }, array_keys($attributesprimary), $attributesprimary);
+        $primary->triggerattributes = array_map(function ($key, $value) {
+            return ['name' => $key, 'value' => $value];
+        }, array_keys($this->triggerattributes), $this->triggerattributes);
+
+        $actionicon = $this->actionicon;
+        if (!empty($this->menutrigger)) {
+            $primary->menutrigger = $this->menutrigger;
+            $primary->triggerextraclasses = $this->triggerextraclasses;
+            if ($this->actionlabel) {
+                $primary->title = $this->actionlabel;
+            } else if ($this->actiontext) {
+                $primary->title = $this->actiontext;
+            } else {
+                $primary->title = strip_tags($this->menutrigger);
+            }
+        } else {
+            $primary->title = get_string('actionsmenu');
+            $iconattributes = ['class' => 'iconsmall actionmenu', 'title' => $primary->title];
+            $actionicon = new pix_icon('t/edit_menu', '', 'moodle', $iconattributes);
+        }
+
+        // If the menu trigger is within the menubar, assign a role of menuitem. Otherwise, assign as a button.
+        $primary->triggerrole = 'button';
+        if (isset($attributes['role']) && $attributes['role'] === 'menubar') {
+            $primary->triggerrole = 'menuitem';
+        }
+
+        if ($actionicon instanceof pix_icon) {
+            $primary->icon = $actionicon->export_for_pix();
+            if (!empty($actionicon->attributes['alt'])) {
+                $primary->title = $actionicon->attributes['alt'];
+            }
+        } else {
+            $primary->iconraw = $actionicon ? $output->render($actionicon) : '';
+        }
+
+        $primary->actiontext = $this->actiontext ? (string) $this->actiontext : '';
+        $primary->items = array_map(function ($item) use ($output) {
+            $data = (object) [];
+            if ($item instanceof action_menu_link) {
+                $data->actionmenulink = $item->export_for_template($output);
+            } else if ($item instanceof action_menu_filler) {
+                $data->actionmenufiller = $item->export_for_template($output);
+            } else if ($item instanceof action_link) {
+                $data->actionlink = $item->export_for_template($output);
+            } else if ($item instanceof pix_icon) {
+                $data->pixicon = $item->export_for_template($output);
+            } else {
+                $data->rawhtml = ($item instanceof renderable) ? $output->render($item) : $item;
+            }
+            return $data;
+        }, $this->primaryactions);
+        return $primary;
+    }
+
+    /**
+     * Export the secondary actions for the template.
+     * @param renderer_base $output
+     * @return stdClass
+     */
+    protected function export_secondary_actions_for_template(renderer_base $output): stdClass {
+        $attributessecondary = $this->attributessecondary;
+        $secondary = new stdClass();
+        $secondary->classes = isset($attributessecondary['class']) ? $attributessecondary['class'] : '';
+        unset($attributessecondary['class']);
+
+        $secondary->attributes = array_map(function ($key, $value) {
+            return ['name' => $key, 'value' => $value];
+        }, array_keys($attributessecondary), $attributessecondary);
+        $secondary->items = array_map(function ($item) use ($output) {
+            $data = (object) [
+                'simpleitem' => true,
+            ];
+            if ($item instanceof action_menu_link) {
+                $data->actionmenulink = $item->export_for_template($output);
+                $data->simpleitem = false;
+            } else if ($item instanceof action_menu_filler) {
+                $data->actionmenufiller = $item->export_for_template($output);
+                $data->simpleitem = false;
+            } else if ($item instanceof subpanel) {
+                $data->subpanel = $item->export_for_template($output);
+                $data->simpleitem = false;
+            } else if ($item instanceof action_link) {
+                $data->actionlink = $item->export_for_template($output);
+            } else if ($item instanceof pix_icon) {
+                $data->pixicon = $item->export_for_template($output);
+            } else {
+                $data->rawhtml = ($item instanceof renderable) ? $output->render($item) : $item;
+            }
+            return $data;
+        }, $this->secondaryactions);
+        return $secondary;
+    }
+}
diff --git a/lib/classes/output/action_menu/filler.php b/lib/classes/output/action_menu/filler.php
new file mode 100644
index 00000000000..2a2fe9a0d00
--- /dev/null
+++ b/lib/classes/output/action_menu/filler.php
@@ -0,0 +1,39 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * An action menu filler
+ *
+ * @package core
+ * @category output
+ * @copyright 2013 Andrew Nicols
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class action_menu_filler extends action_link implements renderable {
+
+    /**
+     * True if this is a primary action. False if not.
+     * @var bool
+     */
+    public $primary = true;
+
+    /**
+     * Constructs the object.
+     */
+    public function __construct() {
+        $this->attributes['id'] = html_writer::random_id('action_link');
+    }
+}
diff --git a/lib/classes/output/action_menu/link.php b/lib/classes/output/action_menu/link.php
new file mode 100644
index 00000000000..d91abd646bc
--- /dev/null
+++ b/lib/classes/output/action_menu/link.php
@@ -0,0 +1,106 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * An action menu action
+ *
+ * @package core
+ * @category output
+ * @copyright 2013 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class action_menu_link extends action_link implements renderable {
+
+    /**
+     * True if this is a primary action. False if not.
+     * @var bool
+     */
+    public $primary = true;
+
+    /**
+     * The action menu this link has been added to.
+     * @var action_menu
+     */
+    public $actionmenu = null;
+
+    /**
+     * The number of instances of this action menu link (and its subclasses).
+     *
+     * @deprecated since Moodle 4.4.
+     * @var int
+     */
+    protected static $instance = 1;
+
+    /**
+     * Constructs the object.
+     *
+     * @param moodle_url $url The URL for the action.
+     * @param pix_icon|null $icon The icon to represent the action.
+     * @param string $text The text to represent the action.
+     * @param bool $primary Whether this is a primary action or not.
+     * @param array $attributes Any attribtues associated with the action.
+     */
+    public function __construct(moodle_url $url, ?pix_icon $icon, $text, $primary = true, array $attributes = array()) {
+        parent::__construct($url, $text, null, $attributes, $icon);
+        $this->primary = (bool)$primary;
+        $this->add_class('menu-action');
+        $this->attributes['role'] = 'menuitem';
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output The renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $data = parent::export_for_template($output);
+
+        // Ignore what the parent did with the attributes, except for ID and class.
+        $data->attributes = [];
+        $attributes = $this->attributes;
+        unset($attributes['id']);
+        unset($attributes['class']);
+
+        // Handle text being a renderable.
+        if ($this->text instanceof renderable) {
+            $data->text = $this->render($this->text);
+        }
+
+        $data->showtext = (!$this->icon || $this->primary === false);
+
+        $data->icon = null;
+        if ($this->icon) {
+            $icon = $this->icon;
+            if ($this->primary || !$this->actionmenu->will_be_enhanced()) {
+                $attributes['title'] = $data->text;
+            }
+            $data->icon = $icon ? $icon->export_for_pix() : null;
+        }
+
+        $data->disabled = !empty($attributes['disabled']);
+        unset($attributes['disabled']);
+
+        $data->attributes = array_map(function($key, $value) {
+            return [
+                'name' => $key,
+                'value' => $value
+            ];
+        }, array_keys($attributes), $attributes);
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/action_menu/link_primary.php b/lib/classes/output/action_menu/link_primary.php
new file mode 100644
index 00000000000..7359fbe4d61
--- /dev/null
+++ b/lib/classes/output/action_menu/link_primary.php
@@ -0,0 +1,37 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * A primary action menu action
+ *
+ * @package core
+ * @category output
+ * @copyright 2013 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class action_menu_link_primary extends action_menu_link {
+    /**
+     * Constructs the object.
+     *
+     * @param moodle_url $url
+     * @param pix_icon|null $icon
+     * @param string $text
+     * @param array $attributes
+     */
+    public function __construct(moodle_url $url, ?pix_icon $icon, $text, array $attributes = array()) {
+        parent::__construct($url, $icon, $text, true, $attributes);
+    }
+}
diff --git a/lib/classes/output/action_menu/link_secondary.php b/lib/classes/output/action_menu/link_secondary.php
new file mode 100644
index 00000000000..45780a1f9ea
--- /dev/null
+++ b/lib/classes/output/action_menu/link_secondary.php
@@ -0,0 +1,37 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * A secondary action menu action
+ *
+ * @package core
+ * @category output
+ * @copyright 2013 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class action_menu_link_secondary extends action_menu_link {
+    /**
+     * Constructs the object.
+     *
+     * @param moodle_url $url
+     * @param pix_icon|null $icon
+     * @param string $text
+     * @param array $attributes
+     */
+    public function __construct(moodle_url $url, ?pix_icon $icon, $text, array $attributes = array()) {
+        parent::__construct($url, $icon, $text, false, $attributes);
+    }
+}
diff --git a/lib/classes/output/actions/component_action.php b/lib/classes/output/actions/component_action.php
new file mode 100644
index 00000000000..72bb07c0480
--- /dev/null
+++ b/lib/classes/output/actions/component_action.php
@@ -0,0 +1,79 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Helper class used by other components that involve an action on the page (URL or JS).
+ *
+ * @copyright 2009 Nicolas Connault
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class component_action implements templatable {
+
+    /**
+     * @var string $event The DOM event that will trigger this action when caught
+     */
+    public $event;
+
+    /**
+     * @var string A function name to call when the button is clicked
+     * The JS function you create must have two arguments:
+     *      1. The event object
+     *      2. An object/array of arguments ($jsfunctionargs)
+     */
+    public $jsfunction = false;
+
+    /**
+     * @var array An array of arguments to pass to the JS function
+     */
+    public $jsfunctionargs = array();
+
+    /**
+     * Constructor
+     * @param string $event DOM event
+     * @param string $jsfunction An optional JS function. Required if jsfunctionargs is given
+     * @param array $jsfunctionargs An array of arguments to pass to the jsfunction
+     */
+    public function __construct($event, $jsfunction, $jsfunctionargs=array()) {
+        $this->event = $event;
+
+        $this->jsfunction = $jsfunction;
+        $this->jsfunctionargs = $jsfunctionargs;
+
+        if (!empty($this->jsfunctionargs)) {
+            if (empty($this->jsfunction)) {
+                throw new coding_exception('The component_action object needs a jsfunction value to pass the jsfunctionargs to.');
+            }
+        }
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output The renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $args = !empty($this->jsfunctionargs) ? json_encode($this->jsfunctionargs) : false;
+        return (object) [
+            'event' => $this->event,
+            'jsfunction' => $this->jsfunction,
+            'jsfunctionargs' => $args,
+        ];
+    }
+}
diff --git a/lib/classes/output/actions/confirm_action.php b/lib/classes/output/actions/confirm_action.php
new file mode 100644
index 00000000000..5ce5b5bfed7
--- /dev/null
+++ b/lib/classes/output/actions/confirm_action.php
@@ -0,0 +1,47 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Confirm action
+ *
+ * @copyright 2009 Nicolas Connault
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class confirm_action extends component_action {
+    /**
+     * Constructs the confirm action object
+     *
+     * @param string $message The message to display to the user when they are shown
+     *    the confirm dialogue.
+     * @param string $callback Deprecated since 2.7
+     * @param string $continuelabel The string to use for he continue button
+     * @param string $cancellabel The string to use for the cancel button
+     */
+    public function __construct($message, $callback = null, $continuelabel = null, $cancellabel = null) {
+        if ($callback !== null) {
+            debugging('The callback argument to new confirm_action() has been deprecated.' .
+                    ' If you need to use a callback, please write Javascript to use moodle-core-notification-confirmation ' .
+                    'and attach to the provided events.',
+                    DEBUG_DEVELOPER);
+        }
+        parent::__construct('click', 'M.util.show_confirm_dialog', array(
+                'message' => $message,
+                'continuelabel' => $continuelabel, 'cancellabel' => $cancellabel));
+    }
+}
diff --git a/lib/classes/output/actions/popup_action.php b/lib/classes/output/actions/popup_action.php
new file mode 100644
index 00000000000..4c0bdc49c4e
--- /dev/null
+++ b/lib/classes/output/actions/popup_action.php
@@ -0,0 +1,106 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+/**
+ * Component action for a popup window.
+ *
+ * @copyright 2009 Nicolas Connault
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class popup_action extends component_action {
+    /**
+     * @var string The JS function to call for the popup
+     */
+    public $jsfunction = 'openpopup';
+
+    /**
+     * @var array An array of parameters that will be passed to the openpopup JS function
+     */
+    public $params = array(
+            'height' =>  400,
+            'width' => 500,
+            'top' => 0,
+            'left' => 0,
+            'menubar' => false,
+            'location' => false,
+            'scrollbars' => true,
+            'resizable' => true,
+            'toolbar' => true,
+            'status' => true,
+            'directories' => false,
+            'fullscreen' => false,
+            'dependent' => true);
+
+    /**
+     * Constructor
+     *
+     * @param string $event DOM event
+     * @param moodle_url|string $url A moodle_url object, required if no jsfunction is given
+     * @param string $name The JS function to call for the popup (default 'popup')
+     * @param array  $params An array of popup parameters
+     */
+    public function __construct($event, $url, $name='popup', $params=array()) {
+        global $CFG;
+
+        $url = new moodle_url($url);
+
+        if ($name) {
+            $_name = $name;
+            if (($_name = preg_replace("/\s/", '_', $_name)) != $name) {
+                throw new coding_exception('The $name of a popup window shouldn\'t contain spaces - string modified. '. $name .' changed to '. $_name);
+                $name = $_name;
+            }
+        } else {
+            $name = 'popup';
+        }
+
+        foreach ($this->params as $var => $val) {
+            if (array_key_exists($var, $params)) {
+                $this->params[$var] = $params[$var];
+            }
+        }
+
+        $attributes = array('url' => $url->out(false), 'name' => $name, 'options' => $this->get_js_options($params));
+        if (!empty($params['fullscreen'])) {
+            $attributes['fullscreen'] = 1;
+        }
+        parent::__construct($event, $this->jsfunction, $attributes);
+    }
+
+    /**
+     * Returns a string of concatenated option->value pairs used by JS to call the popup window,
+     * based on this object's variables
+     *
+     * @return string String of option->value pairs for JS popup function.
+     */
+    public function get_js_options() {
+        $jsoptions = '';
+
+        foreach ($this->params as $var => $val) {
+            if (is_string($val) || is_int($val)) {
+                $jsoptions .= "$var=$val,";
+            } elseif (is_bool($val)) {
+                $jsoptions .= ($val) ? "$var," : "$var=0,";
+            }
+        }
+
+        $jsoptions = substr($jsoptions, 0, strlen($jsoptions) - 1);
+
+        return $jsoptions;
+    }
+}
diff --git a/lib/classes/output/context_header.php b/lib/classes/output/context_header.php
new file mode 100644
index 00000000000..e1c02d8614c
--- /dev/null
+++ b/lib/classes/output/context_header.php
@@ -0,0 +1,147 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Renderable for the main page header.
+ *
+ * @package core
+ * @category output
+ * @since 2.9
+ * @copyright 2015 Adrian Greeve <adrian@moodle.com>
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class context_header implements renderable, templatable {
+    /**
+     * @var string $heading Main heading.
+     */
+    public $heading;
+    /**
+     * @var int $headinglevel Main heading 'h' tag level.
+     */
+    public $headinglevel;
+    /**
+     * @var string|null $imagedata HTML code for the picture in the page header.
+     */
+    public $imagedata;
+    /**
+     * @var array $additionalbuttons Additional buttons for the header e.g. Messaging button for the user header.
+     *      array elements - title => alternate text for the image, or if no image is available the button text.
+     *                       url => Link for the button to head to. Should be a moodle_url.
+     *                       image => location to the image, or name of the image in /pix/t/{image name}.
+     *                       linkattributes => additional attributes for the <a href> element.
+     *                       page => page object. Don't include if the image is an external image.
+     */
+    public $additionalbuttons;
+    /**
+     * @var string $prefix A string that is before the title.
+     */
+    public $prefix;
+
+    /**
+     * Constructor.
+     *
+     * @param string $heading Main heading data.
+     * @param int $headinglevel Main heading 'h' tag level.
+     * @param string|null $imagedata HTML code for the picture in the page header.
+     * @param string $additionalbuttons Buttons for the header e.g. Messaging button for the user header.
+     * @param string $prefix Text that precedes the heading.
+     */
+    public function __construct($heading = null, $headinglevel = 1, $imagedata = null, $additionalbuttons = null, $prefix = null) {
+
+        $this->heading = $heading;
+        $this->headinglevel = $headinglevel;
+        $this->imagedata = $imagedata;
+        $this->additionalbuttons = $additionalbuttons;
+        // If we have buttons then format them.
+        if (isset($this->additionalbuttons)) {
+            $this->format_button_images();
+        }
+        $this->prefix = $prefix;
+    }
+
+    /**
+     * Adds an array element for a formatted image.
+     */
+    protected function format_button_images() {
+
+        foreach ($this->additionalbuttons as $buttontype => $button) {
+            $page = $button['page'];
+            // If no image is provided then just use the title.
+            if (!isset($button['image'])) {
+                $this->additionalbuttons[$buttontype]['formattedimage'] = $button['title'];
+            } else {
+                // Check to see if this is an internal Moodle icon.
+                $internalimage = $page->theme->resolve_image_location('t/' . $button['image'], 'moodle');
+                if ($internalimage) {
+                    $this->additionalbuttons[$buttontype]['formattedimage'] = 't/' . $button['image'];
+                } else {
+                    // Treat as an external image.
+                    $this->additionalbuttons[$buttontype]['formattedimage'] = $button['image'];
+                }
+            }
+
+            if (isset($button['linkattributes']['class'])) {
+                $class = $button['linkattributes']['class'] . ' btn';
+            } else {
+                $class = 'btn';
+            }
+            // Add the bootstrap 'btn' class for formatting.
+            $this->additionalbuttons[$buttontype]['linkattributes'] = array_merge($button['linkattributes'],
+                array('class' => $class));
+        }
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output Renderer.
+     * @return array
+     */
+    public function export_for_template(renderer_base $output): array {
+        // Heading.
+        $headingtext = isset($this->heading) ? $this->heading : $output->get_page()->heading;
+        $heading = $output->heading($headingtext, $this->headinglevel, "h2 mb-0");
+
+        // Buttons.
+        if (isset($this->additionalbuttons)) {
+            $additionalbuttons = [];
+            foreach ($this->additionalbuttons as $button) {
+                if (!isset($button->page)) {
+                    // Include js for messaging.
+                    if ($button['buttontype'] === 'togglecontact') {
+                        \core_message\helper::togglecontact_requirejs();
+                    }
+                    if ($button['buttontype'] === 'message') {
+                        \core_message\helper::messageuser_requirejs();
+                    }
+                }
+                foreach ($button['linkattributes'] as $key => $value) {
+                    $button['attributes'][] = ['name' => $key, 'value' => $value];
+                }
+                $additionalbuttons[] = $button;
+            }
+        }
+
+        return [
+            'heading' => $heading,
+            'headinglevel' => $this->headinglevel,
+            'imagedata' => $this->imagedata,
+            'prefix' => $this->prefix,
+            'hasadditionalbuttons' => !empty($additionalbuttons),
+            'additionalbuttons' => $additionalbuttons ?? [],
+        ];
+    }
+}
diff --git a/lib/classes/output/core_renderer.php b/lib/classes/output/core_renderer.php
new file mode 100644
index 00000000000..df1de09d584
--- /dev/null
+++ b/lib/classes/output/core_renderer.php
@@ -0,0 +1,4765 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+use core\di;
+use core\hook\manager as hook_manager;
+use core\hook\output\after_standard_main_region_html_generation;
+use core\hook\output\before_footer_html_generation;
+use core\hook\output\before_html_attributes;
+use core\hook\output\before_http_headers;
+use core\hook\output\before_standard_footer_html_generation;
+use core\hook\output\before_standard_top_of_body_html_generation;
+use core_completion\cm_completion_details;
+use core_course\output\activity_information;
+
+/**
+ * The standard implementation of the core_renderer interface.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class core_renderer extends renderer_base {
+    /**
+     * Do NOT use, please use <?php echo $OUTPUT->main_content() ?>
+     * in layout files instead.
+     * @deprecated
+     * @var string used in {@link core_renderer::header()}.
+     */
+    const MAIN_CONTENT_TOKEN = '[MAIN CONTENT GOES HERE]';
+
+    /**
+     * @var string Used to pass information from {@link core_renderer::doctype()} to
+     * {@link core_renderer::standard_head_html()}.
+     */
+    protected $contenttype;
+
+    /**
+     * @var string Used by {@link core_renderer::redirect_message()} method to communicate
+     * with {@link core_renderer::header()}.
+     */
+    protected $metarefreshtag = '';
+
+    /**
+     * @var string Unique token for the closing HTML
+     */
+    protected $unique_end_html_token;
+
+    /**
+     * @var string Unique token for performance information
+     */
+    protected $unique_performance_info_token;
+
+    /**
+     * @var string Unique token for the main content.
+     */
+    protected $unique_main_content_token;
+
+    /** @var custom_menu_item language The language menu if created */
+    protected $language = null;
+
+    /** @var string The current selector for an element being streamed into */
+    protected $currentselector = '';
+
+    /** @var string The current element tag which is being streamed into */
+    protected $currentelement = '';
+
+    /**
+     * Constructor
+     *
+     * @param moodle_page $page the page we are doing output for.
+     * @param string $target one of rendering target constants
+     */
+    public function __construct(moodle_page $page, $target) {
+        $this->opencontainers = $page->opencontainers;
+        $this->page = $page;
+        $this->target = $target;
+
+        $this->unique_end_html_token = '%%ENDHTML-'.sesskey().'%%';
+        $this->unique_performance_info_token = '%%PERFORMANCEINFO-'.sesskey().'%%';
+        $this->unique_main_content_token = '[MAIN CONTENT GOES HERE - '.sesskey().']';
+    }
+
+    /**
+     * Get the DOCTYPE declaration that should be used with this page. Designed to
+     * be called in theme layout.php files.
+     *
+     * @return string the DOCTYPE declaration that should be used.
+     */
+    public function doctype() {
+        if ($this->page->theme->doctype === 'html5') {
+            $this->contenttype = 'text/html; charset=utf-8';
+            return "<!DOCTYPE html>\n";
+
+        } else if ($this->page->theme->doctype === 'xhtml5') {
+            $this->contenttype = 'application/xhtml+xml; charset=utf-8';
+            return "<!DOCTYPE html>\n";
+
+        } else {
+            // legacy xhtml 1.0
+            $this->contenttype = 'text/html; charset=utf-8';
+            return ('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' . "\n");
+        }
+    }
+
+    /**
+     * The attributes that should be added to the <html> tag. Designed to
+     * be called in theme layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function htmlattributes() {
+        $return = get_html_lang(true);
+
+        $hook = new before_html_attributes($this);
+
+        if ($this->page->theme->doctype !== 'html5') {
+            $hook->add_attribute('xmlns', 'http://www.w3.org/1999/xhtml');
+        }
+
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+
+        foreach ($hook->get_attributes() as $key => $val) {
+            $val = s($val);
+            $return .= " $key=\"$val\"";
+        }
+
+        return $return;
+    }
+
+    /**
+     * The standard tags (meta tags, links to stylesheets and JavaScript, etc.)
+     * that should be included in the <head> tag. Designed to be called in theme
+     * layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function standard_head_html() {
+        global $CFG, $SESSION, $SITE;
+
+        // Before we output any content, we need to ensure that certain
+        // page components are set up.
+
+        // Blocks must be set up early as they may require javascript which
+        // has to be included in the page header before output is created.
+        foreach ($this->page->blocks->get_regions() as $region) {
+            $this->page->blocks->ensure_content_created($region, $this);
+        }
+
+        // Give plugins an opportunity to add any head elements. The callback
+        // must always return a string containing valid html head content.
+
+        $hook = new \core\hook\output\before_standard_head_html_generation($this);
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+
+        // Allow a url_rewrite plugin to setup any dynamic head content.
+        if (isset($CFG->urlrewriteclass) && !isset($CFG->upgraderunning)) {
+            $class = $CFG->urlrewriteclass;
+            $hook->add_html($class::html_head_setup());
+        }
+
+        $hook->add_html('<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' . "\n");
+        $hook->add_html('<meta name="keywords" content="moodle, ' . $this->page->title . '" />' . "\n");
+        // This is only set by the {@link redirect()} method
+        $hook->add_html($this->metarefreshtag);
+
+        // Check if a periodic refresh delay has been set and make sure we arn't
+        // already meta refreshing
+        if ($this->metarefreshtag=='' && $this->page->periodicrefreshdelay!==null) {
+            $hook->add_html(
+                html_writer::empty_tag('meta', [
+                    'http-equiv' => 'refresh',
+                    'content' => $this->page->periodicrefreshdelay . ';url='.$this->page->url->out(),
+                ]),
+            );
+        }
+
+        $output = $hook->get_output();
+
+        // Set up help link popups for all links with the helptooltip class
+        $this->page->requires->js_init_call('M.util.help_popups.setup');
+
+        $focus = $this->page->focuscontrol;
+        if (!empty($focus)) {
+            if (preg_match("#forms\['([a-zA-Z0-9]+)'\].elements\['([a-zA-Z0-9]+)'\]#", $focus, $matches)) {
+                // This is a horrifically bad way to handle focus but it is passed in
+                // through messy formslib::moodleform
+                $this->page->requires->js_function_call('old_onload_focus', array($matches[1], $matches[2]));
+            } else if (strpos($focus, '.')!==false) {
+                // Old style of focus, bad way to do it
+                debugging('This code is using the old style focus event, Please update this code to focus on an element id or the moodleform focus method.', DEBUG_DEVELOPER);
+                $this->page->requires->js_function_call('old_onload_focus', explode('.', $focus, 2));
+            } else {
+                // Focus element with given id
+                $this->page->requires->js_function_call('focuscontrol', array($focus));
+            }
+        }
+
+        // Get the theme stylesheet - this has to be always first CSS, this loads also styles.css from all plugins;
+        // any other custom CSS can not be overridden via themes and is highly discouraged
+        $urls = $this->page->theme->css_urls($this->page);
+        foreach ($urls as $url) {
+            $this->page->requires->css_theme($url);
+        }
+
+        // Get the theme javascript head and footer
+        if ($jsurl = $this->page->theme->javascript_url(true)) {
+            $this->page->requires->js($jsurl, true);
+        }
+        if ($jsurl = $this->page->theme->javascript_url(false)) {
+            $this->page->requires->js($jsurl);
+        }
+
+        // Get any HTML from the page_requirements_manager.
+        $output .= $this->page->requires->get_head_code($this->page, $this);
+
+        // List alternate versions.
+        foreach ($this->page->alternateversions as $type => $alt) {
+            $output .= html_writer::empty_tag('link', array('rel' => 'alternate',
+                    'type' => $type, 'title' => $alt->title, 'href' => $alt->url));
+        }
+
+        // Add noindex tag if relevant page and setting applied.
+        $allowindexing = isset($CFG->allowindexing) ? $CFG->allowindexing : 0;
+        $loginpages = array('login-index', 'login-signup');
+        if ($allowindexing == 2 || ($allowindexing == 0 && in_array($this->page->pagetype, $loginpages))) {
+            if (!isset($CFG->additionalhtmlhead)) {
+                $CFG->additionalhtmlhead = '';
+            }
+            $CFG->additionalhtmlhead .= '<meta name="robots" content="noindex" />';
+        }
+
+        if (!empty($CFG->additionalhtmlhead)) {
+            $output .= "\n".$CFG->additionalhtmlhead;
+        }
+
+        if ($this->page->pagelayout == 'frontpage') {
+            $summary = s(strip_tags(format_text($SITE->summary, FORMAT_HTML)));
+            if (!empty($summary)) {
+                $output .= "<meta name=\"description\" content=\"$summary\" />\n";
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * The standard tags (typically skip links) that should be output just inside
+     * the start of the <body> tag. Designed to be called in theme layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function standard_top_of_body_html() {
+        global $CFG;
+        $output = $this->page->requires->get_top_of_body_code($this);
+        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmltopofbody)) {
+            $output .= "\n".$CFG->additionalhtmltopofbody;
+        }
+
+        // Allow components to add content to the top of the body.
+        $hook = new before_standard_top_of_body_html_generation($this, $output);
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+        $output = $hook->get_output();
+
+        $output .= $this->maintenance_warning();
+
+        return $output;
+    }
+
+    /**
+     * Scheduled maintenance warning message.
+     *
+     * Note: This is a nasty hack to display maintenance notice, this should be moved
+     *       to some general notification area once we have it.
+     *
+     * @return string
+     */
+    public function maintenance_warning() {
+        global $CFG;
+
+        $output = '';
+        if (isset($CFG->maintenance_later) and $CFG->maintenance_later > time()) {
+            $timeleft = $CFG->maintenance_later - time();
+            // If timeleft less than 30 sec, set the class on block to error to highlight.
+            $errorclass = ($timeleft < 30) ? 'alert-error alert-danger' : 'alert-warning';
+            $output .= $this->box_start($errorclass . ' moodle-has-zindex maintenancewarning m-3 alert');
+            $a = new stdClass();
+            $a->hour = (int)($timeleft / 3600);
+            $a->min = (int)(floor($timeleft / 60) % 60);
+            $a->sec = (int)($timeleft % 60);
+            if ($a->hour > 0) {
+                $output .= get_string('maintenancemodeisscheduledlong', 'admin', $a);
+            } else {
+                $output .= get_string('maintenancemodeisscheduled', 'admin', $a);
+            }
+
+            $output .= $this->box_end();
+            $this->page->requires->yui_module('moodle-core-maintenancemodetimer', 'M.core.maintenancemodetimer',
+                    array(array('timeleftinsec' => $timeleft)));
+            $this->page->requires->strings_for_js(
+                    array('maintenancemodeisscheduled', 'maintenancemodeisscheduledlong', 'sitemaintenance'),
+                    'admin');
+        }
+        return $output;
+    }
+
+    /**
+     * content that should be output in the footer area
+     * of the page. Designed to be called in theme layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function standard_footer_html() {
+        if (during_initial_install()) {
+            // Debugging info can not work before install is finished,
+            // in any case we do not want any links during installation!
+            return '';
+        }
+
+        $hook = new before_standard_footer_html_generation($this);
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+        $output = $hook->get_output();
+
+        if ($this->page->devicetypeinuse == 'legacy') {
+            // The legacy theme is in use print the notification
+            $output .= html_writer::tag('div', get_string('legacythemeinuse'), array('class'=>'legacythemeinuse'));
+        }
+
+        // Get links to switch device types (only shown for users not on a default device)
+        $output .= $this->theme_switch_links();
+
+        return $output;
+    }
+
+    /**
+     * Performance information and validation links for debugging.
+     *
+     * @return string HTML fragment.
+     */
+    public function debug_footer_html() {
+        global $CFG, $SCRIPT;
+        $output = '';
+
+        if (during_initial_install()) {
+            // Debugging info can not work before install is finished.
+            return $output;
+        }
+
+        // This function is normally called from a layout.php file
+        // but some of the content won't be known until later, so we return a placeholder
+        // for now. This will be replaced with the real content in the footer.
+        $output .= $this->unique_performance_info_token;
+
+        if (!empty($CFG->debugpageinfo)) {
+            $output .= '<div class="performanceinfo pageinfo">' . get_string('pageinfodebugsummary', 'core_admin',
+                $this->page->debug_summary()) . '</div>';
+        }
+        if (debugging(null, DEBUG_DEVELOPER) and has_capability('moodle/site:config', context_system::instance())) {  // Only in developer mode
+
+            // Add link to profiling report if necessary
+            if (function_exists('profiling_is_running') && profiling_is_running()) {
+                $txt = get_string('profiledscript', 'admin');
+                $title = get_string('profiledscriptview', 'admin');
+                $url = $CFG->wwwroot . '/admin/tool/profiling/index.php?script=' . urlencode($SCRIPT);
+                $link= '<a title="' . $title . '" href="' . $url . '">' . $txt . '</a>';
+                $output .= '<div class="profilingfooter">' . $link . '</div>';
+            }
+            $purgeurl = new moodle_url('/admin/purgecaches.php', array('confirm' => 1,
+                'sesskey' => sesskey(), 'returnurl' => $this->page->url->out_as_local_url(false)));
+            $output .= '<div class="purgecaches">' .
+                    html_writer::link($purgeurl, get_string('purgecaches', 'admin')) . '</div>';
+
+            // Reactive module debug panel.
+            $output .= $this->render_from_template('core/local/reactive/debugpanel', []);
+        }
+        if (!empty($CFG->debugvalidators)) {
+            $siteurl = qualified_me();
+            $nuurl = new moodle_url('https://validator.w3.org/nu/', ['doc' => $siteurl, 'showsource' => 'yes']);
+            $waveurl = new moodle_url('https://wave.webaim.org/report#/' . urlencode($siteurl));
+            $validatorlinks = [
+                html_writer::link($nuurl, get_string('validatehtml')),
+                html_writer::link($waveurl, get_string('wcagcheck'))
+            ];
+            $validatorlinkslist = html_writer::alist($validatorlinks, ['class' => 'list-unstyled ml-1']);
+            $output .= html_writer::div($validatorlinkslist, 'validators');
+        }
+        return $output;
+    }
+
+    /**
+     * Returns standard main content placeholder.
+     * Designed to be called in theme layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function main_content() {
+        // This is here because it is the only place we can inject the "main" role over the entire main content area
+        // without requiring all theme's to manually do it, and without creating yet another thing people need to
+        // remember in the theme.
+        // This is an unfortunate hack. DO NO EVER add anything more here.
+        // DO NOT add classes.
+        // DO NOT add an id.
+        return '<div role="main">'.$this->unique_main_content_token.'</div>';
+    }
+
+    /**
+     * Returns information about an activity.
+     *
+     * @deprecated since Moodle 4.3 MDL-78744
+     * @todo MDL-78926 This method will be deleted in Moodle 4.7
+     * @param cm_info $cminfo The course module information.
+     * @param cm_completion_details $completiondetails The completion details for this activity module.
+     * @param array $activitydates The dates for this activity module.
+     * @return string the activity information HTML.
+     * @throws coding_exception
+     */
+    public function activity_information(cm_info $cminfo, cm_completion_details $completiondetails, array $activitydates): string {
+        debugging('activity_information method is deprecated.', DEBUG_DEVELOPER);
+        if (!$completiondetails->has_completion() && empty($activitydates)) {
+            // No need to render the activity information when there's no completion info and activity dates to show.
+            return '';
+        }
+        $activityinfo = new activity_information($cminfo, $completiondetails, $activitydates);
+        $renderer = $this->page->get_renderer('core', 'course');
+        return $renderer->render($activityinfo);
+    }
+
+    /**
+     * Returns standard navigation between activities in a course.
+     *
+     * @return string the navigation HTML.
+     */
+    public function activity_navigation() {
+        // First we should check if we want to add navigation.
+        $context = $this->page->context;
+        if (($this->page->pagelayout !== 'incourse' && $this->page->pagelayout !== 'frametop')
+            || $context->contextlevel != CONTEXT_MODULE) {
+            return '';
+        }
+
+        // If the activity is in stealth mode, show no links.
+        if ($this->page->cm->is_stealth()) {
+            return '';
+        }
+
+        $course = $this->page->cm->get_course();
+        $courseformat = course_get_format($course);
+
+        // If the theme implements course index and the current course format uses course index and the current
+        // page layout is not 'frametop' (this layout does not support course index), show no links.
+        if ($this->page->theme->usescourseindex && $courseformat->uses_course_index() &&
+                $this->page->pagelayout !== 'frametop') {
+            return '';
+        }
+
+        // Get a list of all the activities in the course.
+        $modules = get_fast_modinfo($course->id)->get_cms();
+
+        // Put the modules into an array in order by the position they are shown in the course.
+        $mods = [];
+        $activitylist = [];
+        foreach ($modules as $module) {
+            // Only add activities the user can access, aren't in stealth mode and have a url (eg. mod_label does not).
+            if (!$module->uservisible || $module->is_stealth() || empty($module->url)) {
+                continue;
+            }
+            $mods[$module->id] = $module;
+
+            // No need to add the current module to the list for the activity dropdown menu.
+            if ($module->id == $this->page->cm->id) {
+                continue;
+            }
+            // Module name.
+            $modname = $module->get_formatted_name();
+            // Display the hidden text if necessary.
+            if (!$module->visible) {
+                $modname .= ' ' . get_string('hiddenwithbrackets');
+            }
+            // Module URL.
+            $linkurl = new moodle_url($module->url, array('forceview' => 1));
+            // Add module URL (as key) and name (as value) to the activity list array.
+            $activitylist[$linkurl->out(false)] = $modname;
+        }
+
+        $nummods = count($mods);
+
+        // If there is only one mod then do nothing.
+        if ($nummods == 1) {
+            return '';
+        }
+
+        // Get an array of just the course module ids used to get the cmid value based on their position in the course.
+        $modids = array_keys($mods);
+
+        // Get the position in the array of the course module we are viewing.
+        $position = array_search($this->page->cm->id, $modids);
+
+        $prevmod = null;
+        $nextmod = null;
+
+        // Check if we have a previous mod to show.
+        if ($position > 0) {
+            $prevmod = $mods[$modids[$position - 1]];
+        }
+
+        // Check if we have a next mod to show.
+        if ($position < ($nummods - 1)) {
+            $nextmod = $mods[$modids[$position + 1]];
+        }
+
+        $activitynav = new \core_course\output\activity_navigation($prevmod, $nextmod, $activitylist);
+        $renderer = $this->page->get_renderer('core', 'course');
+        return $renderer->render($activitynav);
+    }
+
+    /**
+     * The standard tags (typically script tags that are not needed earlier) that
+     * should be output after everything else. Designed to be called in theme layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function standard_end_of_body_html() {
+        global $CFG;
+
+        // This function is normally called from a layout.php file in {@link core_renderer::header()}
+        // but some of the content won't be known until later, so we return a placeholder
+        // for now. This will be replaced with the real content in {@link core_renderer::footer()}.
+        $output = '';
+        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmlfooter)) {
+            $output .= "\n".$CFG->additionalhtmlfooter;
+        }
+        $output .= $this->unique_end_html_token;
+        return $output;
+    }
+
+    /**
+     * The standard HTML that should be output just before the <footer> tag.
+     * Designed to be called in theme layout.php files.
+     *
+     * @return string HTML fragment.
+     */
+    public function standard_after_main_region_html() {
+        global $CFG;
+
+        $hook = new after_standard_main_region_html_generation($this);
+
+        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmlbottomofbody)) {
+            $hook->add_html("\n");
+            $hook->add_html($CFG->additionalhtmlbottomofbody);
+        }
+
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+
+        return $hook->get_output();
+    }
+
+    /**
+     * Return the standard string that says whether you are logged in (and switched
+     * roles/logged in as another user).
+     * @param bool $withlinks if false, then don't include any links in the HTML produced.
+     * If not set, the default is the nologinlinks option from the theme config.php file,
+     * and if that is not set, then links are included.
+     * @return string HTML fragment.
+     */
+    public function login_info($withlinks = null) {
+        global $USER, $CFG, $DB, $SESSION;
+
+        if (during_initial_install()) {
+            return '';
+        }
+
+        if (is_null($withlinks)) {
+            $withlinks = empty($this->page->layout_options['nologinlinks']);
+        }
+
+        $course = $this->page->course;
+        if (\core\session\manager::is_loggedinas()) {
+            $realuser = \core\session\manager::get_realuser();
+            $fullname = fullname($realuser);
+            if ($withlinks) {
+                $loginastitle = get_string('loginas');
+                $realuserinfo = " [<a href=\"$CFG->wwwroot/course/loginas.php?id=$course->id&amp;sesskey=".sesskey()."\"";
+                $realuserinfo .= "title =\"".$loginastitle."\">$fullname</a>] ";
+            } else {
+                $realuserinfo = " [$fullname] ";
+            }
+        } else {
+            $realuserinfo = '';
+        }
+
+        $loginpage = $this->is_login_page();
+        $loginurl = get_login_url();
+
+        if (empty($course->id)) {
+            // $course->id is not defined during installation
+            return '';
+        } else if (isloggedin()) {
+            $context = context_course::instance($course->id);
+
+            $fullname = fullname($USER);
+            // Since Moodle 2.0 this link always goes to the public profile page (not the course profile page)
+            if ($withlinks) {
+                $linktitle = get_string('viewprofile');
+                $username = "<a href=\"$CFG->wwwroot/user/profile.php?id=$USER->id\" title=\"$linktitle\">$fullname</a>";
+            } else {
+                $username = $fullname;
+            }
+            if (is_mnet_remote_user($USER) and $idprovider = $DB->get_record('mnet_host', array('id'=>$USER->mnethostid))) {
+                if ($withlinks) {
+                    $username .= " from <a href=\"{$idprovider->wwwroot}\">{$idprovider->name}</a>";
+                } else {
+                    $username .= " from {$idprovider->name}";
+                }
+            }
+            if (isguestuser()) {
+                $loggedinas = $realuserinfo.get_string('loggedinasguest');
+                if (!$loginpage && $withlinks) {
+                    $loggedinas .= " (<a href=\"$loginurl\">".get_string('login').'</a>)';
+                }
+            } else if (is_role_switched($course->id)) { // Has switched roles
+                $rolename = '';
+                if ($role = $DB->get_record('role', array('id'=>$USER->access['rsw'][$context->path]))) {
+                    $rolename = ': '.role_get_name($role, $context);
+                }
+                $loggedinas = get_string('loggedinas', 'moodle', $username).$rolename;
+                if ($withlinks) {
+                    $url = new moodle_url('/course/switchrole.php', array('id'=>$course->id,'sesskey'=>sesskey(), 'switchrole'=>0, 'returnurl'=>$this->page->url->out_as_local_url(false)));
+                    $loggedinas .= ' ('.html_writer::tag('a', get_string('switchrolereturn'), array('href' => $url)).')';
+                }
+            } else {
+                $loggedinas = $realuserinfo.get_string('loggedinas', 'moodle', $username);
+                if ($withlinks) {
+                    $loggedinas .= " (<a href=\"$CFG->wwwroot/login/logout.php?sesskey=".sesskey()."\">".get_string('logout').'</a>)';
+                }
+            }
+        } else {
+            $loggedinas = get_string('loggedinnot', 'moodle');
+            if (!$loginpage && $withlinks) {
+                $loggedinas .= " (<a href=\"$loginurl\">".get_string('login').'</a>)';
+            }
+        }
+
+        $loggedinas = '<div class="logininfo">'.$loggedinas.'</div>';
+
+        if (isset($SESSION->justloggedin)) {
+            unset($SESSION->justloggedin);
+            if (!isguestuser()) {
+                // Include this file only when required.
+                require_once($CFG->dirroot . '/user/lib.php');
+                if (($count = user_count_login_failures($USER)) && !empty($CFG->displayloginfailures)) {
+                    $loggedinas .= '<div class="loginfailures">';
+                    $a = new stdClass();
+                    $a->attempts = $count;
+                    $loggedinas .= get_string('failedloginattempts', '', $a);
+                    if (file_exists("$CFG->dirroot/report/log/index.php") and has_capability('report/log:view', context_system::instance())) {
+                        $loggedinas .= ' ('.html_writer::link(new moodle_url('/report/log/index.php', array('chooselog' => 1,
+                                'id' => 0 , 'modid' => 'site_errors')), get_string('logs')).')';
+                    }
+                    $loggedinas .= '</div>';
+                }
+            }
+        }
+
+        return $loggedinas;
+    }
+
+    /**
+     * Check whether the current page is a login page.
+     *
+     * @since Moodle 2.9
+     * @return bool
+     */
+    protected function is_login_page() {
+        // This is a real bit of a hack, but its a rarety that we need to do something like this.
+        // In fact the login pages should be only these two pages and as exposing this as an option for all pages
+        // could lead to abuse (or at least unneedingly complex code) the hack is the way to go.
+        return in_array(
+            $this->page->url->out_as_local_url(false, array()),
+            array(
+                '/login/index.php',
+                '/login/forgot_password.php',
+            )
+        );
+    }
+
+    /**
+     * Return the 'back' link that normally appears in the footer.
+     *
+     * @return string HTML fragment.
+     */
+    public function home_link() {
+        global $CFG, $SITE;
+
+        if ($this->page->pagetype == 'site-index') {
+            // Special case for site home page - please do not remove
+            return '<div class="sitelink">' .
+                   '<a title="Moodle" class="d-inline-block aalink" href="http://moodle.org/">' .
+                   '<img src="' . $this->image_url('moodlelogo_grayhat') . '" alt="'.get_string('moodlelogo').'" /></a></div>';
+
+        } else if (!empty($CFG->target_release) && $CFG->target_release != $CFG->release) {
+            // Special case for during install/upgrade.
+            return '<div class="sitelink">'.
+                   '<a title="Moodle" href="http://docs.moodle.org/en/Administrator_documentation" onclick="this.target=\'_blank\'">' .
+                   '<img src="' . $this->image_url('moodlelogo_grayhat') . '" alt="'.get_string('moodlelogo').'" /></a></div>';
+
+        } else if ($this->page->course->id == $SITE->id || strpos($this->page->pagetype, 'course-view') === 0) {
+            return '<div class="homelink"><a href="' . $CFG->wwwroot . '/">' .
+                    get_string('home') . '</a></div>';
+
+        } else {
+            return '<div class="homelink"><a href="' . $CFG->wwwroot . '/course/view.php?id=' . $this->page->course->id . '">' .
+                    format_string($this->page->course->shortname, true, array('context' => $this->page->context)) . '</a></div>';
+        }
+    }
+
+    /**
+     * Redirects the user by any means possible given the current state
+     *
+     * This function should not be called directly, it should always be called using
+     * the redirect function in lib/weblib.php
+     *
+     * The redirect function should really only be called before page output has started
+     * however it will allow itself to be called during the state STATE_IN_BODY
+     *
+     * @param string $encodedurl The URL to send to encoded if required
+     * @param string $message The message to display to the user if any
+     * @param int $delay The delay before redirecting a user, if $message has been
+     *         set this is a requirement and defaults to 3, set to 0 no delay
+     * @param boolean $debugdisableredirect this redirect has been disabled for
+     *         debugging purposes. Display a message that explains, and don't
+     *         trigger the redirect.
+     * @param string $messagetype The type of notification to show the message in.
+     *         See constants on \core\output\notification.
+     * @return string The HTML to display to the user before dying, may contain
+     *         meta refresh, javascript refresh, and may have set header redirects
+     */
+    public function redirect_message($encodedurl, $message, $delay, $debugdisableredirect,
+                                     $messagetype = \core\output\notification::NOTIFY_INFO) {
+        global $CFG;
+        $url = str_replace('&amp;', '&', $encodedurl);
+
+        switch ($this->page->state) {
+            case moodle_page::STATE_BEFORE_HEADER :
+                // No output yet it is safe to delivery the full arsenal of redirect methods
+                if (!$debugdisableredirect) {
+                    // Don't use exactly the same time here, it can cause problems when both redirects fire at the same time.
+                    $this->metarefreshtag = '<meta http-equiv="refresh" content="'. $delay .'; url='. $encodedurl .'" />'."\n";
+                    $this->page->requires->js_function_call('document.location.replace', array($url), false, ($delay + 3));
+                }
+                $output = $this->header();
+                break;
+            case moodle_page::STATE_PRINTING_HEADER :
+                // We should hopefully never get here
+                throw new coding_exception('You cannot redirect while printing the page header');
+                break;
+            case moodle_page::STATE_IN_BODY :
+                // We really shouldn't be here but we can deal with this
+                debugging("You should really redirect before you start page output");
+                if (!$debugdisableredirect) {
+                    $this->page->requires->js_function_call('document.location.replace', array($url), false, $delay);
+                }
+                $output = $this->opencontainers->pop_all_but_last();
+                break;
+            case moodle_page::STATE_DONE :
+                // Too late to be calling redirect now
+                throw new coding_exception('You cannot redirect after the entire page has been generated');
+                break;
+        }
+        $output .= $this->notification($message, $messagetype);
+        $output .= '<div class="continuebutton">(<a href="'. $encodedurl .'">'. get_string('continue') .'</a>)</div>';
+        if ($debugdisableredirect) {
+            $output .= '<p><strong>'.get_string('erroroutput', 'error').'</strong></p>';
+        }
+        $output .= $this->footer();
+        return $output;
+    }
+
+    /**
+     * Start output by sending the HTTP headers, and printing the HTML <head>
+     * and the start of the <body>.
+     *
+     * To control what is printed, you should set properties on $PAGE.
+     *
+     * @return string HTML that you must output this, preferably immediately.
+     */
+    public function header() {
+        global $USER, $CFG, $SESSION;
+
+        $hook = new before_http_headers($this);
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+
+        if (\core\session\manager::is_loggedinas()) {
+            $this->page->add_body_class('userloggedinas');
+        }
+
+        if (isset($SESSION->justloggedin) && !empty($CFG->displayloginfailures)) {
+            require_once($CFG->dirroot . '/user/lib.php');
+            // Set second parameter to false as we do not want reset the counter, the same message appears on footer.
+            if ($count = user_count_login_failures($USER, false)) {
+                $this->page->add_body_class('loginfailures');
+            }
+        }
+
+        // If the user is logged in, and we're not in initial install,
+        // check to see if the user is role-switched and add the appropriate
+        // CSS class to the body element.
+        if (!during_initial_install() && isloggedin() && is_role_switched($this->page->course->id)) {
+            $this->page->add_body_class('userswitchedrole');
+        }
+
+        // Give themes a chance to init/alter the page object.
+        $this->page->theme->init_page($this->page);
+
+        $this->page->set_state(moodle_page::STATE_PRINTING_HEADER);
+
+        // Find the appropriate page layout file, based on $this->page->pagelayout.
+        $layoutfile = $this->page->theme->layout_file($this->page->pagelayout);
+        // Render the layout using the layout file.
+        $rendered = $this->render_page_layout($layoutfile);
+
+        // Slice the rendered output into header and footer.
+        $cutpos = strpos($rendered, $this->unique_main_content_token);
+        if ($cutpos === false) {
+            $cutpos = strpos($rendered, self::MAIN_CONTENT_TOKEN);
+            $token = self::MAIN_CONTENT_TOKEN;
+        } else {
+            $token = $this->unique_main_content_token;
+        }
+
+        if ($cutpos === false) {
+            throw new coding_exception('page layout file ' . $layoutfile . ' does not contain the main content placeholder, please include "<?php echo $OUTPUT->main_content() ?>" in theme layout file.');
+        }
+
+        $header = substr($rendered, 0, $cutpos);
+        $footer = substr($rendered, $cutpos + strlen($token));
+
+        if (empty($this->contenttype)) {
+            debugging('The page layout file did not call $OUTPUT->doctype()');
+            $header = $this->doctype() . $header;
+        }
+
+        // If this theme version is below 2.4 release and this is a course view page
+        if ((!isset($this->page->theme->settings->version) || $this->page->theme->settings->version < 2012101500) &&
+                $this->page->pagelayout === 'course' && $this->page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)) {
+            // check if course content header/footer have not been output during render of theme layout
+            $coursecontentheader = $this->course_content_header(true);
+            $coursecontentfooter = $this->course_content_footer(true);
+            if (!empty($coursecontentheader)) {
+                // display debug message and add header and footer right above and below main content
+                // Please note that course header and footer (to be displayed above and below the whole page)
+                // are not displayed in this case at all.
+                // Besides the content header and footer are not displayed on any other course page
+                debugging('The current theme is not optimised for 2.4, the course-specific header and footer defined in course format will not be output', DEBUG_DEVELOPER);
+                $header .= $coursecontentheader;
+                $footer = $coursecontentfooter. $footer;
+            }
+        }
+
+        send_headers($this->contenttype, $this->page->cacheable);
+
+        $this->opencontainers->push('header/footer', $footer);
+        $this->page->set_state(moodle_page::STATE_IN_BODY);
+
+        // If an activity record has been set, activity_header will handle this.
+        if (!$this->page->cm || !empty($this->page->layout_options['noactivityheader'])) {
+            $header .= $this->skip_link_target('maincontent');
+        }
+        return $header;
+    }
+
+    /**
+     * Renders and outputs the page layout file.
+     *
+     * This is done by preparing the normal globals available to a script, and
+     * then including the layout file provided by the current theme for the
+     * requested layout.
+     *
+     * @param string $layoutfile The name of the layout file
+     * @return string HTML code
+     */
+    protected function render_page_layout($layoutfile) {
+        global $CFG, $SITE, $USER;
+        // The next lines are a bit tricky. The point is, here we are in a method
+        // of a renderer class, and this object may, or may not, be the same as
+        // the global $OUTPUT object. When rendering the page layout file, we want to use
+        // this object. However, people writing Moodle code expect the current
+        // renderer to be called $OUTPUT, not $this, so define a variable called
+        // $OUTPUT pointing at $this. The same comment applies to $PAGE and $COURSE.
+        $OUTPUT = $this;
+        $PAGE = $this->page;
+        $COURSE = $this->page->course;
+
+        ob_start();
+        include($layoutfile);
+        $rendered = ob_get_contents();
+        ob_end_clean();
+        return $rendered;
+    }
+
+    /**
+     * Outputs the page's footer
+     *
+     * @return string HTML fragment
+     */
+    public function footer() {
+        global $CFG, $DB, $PERF;
+
+        $hook = new before_footer_html_generation($this);
+        $hook->process_legacy_callbacks();
+        di::get(hook_manager::class)->dispatch($hook);
+        $hook->add_html($this->container_end_all(true));
+        $output = $hook->get_output();
+
+        $footer = $this->opencontainers->pop('header/footer');
+
+        if (debugging() and $DB and $DB->is_transaction_started()) {
+            // TODO: MDL-20625 print warning - transaction will be rolled back
+        }
+
+        // Provide some performance info if required
+        $performanceinfo = '';
+        if (MDL_PERF || (!empty($CFG->perfdebug) && $CFG->perfdebug > 7)) {
+            if (MDL_PERFTOFOOT || debugging() || (!empty($CFG->perfdebug) && $CFG->perfdebug > 7)) {
+                if (NO_OUTPUT_BUFFERING) {
+                    // If the output buffer was off then we render a placeholder and stream the
+                    // performance debugging into it at the very end in the shutdown handler.
+                    $PERF->perfdebugdeferred = true;
+                    $performanceinfo .= html_writer::tag('div',
+                        get_string('perfdebugdeferred', 'admin'),
+                        [
+                            'id' => 'perfdebugfooter',
+                            'style' => 'min-height: 30em',
+                        ]);
+                } else {
+                    $perf = get_performance_info();
+                    $performanceinfo = $perf['html'];
+                }
+            }
+        }
+
+        // We always want performance data when running a performance test, even if the user is redirected to another page.
+        if (MDL_PERF_TEST && strpos($footer, $this->unique_performance_info_token) === false) {
+            $footer = $this->unique_performance_info_token . $footer;
+        }
+        $footer = str_replace($this->unique_performance_info_token, $performanceinfo, $footer);
+
+        // Only show notifications when the current page has a context id.
+        if (!empty($this->page->context->id)) {
+            $this->page->requires->js_call_amd('core/notification', 'init', array(
+                $this->page->context->id,
+                \core\notification::fetch_as_array($this)
+            ));
+        }
+        $footer = str_replace($this->unique_end_html_token, $this->page->requires->get_end_code(), $footer);
+
+        $this->page->set_state(moodle_page::STATE_DONE);
+
+        // Here we remove the closing body and html tags and store them to be added back
+        // in the shutdown handler so we can have valid html with streaming script tags
+        // which are rendered after the visible footer.
+        $tags = '';
+        preg_match('#\<\/body>#i', $footer, $matches);
+        $tags .= $matches[0];
+        $footer = str_replace($matches[0], '', $footer);
+
+        preg_match('#\<\/html>#i', $footer, $matches);
+        $tags .= $matches[0];
+        $footer = str_replace($matches[0], '', $footer);
+
+        $CFG->closingtags = $tags;
+
+        return $output . $footer;
+    }
+
+    /**
+     * Close all but the last open container. This is useful in places like error
+     * handling, where you want to close all the open containers (apart from <body>)
+     * before outputting the error message.
+     *
+     * @param bool $shouldbenone assert that the stack should be empty now - causes a
+     *      developer debug warning if it isn't.
+     * @return string the HTML required to close any open containers inside <body>.
+     */
+    public function container_end_all($shouldbenone = false) {
+        return $this->opencontainers->pop_all_but_last($shouldbenone);
+    }
+
+    /**
+     * Returns course-specific information to be output immediately above content on any course page
+     * (for the current course)
+     *
+     * @param bool $onlyifnotcalledbefore output content only if it has not been output before
+     * @return string
+     */
+    public function course_content_header($onlyifnotcalledbefore = false) {
+        global $CFG;
+        static $functioncalled = false;
+        if ($functioncalled && $onlyifnotcalledbefore) {
+            // we have already output the content header
+            return '';
+        }
+
+        // Output any session notification.
+        $notifications = \core\notification::fetch();
+
+        $bodynotifications = '';
+        foreach ($notifications as $notification) {
+            $bodynotifications .= $this->render_from_template(
+                    $notification->get_template_name(),
+                    $notification->export_for_template($this)
+                );
+        }
+
+        $output = html_writer::span($bodynotifications, 'notifications', array('id' => 'user-notifications'));
+
+        if ($this->page->course->id == SITEID) {
+            // return immediately and do not include /course/lib.php if not necessary
+            return $output;
+        }
+
+        require_once($CFG->dirroot.'/course/lib.php');
+        $functioncalled = true;
+        $courseformat = course_get_format($this->page->course);
+        if (($obj = $courseformat->course_content_header()) !== null) {
+            $output .= html_writer::div($courseformat->get_renderer($this->page)->render($obj), 'course-content-header');
+        }
+        return $output;
+    }
+
+    /**
+     * Returns course-specific information to be output immediately below content on any course page
+     * (for the current course)
+     *
+     * @param bool $onlyifnotcalledbefore output content only if it has not been output before
+     * @return string
+     */
+    public function course_content_footer($onlyifnotcalledbefore = false) {
+        global $CFG;
+        if ($this->page->course->id == SITEID) {
+            // return immediately and do not include /course/lib.php if not necessary
+            return '';
+        }
+        static $functioncalled = false;
+        if ($functioncalled && $onlyifnotcalledbefore) {
+            // we have already output the content footer
+            return '';
+        }
+        $functioncalled = true;
+        require_once($CFG->dirroot.'/course/lib.php');
+        $courseformat = course_get_format($this->page->course);
+        if (($obj = $courseformat->course_content_footer()) !== null) {
+            return html_writer::div($courseformat->get_renderer($this->page)->render($obj), 'course-content-footer');
+        }
+        return '';
+    }
+
+    /**
+     * Returns course-specific information to be output on any course page in the header area
+     * (for the current course)
+     *
+     * @return string
+     */
+    public function course_header() {
+        global $CFG;
+        if ($this->page->course->id == SITEID) {
+            // return immediately and do not include /course/lib.php if not necessary
+            return '';
+        }
+        require_once($CFG->dirroot.'/course/lib.php');
+        $courseformat = course_get_format($this->page->course);
+        if (($obj = $courseformat->course_header()) !== null) {
+            return $courseformat->get_renderer($this->page)->render($obj);
+        }
+        return '';
+    }
+
+    /**
+     * Returns course-specific information to be output on any course page in the footer area
+     * (for the current course)
+     *
+     * @return string
+     */
+    public function course_footer() {
+        global $CFG;
+        if ($this->page->course->id == SITEID) {
+            // return immediately and do not include /course/lib.php if not necessary
+            return '';
+        }
+        require_once($CFG->dirroot.'/course/lib.php');
+        $courseformat = course_get_format($this->page->course);
+        if (($obj = $courseformat->course_footer()) !== null) {
+            return $courseformat->get_renderer($this->page)->render($obj);
+        }
+        return '';
+    }
+
+    /**
+     * Get the course pattern datauri to show on a course card.
+     *
+     * The datauri is an encoded svg that can be passed as a url.
+     * @param int $id Id to use when generating the pattern
+     * @return string datauri
+     */
+    public function get_generated_image_for_id($id) {
+        $color = $this->get_generated_color_for_id($id);
+        $pattern = new \core_geopattern();
+        $pattern->setColor($color);
+        $pattern->patternbyid($id);
+        return $pattern->datauri();
+    }
+
+    /**
+     * Get the course pattern image URL.
+     *
+     * @param context_course $context course context object
+     * @return string URL of the course pattern image in SVG format
+     */
+    public function get_generated_url_for_course(context_course $context): string {
+        return moodle_url::make_pluginfile_url($context->id, 'course', 'generated', null, '/', 'course.svg')->out();
+    }
+
+    /**
+     * Get the course pattern in SVG format to show on a course card.
+     *
+     * @param int $id id to use when generating the pattern
+     * @return string SVG file contents
+     */
+    public function get_generated_svg_for_id(int $id): string {
+        $color = $this->get_generated_color_for_id($id);
+        $pattern = new \core_geopattern();
+        $pattern->setColor($color);
+        $pattern->patternbyid($id);
+        return $pattern->toSVG();
+    }
+
+    /**
+     * Get the course color to show on a course card.
+     *
+     * @param int $id Id to use when generating the color.
+     * @return string hex color code.
+     */
+    public function get_generated_color_for_id($id) {
+        $colornumbers = range(1, 10);
+        $basecolors = [];
+        foreach ($colornumbers as $number) {
+            $basecolors[] = get_config('core_admin', 'coursecolor' . $number);
+        }
+
+        $color = $basecolors[$id % 10];
+        return $color;
+    }
+
+    /**
+     * Returns lang menu or '', this method also checks forcing of languages in courses.
+     *
+     * This function calls {@link core_renderer::render_single_select()} to actually display the language menu.
+     *
+     * @return string The lang menu HTML or empty string
+     */
+    public function lang_menu() {
+        $languagemenu = new \core\output\language_menu($this->page);
+        $data = $languagemenu->export_for_single_select($this);
+        if ($data) {
+            return $this->render_from_template('core/single_select', $data);
+        }
+        return '';
+    }
+
+    /**
+     * Output the row of editing icons for a block, as defined by the controls array.
+     *
+     * @param array $controls an array like {@link block_contents::$controls}.
+     * @param string $blockid The ID given to the block.
+     * @return string HTML fragment.
+     */
+    public function block_controls($actions, $blockid = null) {
+        if (empty($actions)) {
+            return '';
+        }
+        $menu = new action_menu($actions);
+        if ($blockid !== null) {
+            $menu->set_owner_selector('#'.$blockid);
+        }
+        $menu->attributes['class'] .= ' block-control-actions commands';
+        return $this->render($menu);
+    }
+
+    /**
+     * Returns the HTML for a basic textarea field.
+     *
+     * @param string $name Name to use for the textarea element
+     * @param string $id The id to use fort he textarea element
+     * @param string $value Initial content to display in the textarea
+     * @param int $rows Number of rows to display
+     * @param int $cols Number of columns to display
+     * @return string the HTML to display
+     */
+    public function print_textarea($name, $id, $value, $rows, $cols) {
+        editors_head_setup();
+        $editor = editors_get_preferred_editor(FORMAT_HTML);
+        $editor->set_text($value);
+        $editor->use_editor($id, []);
+
+        $context = [
+            'id' => $id,
+            'name' => $name,
+            'value' => $value,
+            'rows' => $rows,
+            'cols' => $cols
+        ];
+
+        return $this->render_from_template('core_form/editor_textarea', $context);
+    }
+
+    /**
+     * Renders an action menu component.
+     *
+     * @param action_menu $menu
+     * @return string HTML
+     */
+    public function render_action_menu(action_menu $menu) {
+
+        // We don't want the class icon there!
+        foreach ($menu->get_secondary_actions() as $action) {
+            if ($action instanceof \action_menu_link && $action->has_class('icon')) {
+                $action->attributes['class'] = preg_replace('/(^|\s+)icon(\s+|$)/i', '', $action->attributes['class']);
+            }
+        }
+
+        if ($menu->is_empty()) {
+            return '';
+        }
+        $context = $menu->export_for_template($this);
+
+        return $this->render_from_template('core/action_menu', $context);
+    }
+
+    /**
+     * Renders a full check API result including summary and details
+     *
+     * @param core\check\check $check the check that was run to get details from
+     * @param core\check\result $result the result of a check
+     * @param bool $includedetails if true, details are included as well
+     * @return string rendered html
+     */
+    protected function render_check_full_result(core\check\check $check, core\check\result $result, bool $includedetails): string {
+        // Initially render just badge itself.
+        $renderedresult = $this->render_from_template($result->get_template_name(), $result->export_for_template($this));
+
+        // Add summary.
+        $renderedresult .= ' ' . $result->get_summary();
+
+        // Wrap in notificaiton.
+        $notificationmap = [
+            \core\check\result::NA => \core\output\notification::NOTIFY_INFO,
+            \core\check\result::OK => \core\output\notification::NOTIFY_SUCCESS,
+            \core\check\result::INFO => \core\output\notification::NOTIFY_INFO,
+            \core\check\result::UNKNOWN => \core\output\notification::NOTIFY_WARNING,
+            \core\check\result::WARNING => \core\output\notification::NOTIFY_WARNING,
+            \core\check\result::ERROR => \core\output\notification::NOTIFY_ERROR,
+            \core\check\result::CRITICAL => \core\output\notification::NOTIFY_ERROR,
+        ];
+
+        // Get type, or default to error.
+        $notificationtype = $notificationmap[$result->get_status()] ?? \core\output\notification::NOTIFY_ERROR;
+        $renderedresult = $this->notification($renderedresult, $notificationtype, false);
+
+        // If adding details, add on new line.
+        if ($includedetails) {
+            $renderedresult .= $result->get_details();
+        }
+
+        // Add the action link.
+        $renderedresult .= $this->render_action_link($check->get_action_link());
+
+        return $renderedresult;
+    }
+
+    /**
+     * Renders a full check API result including summary and details
+     *
+     * @param core\check\check $check the check that was run to get details from
+     * @param core\check\result $result the result of a check
+     * @param bool $includedetails if details should be included
+     * @return string HTML fragment
+     */
+    public function check_full_result(core\check\check $check, core\check\result $result, bool $includedetails = false) {
+        return $this->render_check_full_result($check, $result, $includedetails);
+    }
+
+    /**
+     * Renders a Check API result
+     *
+     * @param core\check\result $result
+     * @return string HTML fragment
+     */
+    protected function render_check_result(core\check\result $result) {
+        return $this->render_from_template($result->get_template_name(), $result->export_for_template($this));
+    }
+
+    /**
+     * Renders a Check API result
+     *
+     * @param core\check\result $result
+     * @return string HTML fragment
+     */
+    public function check_result(core\check\result $result) {
+        return $this->render_check_result($result);
+    }
+
+    /**
+     * Renders an action_menu_link item.
+     *
+     * @param action_menu_link $action
+     * @return string HTML fragment
+     */
+    protected function render_action_menu_link(action_menu_link $action) {
+        return $this->render_from_template('core/action_menu_link', $action->export_for_template($this));
+    }
+
+    /**
+     * Renders a primary action_menu_filler item.
+     *
+     * @param action_menu_filler $action
+     * @return string HTML fragment
+     */
+    protected function render_action_menu_filler(action_menu_filler $action) {
+        return html_writer::span('&nbsp;', 'filler');
+    }
+
+    /**
+     * Renders a primary action_menu_link item.
+     *
+     * @param action_menu_link_primary $action
+     * @return string HTML fragment
+     */
+    protected function render_action_menu_link_primary(action_menu_link_primary $action) {
+        return $this->render_action_menu_link($action);
+    }
+
+    /**
+     * Renders a secondary action_menu_link item.
+     *
+     * @param action_menu_link_secondary $action
+     * @return string HTML fragment
+     */
+    protected function render_action_menu_link_secondary(action_menu_link_secondary $action) {
+        return $this->render_action_menu_link($action);
+    }
+
+    /**
+     * Prints a nice side block with an optional header.
+     *
+     * @param block_contents $bc HTML for the content
+     * @param string $region the region the block is appearing in.
+     * @return string the HTML to be output.
+     */
+    public function block(block_contents $bc, $region) {
+        $bc = clone($bc); // Avoid messing up the object passed in.
+        if (empty($bc->blockinstanceid) || !strip_tags($bc->title)) {
+            $bc->collapsible = block_contents::NOT_HIDEABLE;
+        }
+
+        $id = !empty($bc->attributes['id']) ? $bc->attributes['id'] : uniqid('block-');
+        $context = new stdClass();
+        $context->skipid = $bc->skipid;
+        $context->blockinstanceid = $bc->blockinstanceid ?: uniqid('fakeid-');
+        $context->dockable = $bc->dockable;
+        $context->id = $id;
+        $context->hidden = $bc->collapsible == block_contents::HIDDEN;
+        $context->skiptitle = strip_tags($bc->title);
+        $context->showskiplink = !empty($context->skiptitle);
+        $context->arialabel = $bc->arialabel;
+        $context->ariarole = !empty($bc->attributes['role']) ? $bc->attributes['role'] : 'complementary';
+        $context->class = $bc->attributes['class'];
+        $context->type = $bc->attributes['data-block'];
+        $context->title = $bc->title;
+        $context->content = $bc->content;
+        $context->annotation = $bc->annotation;
+        $context->footer = $bc->footer;
+        $context->hascontrols = !empty($bc->controls);
+        if ($context->hascontrols) {
+            $context->controls = $this->block_controls($bc->controls, $id);
+        }
+
+        return $this->render_from_template('core/block', $context);
+    }
+
+    /**
+     * Render the contents of a block_list.
+     *
+     * @param array $icons the icon for each item.
+     * @param array $items the content of each item.
+     * @return string HTML
+     */
+    public function list_block_contents($icons, $items) {
+        $row = 0;
+        $lis = array();
+        foreach ($items as $key => $string) {
+            $item = html_writer::start_tag('li', array('class' => 'r' . $row));
+            if (!empty($icons[$key])) { //test if the content has an assigned icon
+                $item .= html_writer::tag('div', $icons[$key], array('class' => 'icon column c0'));
+            }
+            $item .= html_writer::tag('div', $string, array('class' => 'column c1'));
+            $item .= html_writer::end_tag('li');
+            $lis[] = $item;
+            $row = 1 - $row; // Flip even/odd.
+        }
+        return html_writer::tag('ul', implode("\n", $lis), array('class' => 'unlist'));
+    }
+
+    /**
+     * Output all the blocks in a particular region.
+     *
+     * @param string $region the name of a region on this page.
+     * @param boolean $fakeblocksonly Output fake block only.
+     * @return string the HTML to be output.
+     */
+    public function blocks_for_region($region, $fakeblocksonly = false) {
+        $blockcontents = $this->page->blocks->get_content_for_region($region, $this);
+        $lastblock = null;
+        $zones = array();
+        foreach ($blockcontents as $bc) {
+            if ($bc instanceof block_contents) {
+                $zones[] = $bc->title;
+            }
+        }
+        $output = '';
+
+        foreach ($blockcontents as $bc) {
+            if ($bc instanceof block_contents) {
+                if ($fakeblocksonly && !$bc->is_fake()) {
+                    // Skip rendering real blocks if we only want to show fake blocks.
+                    continue;
+                }
+                $output .= $this->block($bc, $region);
+                $lastblock = $bc->title;
+            } else if ($bc instanceof block_move_target) {
+                if (!$fakeblocksonly) {
+                    $output .= $this->block_move_target($bc, $zones, $lastblock, $region);
+                }
+            } else {
+                throw new coding_exception('Unexpected type of thing (' . get_class($bc) . ') found in list of block contents.');
+            }
+        }
+        return $output;
+    }
+
+    /**
+     * Output a place where the block that is currently being moved can be dropped.
+     *
+     * @param block_move_target $target with the necessary details.
+     * @param array $zones array of areas where the block can be moved to
+     * @param string $previous the block located before the area currently being rendered.
+     * @param string $region the name of the region
+     * @return string the HTML to be output.
+     */
+    public function block_move_target($target, $zones, $previous, $region) {
+        if ($previous == null) {
+            if (empty($zones)) {
+                // There are no zones, probably because there are no blocks.
+                $regions = $this->page->theme->get_all_block_regions();
+                $position = get_string('moveblockinregion', 'block', $regions[$region]);
+            } else {
+                $position = get_string('moveblockbefore', 'block', $zones[0]);
+            }
+        } else {
+            $position = get_string('moveblockafter', 'block', $previous);
+        }
+        return html_writer::tag('a', html_writer::tag('span', $position, array('class' => 'accesshide')), array('href' => $target->url, 'class' => 'blockmovetarget'));
+    }
+
+    /**
+     * Renders a special html link with attached action
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_action_link()} instead.
+     *
+     * @param string|moodle_url $url
+     * @param string $text HTML fragment
+     * @param component_action $action
+     * @param array $attributes associative array of html link attributes + disabled
+     * @param pix_icon optional pix icon to render with the link
+     * @return string HTML fragment
+     */
+    public function action_link($url, $text, component_action $action = null, array $attributes = null, $icon = null) {
+        if (!($url instanceof moodle_url)) {
+            $url = new moodle_url($url);
+        }
+        $link = new action_link($url, $text, $action, $attributes, $icon);
+
+        return $this->render($link);
+    }
+
+    /**
+     * Renders an action_link object.
+     *
+     * The provided link is renderer and the HTML returned. At the same time the
+     * associated actions are setup in JS by {@link core_renderer::add_action_handler()}
+     *
+     * @param action_link $link
+     * @return string HTML fragment
+     */
+    protected function render_action_link(action_link $link) {
+        return $this->render_from_template('core/action_link', $link->export_for_template($this));
+    }
+
+    /**
+     * Renders an action_icon.
+     *
+     * This function uses the {@link core_renderer::action_link()} method for the
+     * most part. What it does different is prepare the icon as HTML and use it
+     * as the link text.
+     *
+     * Theme developers: If you want to change how action links and/or icons are rendered,
+     * consider overriding function {@link core_renderer::render_action_link()} and
+     * {@link core_renderer::render_pix_icon()}.
+     *
+     * @param string|moodle_url $url A string URL or moodel_url
+     * @param pix_icon $pixicon
+     * @param component_action $action
+     * @param array $attributes associative array of html link attributes + disabled
+     * @param bool $linktext show title next to image in link
+     * @return string HTML fragment
+     */
+    public function action_icon($url, pix_icon $pixicon, component_action $action = null, array $attributes = null, $linktext=false) {
+        if (!($url instanceof moodle_url)) {
+            $url = new moodle_url($url);
+        }
+        $attributes = (array)$attributes;
+
+        if (empty($attributes['class'])) {
+            // let ppl override the class via $options
+            $attributes['class'] = 'action-icon';
+        }
+
+        if ($linktext) {
+            $text = $pixicon->attributes['alt'];
+            // Set the icon as a decorative image if we're displaying the action text.
+            // Otherwise, the action name will be read twice by assistive technologies.
+            $pixicon->attributes['alt'] = '';
+            $pixicon->attributes['title'] = '';
+            $pixicon->attributes['aria-hidden'] = 'true';
+        } else {
+            $text = '';
+        }
+
+        $icon = $this->render($pixicon);
+
+        return $this->action_link($url, $text.$icon, $action, $attributes);
+    }
+
+   /**
+    * Print a message along with button choices for Continue/Cancel
+    *
+    * If a string or moodle_url is given instead of a single_button, method defaults to post.
+    *
+    * @param string $message The question to ask the user
+    * @param single_button|moodle_url|string $continue The single_button component representing the Continue answer. Can also be a moodle_url or string URL
+    * @param single_button|moodle_url|string $cancel The single_button component representing the Cancel answer. Can also be a moodle_url or string URL
+    * @param array $displayoptions optional extra display options
+    * @return string HTML fragment
+    */
+    public function confirm($message, $continue, $cancel, array $displayoptions = []) {
+
+        // Check existing displayoptions.
+        $displayoptions['confirmtitle'] = $displayoptions['confirmtitle'] ?? get_string('confirm');
+        $displayoptions['continuestr'] = $displayoptions['continuestr'] ?? get_string('continue');
+        $displayoptions['cancelstr'] = $displayoptions['cancelstr'] ?? get_string('cancel');
+
+        if ($continue instanceof single_button) {
+            // Continue button should be primary if set to secondary type as it is the fefault.
+            if ($continue->type === single_button::BUTTON_SECONDARY) {
+                $continue->type = single_button::BUTTON_PRIMARY;
+            }
+        } else if (is_string($continue)) {
+            $continue = new single_button(new moodle_url($continue), $displayoptions['continuestr'], 'post',
+                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
+        } else if ($continue instanceof moodle_url) {
+            $continue = new single_button($continue, $displayoptions['continuestr'], 'post',
+                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
+        } else {
+            throw new coding_exception('The continue param to $OUTPUT->confirm() must be either a URL (string/moodle_url) or a single_button instance.');
+        }
+
+        if ($cancel instanceof single_button) {
+            // ok
+        } else if (is_string($cancel)) {
+            $cancel = new single_button(new moodle_url($cancel), $displayoptions['cancelstr'], 'get');
+        } else if ($cancel instanceof moodle_url) {
+            $cancel = new single_button($cancel, $displayoptions['cancelstr'], 'get');
+        } else {
+            throw new coding_exception('The cancel param to $OUTPUT->confirm() must be either a URL (string/moodle_url) or a single_button instance.');
+        }
+
+        $attributes = [
+            'role'=>'alertdialog',
+            'aria-labelledby'=>'modal-header',
+            'aria-describedby'=>'modal-body',
+            'aria-modal'=>'true'
+        ];
+
+        $output = $this->box_start('generalbox modal modal-dialog modal-in-page show', 'notice', $attributes);
+        $output .= $this->box_start('modal-content', 'modal-content');
+        $output .= $this->box_start('modal-header px-3', 'modal-header');
+        $output .= html_writer::tag('h4', $displayoptions['confirmtitle']);
+        $output .= $this->box_end();
+        $attributes = [
+            'role'=>'alert',
+            'data-aria-autofocus'=>'true'
+        ];
+        $output .= $this->box_start('modal-body', 'modal-body', $attributes);
+        $output .= html_writer::tag('p', $message);
+        $output .= $this->box_end();
+        $output .= $this->box_start('modal-footer', 'modal-footer');
+        $output .= html_writer::tag('div', $this->render($cancel) . $this->render($continue), ['class' => 'buttons']);
+        $output .= $this->box_end();
+        $output .= $this->box_end();
+        $output .= $this->box_end();
+        return $output;
+    }
+
+    /**
+     * Returns a form with a single button.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_single_button()} instead.
+     *
+     * @param string|moodle_url $url
+     * @param string $label button text
+     * @param string $method get or post submit method
+     * @param array $options associative array {disabled, title, etc.}
+     * @return string HTML fragment
+     */
+    public function single_button($url, $label, $method='post', array $options=null) {
+        if (!($url instanceof moodle_url)) {
+            $url = new moodle_url($url);
+        }
+        $button = new single_button($url, $label, $method);
+
+        foreach ((array)$options as $key=>$value) {
+            if (property_exists($button, $key)) {
+                $button->$key = $value;
+            } else {
+                $button->set_attribute($key, $value);
+            }
+        }
+
+        return $this->render($button);
+    }
+
+    /**
+     * Renders a single button widget.
+     *
+     * This will return HTML to display a form containing a single button.
+     *
+     * @param single_button $button
+     * @return string HTML fragment
+     */
+    protected function render_single_button(single_button $button) {
+        return $this->render_from_template('core/single_button', $button->export_for_template($this));
+    }
+
+    /**
+     * Returns a form with a single select widget.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_single_select()} instead.
+     *
+     * @param moodle_url $url form action target, includes hidden fields
+     * @param string $name name of selection field - the changing parameter in url
+     * @param array $options list of options
+     * @param string $selected selected element
+     * @param array $nothing
+     * @param string $formid
+     * @param array $attributes other attributes for the single select
+     * @return string HTML fragment
+     */
+    public function single_select($url, $name, array $options, $selected = '',
+                                $nothing = array('' => 'choosedots'), $formid = null, $attributes = array()) {
+        if (!($url instanceof moodle_url)) {
+            $url = new moodle_url($url);
+        }
+        $select = new single_select($url, $name, $options, $selected, $nothing, $formid);
+
+        if (array_key_exists('label', $attributes)) {
+            $select->set_label($attributes['label']);
+            unset($attributes['label']);
+        }
+        $select->attributes = $attributes;
+
+        return $this->render($select);
+    }
+
+    /**
+     * Returns a dataformat selection and download form
+     *
+     * @param string $label A text label
+     * @param moodle_url|string $base The download page url
+     * @param string $name The query param which will hold the type of the download
+     * @param array $params Extra params sent to the download page
+     * @return string HTML fragment
+     */
+    public function download_dataformat_selector($label, $base, $name = 'dataformat', $params = array()) {
+
+        $formats = core_plugin_manager::instance()->get_plugins_of_type('dataformat');
+        $options = array();
+        foreach ($formats as $format) {
+            if ($format->is_enabled()) {
+                $options[] = array(
+                    'value' => $format->name,
+                    'label' => get_string('dataformat', $format->component),
+                );
+            }
+        }
+        $hiddenparams = array();
+        foreach ($params as $key => $value) {
+            $hiddenparams[] = array(
+                'name' => $key,
+                'value' => $value,
+            );
+        }
+        $data = array(
+            'label' => $label,
+            'base' => $base,
+            'name' => $name,
+            'params' => $hiddenparams,
+            'options' => $options,
+            'sesskey' => sesskey(),
+            'submit' => get_string('download'),
+        );
+
+        return $this->render_from_template('core/dataformat_selector', $data);
+    }
+
+
+    /**
+     * Internal implementation of single_select rendering
+     *
+     * @param single_select $select
+     * @return string HTML fragment
+     */
+    protected function render_single_select(single_select $select) {
+        return $this->render_from_template('core/single_select', $select->export_for_template($this));
+    }
+
+    /**
+     * Returns a form with a url select widget.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_url_select()} instead.
+     *
+     * @param array $urls list of urls - array('/course/view.php?id=1'=>'Frontpage', ....)
+     * @param string $selected selected element
+     * @param array $nothing
+     * @param string $formid
+     * @return string HTML fragment
+     */
+    public function url_select(array $urls, $selected, $nothing = array('' => 'choosedots'), $formid = null) {
+        $select = new url_select($urls, $selected, $nothing, $formid);
+        return $this->render($select);
+    }
+
+    /**
+     * Internal implementation of url_select rendering
+     *
+     * @param url_select $select
+     * @return string HTML fragment
+     */
+    protected function render_url_select(url_select $select) {
+        return $this->render_from_template('core/url_select', $select->export_for_template($this));
+    }
+
+    /**
+     * Returns a string containing a link to the user documentation.
+     * Also contains an icon by default. Shown to teachers and admin only.
+     *
+     * @param string $path The page link after doc root and language, no leading slash.
+     * @param string $text The text to be displayed for the link
+     * @param boolean $forcepopup Whether to force a popup regardless of the value of $CFG->doctonewwindow
+     * @param array $attributes htm attributes
+     * @return string
+     */
+    public function doc_link($path, $text = '', $forcepopup = false, array $attributes = []) {
+        global $CFG;
+
+        $icon = $this->pix_icon('book', '', 'moodle', array('class' => 'iconhelp icon-pre'));
+
+        $attributes['href'] = new moodle_url(get_docs_url($path));
+        $newwindowicon = '';
+        if (!empty($CFG->doctonewwindow) || $forcepopup) {
+            $attributes['target'] = '_blank';
+            $newwindowicon = $this->pix_icon('i/externallink', get_string('opensinnewwindow'), 'moodle',
+            ['class' => 'fa fa-externallink fa-fw']);
+        }
+
+        return html_writer::tag('a', $icon . $text . $newwindowicon, $attributes);
+    }
+
+    /**
+     * Return HTML for an image_icon.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_image_icon()} instead.
+     *
+     * @param string $pix short pix name
+     * @param string $alt mandatory alt attribute
+     * @param string $component standard compoennt name like 'moodle', 'mod_forum', etc.
+     * @param array $attributes htm attributes
+     * @return string HTML fragment
+     */
+    public function image_icon($pix, $alt, $component='moodle', array $attributes = null) {
+        $icon = new image_icon($pix, $alt, $component, $attributes);
+        return $this->render($icon);
+    }
+
+    /**
+     * Renders a pix_icon widget and returns the HTML to display it.
+     *
+     * @param image_icon $icon
+     * @return string HTML fragment
+     */
+    protected function render_image_icon(image_icon $icon) {
+        $system = \core\output\icon_system::instance(\core\output\icon_system::STANDARD);
+        return $system->render_pix_icon($this, $icon);
+    }
+
+    /**
+     * Return HTML for a pix_icon.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_pix_icon()} instead.
+     *
+     * @param string $pix short pix name
+     * @param string $alt mandatory alt attribute
+     * @param string $component standard compoennt name like 'moodle', 'mod_forum', etc.
+     * @param array $attributes htm lattributes
+     * @return string HTML fragment
+     */
+    public function pix_icon($pix, $alt, $component='moodle', array $attributes = null) {
+        $icon = new pix_icon($pix, $alt, $component, $attributes);
+        return $this->render($icon);
+    }
+
+    /**
+     * Renders a pix_icon widget and returns the HTML to display it.
+     *
+     * @param pix_icon $icon
+     * @return string HTML fragment
+     */
+    protected function render_pix_icon(pix_icon $icon) {
+        $system = \core\output\icon_system::instance();
+        return $system->render_pix_icon($this, $icon);
+    }
+
+    /**
+     * Return HTML to display an emoticon icon.
+     *
+     * @param pix_emoticon $emoticon
+     * @return string HTML fragment
+     */
+    protected function render_pix_emoticon(pix_emoticon $emoticon) {
+        $system = \core\output\icon_system::instance(\core\output\icon_system::STANDARD);
+        return $system->render_pix_icon($this, $emoticon);
+    }
+
+    /**
+     * Produces the html that represents this rating in the UI
+     *
+     * @param rating $rating the page object on which this rating will appear
+     * @return string
+     */
+    function render_rating(rating $rating) {
+        global $CFG, $USER;
+
+        if ($rating->settings->aggregationmethod == RATING_AGGREGATE_NONE) {
+            return null;//ratings are turned off
+        }
+
+        $ratingmanager = new rating_manager();
+        // Initialise the JavaScript so ratings can be done by AJAX.
+        $ratingmanager->initialise_rating_javascript($this->page);
+
+        $strrate = get_string("rate", "rating");
+        $ratinghtml = ''; //the string we'll return
+
+        // permissions check - can they view the aggregate?
+        if ($rating->user_can_view_aggregate()) {
+
+            $aggregatelabel = $ratingmanager->get_aggregate_label($rating->settings->aggregationmethod);
+            $aggregatelabel = html_writer::tag('span', $aggregatelabel, array('class'=>'rating-aggregate-label'));
+            $aggregatestr   = $rating->get_aggregate_string();
+
+            $aggregatehtml  = html_writer::tag('span', $aggregatestr, array('id' => 'ratingaggregate'.$rating->itemid, 'class' => 'ratingaggregate')).' ';
+            if ($rating->count > 0) {
+                $countstr = "({$rating->count})";
+            } else {
+                $countstr = '-';
+            }
+            $aggregatehtml .= html_writer::tag('span', $countstr, array('id'=>"ratingcount{$rating->itemid}", 'class' => 'ratingcount')).' ';
+
+            if ($rating->settings->permissions->viewall && $rating->settings->pluginpermissions->viewall) {
+
+                $nonpopuplink = $rating->get_view_ratings_url();
+                $popuplink = $rating->get_view_ratings_url(true);
+
+                $action = new popup_action('click', $popuplink, 'ratings', array('height' => 400, 'width' => 600));
+                $aggregatehtml = $this->action_link($nonpopuplink, $aggregatehtml, $action);
+            }
+
+            $ratinghtml .= html_writer::tag('span', $aggregatelabel . $aggregatehtml, array('class' => 'rating-aggregate-container'));
+        }
+
+        $formstart = null;
+        // if the item doesn't belong to the current user, the user has permission to rate
+        // and we're within the assessable period
+        if ($rating->user_can_rate()) {
+
+            $rateurl = $rating->get_rate_url();
+            $inputs = $rateurl->params();
+
+            //start the rating form
+            $formattrs = array(
+                'id'     => "postrating{$rating->itemid}",
+                'class'  => 'postratingform',
+                'method' => 'post',
+                'action' => $rateurl->out_omit_querystring()
+            );
+            $formstart  = html_writer::start_tag('form', $formattrs);
+            $formstart .= html_writer::start_tag('div', array('class' => 'ratingform'));
+
+            // add the hidden inputs
+            foreach ($inputs as $name => $value) {
+                $attributes = array('type' => 'hidden', 'class' => 'ratinginput', 'name' => $name, 'value' => $value);
+                $formstart .= html_writer::empty_tag('input', $attributes);
+            }
+
+            if (empty($ratinghtml)) {
+                $ratinghtml .= $strrate.': ';
+            }
+            $ratinghtml = $formstart.$ratinghtml;
+
+            $scalearray = array(RATING_UNSET_RATING => $strrate.'...') + $rating->settings->scale->scaleitems;
+            $scaleattrs = array('class'=>'postratingmenu ratinginput','id'=>'menurating'.$rating->itemid);
+            $ratinghtml .= html_writer::label($rating->rating, 'menurating'.$rating->itemid, false, array('class' => 'accesshide'));
+            $ratinghtml .= html_writer::select($scalearray, 'rating', $rating->rating, false, $scaleattrs);
+
+            //output submit button
+            $ratinghtml .= html_writer::start_tag('span', array('class'=>"ratingsubmit"));
+
+            $attributes = array('type' => 'submit', 'class' => 'postratingmenusubmit', 'id' => 'postratingsubmit'.$rating->itemid, 'value' => s(get_string('rate', 'rating')));
+            $ratinghtml .= html_writer::empty_tag('input', $attributes);
+
+            if (!$rating->settings->scale->isnumeric) {
+                // If a global scale, try to find current course ID from the context
+                if (empty($rating->settings->scale->courseid) and $coursecontext = $rating->context->get_course_context(false)) {
+                    $courseid = $coursecontext->instanceid;
+                } else {
+                    $courseid = $rating->settings->scale->courseid;
+                }
+                $ratinghtml .= $this->help_icon_scale($courseid, $rating->settings->scale);
+            }
+            $ratinghtml .= html_writer::end_tag('span');
+            $ratinghtml .= html_writer::end_tag('div');
+            $ratinghtml .= html_writer::end_tag('form');
+        }
+
+        return $ratinghtml;
+    }
+
+    /**
+     * Centered heading with attached help button (same title text)
+     * and optional icon attached.
+     *
+     * @param string $text A heading text
+     * @param string $helpidentifier The keyword that defines a help page
+     * @param string $component component name
+     * @param string|moodle_url $icon
+     * @param string $iconalt icon alt text
+     * @param int $level The level of importance of the heading. Defaulting to 2
+     * @param string $classnames A space-separated list of CSS classes. Defaulting to null
+     * @return string HTML fragment
+     */
+    public function heading_with_help($text, $helpidentifier, $component = 'moodle', $icon = '', $iconalt = '', $level = 2, $classnames = null) {
+        $image = '';
+        if ($icon) {
+            $image = $this->pix_icon($icon, $iconalt, $component, array('class'=>'icon iconlarge'));
+        }
+
+        $help = '';
+        if ($helpidentifier) {
+            $help = $this->help_icon($helpidentifier, $component);
+        }
+
+        return $this->heading($image.$text.$help, $level, $classnames);
+    }
+
+    /**
+     * Returns HTML to display a help icon.
+     *
+     * @deprecated since Moodle 2.0
+     */
+    public function old_help_icon($helpidentifier, $title, $component = 'moodle', $linktext = '') {
+        throw new coding_exception('old_help_icon() can not be used any more, please see help_icon().');
+    }
+
+    /**
+     * Returns HTML to display a help icon.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_help_icon()} instead.
+     *
+     * @param string $identifier The keyword that defines a help page
+     * @param string $component component name
+     * @param string|bool $linktext true means use $title as link text, string means link text value
+     * @param string|object|array|int $a An object, string or number that can be used
+     *      within translation strings
+     * @return string HTML fragment
+     */
+    public function help_icon($identifier, $component = 'moodle', $linktext = '', $a = null) {
+        $icon = new help_icon($identifier, $component, $a);
+        $icon->diag_strings();
+        if ($linktext === true) {
+            $icon->linktext = get_string($icon->identifier, $icon->component, $a);
+        } else if (!empty($linktext)) {
+            $icon->linktext = $linktext;
+        }
+        return $this->render($icon);
+    }
+
+    /**
+     * Implementation of user image rendering.
+     *
+     * @param help_icon $helpicon A help icon instance
+     * @return string HTML fragment
+     */
+    protected function render_help_icon(help_icon $helpicon) {
+        $context = $helpicon->export_for_template($this);
+        return $this->render_from_template('core/help_icon', $context);
+    }
+
+    /**
+     * Returns HTML to display a scale help icon.
+     *
+     * @param int $courseid
+     * @param stdClass $scale instance
+     * @return string HTML fragment
+     */
+    public function help_icon_scale($courseid, stdClass $scale) {
+        global $CFG;
+
+        $title = get_string('helpprefix2', '', $scale->name) .' ('.get_string('newwindow').')';
+
+        $icon = $this->pix_icon('help', get_string('scales'), 'moodle', array('class'=>'iconhelp'));
+
+        $scaleid = abs($scale->id);
+
+        $link = new moodle_url('/course/scales.php', array('id' => $courseid, 'list' => true, 'scaleid' => $scaleid));
+        $action = new popup_action('click', $link, 'ratingscale');
+
+        return html_writer::tag('span', $this->action_link($link, $icon, $action), array('class' => 'helplink'));
+    }
+
+    /**
+     * Creates and returns a spacer image with optional line break.
+     *
+     * @param array $attributes Any HTML attributes to add to the spaced.
+     * @param bool $br Include a BR after the spacer.... DON'T USE THIS. Don't be
+     *     laxy do it with CSS which is a much better solution.
+     * @return string HTML fragment
+     */
+    public function spacer(array $attributes = null, $br = false) {
+        $attributes = (array)$attributes;
+        if (empty($attributes['width'])) {
+            $attributes['width'] = 1;
+        }
+        if (empty($attributes['height'])) {
+            $attributes['height'] = 1;
+        }
+        $attributes['class'] = 'spacer';
+
+        $output = $this->pix_icon('spacer', '', 'moodle', $attributes);
+
+        if (!empty($br)) {
+            $output .= '<br />';
+        }
+
+        return $output;
+    }
+
+    /**
+     * Returns HTML to display the specified user's avatar.
+     *
+     * User avatar may be obtained in two ways:
+     * <pre>
+     * // Option 1: (shortcut for simple cases, preferred way)
+     * // $user has come from the DB and has fields id, picture, imagealt, firstname and lastname
+     * $OUTPUT->user_picture($user, array('popup'=>true));
+     *
+     * // Option 2:
+     * $userpic = new user_picture($user);
+     * // Set properties of $userpic
+     * $userpic->popup = true;
+     * $OUTPUT->render($userpic);
+     * </pre>
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_user_picture()} instead.
+     *
+     * @param stdClass $user Object with at least fields id, picture, imagealt, firstname, lastname
+     *     If any of these are missing, the database is queried. Avoid this
+     *     if at all possible, particularly for reports. It is very bad for performance.
+     * @param array $options associative array with user picture options, used only if not a user_picture object,
+     *     options are:
+     *     - courseid=$this->page->course->id (course id of user profile in link)
+     *     - size=35 (size of image)
+     *     - link=true (make image clickable - the link leads to user profile)
+     *     - popup=false (open in popup)
+     *     - alttext=true (add image alt attribute)
+     *     - class = image class attribute (default 'userpicture')
+     *     - visibletoscreenreaders=true (whether to be visible to screen readers)
+     *     - includefullname=false (whether to include the user's full name together with the user picture)
+     *     - includetoken = false (whether to use a token for authentication. True for current user, int value for other user id)
+     * @return string HTML fragment
+     */
+    public function user_picture(stdClass $user, array $options = null) {
+        $userpicture = new user_picture($user);
+        foreach ((array)$options as $key=>$value) {
+            if (property_exists($userpicture, $key)) {
+                $userpicture->$key = $value;
+            }
+        }
+        return $this->render($userpicture);
+    }
+
+    /**
+     * Internal implementation of user image rendering.
+     *
+     * @param user_picture $userpicture
+     * @return string
+     */
+    protected function render_user_picture(user_picture $userpicture) {
+        global $CFG;
+
+        $user = $userpicture->user;
+        $canviewfullnames = has_capability('moodle/site:viewfullnames', $this->page->context);
+
+        $alt = '';
+        if ($userpicture->alttext) {
+            if (!empty($user->imagealt)) {
+                $alt = trim($user->imagealt);
+            }
+        }
+
+        // If the user picture is being rendered as a link but without the full name, an empty alt text for the user picture
+        // would mean that the link displayed will not have any discernible text. This becomes an accessibility issue,
+        // especially to screen reader users. Use the user's full name by default for the user picture's alt-text if this is
+        // the case.
+        if ($userpicture->link && !$userpicture->includefullname && empty($alt)) {
+            $alt = fullname($user);
+        }
+
+        if (empty($userpicture->size)) {
+            $size = 35;
+        } else if ($userpicture->size === true or $userpicture->size == 1) {
+            $size = 100;
+        } else {
+            $size = $userpicture->size;
+        }
+
+        $class = $userpicture->class;
+
+        if ($user->picture == 0) {
+            $class .= ' defaultuserpic';
+        }
+
+        $src = $userpicture->get_url($this->page, $this);
+
+        $attributes = array('src' => $src, 'class' => $class, 'width' => $size, 'height' => $size);
+        if (!$userpicture->visibletoscreenreaders) {
+            $alt = '';
+        }
+        $attributes['alt'] = $alt;
+
+        if (!empty($alt)) {
+            $attributes['title'] = $alt;
+        }
+
+        // Get the image html output first, auto generated based on initials if one isn't already set.
+        if ($user->picture == 0 && empty($CFG->enablegravatar) && !defined('BEHAT_SITE_RUNNING')) {
+            $initials = \core_user::get_initials($user);
+            $fullname = fullname($userpicture->user, $canviewfullnames);
+            // Don't modify in corner cases where neither the firstname nor the lastname appears.
+            $output = html_writer::tag(
+                'span', $initials,
+                [
+                    'class' => 'userinitials size-' . $size,
+                    'title' => $fullname,
+                    'aria-label' => $fullname,
+                    'role' => 'img',
+                ]
+            );
+        } else {
+            $output = html_writer::empty_tag('img', $attributes);
+        }
+
+        // Show fullname together with the picture when desired.
+        if ($userpicture->includefullname) {
+            $output .= fullname($userpicture->user, $canviewfullnames);
+        }
+
+        if (empty($userpicture->courseid)) {
+            $courseid = $this->page->course->id;
+        } else {
+            $courseid = $userpicture->courseid;
+        }
+        if ($courseid == SITEID) {
+            $url = new moodle_url('/user/profile.php', array('id' => $user->id));
+        } else {
+            $url = new moodle_url('/user/view.php', array('id' => $user->id, 'course' => $courseid));
+        }
+
+        // Then wrap it in link if needed. Also we don't wrap it in link if the link redirects to itself.
+        if (!$userpicture->link ||
+                ($this->page->has_set_url() && $this->page->url == $url)) { // Protect against unset page->url.
+            return $output;
+        }
+
+        $attributes = array('href' => $url, 'class' => 'd-inline-block aabtn');
+        if (!$userpicture->visibletoscreenreaders) {
+            $attributes['tabindex'] = '-1';
+            $attributes['aria-hidden'] = 'true';
+        }
+
+        if ($userpicture->popup) {
+            $id = html_writer::random_id('userpicture');
+            $attributes['id'] = $id;
+            $this->add_action_handler(new popup_action('click', $url), $id);
+        }
+
+        return html_writer::tag('a', $output, $attributes);
+    }
+
+    /**
+     * @deprecated since Moodle 4.3
+     */
+    public function htmllize_file_tree() {
+        throw new coding_exception('This function is deprecated and no longer relevant.');
+    }
+
+    /**
+     * Returns HTML to display the file picker
+     *
+     * <pre>
+     * $OUTPUT->file_picker($options);
+     * </pre>
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_file_picker()} instead.
+     *
+     * @param stdClass $options file manager options
+     *   options are:
+     *       maxbytes=>-1,
+     *       itemid=>0,
+     *       client_id=>uniqid(),
+     *       acepted_types=>'*',
+     *       return_types=>FILE_INTERNAL,
+     *       context=>current page context
+     * @return string HTML fragment
+     */
+    public function file_picker($options) {
+        $fp = new file_picker($options);
+        return $this->render($fp);
+    }
+
+    /**
+     * Internal implementation of file picker rendering.
+     *
+     * @param file_picker $fp
+     * @return string
+     */
+    public function render_file_picker(file_picker $fp) {
+        $options = $fp->options;
+        $client_id = $options->client_id;
+        $strsaved = get_string('filesaved', 'repository');
+        $straddfile = get_string('openpicker', 'repository');
+        $strloading  = get_string('loading', 'repository');
+        $strdndenabled = get_string('dndenabled_inbox', 'moodle');
+        $strdroptoupload = get_string('droptoupload', 'moodle');
+        $iconprogress = $this->pix_icon('i/loading_small', $strloading).'';
+
+        $currentfile = $options->currentfile;
+        if (empty($currentfile)) {
+            $currentfile = '';
+        } else {
+            $currentfile .= ' - ';
+        }
+        if ($options->maxbytes) {
+            $size = $options->maxbytes;
+        } else {
+            $size = get_max_upload_file_size();
+        }
+        if ($size == -1) {
+            $maxsize = '';
+        } else {
+            $maxsize = get_string('maxfilesize', 'moodle', display_size($size, 0));
+        }
+        if ($options->buttonname) {
+            $buttonname = ' name="' . $options->buttonname . '"';
+        } else {
+            $buttonname = '';
+        }
+        $html = <<<EOD
+<div class="filemanager-loading mdl-align" id='filepicker-loading-{$client_id}'>
+$iconprogress
+</div>
+<div id="filepicker-wrapper-{$client_id}" class="mdl-left w-100" style="display:none">
+    <div>
+        <input type="button" class="btn btn-secondary fp-btn-choose" id="filepicker-button-{$client_id}" value="{$straddfile}"{$buttonname}/>
+        <span> $maxsize </span>
+    </div>
+EOD;
+        if ($options->env != 'url') {
+            $html .= <<<EOD
+    <div id="file_info_{$client_id}" class="mdl-left filepicker-filelist" style="position: relative">
+    <div class="filepicker-filename">
+        <div class="filepicker-container">$currentfile
+            <div class="dndupload-message">$strdndenabled <br/>
+                <div class="dndupload-arrow d-flex"><i class="fa fa-arrow-circle-o-down fa-3x m-auto"></i></div>
+            </div>
+        </div>
+        <div class="dndupload-progressbars"></div>
+    </div>
+    <div>
+        <div class="dndupload-target">{$strdroptoupload}<br/>
+            <div class="dndupload-arrow d-flex"><i class="fa fa-arrow-circle-o-down fa-3x m-auto"></i></div>
+        </div>
+    </div>
+    </div>
+EOD;
+        }
+        $html .= '</div>';
+        return $html;
+    }
+
+    /**
+     * @deprecated since Moodle 3.2
+     */
+    public function update_module_button() {
+        throw new coding_exception('core_renderer::update_module_button() can not be used anymore. Activity ' .
+            'modules should not add the edit module button, the link is already available in the Administration block. ' .
+            'Themes can choose to display the link in the buttons row consistently for all module types.');
+    }
+
+    /**
+     * Returns HTML to display a "Turn editing on/off" button in a form.
+     *
+     * @param moodle_url $url The URL + params to send through when clicking the button
+     * @param string $method
+     * @return ?string HTML the button
+     */
+    public function edit_button(moodle_url $url, string $method = 'post') {
+
+        if ($this->page->theme->haseditswitch == true) {
+            return;
+        }
+        $url->param('sesskey', sesskey());
+        if ($this->page->user_is_editing()) {
+            $url->param('edit', 'off');
+            $editstring = get_string('turneditingoff');
+        } else {
+            $url->param('edit', 'on');
+            $editstring = get_string('turneditingon');
+        }
+
+        return $this->single_button($url, $editstring, $method);
+    }
+
+    /**
+     * Create a navbar switch for toggling editing mode.
+     *
+     * @return ?string Html containing the edit switch
+     */
+    public function edit_switch() {
+        if ($this->page->user_allowed_editing()) {
+
+            $temp = (object) [
+                'legacyseturl' => (new moodle_url('/editmode.php'))->out(false),
+                'pagecontextid' => $this->page->context->id,
+                'pageurl' => $this->page->url,
+                'sesskey' => sesskey(),
+            ];
+            if ($this->page->user_is_editing()) {
+                $temp->checked = true;
+            }
+            return $this->render_from_template('core/editswitch', $temp);
+        }
+    }
+
+    /**
+     * Returns HTML to display a simple button to close a window
+     *
+     * @param string $text The lang string for the button's label (already output from get_string())
+     * @return string html fragment
+     */
+    public function close_window_button($text='') {
+        if (empty($text)) {
+            $text = get_string('closewindow');
+        }
+        $button = new single_button(new moodle_url('#'), $text, 'get');
+        $button->add_action(new component_action('click', 'close_window'));
+
+        return $this->container($this->render($button), 'closewindow');
+    }
+
+    /**
+     * Output an error message. By default wraps the error message in <span class="error">.
+     * If the error message is blank, nothing is output.
+     *
+     * @param string $message the error message.
+     * @return string the HTML to output.
+     */
+    public function error_text($message) {
+        if (empty($message)) {
+            return '';
+        }
+        $message = $this->pix_icon('i/warning', get_string('error'), '', array('class' => 'icon icon-pre', 'title'=>'')) . $message;
+        return html_writer::tag('span', $message, array('class' => 'error'));
+    }
+
+    /**
+     * Do not call this function directly.
+     *
+     * To terminate the current script with a fatal error, throw an exception.
+     * Doing this will then call this function to display the error, before terminating the execution.
+     *
+     * @param string $message The message to output
+     * @param string $moreinfourl URL where more info can be found about the error
+     * @param string $link Link for the Continue button
+     * @param array $backtrace The execution backtrace
+     * @param string $debuginfo Debugging information
+     * @return string the HTML to output.
+     */
+    public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null, $errorcode = "") {
+        global $CFG;
+
+        $output = '';
+        $obbuffer = '';
+
+        if ($this->has_started()) {
+            // we can not always recover properly here, we have problems with output buffering,
+            // html tables, etc.
+            $output .= $this->opencontainers->pop_all_but_last();
+
+        } else {
+            // It is really bad if library code throws exception when output buffering is on,
+            // because the buffered text would be printed before our start of page.
+            // NOTE: this hack might be behave unexpectedly in case output buffering is enabled in PHP.ini
+            error_reporting(0); // disable notices from gzip compression, etc.
+            while (ob_get_level() > 0) {
+                $buff = ob_get_clean();
+                if ($buff === false) {
+                    break;
+                }
+                $obbuffer .= $buff;
+            }
+            error_reporting($CFG->debug);
+
+            // Output not yet started.
+            $protocol = (isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0');
+            if (empty($_SERVER['HTTP_RANGE'])) {
+                @header($protocol . ' 404 Not Found');
+            } else if (core_useragent::check_safari_ios_version(602) && !empty($_SERVER['HTTP_X_PLAYBACK_SESSION_ID'])) {
+                // Coax iOS 10 into sending the session cookie.
+                @header($protocol . ' 403 Forbidden');
+            } else {
+                // Must stop byteserving attempts somehow,
+                // this is weird but Chrome PDF viewer can be stopped only with 407!
+                @header($protocol . ' 407 Proxy Authentication Required');
+            }
+
+            $this->page->set_context(null); // ugly hack - make sure page context is set to something, we do not want bogus warnings here
+            $this->page->set_url('/'); // no url
+            //$this->page->set_pagelayout('base'); //TODO: MDL-20676 blocks on error pages are weird, unfortunately it somehow detect the pagelayout from URL :-(
+            $this->page->set_title(get_string('error'));
+            $this->page->set_heading($this->page->course->fullname);
+            // No need to display the activity header when encountering an error.
+            $this->page->activityheader->disable();
+            $output .= $this->header();
+        }
+
+        $message = '<p class="errormessage">' . s($message) . '</p>'.
+                '<p class="errorcode"><a href="' . s($moreinfourl) . '">' .
+                get_string('moreinformation') . '</a></p>';
+        if (empty($CFG->rolesactive)) {
+            $message .= '<p class="errormessage">' . get_string('installproblem', 'error') . '</p>';
+            //It is usually not possible to recover from errors triggered during installation, you may need to create a new database or use a different database prefix for new installation.
+        }
+        $output .= $this->box($message, 'errorbox alert alert-danger', null, array('data-rel' => 'fatalerror'));
+
+        if ($CFG->debugdeveloper) {
+            $labelsep = get_string('labelsep', 'langconfig');
+            if (!empty($debuginfo)) {
+                $debuginfo = s($debuginfo); // removes all nasty JS
+                $debuginfo = str_replace("\n", '<br />', $debuginfo); // keep newlines
+                $label = get_string('debuginfo', 'debug') . $labelsep;
+                $output .= $this->notification("<strong>$label</strong> " . $debuginfo, 'notifytiny');
+            }
+            if (!empty($backtrace)) {
+                $label = get_string('stacktrace', 'debug') . $labelsep;
+                $output .= $this->notification("<strong>$label</strong> " . format_backtrace($backtrace), 'notifytiny');
+            }
+            if ($obbuffer !== '' ) {
+                $label = get_string('outputbuffer', 'debug') . $labelsep;
+                $output .= $this->notification("<strong>$label</strong> " . s($obbuffer), 'notifytiny');
+            }
+        }
+
+        if (empty($CFG->rolesactive)) {
+            // continue does not make much sense if moodle is not installed yet because error is most probably not recoverable
+        } else if (!empty($link)) {
+            $output .= $this->continue_button($link);
+        }
+
+        $output .= $this->footer();
+
+        // Padding to encourage IE to display our error page, rather than its own.
+        $output .= str_repeat(' ', 512);
+
+        return $output;
+    }
+
+    /**
+     * Output a notification (that is, a status message about something that has just happened).
+     *
+     * Note: \core\notification::add() may be more suitable for your usage.
+     *
+     * @param string $message The message to print out.
+     * @param ?string $type   The type of notification. See constants on \core\output\notification.
+     * @param bool $closebutton Whether to show a close icon to remove the notification (default true).
+     * @return string the HTML to output.
+     */
+    public function notification($message, $type = null, $closebutton = true) {
+        $typemappings = [
+            // Valid types.
+            'success'           => \core\output\notification::NOTIFY_SUCCESS,
+            'info'              => \core\output\notification::NOTIFY_INFO,
+            'warning'           => \core\output\notification::NOTIFY_WARNING,
+            'error'             => \core\output\notification::NOTIFY_ERROR,
+
+            // Legacy types mapped to current types.
+            'notifyproblem'     => \core\output\notification::NOTIFY_ERROR,
+            'notifytiny'        => \core\output\notification::NOTIFY_ERROR,
+            'notifyerror'       => \core\output\notification::NOTIFY_ERROR,
+            'notifysuccess'     => \core\output\notification::NOTIFY_SUCCESS,
+            'notifymessage'     => \core\output\notification::NOTIFY_INFO,
+            'notifyredirect'    => \core\output\notification::NOTIFY_INFO,
+            'redirectmessage'   => \core\output\notification::NOTIFY_INFO,
+        ];
+
+        $extraclasses = [];
+
+        if ($type) {
+            if (strpos($type, ' ') === false) {
+                // No spaces in the list of classes, therefore no need to loop over and determine the class.
+                if (isset($typemappings[$type])) {
+                    $type = $typemappings[$type];
+                } else {
+                    // The value provided did not match a known type. It must be an extra class.
+                    $extraclasses = [$type];
+                }
+            } else {
+                // Identify what type of notification this is.
+                $classarray = explode(' ', self::prepare_classes($type));
+
+                // Separate out the type of notification from the extra classes.
+                foreach ($classarray as $class) {
+                    if (isset($typemappings[$class])) {
+                        $type = $typemappings[$class];
+                    } else {
+                        $extraclasses[] = $class;
+                    }
+                }
+            }
+        }
+
+        $notification = new \core\output\notification($message, $type, $closebutton);
+        if (count($extraclasses)) {
+            $notification->set_extra_classes($extraclasses);
+        }
+
+        // Return the rendered template.
+        return $this->render_from_template($notification->get_template_name(), $notification->export_for_template($this));
+    }
+
+    /**
+     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
+     */
+    public function notify_problem() {
+        throw new coding_exception('core_renderer::notify_problem() can not be used any more, '.
+            'please use \core\notification::add(), or \core\output\notification as required.');
+    }
+
+    /**
+     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
+     */
+    public function notify_success() {
+        throw new coding_exception('core_renderer::notify_success() can not be used any more, '.
+            'please use \core\notification::add(), or \core\output\notification as required.');
+    }
+
+    /**
+     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
+     */
+    public function notify_message() {
+        throw new coding_exception('core_renderer::notify_message() can not be used any more, '.
+            'please use \core\notification::add(), or \core\output\notification as required.');
+    }
+
+    /**
+     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
+     */
+    public function notify_redirect() {
+        throw new coding_exception('core_renderer::notify_redirect() can not be used any more, '.
+            'please use \core\notification::add(), or \core\output\notification as required.');
+    }
+
+    /**
+     * Render a notification (that is, a status message about something that has
+     * just happened).
+     *
+     * @param \core\output\notification $notification the notification to print out
+     * @return string the HTML to output.
+     */
+    protected function render_notification(\core\output\notification $notification) {
+        return $this->render_from_template($notification->get_template_name(), $notification->export_for_template($this));
+    }
+
+    /**
+     * Returns HTML to display a continue button that goes to a particular URL.
+     *
+     * @param string|moodle_url $url The url the button goes to.
+     * @return string the HTML to output.
+     */
+    public function continue_button($url) {
+        if (!($url instanceof moodle_url)) {
+            $url = new moodle_url($url);
+        }
+        $button = new single_button($url, get_string('continue'), 'get', single_button::BUTTON_PRIMARY);
+        $button->class = 'continuebutton';
+
+        return $this->render($button);
+    }
+
+    /**
+     * Returns HTML to display a single paging bar to provide access to other pages  (usually in a search)
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_paging_bar()} instead.
+     *
+     * @param int $totalcount The total number of entries available to be paged through
+     * @param int $page The page you are currently viewing
+     * @param int $perpage The number of entries that should be shown per page
+     * @param string|moodle_url $baseurl url of the current page, the $pagevar parameter is added
+     * @param string $pagevar name of page parameter that holds the page number
+     * @return string the HTML to output.
+     */
+    public function paging_bar($totalcount, $page, $perpage, $baseurl, $pagevar = 'page') {
+        $pb = new paging_bar($totalcount, $page, $perpage, $baseurl, $pagevar);
+        return $this->render($pb);
+    }
+
+    /**
+     * Returns HTML to display the paging bar.
+     *
+     * @param paging_bar $pagingbar
+     * @return string the HTML to output.
+     */
+    protected function render_paging_bar(paging_bar $pagingbar) {
+        // Any more than 10 is not usable and causes weird wrapping of the pagination.
+        $pagingbar->maxdisplay = 10;
+        return $this->render_from_template('core/paging_bar', $pagingbar->export_for_template($this));
+    }
+
+    /**
+     * Returns HTML to display initials bar to provide access to other pages  (usually in a search)
+     *
+     * @param string $current the currently selected letter.
+     * @param string $class class name to add to this initial bar.
+     * @param string $title the name to put in front of this initial bar.
+     * @param string $urlvar URL parameter name for this initial.
+     * @param string $url URL object.
+     * @param array $alpha of letters in the alphabet.
+     * @param bool $minirender Return a trimmed down view of the initials bar.
+     * @return string the HTML to output.
+     */
+    public function initials_bar($current, $class, $title, $urlvar, $url, $alpha = null, bool $minirender = false) {
+        $ib = new initials_bar($current, $class, $title, $urlvar, $url, $alpha, $minirender);
+        return $this->render($ib);
+    }
+
+    /**
+     * Internal implementation of initials bar rendering.
+     *
+     * @param initials_bar $initialsbar
+     * @return string
+     */
+    protected function render_initials_bar(initials_bar $initialsbar) {
+        return $this->render_from_template('core/initials_bar', $initialsbar->export_for_template($this));
+    }
+
+    /**
+     * Output the place a skip link goes to.
+     *
+     * @param string $id The target name from the corresponding $PAGE->requires->skip_link_to($target) call.
+     * @return string the HTML to output.
+     */
+    public function skip_link_target($id = null) {
+        return html_writer::span('', '', array('id' => $id));
+    }
+
+    /**
+     * Outputs a heading
+     *
+     * @param string $text The text of the heading
+     * @param int $level The level of importance of the heading. Defaulting to 2
+     * @param string $classes A space-separated list of CSS classes. Defaulting to null
+     * @param string $id An optional ID
+     * @return string the HTML to output.
+     */
+    public function heading($text, $level = 2, $classes = null, $id = null) {
+        $level = (integer) $level;
+        if ($level < 1 or $level > 6) {
+            throw new coding_exception('Heading level must be an integer between 1 and 6.');
+        }
+        return html_writer::tag('h' . $level, $text, array('id' => $id, 'class' => renderer_base::prepare_classes($classes)));
+    }
+
+    /**
+     * Outputs a box.
+     *
+     * @param string $contents The contents of the box
+     * @param string $classes A space-separated list of CSS classes
+     * @param string $id An optional ID
+     * @param array $attributes An array of other attributes to give the box.
+     * @return string the HTML to output.
+     */
+    public function box($contents, $classes = 'generalbox', $id = null, $attributes = array()) {
+        return $this->box_start($classes, $id, $attributes) . $contents . $this->box_end();
+    }
+
+    /**
+     * Outputs the opening section of a box.
+     *
+     * @param string $classes A space-separated list of CSS classes
+     * @param string $id An optional ID
+     * @param array $attributes An array of other attributes to give the box.
+     * @return string the HTML to output.
+     */
+    public function box_start($classes = 'generalbox', $id = null, $attributes = array()) {
+        $this->opencontainers->push('box', html_writer::end_tag('div'));
+        $attributes['id'] = $id;
+        $attributes['class'] = 'box py-3 ' . renderer_base::prepare_classes($classes);
+        return html_writer::start_tag('div', $attributes);
+    }
+
+    /**
+     * Outputs the closing section of a box.
+     *
+     * @return string the HTML to output.
+     */
+    public function box_end() {
+        return $this->opencontainers->pop('box');
+    }
+
+    /**
+     * Outputs a paragraph.
+     *
+     * @param string $contents The contents of the paragraph
+     * @param string|null $classes A space-separated list of CSS classes
+     * @param string|null $id An optional ID
+     * @return string the HTML to output.
+     */
+    public function paragraph(string $contents, ?string $classes = null, ?string $id = null): string {
+        return html_writer::tag(
+            'p',
+            $contents,
+            ['id' => $id, 'class' => renderer_base::prepare_classes($classes)]
+        );
+    }
+
+    /**
+     * Outputs a screen reader only inline text.
+     *
+     * @param string $contents The contents of the paragraph
+     * @return string the HTML to output.
+     */
+    public function sr_text(string $contents): string {
+        return html_writer::tag(
+            'span',
+            $contents,
+            ['class' => 'sr-only']
+        ) . ' ';
+    }
+
+    /**
+     * Outputs a container.
+     *
+     * @param string $contents The contents of the box
+     * @param string $classes A space-separated list of CSS classes
+     * @param string $id An optional ID
+     * @param array $attributes Optional other attributes as array
+     * @return string the HTML to output.
+     */
+    public function container($contents, $classes = null, $id = null, $attributes = []) {
+        return $this->container_start($classes, $id, $attributes) . $contents . $this->container_end();
+    }
+
+    /**
+     * Outputs the opening section of a container.
+     *
+     * @param string $classes A space-separated list of CSS classes
+     * @param string $id An optional ID
+     * @param array $attributes Optional other attributes as array
+     * @return string the HTML to output.
+     */
+    public function container_start($classes = null, $id = null, $attributes = []) {
+        $this->opencontainers->push('container', html_writer::end_tag('div'));
+        $attributes = array_merge(['id' => $id, 'class' => renderer_base::prepare_classes($classes)], $attributes);
+        return html_writer::start_tag('div', $attributes);
+    }
+
+    /**
+     * Outputs the closing section of a container.
+     *
+     * @return string the HTML to output.
+     */
+    public function container_end() {
+        return $this->opencontainers->pop('container');
+    }
+
+    /**
+     * Make nested HTML lists out of the items
+     *
+     * The resulting list will look something like this:
+     *
+     * <pre>
+     * <<ul>>
+     * <<li>><div class='tree_item parent'>(item contents)</div>
+     *      <<ul>
+     *      <<li>><div class='tree_item'>(item contents)</div><</li>>
+     *      <</ul>>
+     * <</li>>
+     * <</ul>>
+     * </pre>
+     *
+     * @param array $items
+     * @param array $attrs html attributes passed to the top ofs the list
+     * @return string HTML
+     */
+    public function tree_block_contents($items, $attrs = array()) {
+        // exit if empty, we don't want an empty ul element
+        if (empty($items)) {
+            return '';
+        }
+        // array of nested li elements
+        $lis = array();
+        foreach ($items as $item) {
+            // this applies to the li item which contains all child lists too
+            $content = $item->content($this);
+            $liclasses = array($item->get_css_type());
+            if (!$item->forceopen || (!$item->forceopen && $item->collapse) || ($item->children->count()==0  && $item->nodetype==navigation_node::NODETYPE_BRANCH)) {
+                $liclasses[] = 'collapsed';
+            }
+            if ($item->isactive === true) {
+                $liclasses[] = 'current_branch';
+            }
+            $liattr = array('class'=>join(' ',$liclasses));
+            // class attribute on the div item which only contains the item content
+            $divclasses = array('tree_item');
+            if ($item->children->count()>0  || $item->nodetype==navigation_node::NODETYPE_BRANCH) {
+                $divclasses[] = 'branch';
+            } else {
+                $divclasses[] = 'leaf';
+            }
+            if (!empty($item->classes) && count($item->classes)>0) {
+                $divclasses[] = join(' ', $item->classes);
+            }
+            $divattr = array('class'=>join(' ', $divclasses));
+            if (!empty($item->id)) {
+                $divattr['id'] = $item->id;
+            }
+            $content = html_writer::tag('p', $content, $divattr) . $this->tree_block_contents($item->children);
+            if (!empty($item->preceedwithhr) && $item->preceedwithhr===true) {
+                $content = html_writer::empty_tag('hr') . $content;
+            }
+            $content = html_writer::tag('li', $content, $liattr);
+            $lis[] = $content;
+        }
+        return html_writer::tag('ul', implode("\n", $lis), $attrs);
+    }
+
+    /**
+     * Returns a search box.
+     *
+     * @param  string $id     The search box wrapper div id, defaults to an autogenerated one.
+     * @return string         HTML with the search form hidden by default.
+     */
+    public function search_box($id = false) {
+        global $CFG;
+
+        // Accessing $CFG directly as using \core_search::is_global_search_enabled would
+        // result in an extra included file for each site, even the ones where global search
+        // is disabled.
+        if (empty($CFG->enableglobalsearch) || !has_capability('moodle/search:query', context_system::instance())) {
+            return '';
+        }
+
+        $data = [
+            'action' => new moodle_url('/search/index.php'),
+            'hiddenfields' => (object) ['name' => 'context', 'value' => $this->page->context->id],
+            'inputname' => 'q',
+            'searchstring' => get_string('search'),
+            ];
+        return $this->render_from_template('core/search_input_navbar', $data);
+    }
+
+    /**
+     * Allow plugins to provide some content to be rendered in the navbar.
+     * The plugin must define a PLUGIN_render_navbar_output function that returns
+     * the HTML they wish to add to the navbar.
+     *
+     * @return string HTML for the navbar
+     */
+    public function navbar_plugin_output() {
+        $output = '';
+
+        // Give subsystems an opportunity to inject extra html content. The callback
+        // must always return a string containing valid html.
+        foreach (\core_component::get_core_subsystems() as $name => $path) {
+            if ($path) {
+                $output .= component_callback($name, 'render_navbar_output', [$this], '');
+            }
+        }
+
+        if ($pluginsfunction = get_plugins_with_function('render_navbar_output')) {
+            foreach ($pluginsfunction as $plugintype => $plugins) {
+                foreach ($plugins as $pluginfunction) {
+                    $output .= $pluginfunction($this);
+                }
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Construct a user menu, returning HTML that can be echoed out by a
+     * layout file.
+     *
+     * @param stdClass $user A user object, usually $USER.
+     * @param bool $withlinks true if a dropdown should be built.
+     * @return string HTML fragment.
+     */
+    public function user_menu($user = null, $withlinks = null) {
+        global $USER, $CFG;
+        require_once($CFG->dirroot . '/user/lib.php');
+
+        if (is_null($user)) {
+            $user = $USER;
+        }
+
+        // Note: this behaviour is intended to match that of core_renderer::login_info,
+        // but should not be considered to be good practice; layout options are
+        // intended to be theme-specific. Please don't copy this snippet anywhere else.
+        if (is_null($withlinks)) {
+            $withlinks = empty($this->page->layout_options['nologinlinks']);
+        }
+
+        // Add a class for when $withlinks is false.
+        $usermenuclasses = 'usermenu';
+        if (!$withlinks) {
+            $usermenuclasses .= ' withoutlinks';
+        }
+
+        $returnstr = "";
+
+        // If during initial install, return the empty return string.
+        if (during_initial_install()) {
+            return $returnstr;
+        }
+
+        $loginpage = $this->is_login_page();
+        $loginurl = get_login_url();
+
+        // Get some navigation opts.
+        $opts = user_get_user_navigation_info($user, $this->page);
+
+        if (!empty($opts->unauthenticateduser)) {
+            $returnstr = get_string($opts->unauthenticateduser['content'], 'moodle');
+            // If not logged in, show the typical not-logged-in string.
+            if (!$loginpage && (!$opts->unauthenticateduser['guest'] || $withlinks)) {
+                $returnstr .= " (<a href=\"$loginurl\">" . get_string('login') . '</a>)';
+            }
+
+            return html_writer::div(
+                html_writer::span(
+                    $returnstr,
+                    'login nav-link'
+                ),
+                $usermenuclasses
+            );
+        }
+
+        $avatarclasses = "avatars";
+        $avatarcontents = html_writer::span($opts->metadata['useravatar'], 'avatar current');
+        $usertextcontents = $opts->metadata['userfullname'];
+
+        // Other user.
+        if (!empty($opts->metadata['asotheruser'])) {
+            $avatarcontents .= html_writer::span(
+                $opts->metadata['realuseravatar'],
+                'avatar realuser'
+            );
+            $usertextcontents = $opts->metadata['realuserfullname'];
+            $usertextcontents .= html_writer::tag(
+                'span',
+                get_string(
+                    'loggedinas',
+                    'moodle',
+                    html_writer::span(
+                        $opts->metadata['userfullname'],
+                        'value'
+                    )
+                ),
+                array('class' => 'meta viewingas')
+            );
+        }
+
+        // Role.
+        if (!empty($opts->metadata['asotherrole'])) {
+            $role = core_text::strtolower(preg_replace('#[ ]+#', '-', trim($opts->metadata['rolename'])));
+            $usertextcontents .= html_writer::span(
+                $opts->metadata['rolename'],
+                'meta role role-' . $role
+            );
+        }
+
+        // User login failures.
+        if (!empty($opts->metadata['userloginfail'])) {
+            $usertextcontents .= html_writer::span(
+                $opts->metadata['userloginfail'],
+                'meta loginfailures'
+            );
+        }
+
+        // MNet.
+        if (!empty($opts->metadata['asmnetuser'])) {
+            $mnet = strtolower(preg_replace('#[ ]+#', '-', trim($opts->metadata['mnetidprovidername'])));
+            $usertextcontents .= html_writer::span(
+                $opts->metadata['mnetidprovidername'],
+                'meta mnet mnet-' . $mnet
+            );
+        }
+
+        $returnstr .= html_writer::span(
+            html_writer::span($usertextcontents, 'usertext mr-1') .
+            html_writer::span($avatarcontents, $avatarclasses),
+            'userbutton'
+        );
+
+        // Create a divider (well, a filler).
+        $divider = new action_menu_filler();
+        $divider->primary = false;
+
+        $am = new action_menu();
+        $am->set_menu_trigger(
+            $returnstr,
+            'nav-link'
+        );
+        $am->set_action_label(get_string('usermenu'));
+        $am->set_nowrap_on_items();
+        if ($withlinks) {
+            $navitemcount = count($opts->navitems);
+            $idx = 0;
+            foreach ($opts->navitems as $key => $value) {
+
+                switch ($value->itemtype) {
+                    case 'divider':
+                        // If the nav item is a divider, add one and skip link processing.
+                        $am->add($divider);
+                        break;
+
+                    case 'invalid':
+                        // Silently skip invalid entries (should we post a notification?).
+                        break;
+
+                    case 'link':
+                        // Process this as a link item.
+                        $pix = null;
+                        if (isset($value->pix) && !empty($value->pix)) {
+                            $pix = new pix_icon($value->pix, '', null, array('class' => 'iconsmall'));
+                        } else if (isset($value->imgsrc) && !empty($value->imgsrc)) {
+                            $value->title = html_writer::img(
+                                $value->imgsrc,
+                                $value->title,
+                                array('class' => 'iconsmall')
+                            ) . $value->title;
+                        }
+
+                        $al = new action_menu_link_secondary(
+                            $value->url,
+                            $pix,
+                            $value->title,
+                            array('class' => 'icon')
+                        );
+                        if (!empty($value->titleidentifier)) {
+                            $al->attributes['data-title'] = $value->titleidentifier;
+                        }
+                        $am->add($al);
+                        break;
+                }
+
+                $idx++;
+
+                // Add dividers after the first item and before the last item.
+                if ($idx == 1 || $idx == $navitemcount - 1) {
+                    $am->add($divider);
+                }
+            }
+        }
+
+        return html_writer::div(
+            $this->render($am),
+            $usermenuclasses
+        );
+    }
+
+    /**
+     * Secure layout login info.
+     *
+     * @return string
+     */
+    public function secure_layout_login_info() {
+        if (get_config('core', 'logininfoinsecurelayout')) {
+            return $this->login_info(false);
+        } else {
+            return '';
+        }
+    }
+
+    /**
+     * Returns the language menu in the secure layout.
+     *
+     * No custom menu items are passed though, such that it will render only the language selection.
+     *
+     * @return string
+     */
+    public function secure_layout_language_menu() {
+        if (get_config('core', 'langmenuinsecurelayout')) {
+            $custommenu = new custom_menu('', current_language());
+            return $this->render_custom_menu($custommenu);
+        } else {
+            return '';
+        }
+    }
+
+    /**
+     * This renders the navbar.
+     * Uses bootstrap compatible html.
+     */
+    public function navbar() {
+        return $this->render_from_template('core/navbar', $this->page->navbar);
+    }
+
+    /**
+     * Renders a breadcrumb navigation node object.
+     *
+     * @param breadcrumb_navigation_node $item The navigation node to render.
+     * @return string HTML fragment
+     */
+    protected function render_breadcrumb_navigation_node(breadcrumb_navigation_node $item) {
+
+        if ($item->action instanceof moodle_url) {
+            $content = $item->get_content();
+            $title = $item->get_title();
+            $attributes = array();
+            $attributes['itemprop'] = 'url';
+            if ($title !== '') {
+                $attributes['title'] = $title;
+            }
+            if ($item->hidden) {
+                $attributes['class'] = 'dimmed_text';
+            }
+            if ($item->is_last()) {
+                $attributes['aria-current'] = 'page';
+            }
+            $content = html_writer::tag('span', $content, array('itemprop' => 'title'));
+            $content = html_writer::link($item->action, $content, $attributes);
+
+            $attributes = array();
+            $attributes['itemscope'] = '';
+            $attributes['itemtype'] = 'http://data-vocabulary.org/Breadcrumb';
+            $content = html_writer::tag('span', $content, $attributes);
+
+        } else {
+            $content = $this->render_navigation_node($item);
+        }
+        return $content;
+    }
+
+    /**
+     * Renders a navigation node object.
+     *
+     * @param navigation_node $item The navigation node to render.
+     * @return string HTML fragment
+     */
+    protected function render_navigation_node(navigation_node $item) {
+        $content = $item->get_content();
+        $title = $item->get_title();
+        if ($item->icon instanceof renderable && !$item->hideicon) {
+            $icon = $this->render($item->icon);
+            $content = $icon.$content; // use CSS for spacing of icons
+        }
+        if ($item->helpbutton !== null) {
+            $content = trim($item->helpbutton).html_writer::tag('span', $content, array('class'=>'clearhelpbutton', 'tabindex'=>'0'));
+        }
+        if ($content === '') {
+            return '';
+        }
+        if ($item->action instanceof action_link) {
+            $link = $item->action;
+            if ($item->hidden) {
+                $link->add_class('dimmed');
+            }
+            if (!empty($content)) {
+                // Providing there is content we will use that for the link content.
+                $link->text = $content;
+            }
+            $content = $this->render($link);
+        } else if ($item->action instanceof moodle_url) {
+            $attributes = array();
+            if ($title !== '') {
+                $attributes['title'] = $title;
+            }
+            if ($item->hidden) {
+                $attributes['class'] = 'dimmed_text';
+            }
+            $content = html_writer::link($item->action, $content, $attributes);
+
+        } else if (is_string($item->action) || empty($item->action)) {
+            $attributes = array('tabindex'=>'0'); //add tab support to span but still maintain character stream sequence.
+            if ($title !== '') {
+                $attributes['title'] = $title;
+            }
+            if ($item->hidden) {
+                $attributes['class'] = 'dimmed_text';
+            }
+            $content = html_writer::tag('span', $content, $attributes);
+        }
+        return $content;
+    }
+
+    /**
+     * Accessibility: Right arrow-like character is
+     * used in the breadcrumb trail, course navigation menu
+     * (previous/next activity), calendar, and search forum block.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically. Please DO NOT
+     * use &lt; &gt; &raquo; - these are confusing for blind users.
+     *
+     * @return string
+     */
+    public function rarrow() {
+        return $this->page->theme->rarrow;
+    }
+
+    /**
+     * Accessibility: Left arrow-like character is
+     * used in the breadcrumb trail, course navigation menu
+     * (previous/next activity), calendar, and search forum block.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically. Please DO NOT
+     * use &lt; &gt; &raquo; - these are confusing for blind users.
+     *
+     * @return string
+     */
+    public function larrow() {
+        return $this->page->theme->larrow;
+    }
+
+    /**
+     * Accessibility: Up arrow-like character is used in
+     * the book heirarchical navigation.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically. Please DO NOT
+     * use ^ - this is confusing for blind users.
+     *
+     * @return string
+     */
+    public function uarrow() {
+        return $this->page->theme->uarrow;
+    }
+
+    /**
+     * Accessibility: Down arrow-like character.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically.
+     *
+     * @return string
+     */
+    public function darrow() {
+        return $this->page->theme->darrow;
+    }
+
+    /**
+     * Returns the custom menu if one has been set
+     *
+     * A custom menu can be configured by browsing to a theme's settings page
+     * and then configuring the custommenu config setting as described.
+     *
+     * Theme developers: DO NOT OVERRIDE! Please override function
+     * {@link core_renderer::render_custom_menu()} instead.
+     *
+     * @param string $custommenuitems - custom menuitems set by theme instead of global theme settings
+     * @return string
+     */
+    public function custom_menu($custommenuitems = '') {
+        global $CFG;
+
+        if (empty($custommenuitems) && !empty($CFG->custommenuitems)) {
+            $custommenuitems = $CFG->custommenuitems;
+        }
+        $custommenu = new custom_menu($custommenuitems, current_language());
+        return $this->render_custom_menu($custommenu);
+    }
+
+    /**
+     * We want to show the custom menus as a list of links in the footer on small screens.
+     * Just return the menu object exported so we can render it differently.
+     */
+    public function custom_menu_flat() {
+        global $CFG;
+        $custommenuitems = '';
+
+        if (empty($custommenuitems) && !empty($CFG->custommenuitems)) {
+            $custommenuitems = $CFG->custommenuitems;
+        }
+        $custommenu = new custom_menu($custommenuitems, current_language());
+        $langs = get_string_manager()->get_list_of_translations();
+        $haslangmenu = $this->lang_menu() != '';
+
+        if ($haslangmenu) {
+            $strlang = get_string('language');
+            $currentlang = current_language();
+            if (isset($langs[$currentlang])) {
+                $currentlang = $langs[$currentlang];
+            } else {
+                $currentlang = $strlang;
+            }
+            $this->language = $custommenu->add($currentlang, new moodle_url('#'), $strlang, 10000);
+            foreach ($langs as $langtype => $langname) {
+                $this->language->add($langname, new moodle_url($this->page->url, array('lang' => $langtype)), $langname);
+            }
+        }
+
+        return $custommenu->export_for_template($this);
+    }
+
+    /**
+     * Renders a custom menu object (located in outputcomponents.php)
+     *
+     * The custom menu this method produces makes use of the YUI3 menunav widget
+     * and requires very specific html elements and classes.
+     *
+     * @staticvar int $menucount
+     * @param custom_menu $menu
+     * @return string
+     */
+    protected function render_custom_menu(custom_menu $menu) {
+        global $CFG;
+
+        $langs = get_string_manager()->get_list_of_translations();
+        $haslangmenu = $this->lang_menu() != '';
+
+        if (!$menu->has_children() && !$haslangmenu) {
+            return '';
+        }
+
+        if ($haslangmenu) {
+            $strlang = get_string('language');
+            $currentlang = current_language();
+            if (isset($langs[$currentlang])) {
+                $currentlangstr = $langs[$currentlang];
+            } else {
+                $currentlangstr = $strlang;
+            }
+            $this->language = $menu->add($currentlangstr, new moodle_url('#'), $strlang, 10000);
+            foreach ($langs as $langtype => $langname) {
+                $attributes = [];
+                // Set the lang attribute for languages different from the page's current language.
+                if ($langtype !== $currentlang) {
+                    $attributes[] = [
+                        'key' => 'lang',
+                        'value' => get_html_lang_attribute_value($langtype),
+                    ];
+                }
+                $this->language->add($langname, new moodle_url($this->page->url, ['lang' => $langtype]), null, null, $attributes);
+            }
+        }
+
+        $content = '';
+        foreach ($menu->get_children() as $item) {
+            $context = $item->export_for_template($this);
+            $content .= $this->render_from_template('core/custom_menu_item', $context);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Renders a custom menu node as part of a submenu
+     *
+     * The custom menu this method produces makes use of the YUI3 menunav widget
+     * and requires very specific html elements and classes.
+     *
+     * @see core:renderer::render_custom_menu()
+     *
+     * @staticvar int $submenucount
+     * @param custom_menu_item $menunode
+     * @return string
+     */
+    protected function render_custom_menu_item(custom_menu_item $menunode) {
+        // Required to ensure we get unique trackable id's
+        static $submenucount = 0;
+        if ($menunode->has_children()) {
+            // If the child has menus render it as a sub menu
+            $submenucount++;
+            $content = html_writer::start_tag('li');
+            if ($menunode->get_url() !== null) {
+                $url = $menunode->get_url();
+            } else {
+                $url = '#cm_submenu_'.$submenucount;
+            }
+            $content .= html_writer::link($url, $menunode->get_text(), array('class'=>'yui3-menu-label', 'title'=>$menunode->get_title()));
+            $content .= html_writer::start_tag('div', array('id'=>'cm_submenu_'.$submenucount, 'class'=>'yui3-menu custom_menu_submenu'));
+            $content .= html_writer::start_tag('div', array('class'=>'yui3-menu-content'));
+            $content .= html_writer::start_tag('ul');
+            foreach ($menunode->get_children() as $menunode) {
+                $content .= $this->render_custom_menu_item($menunode);
+            }
+            $content .= html_writer::end_tag('ul');
+            $content .= html_writer::end_tag('div');
+            $content .= html_writer::end_tag('div');
+            $content .= html_writer::end_tag('li');
+        } else {
+            // The node doesn't have children so produce a final menuitem.
+            // Also, if the node's text matches '####', add a class so we can treat it as a divider.
+            $content = '';
+            if (preg_match("/^#+$/", $menunode->get_text())) {
+
+                // This is a divider.
+                $content = html_writer::start_tag('li', array('class' => 'yui3-menuitem divider'));
+            } else {
+                $content = html_writer::start_tag(
+                    'li',
+                    array(
+                        'class' => 'yui3-menuitem'
+                    )
+                );
+                if ($menunode->get_url() !== null) {
+                    $url = $menunode->get_url();
+                } else {
+                    $url = '#';
+                }
+                $content .= html_writer::link(
+                    $url,
+                    $menunode->get_text(),
+                    array('class' => 'yui3-menuitem-content', 'title' => $menunode->get_title())
+                );
+            }
+            $content .= html_writer::end_tag('li');
+        }
+        // Return the sub menu
+        return $content;
+    }
+
+    /**
+     * Renders theme links for switching between default and other themes.
+     *
+     * @return string
+     */
+    protected function theme_switch_links() {
+
+        $actualdevice = core_useragent::get_device_type();
+        $currentdevice = $this->page->devicetypeinuse;
+        $switched = ($actualdevice != $currentdevice);
+
+        if (!$switched && $currentdevice == 'default' && $actualdevice == 'default') {
+            // The user is using the a default device and hasn't switched so don't shown the switch
+            // device links.
+            return '';
+        }
+
+        if ($switched) {
+            $linktext = get_string('switchdevicerecommended');
+            $devicetype = $actualdevice;
+        } else {
+            $linktext = get_string('switchdevicedefault');
+            $devicetype = 'default';
+        }
+        $linkurl = new moodle_url('/theme/switchdevice.php', array('url' => $this->page->url, 'device' => $devicetype, 'sesskey' => sesskey()));
+
+        $content  = html_writer::start_tag('div', array('id' => 'theme_switch_link'));
+        $content .= html_writer::link($linkurl, $linktext, array('rel' => 'nofollow'));
+        $content .= html_writer::end_tag('div');
+
+        return $content;
+    }
+
+    /**
+     * Renders tabs
+     *
+     * This function replaces print_tabs() used before Moodle 2.5 but with slightly different arguments
+     *
+     * Theme developers: In order to change how tabs are displayed please override functions
+     * {@link core_renderer::render_tabtree()} and/or {@link core_renderer::render_tabobject()}
+     *
+     * @param array $tabs array of tabs, each of them may have it's own ->subtree
+     * @param string|null $selected which tab to mark as selected, all parent tabs will
+     *     automatically be marked as activated
+     * @param array|string|null $inactive list of ids of inactive tabs, regardless of
+     *     their level. Note that you can as weel specify tabobject::$inactive for separate instances
+     * @return string
+     */
+    final public function tabtree($tabs, $selected = null, $inactive = null) {
+        return $this->render(new tabtree($tabs, $selected, $inactive));
+    }
+
+    /**
+     * Renders tabtree
+     *
+     * @param tabtree $tabtree
+     * @return string
+     */
+    protected function render_tabtree(tabtree $tabtree) {
+        if (empty($tabtree->subtree)) {
+            return '';
+        }
+        $data = $tabtree->export_for_template($this);
+        return $this->render_from_template('core/tabtree', $data);
+    }
+
+    /**
+     * Renders tabobject (part of tabtree)
+     *
+     * This function is called from {@link core_renderer::render_tabtree()}
+     * and also it calls itself when printing the $tabobject subtree recursively.
+     *
+     * Property $tabobject->level indicates the number of row of tabs.
+     *
+     * @param tabobject $tabobject
+     * @return string HTML fragment
+     */
+    protected function render_tabobject(tabobject $tabobject) {
+        $str = '';
+
+        // Print name of the current tab.
+        if ($tabobject instanceof tabtree) {
+            // No name for tabtree root.
+        } else if ($tabobject->inactive || $tabobject->activated || ($tabobject->selected && !$tabobject->linkedwhenselected)) {
+            // Tab name without a link. The <a> tag is used for styling.
+            $str .= html_writer::tag('a', html_writer::span($tabobject->text), array('class' => 'nolink moodle-has-zindex'));
+        } else {
+            // Tab name with a link.
+            if (!($tabobject->link instanceof moodle_url)) {
+                // backward compartibility when link was passed as quoted string
+                $str .= "<a href=\"$tabobject->link\" title=\"$tabobject->title\"><span>$tabobject->text</span></a>";
+            } else {
+                $str .= html_writer::link($tabobject->link, html_writer::span($tabobject->text), array('title' => $tabobject->title));
+            }
+        }
+
+        if (empty($tabobject->subtree)) {
+            if ($tabobject->selected) {
+                $str .= html_writer::tag('div', '&nbsp;', array('class' => 'tabrow'. ($tabobject->level + 1). ' empty'));
+            }
+            return $str;
+        }
+
+        // Print subtree.
+        if ($tabobject->level == 0 || $tabobject->selected || $tabobject->activated) {
+            $str .= html_writer::start_tag('ul', array('class' => 'tabrow'. $tabobject->level));
+            $cnt = 0;
+            foreach ($tabobject->subtree as $tab) {
+                $liclass = '';
+                if (!$cnt) {
+                    $liclass .= ' first';
+                }
+                if ($cnt == count($tabobject->subtree) - 1) {
+                    $liclass .= ' last';
+                }
+                if ((empty($tab->subtree)) && (!empty($tab->selected))) {
+                    $liclass .= ' onerow';
+                }
+
+                if ($tab->selected) {
+                    $liclass .= ' here selected';
+                } else if ($tab->activated) {
+                    $liclass .= ' here active';
+                }
+
+                // This will recursively call function render_tabobject() for each item in subtree.
+                $str .= html_writer::tag('li', $this->render($tab), array('class' => trim($liclass)));
+                $cnt++;
+            }
+            $str .= html_writer::end_tag('ul');
+        }
+
+        return $str;
+    }
+
+    /**
+     * Get the HTML for blocks in the given region.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @param string $region The region to get HTML for.
+     * @param array $classes Wrapping tag classes.
+     * @param string $tag Wrapping tag.
+     * @param boolean $fakeblocksonly Include fake blocks only.
+     * @return string HTML.
+     */
+    public function blocks($region, $classes = array(), $tag = 'aside', $fakeblocksonly = false) {
+        $displayregion = $this->page->apply_theme_region_manipulations($region);
+        $classes = (array)$classes;
+        $classes[] = 'block-region';
+        $attributes = array(
+            'id' => 'block-region-'.preg_replace('#[^a-zA-Z0-9_\-]+#', '-', $displayregion),
+            'class' => join(' ', $classes),
+            'data-blockregion' => $displayregion,
+            'data-droptarget' => '1'
+        );
+        if ($this->page->blocks->region_has_content($displayregion, $this)) {
+            $content = html_writer::tag('h2', get_string('blocks'), ['class' => 'sr-only']) .
+                $this->blocks_for_region($displayregion, $fakeblocksonly);
+        } else {
+            $content = html_writer::tag('h2', get_string('blocks'), ['class' => 'sr-only']);
+        }
+        return html_writer::tag($tag, $content, $attributes);
+    }
+
+    /**
+     * Renders a custom block region.
+     *
+     * Use this method if you want to add an additional block region to the content of the page.
+     * Please note this should only be used in special situations.
+     * We want to leave the theme is control where ever possible!
+     *
+     * This method must use the same method that the theme uses within its layout file.
+     * As such it asks the theme what method it is using.
+     * It can be one of two values, blocks or blocks_for_region (deprecated).
+     *
+     * @param string $regionname The name of the custom region to add.
+     * @return string HTML for the block region.
+     */
+    public function custom_block_region($regionname) {
+        if ($this->page->theme->get_block_render_method() === 'blocks') {
+            return $this->blocks($regionname);
+        } else {
+            return $this->blocks_for_region($regionname);
+        }
+    }
+
+    /**
+     * Returns the CSS classes to apply to the body tag.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @param array $additionalclasses Any additional classes to apply.
+     * @return string
+     */
+    public function body_css_classes(array $additionalclasses = array()) {
+        return $this->page->bodyclasses . ' ' . implode(' ', $additionalclasses);
+    }
+
+    /**
+     * The ID attribute to apply to the body tag.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @return string
+     */
+    public function body_id() {
+        return $this->page->bodyid;
+    }
+
+    /**
+     * Returns HTML attributes to use within the body tag. This includes an ID and classes.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @param string|array $additionalclasses Any additional classes to give the body tag,
+     * @return string
+     */
+    public function body_attributes($additionalclasses = array()) {
+        if (!is_array($additionalclasses)) {
+            $additionalclasses = explode(' ', $additionalclasses);
+        }
+        return ' id="'. $this->body_id().'" class="'.$this->body_css_classes($additionalclasses).'"';
+    }
+
+    /**
+     * Gets HTML for the page heading.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @param string $tag The tag to encase the heading in. h1 by default.
+     * @return string HTML.
+     */
+    public function page_heading($tag = 'h1') {
+        return html_writer::tag($tag, $this->page->heading);
+    }
+
+    /**
+     * Gets the HTML for the page heading button.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @return string HTML.
+     */
+    public function page_heading_button() {
+        return $this->page->button;
+    }
+
+    /**
+     * Returns the Moodle docs link to use for this page.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @param string $text
+     * @return string
+     */
+    public function page_doc_link($text = null) {
+        if ($text === null) {
+            $text = get_string('moodledocslink');
+        }
+        $path = page_get_doc_link_path($this->page);
+        if (!$path) {
+            return '';
+        }
+        return $this->doc_link($path, $text);
+    }
+
+    /**
+     * Returns the HTML for the site support email link
+     *
+     * @param array $customattribs Array of custom attributes for the support email anchor tag.
+     * @param bool $embed Set to true if you want to embed the link in other inline content.
+     * @return string The html code for the support email link.
+     */
+    public function supportemail(array $customattribs = [], bool $embed = false): string {
+        global $CFG;
+
+        // Do not provide a link to contact site support if it is unavailable to this user. This would be where the site has
+        // disabled support, or limited it to authenticated users and the current user is a guest or not logged in.
+        if (!isset($CFG->supportavailability) ||
+                $CFG->supportavailability == CONTACT_SUPPORT_DISABLED ||
+                ($CFG->supportavailability == CONTACT_SUPPORT_AUTHENTICATED && (!isloggedin() || isguestuser()))) {
+            return '';
+        }
+
+        $label = get_string('contactsitesupport', 'admin');
+        $icon = $this->pix_icon('t/email', '');
+
+        if (!$embed) {
+            $content = $icon . $label;
+        } else {
+            $content = $label;
+        }
+
+        if (!empty($CFG->supportpage)) {
+            $attributes = ['href' => $CFG->supportpage, 'target' => 'blank'];
+            $content .= $this->pix_icon('i/externallink', '', 'moodle', ['class' => 'ml-1']);
+        } else {
+            $attributes = ['href' => $CFG->wwwroot . '/user/contactsitesupport.php'];
+        }
+
+        $attributes += $customattribs;
+
+        return html_writer::tag('a', $content, $attributes);
+    }
+
+    /**
+     * Returns the services and support link for the help pop-up.
+     *
+     * @return string
+     */
+    public function services_support_link(): string {
+        global $CFG;
+
+        if (during_initial_install() ||
+            (isset($CFG->showservicesandsupportcontent) && $CFG->showservicesandsupportcontent == false) ||
+            !is_siteadmin()) {
+            return '';
+        }
+
+        $liferingicon = $this->pix_icon('t/life-ring', '', 'moodle', ['class' => 'fa fa-life-ring']);
+        $newwindowicon = $this->pix_icon('i/externallink', get_string('opensinnewwindow'), 'moodle', ['class' => 'ml-1']);
+        $link = !empty($CFG->servicespage)
+            ? $CFG->servicespage
+            : 'https://moodle.com/help/?utm_source=CTA-banner&utm_medium=platform&utm_campaign=name~Moodle4+cat~lms+mp~no';
+        $content = $liferingicon . get_string('moodleservicesandsupport') . $newwindowicon;
+
+        return html_writer::tag('a', $content, ['target' => '_blank', 'href' => $link]);
+    }
+
+    /**
+     * Helper function to decide whether to show the help popover header or not.
+     *
+     * @return bool
+     */
+    public function has_popover_links(): bool {
+        return !empty($this->services_support_link()) || !empty($this->page_doc_link()) || !empty($this->supportemail());
+    }
+
+    /**
+     * Helper function to decide whether to show the communication link or not.
+     *
+     * @return bool
+     */
+    public function has_communication_links(): bool {
+        if (during_initial_install() || !core_communication\api::is_available()) {
+            return false;
+        }
+        return !empty($this->communication_link());
+    }
+
+    /**
+     * Returns the communication link, complete with html.
+     *
+     * @return string
+     */
+    public function communication_link(): string {
+        $link = $this->communication_url() ?? '';
+        $commicon = $this->pix_icon('t/messages-o', '', 'moodle', ['class' => 'fa fa-comments']);
+        $newwindowicon = $this->pix_icon('i/externallink', get_string('opensinnewwindow'), 'moodle', ['class' => 'ml-1']);
+        $content = $commicon . get_string('communicationroomlink', 'course') . $newwindowicon;
+        $html = html_writer::tag('a', $content, ['target' => '_blank', 'href' => $link]);
+
+        return !empty($link) ? $html : '';
+    }
+
+    /**
+     * Returns the communication url for a given instance if it exists.
+     *
+     * @return string
+     */
+    public function communication_url(): string {
+        global $COURSE;
+        return \core_communication\helper::get_course_communication_url($COURSE);
+    }
+
+    /**
+     * Returns the page heading menu.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @return string HTML.
+     */
+    public function page_heading_menu() {
+        return $this->page->headingmenu;
+    }
+
+    /**
+     * Returns the title to use on the page.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @return string
+     */
+    public function page_title() {
+        return $this->page->title;
+    }
+
+    /**
+     * Returns the moodle_url for the favicon.
+     *
+     * @since Moodle 2.5.1 2.6
+     * @return moodle_url The moodle_url for the favicon
+     */
+    public function favicon() {
+        $logo = null;
+        if (!during_initial_install()) {
+            $logo = get_config('core_admin', 'favicon');
+        }
+        if (empty($logo)) {
+            return $this->image_url('favicon', 'theme');
+        }
+
+        // Use $CFG->themerev to prevent browser caching when the file changes.
+        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'favicon', '64x64/',
+            theme_get_revision(), $logo);
+    }
+
+    /**
+     * Renders preferences groups.
+     *
+     * @param  preferences_groups $renderable The renderable
+     * @return string The output.
+     */
+    public function render_preferences_groups(preferences_groups $renderable) {
+        return $this->render_from_template('core/preferences_groups', $renderable);
+    }
+
+    /**
+     * Renders preferences group.
+     *
+     * @param  preferences_group $renderable The renderable
+     * @return string The output.
+     */
+    public function render_preferences_group(preferences_group $renderable) {
+        $html = '';
+        $html .= html_writer::start_tag('div', array('class' => 'col-sm-4 preferences-group'));
+        $html .= $this->heading($renderable->title, 3);
+        $html .= html_writer::start_tag('ul');
+        foreach ($renderable->nodes as $node) {
+            if ($node->has_children()) {
+                debugging('Preferences nodes do not support children', DEBUG_DEVELOPER);
+            }
+            $html .= html_writer::tag('li', $this->render($node));
+        }
+        $html .= html_writer::end_tag('ul');
+        $html .= html_writer::end_tag('div');
+        return $html;
+    }
+
+    public function context_header($headerinfo = null, $headinglevel = 1) {
+        global $DB, $USER, $CFG, $SITE;
+        require_once($CFG->dirroot . '/user/lib.php');
+        $context = $this->page->context;
+        $heading = null;
+        $imagedata = null;
+        $subheader = null;
+        $userbuttons = null;
+
+        // Make sure to use the heading if it has been set.
+        if (isset($headerinfo['heading'])) {
+            $heading = $headerinfo['heading'];
+        } else {
+            $heading = $this->page->heading;
+        }
+
+        // The user context currently has images and buttons. Other contexts may follow.
+        if ((isset($headerinfo['user']) || $context->contextlevel == CONTEXT_USER) && $this->page->pagetype !== 'my-index') {
+            if (isset($headerinfo['user'])) {
+                $user = $headerinfo['user'];
+            } else {
+                // Look up the user information if it is not supplied.
+                $user = $DB->get_record('user', array('id' => $context->instanceid));
+            }
+
+            // If the user context is set, then use that for capability checks.
+            if (isset($headerinfo['usercontext'])) {
+                $context = $headerinfo['usercontext'];
+            }
+
+            // Only provide user information if the user is the current user, or a user which the current user can view.
+            // When checking user_can_view_profile(), either:
+            // If the page context is course, check the course context (from the page object) or;
+            // If page context is NOT course, then check across all courses.
+            $course = ($this->page->context->contextlevel == CONTEXT_COURSE) ? $this->page->course : null;
+
+            if (user_can_view_profile($user, $course)) {
+                // Use the user's full name if the heading isn't set.
+                if (empty($heading)) {
+                    $heading = fullname($user);
+                }
+
+                $imagedata = $this->user_picture($user, array('size' => 100));
+
+                // Check to see if we should be displaying a message button.
+                if (!empty($CFG->messaging) && has_capability('moodle/site:sendmessage', $context)) {
+                    $userbuttons = array(
+                        'messages' => array(
+                            'buttontype' => 'message',
+                            'title' => get_string('message', 'message'),
+                            'url' => new moodle_url('/message/index.php', array('id' => $user->id)),
+                            'image' => 'message',
+                            'linkattributes' => \core_message\helper::messageuser_link_params($user->id),
+                            'page' => $this->page
+                        )
+                    );
+
+                    if ($USER->id != $user->id) {
+                        $iscontact = \core_message\api::is_contact($USER->id, $user->id);
+                        $isrequested = \core_message\api::get_contact_requests_between_users($USER->id, $user->id);
+                        $contacturlaction = '';
+                        $linkattributes = \core_message\helper::togglecontact_link_params(
+                            $user,
+                            $iscontact,
+                            true,
+                            !empty($isrequested),
+                        );
+                        // If the user is not a contact.
+                        if (!$iscontact) {
+                            if ($isrequested) {
+                                // We just need the first request.
+                                $requests = array_shift($isrequested);
+                                if ($requests->userid == $USER->id) {
+                                    // If the user has requested to be a contact.
+                                    $contacttitle = 'contactrequestsent';
+                                } else {
+                                    // If the user has been requested to be a contact.
+                                    $contacttitle = 'waitingforcontactaccept';
+                                }
+                                $linkattributes = array_merge($linkattributes, [
+                                    'class' => 'disabled',
+                                    'tabindex' => '-1',
+                                ]);
+                            } else {
+                                // If the user is not a contact and has not requested to be a contact.
+                                $contacttitle = 'addtoyourcontacts';
+                                $contacturlaction = 'addcontact';
+                            }
+                            $contactimage = 'addcontact';
+                        } else {
+                            // If the user is a contact.
+                            $contacttitle = 'removefromyourcontacts';
+                            $contacturlaction = 'removecontact';
+                            $contactimage = 'removecontact';
+                        }
+                        $userbuttons['togglecontact'] = array(
+                                'buttontype' => 'togglecontact',
+                                'title' => get_string($contacttitle, 'message'),
+                                'url' => new moodle_url('/message/index.php', array(
+                                        'user1' => $USER->id,
+                                        'user2' => $user->id,
+                                        $contacturlaction => $user->id,
+                                        'sesskey' => sesskey())
+                                ),
+                                'image' => $contactimage,
+                                'linkattributes' => $linkattributes,
+                                'page' => $this->page
+                            );
+                    }
+                }
+            } else {
+                $heading = null;
+            }
+        }
+
+        // Return the heading wrapped in an sr-only element so it is only visible to screen-readers for nocontextheader layouts.
+        if (!empty($this->page->layout_options['nocontextheader'])) {
+            return html_writer::div($heading, 'sr-only');
+        }
+
+        $contextheader = new context_header($heading, $headinglevel, $imagedata, $userbuttons);
+        return $this->render($contextheader);
+    }
+
+    /**
+     * Renders the skip links for the page.
+     *
+     * @param array $links List of skip links.
+     * @return string HTML for the skip links.
+     */
+    public function render_skip_links($links) {
+        $context = [ 'links' => []];
+
+        foreach ($links as $url => $text) {
+            $context['links'][] = [ 'url' => $url, 'text' => $text];
+        }
+
+        return $this->render_from_template('core/skip_links', $context);
+    }
+
+    /**
+     * Wrapper for header elements.
+     *
+     * @return string HTML to display the main header.
+     */
+    public function full_header() {
+        $pagetype = $this->page->pagetype;
+        $homepage = get_home_page();
+        $homepagetype = null;
+        // Add a special case since /my/courses is a part of the /my subsystem.
+        if ($homepage == HOMEPAGE_MY || $homepage == HOMEPAGE_MYCOURSES) {
+            $homepagetype = 'my-index';
+        } else if ($homepage == HOMEPAGE_SITE) {
+            $homepagetype = 'site-index';
+        }
+        if ($this->page->include_region_main_settings_in_header_actions() &&
+                !$this->page->blocks->is_block_present('settings')) {
+            // Only include the region main settings if the page has requested it and it doesn't already have
+            // the settings block on it. The region main settings are included in the settings block and
+            // duplicating the content causes behat failures.
+            $this->page->add_header_action(html_writer::div(
+                $this->region_main_settings_menu(),
+                'd-print-none',
+                ['id' => 'region-main-settings-menu']
+            ));
+        }
+
+        $header = new stdClass();
+        $header->settingsmenu = $this->context_header_settings_menu();
+        $header->contextheader = $this->context_header();
+        $header->hasnavbar = empty($this->page->layout_options['nonavbar']);
+        $header->navbar = $this->navbar();
+        $header->pageheadingbutton = $this->page_heading_button();
+        $header->courseheader = $this->course_header();
+        $header->headeractions = $this->page->get_header_actions();
+        if (!empty($pagetype) && !empty($homepagetype) && $pagetype == $homepagetype) {
+            $header->welcomemessage = \core_user::welcome_message();
+        }
+        return $this->render_from_template('core/full_header', $header);
+    }
+
+    /**
+     * This is an optional menu that can be added to a layout by a theme. It contains the
+     * menu for the course administration, only on the course main page.
+     *
+     * @return string
+     */
+    public function context_header_settings_menu() {
+        $context = $this->page->context;
+        $menu = new action_menu();
+
+        $items = $this->page->navbar->get_items();
+        $currentnode = end($items);
+
+        $showcoursemenu = false;
+        $showfrontpagemenu = false;
+        $showusermenu = false;
+
+        // We are on the course home page.
+        if (($context->contextlevel == CONTEXT_COURSE) &&
+                !empty($currentnode) &&
+                ($currentnode->type == navigation_node::TYPE_COURSE || $currentnode->type == navigation_node::TYPE_SECTION)) {
+            $showcoursemenu = true;
+        }
+
+        $courseformat = course_get_format($this->page->course);
+        // This is a single activity course format, always show the course menu on the activity main page.
+        if ($context->contextlevel == CONTEXT_MODULE &&
+                !$courseformat->has_view_page()) {
+
+            $this->page->navigation->initialise();
+            $activenode = $this->page->navigation->find_active_node();
+            // If the settings menu has been forced then show the menu.
+            if ($this->page->is_settings_menu_forced()) {
+                $showcoursemenu = true;
+            } else if (!empty($activenode) && ($activenode->type == navigation_node::TYPE_ACTIVITY ||
+                            $activenode->type == navigation_node::TYPE_RESOURCE)) {
+
+                // We only want to show the menu on the first page of the activity. This means
+                // the breadcrumb has no additional nodes.
+                if ($currentnode && ($currentnode->key == $activenode->key && $currentnode->type == $activenode->type)) {
+                    $showcoursemenu = true;
+                }
+            }
+        }
+
+        // This is the site front page.
+        if ($context->contextlevel == CONTEXT_COURSE &&
+                !empty($currentnode) &&
+                $currentnode->key === 'home') {
+            $showfrontpagemenu = true;
+        }
+
+        // This is the user profile page.
+        if ($context->contextlevel == CONTEXT_USER &&
+                !empty($currentnode) &&
+                ($currentnode->key === 'myprofile')) {
+            $showusermenu = true;
+        }
+
+        if ($showfrontpagemenu) {
+            $settingsnode = $this->page->settingsnav->find('frontpage', navigation_node::TYPE_SETTING);
+            if ($settingsnode) {
+                // Build an action menu based on the visible nodes from this navigation tree.
+                $skipped = $this->build_action_menu_from_navigation($menu, $settingsnode, false, true);
+
+                // We only add a list to the full settings menu if we didn't include every node in the short menu.
+                if ($skipped) {
+                    $text = get_string('morenavigationlinks');
+                    $url = new moodle_url('/course/admin.php', array('courseid' => $this->page->course->id));
+                    $link = new action_link($url, $text, null, null, new pix_icon('t/edit', $text));
+                    $menu->add_secondary_action($link);
+                }
+            }
+        } else if ($showcoursemenu) {
+            $settingsnode = $this->page->settingsnav->find('courseadmin', navigation_node::TYPE_COURSE);
+            if ($settingsnode) {
+                // Build an action menu based on the visible nodes from this navigation tree.
+                $skipped = $this->build_action_menu_from_navigation($menu, $settingsnode, false, true);
+
+                // We only add a list to the full settings menu if we didn't include every node in the short menu.
+                if ($skipped) {
+                    $text = get_string('morenavigationlinks');
+                    $url = new moodle_url('/course/admin.php', array('courseid' => $this->page->course->id));
+                    $link = new action_link($url, $text, null, null, new pix_icon('t/edit', $text));
+                    $menu->add_secondary_action($link);
+                }
+            }
+        } else if ($showusermenu) {
+            // Get the course admin node from the settings navigation.
+            $settingsnode = $this->page->settingsnav->find('useraccount', navigation_node::TYPE_CONTAINER);
+            if ($settingsnode) {
+                // Build an action menu based on the visible nodes from this navigation tree.
+                $this->build_action_menu_from_navigation($menu, $settingsnode);
+            }
+        }
+
+        return $this->render($menu);
+    }
+
+    /**
+     * Take a node in the nav tree and make an action menu out of it.
+     * The links are injected in the action menu.
+     *
+     * @param action_menu $menu
+     * @param navigation_node $node
+     * @param boolean $indent
+     * @param boolean $onlytopleafnodes
+     * @return boolean nodesskipped - True if nodes were skipped in building the menu
+     */
+    protected function build_action_menu_from_navigation(action_menu $menu,
+            navigation_node $node,
+            $indent = false,
+            $onlytopleafnodes = false) {
+        $skipped = false;
+        // Build an action menu based on the visible nodes from this navigation tree.
+        foreach ($node->children as $menuitem) {
+            if ($menuitem->display) {
+                if ($onlytopleafnodes && $menuitem->children->count()) {
+                    $skipped = true;
+                    continue;
+                }
+                if ($menuitem->action) {
+                    if ($menuitem->action instanceof action_link) {
+                        $link = $menuitem->action;
+                        // Give preference to setting icon over action icon.
+                        if (!empty($menuitem->icon)) {
+                            $link->icon = $menuitem->icon;
+                        }
+                    } else {
+                        $link = new action_link($menuitem->action, $menuitem->text, null, null, $menuitem->icon);
+                    }
+                } else {
+                    if ($onlytopleafnodes) {
+                        $skipped = true;
+                        continue;
+                    }
+                    $link = new action_link(new moodle_url('#'), $menuitem->text, null, ['disabled' => true], $menuitem->icon);
+                }
+                if ($indent) {
+                    $link->add_class('ml-4');
+                }
+                if (!empty($menuitem->classes)) {
+                    $link->add_class(implode(" ", $menuitem->classes));
+                }
+
+                $menu->add_secondary_action($link);
+                $skipped = $skipped || $this->build_action_menu_from_navigation($menu, $menuitem, true);
+            }
+        }
+        return $skipped;
+    }
+
+    /**
+     * This is an optional menu that can be added to a layout by a theme. It contains the
+     * menu for the most specific thing from the settings block. E.g. Module administration.
+     *
+     * @return string
+     */
+    public function region_main_settings_menu() {
+        $context = $this->page->context;
+        $menu = new action_menu();
+
+        if ($context->contextlevel == CONTEXT_MODULE) {
+
+            $this->page->navigation->initialise();
+            $node = $this->page->navigation->find_active_node();
+            $buildmenu = false;
+            // If the settings menu has been forced then show the menu.
+            if ($this->page->is_settings_menu_forced()) {
+                $buildmenu = true;
+            } else if (!empty($node) && ($node->type == navigation_node::TYPE_ACTIVITY ||
+                            $node->type == navigation_node::TYPE_RESOURCE)) {
+
+                $items = $this->page->navbar->get_items();
+                $navbarnode = end($items);
+                // We only want to show the menu on the first page of the activity. This means
+                // the breadcrumb has no additional nodes.
+                if ($navbarnode && ($navbarnode->key === $node->key && $navbarnode->type == $node->type)) {
+                    $buildmenu = true;
+                }
+            }
+            if ($buildmenu) {
+                // Get the course admin node from the settings navigation.
+                $node = $this->page->settingsnav->find('modulesettings', navigation_node::TYPE_SETTING);
+                if ($node) {
+                    // Build an action menu based on the visible nodes from this navigation tree.
+                    $this->build_action_menu_from_navigation($menu, $node);
+                }
+            }
+
+        } else if ($context->contextlevel == CONTEXT_COURSECAT) {
+            // For course category context, show category settings menu, if we're on the course category page.
+            if ($this->page->pagetype === 'course-index-category') {
+                $node = $this->page->settingsnav->find('categorysettings', navigation_node::TYPE_CONTAINER);
+                if ($node) {
+                    // Build an action menu based on the visible nodes from this navigation tree.
+                    $this->build_action_menu_from_navigation($menu, $node);
+                }
+            }
+
+        } else {
+            $items = $this->page->navbar->get_items();
+            $navbarnode = end($items);
+
+            if ($navbarnode && ($navbarnode->key === 'participants')) {
+                $node = $this->page->settingsnav->find('users', navigation_node::TYPE_CONTAINER);
+                if ($node) {
+                    // Build an action menu based on the visible nodes from this navigation tree.
+                    $this->build_action_menu_from_navigation($menu, $node);
+                }
+
+            }
+        }
+        return $this->render($menu);
+    }
+
+    /**
+     * Displays the list of tags associated with an entry
+     *
+     * @param array $tags list of instances of core_tag or stdClass
+     * @param string $label label to display in front, by default 'Tags' (get_string('tags')), set to null
+     *               to use default, set to '' (empty string) to omit the label completely
+     * @param string $classes additional classes for the enclosing div element
+     * @param int $limit limit the number of tags to display, if size of $tags is more than this limit the "more" link
+     *               will be appended to the end, JS will toggle the rest of the tags
+     * @param context $pagecontext specify if needed to overwrite the current page context for the view tag link
+     * @param bool $accesshidelabel if true, the label should have class="accesshide" added.
+     * @return string
+     */
+    public function tag_list($tags, $label = null, $classes = '', $limit = 10,
+            $pagecontext = null, $accesshidelabel = false) {
+        $list = new \core_tag\output\taglist($tags, $label, $classes, $limit, $pagecontext, $accesshidelabel);
+        return $this->render_from_template('core_tag/taglist', $list->export_for_template($this));
+    }
+
+    /**
+     * Renders element for inline editing of any value
+     *
+     * @param \core\output\inplace_editable $element
+     * @return string
+     */
+    public function render_inplace_editable(\core\output\inplace_editable $element) {
+        return $this->render_from_template('core/inplace_editable', $element->export_for_template($this));
+    }
+
+    /**
+     * Renders a bar chart.
+     *
+     * @param \core\chart_bar $chart The chart.
+     * @return string
+     */
+    public function render_chart_bar(\core\chart_bar $chart) {
+        return $this->render_chart($chart);
+    }
+
+    /**
+     * Renders a line chart.
+     *
+     * @param \core\chart_line $chart The chart.
+     * @return string
+     */
+    public function render_chart_line(\core\chart_line $chart) {
+        return $this->render_chart($chart);
+    }
+
+    /**
+     * Renders a pie chart.
+     *
+     * @param \core\chart_pie $chart The chart.
+     * @return string
+     */
+    public function render_chart_pie(\core\chart_pie $chart) {
+        return $this->render_chart($chart);
+    }
+
+    /**
+     * Renders a chart.
+     *
+     * @param \core\chart_base $chart The chart.
+     * @param bool $withtable Whether to include a data table with the chart.
+     * @return string
+     */
+    public function render_chart(\core\chart_base $chart, $withtable = true) {
+        $chartdata = json_encode($chart);
+        return $this->render_from_template('core/chart', (object) [
+            'chartdata' => $chartdata,
+            'withtable' => $withtable
+        ]);
+    }
+
+    /**
+     * Renders the login form.
+     *
+     * @param \core_auth\output\login $form The renderable.
+     * @return string
+     */
+    public function render_login(\core_auth\output\login $form) {
+        global $CFG, $SITE;
+
+        $context = $form->export_for_template($this);
+
+        $context->errorformatted = $this->error_text($context->error);
+        $url = $this->get_logo_url();
+        if ($url) {
+            $url = $url->out(false);
+        }
+        $context->logourl = $url;
+        $context->sitename = format_string($SITE->fullname, true,
+                ['context' => context_course::instance(SITEID), "escape" => false]);
+
+        return $this->render_from_template('core/loginform', $context);
+    }
+
+    /**
+     * Renders an mform element from a template.
+     *
+     * @param HTML_QuickForm_element $element element
+     * @param bool $required if input is required field
+     * @param bool $advanced if input is an advanced field
+     * @param string $error error message to display
+     * @param bool $ingroup True if this element is rendered as part of a group
+     * @return mixed string|bool
+     */
+    public function mform_element($element, $required, $advanced, $error, $ingroup) {
+        $templatename = 'core_form/element-' . $element->getType();
+        if ($ingroup) {
+            $templatename .= "-inline";
+        }
+        try {
+            // We call this to generate a file not found exception if there is no template.
+            // We don't want to call export_for_template if there is no template.
+            core\output\mustache_template_finder::get_template_filepath($templatename);
+
+            if ($element instanceof templatable) {
+                $elementcontext = $element->export_for_template($this);
+
+                $helpbutton = '';
+                if (method_exists($element, 'getHelpButton')) {
+                    $helpbutton = $element->getHelpButton();
+                }
+                $label = $element->getLabel();
+                $text = '';
+                if (method_exists($element, 'getText')) {
+                    // There currently exists code that adds a form element with an empty label.
+                    // If this is the case then set the label to the description.
+                    if (empty($label)) {
+                        $label = $element->getText();
+                    } else {
+                        $text = $element->getText();
+                    }
+                }
+
+                // Generate the form element wrapper ids and names to pass to the template.
+                // This differs between group and non-group elements.
+                if ($element->getType() === 'group') {
+                    // Group element.
+                    // The id will be something like 'fgroup_id_NAME'. E.g. fgroup_id_mygroup.
+                    $elementcontext['wrapperid'] = $elementcontext['id'];
+
+                    // Ensure group elements pass through the group name as the element name.
+                    $elementcontext['name'] = $elementcontext['groupname'];
+                } else {
+                    // Non grouped element.
+                    // Creates an id like 'fitem_id_NAME'. E.g. fitem_id_mytextelement.
+                    $elementcontext['wrapperid'] = 'fitem_' . $elementcontext['id'];
+                }
+
+                $context = array(
+                    'element' => $elementcontext,
+                    'label' => $label,
+                    'text' => $text,
+                    'required' => $required,
+                    'advanced' => $advanced,
+                    'helpbutton' => $helpbutton,
+                    'error' => $error
+                );
+                return $this->render_from_template($templatename, $context);
+            }
+        } catch (Exception $e) {
+            // No template for this element.
+            return false;
+        }
+    }
+
+    /**
+     * Render the login signup form into a nice template for the theme.
+     *
+     * @param moodleform $form
+     * @return string
+     */
+    public function render_login_signup_form($form) {
+        global $SITE;
+
+        $context = $form->export_for_template($this);
+        $url = $this->get_logo_url();
+        if ($url) {
+            $url = $url->out(false);
+        }
+        $context['logourl'] = $url;
+        $context['sitename'] = format_string($SITE->fullname, true,
+                ['context' => context_course::instance(SITEID), "escape" => false]);
+
+        return $this->render_from_template('core/signup_form_layout', $context);
+    }
+
+    /**
+     * Render the verify age and location page into a nice template for the theme.
+     *
+     * @param \core_auth\output\verify_age_location_page $page The renderable
+     * @return string
+     */
+    protected function render_verify_age_location_page($page) {
+        $context = $page->export_for_template($this);
+
+        return $this->render_from_template('core/auth_verify_age_location_page', $context);
+    }
+
+    /**
+     * Render the digital minor contact information page into a nice template for the theme.
+     *
+     * @param \core_auth\output\digital_minor_page $page The renderable
+     * @return string
+     */
+    protected function render_digital_minor_page($page) {
+        $context = $page->export_for_template($this);
+
+        return $this->render_from_template('core/auth_digital_minor_page', $context);
+    }
+
+    /**
+     * Renders a progress bar.
+     *
+     * Do not use $OUTPUT->render($bar), instead use progress_bar::create().
+     *
+     * @param  progress_bar $bar The bar.
+     * @return string HTML fragment
+     */
+    public function render_progress_bar(progress_bar $bar) {
+        $data = $bar->export_for_template($this);
+        return $this->render_from_template('core/progress_bar', $data);
+    }
+
+    /**
+     * Renders an update to a progress bar.
+     *
+     * Note: This does not cleanly map to a renderable class and should
+     * never be used directly.
+     *
+     * @param  string $id
+     * @param  float $percent
+     * @param  string $msg Message
+     * @param  string $estimate time remaining message
+     * @return string ascii fragment
+     */
+    public function render_progress_bar_update(string $id, float $percent, string $msg, string $estimate): string {
+        return html_writer::script(js_writer::function_call('updateProgressBar', [
+            $id,
+            round($percent, 1),
+            $msg,
+            $estimate,
+        ]));
+    }
+
+    /**
+     * Renders element for a toggle-all checkbox.
+     *
+     * @param \core\output\checkbox_toggleall $element
+     * @return string
+     */
+    public function render_checkbox_toggleall(\core\output\checkbox_toggleall $element) {
+        return $this->render_from_template($element->get_template(), $element->export_for_template($this));
+    }
+
+    /**
+     * Renders the tertiary nav for the participants page
+     *
+     * @param object $course The course we are operating within
+     * @param string|null $renderedbuttons Any additional buttons/content to be displayed in line with the nav
+     * @return string
+     */
+    public function render_participants_tertiary_nav(object $course, ?string $renderedbuttons = null) {
+        $actionbar = new \core\output\participants_action_bar($course, $this->page, $renderedbuttons);
+        $content = $this->render_from_template('core_course/participants_actionbar', $actionbar->export_for_template($this));
+        return $content ?: "";
+    }
+
+    /**
+     * Renders release information in the footer popup
+     * @return ?string Moodle release info.
+     */
+    public function moodle_release() {
+        global $CFG;
+        if (!during_initial_install() && is_siteadmin()) {
+            return $CFG->release;
+        }
+    }
+
+    /**
+     * Generate the add block button when editing mode is turned on and the user can edit blocks.
+     *
+     * @param string $region where new blocks should be added.
+     * @return string html for the add block button.
+     */
+    public function addblockbutton($region = ''): string {
+        $addblockbutton = '';
+        $regions = $this->page->blocks->get_regions();
+        if (count($regions) == 0) {
+            return '';
+        }
+        if (isset($this->page->theme->addblockposition) &&
+                $this->page->user_is_editing() &&
+                $this->page->user_can_edit_blocks() &&
+                $this->page->pagelayout !== 'mycourses'
+        ) {
+            $params = ['bui_addblock' => '', 'sesskey' => sesskey()];
+            if (!empty($region)) {
+                $params['bui_blockregion'] = $region;
+            }
+            $url = new moodle_url($this->page->url, $params);
+            $addblockbutton = $this->render_from_template('core/add_block_button',
+                [
+                    'link' => $url->out(false),
+                    'escapedlink' => "?{$url->get_query_string(false)}",
+                    'pagehash' => $this->page->get_edited_page_hash(),
+                    'blockregion' => $region,
+                    // The following parameters are not used since Moodle 4.2 but are
+                    // still passed for backward-compatibility.
+                    'pageType' => $this->page->pagetype,
+                    'pageLayout' => $this->page->pagelayout,
+                    'subPage' => $this->page->subpage,
+                ]
+            );
+        }
+        return $addblockbutton;
+    }
+
+    /**
+     * Prepares an element for streaming output
+     *
+     * This must be used with NO_OUTPUT_BUFFERING set to true. After using this method
+     * any subsequent prints or echos to STDOUT result in the outputted content magically
+     * being appended inside that element rather than where the current html would be
+     * normally. This enables pages which take some time to render incremental content to
+     * first output a fully formed html page, including the footer, and to then stream
+     * into an element such as the main content div. This fixes a class of page layout
+     * bugs and reduces layout shift issues and was inspired by Facebook BigPipe.
+     *
+     * Some use cases such as a simple page which loads content via ajax could be swapped
+     * to this method wich saves another http request and its network latency resulting
+     * in both lower server load and better front end performance.
+     *
+     * You should consider giving the element you stream into a minimum height to further
+     * reduce layout shift as the content initally streams into the element.
+     *
+     * You can safely finish the output without closing the streamed element. You can also
+     * call this method again to swap the target of the streaming to a new element as
+     * often as you want.
+
+     * https://www.youtube.com/watch?v=LLRig4s1_yA&t=1022s
+     * Watch this video segment to explain how and why this 'One Weird Trick' works.
+     *
+     * @param string $selector where new content should be appended
+     * @param string $element which contains the streamed content
+     * @return string html to be written
+     */
+    public function select_element_for_append(string $selector = '#region-main [role=main]', string $element = 'div') {
+
+        if (!CLI_SCRIPT && !NO_OUTPUT_BUFFERING) {
+            throw new coding_exception('select_element_for_append used in a non-CLI script without setting NO_OUTPUT_BUFFERING.',
+                DEBUG_DEVELOPER);
+        }
+
+        // We are already streaming into this element so don't change anything.
+        if ($this->currentselector === $selector && $this->currentelement === $element) {
+            return;
+        }
+
+        // If we have a streaming element close it before starting a new one.
+        $html = $this->close_element_for_append();
+
+        $this->currentselector = $selector;
+        $this->currentelement = $element;
+
+        // Create an unclosed element for the streamed content to append into.
+        $id = uniqid();
+        $html .= html_writer::start_tag($element, ['id' => $id]);
+        $html .= html_writer::tag('script', "document.querySelector('$selector').append(document.getElementById('$id'))");
+        $html .= "\n";
+        return $html;
+    }
+
+    /**
+     * This closes any opened stream elements
+     *
+     * @return string html to be written
+     */
+    public function close_element_for_append() {
+        $html = '';
+        if ($this->currentselector !== '') {
+            $html .= html_writer::end_tag($this->currentelement);
+            $html .= "\n";
+            $this->currentelement = '';
+        }
+        return $html;
+    }
+
+    /**
+     * A companion method to select_element_for_append
+     *
+     * This must be used with NO_OUTPUT_BUFFERING set to true.
+     *
+     * This is similar but instead of appending into the element it replaces
+     * the content in the element. Depending on the 3rd argument it can replace
+     * the innerHTML or the outerHTML which can be useful to completely remove
+     * the element if needed.
+     *
+     * @param string $selector where new content should be replaced
+     * @param string $html A chunk of well formed html
+     * @param bool $outer Wether it replaces the innerHTML or the outerHTML
+     * @return string html to be written
+     */
+    public function select_element_for_replace(string $selector, string $html, bool $outer = false) {
+
+        if (!CLI_SCRIPT && !NO_OUTPUT_BUFFERING) {
+            throw new coding_exception('select_element_for_replace used in a non-CLI script without setting NO_OUTPUT_BUFFERING.',
+                DEBUG_DEVELOPER);
+        }
+
+        // Escape html for use inside a javascript string.
+        $html = addslashes_js($html);
+        $property = $outer ? 'outerHTML' : 'innerHTML';
+        $output = html_writer::tag('script', "document.querySelector('$selector').$property = '$html';");
+        $output .= "\n";
+        return $output;
+    }
+}
diff --git a/lib/classes/output/core_renderer_ajax.php b/lib/classes/output/core_renderer_ajax.php
new file mode 100644
index 00000000000..61e0ac12912
--- /dev/null
+++ b/lib/classes/output/core_renderer_ajax.php
@@ -0,0 +1,134 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * A renderer that generates output for ajax scripts.
+ *
+ * This renderer prevents accidental sends back only json
+ * encoded error messages, all other output is ignored.
+ *
+ * @copyright 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class core_renderer_ajax extends core_renderer {
+
+    /**
+     * Returns a template fragment representing a fatal error.
+     *
+     * @param string $message The message to output
+     * @param string $moreinfourl URL where more info can be found about the error
+     * @param string $link Link for the Continue button
+     * @param array $backtrace The execution backtrace
+     * @param string $debuginfo Debugging information
+     * @return string A template fragment for a fatal error
+     */
+    public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null, $errorcode = "") {
+        global $CFG;
+
+        $this->page->set_context(null); // ugly hack - make sure page context is set to something, we do not want bogus warnings here
+
+        $e = new stdClass();
+        $e->error      = $message;
+        $e->errorcode  = $errorcode;
+        $e->stacktrace = NULL;
+        $e->debuginfo  = NULL;
+        $e->reproductionlink = NULL;
+        if (!empty($CFG->debug) and $CFG->debug >= DEBUG_DEVELOPER) {
+            $link = (string) $link;
+            if ($link) {
+                $e->reproductionlink = $link;
+            }
+            if (!empty($debuginfo)) {
+                $e->debuginfo = $debuginfo;
+            }
+            if (!empty($backtrace)) {
+                $e->stacktrace = format_backtrace($backtrace, true);
+            }
+        }
+        $this->header();
+        return json_encode($e);
+    }
+
+    /**
+     * Used to display a notification.
+     * For the AJAX notifications are discarded.
+     *
+     * @param string $message The message to print out.
+     * @param string $type    The type of notification. See constants on \core\output\notification.
+     * @param bool $closebutton Whether to show a close icon to remove the notification (default true).
+     */
+    public function notification($message, $type = null, $closebutton = true) {
+    }
+
+    /**
+     * Used to display a redirection message.
+     * AJAX redirections should not occur and as such redirection messages
+     * are discarded.
+     *
+     * @param moodle_url|string $encodedurl
+     * @param string $message
+     * @param int $delay
+     * @param bool $debugdisableredirect
+     * @param string $messagetype The type of notification to show the message in.
+     *         See constants on \core\output\notification.
+     */
+    public function redirect_message($encodedurl, $message, $delay, $debugdisableredirect,
+                                     $messagetype = \core\output\notification::NOTIFY_INFO) {}
+
+    /**
+     * Prepares the start of an AJAX output.
+     */
+    public function header() {
+        // unfortunately YUI iframe upload does not support application/json
+        if (!empty($_FILES)) {
+            @header('Content-type: text/plain; charset=utf-8');
+            if (!core_useragent::supports_json_contenttype()) {
+                @header('X-Content-Type-Options: nosniff');
+            }
+        } else if (!core_useragent::supports_json_contenttype()) {
+            @header('Content-type: text/plain; charset=utf-8');
+            @header('X-Content-Type-Options: nosniff');
+        } else {
+            @header('Content-type: application/json; charset=utf-8');
+        }
+
+        // Headers to make it not cacheable and json
+        @header('Cache-Control: no-store, no-cache, must-revalidate');
+        @header('Cache-Control: post-check=0, pre-check=0', false);
+        @header('Pragma: no-cache');
+        @header('Expires: Mon, 20 Aug 1969 09:23:00 GMT');
+        @header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
+        @header('Accept-Ranges: none');
+    }
+
+    /**
+     * There is no footer for an AJAX request, however we must override the
+     * footer method to prevent the default footer.
+     */
+    public function footer() {}
+
+    /**
+     * No need for headers in an AJAX request... this should never happen.
+     * @param string $text
+     * @param int $level
+     * @param string $classes
+     * @param string $id
+     */
+    public function heading($text, $level = 2, $classes = 'main', $id = null) {}
+}
diff --git a/lib/classes/output/core_renderer_cli.php b/lib/classes/output/core_renderer_cli.php
new file mode 100644
index 00000000000..21b0bb113eb
--- /dev/null
+++ b/lib/classes/output/core_renderer_cli.php
@@ -0,0 +1,250 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * A renderer that generates output for command-line scripts.
+ *
+ * The implementation of this renderer is probably incomplete.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class core_renderer_cli extends core_renderer {
+
+    /**
+     * @var array $progressmaximums stores the largest percentage for a progress bar.
+     * @return string ascii fragment
+     */
+    private $progressmaximums = [];
+
+    /**
+     * Returns the page header.
+     *
+     * @return string HTML fragment
+     */
+    public function header() {
+        return $this->page->heading . "\n";
+    }
+
+    /**
+     * Renders a Check API result
+     *
+     * To aid in CLI consistency this status is NOT translated and the visual
+     * width is always exactly 10 chars.
+     *
+     * @param core\check\result $result
+     * @return string HTML fragment
+     */
+    protected function render_check_result(core\check\result $result) {
+        $status = $result->get_status();
+
+        $labels = [
+            core\check\result::NA        => '      ' . cli_ansi_format('<colour:darkGray>' ) . ' NA ',
+            core\check\result::OK        => '      ' . cli_ansi_format('<colour:green>') . ' OK ',
+            core\check\result::INFO      => '    '   . cli_ansi_format('<colour:blue>' ) . ' INFO ',
+            core\check\result::UNKNOWN   => ' '      . cli_ansi_format('<colour:darkGray>' ) . ' UNKNOWN ',
+            core\check\result::WARNING   => ' '      . cli_ansi_format('<colour:black><bgcolour:yellow>') . ' WARNING ',
+            core\check\result::ERROR     => '   '    . cli_ansi_format('<bgcolour:red>') . ' ERROR ',
+            core\check\result::CRITICAL  => ''       . cli_ansi_format('<bgcolour:red>') . ' CRITICAL ',
+        ];
+        $string = $labels[$status] . cli_ansi_format('<colour:normal>');
+        return $string;
+    }
+
+    /**
+     * Renders a Check API result
+     *
+     * @param core\check\result $result
+     * @return string fragment
+     */
+    public function check_result(core\check\result $result) {
+        return $this->render_check_result($result);
+    }
+
+    /**
+     * Renders a progress bar.
+     *
+     * Do not use $OUTPUT->render($bar), instead use progress_bar::create().
+     *
+     * @param  progress_bar $bar The bar.
+     * @return string ascii fragment
+     */
+    public function render_progress_bar(progress_bar $bar) {
+        global $CFG;
+
+        $size = 55; // The width of the progress bar in chars.
+        $ascii = "\n";
+
+        if (stream_isatty(STDOUT)) {
+            require_once($CFG->libdir.'/clilib.php');
+
+            $ascii .= "[" . str_repeat(' ', $size) . "] 0% \n";
+            return cli_ansi_format($ascii);
+        }
+
+        $this->progressmaximums[$bar->get_id()] = 0;
+        $ascii .= '[';
+        return $ascii;
+    }
+
+    /**
+     * Renders an update to a progress bar.
+     *
+     * Note: This does not cleanly map to a renderable class and should
+     * never be used directly.
+     *
+     * @param  string $id
+     * @param  float $percent
+     * @param  string $msg Message
+     * @param  string $estimate time remaining message
+     * @return string ascii fragment
+     */
+    public function render_progress_bar_update(string $id, float $percent, string $msg, string $estimate): string {
+        $size = 55; // The width of the progress bar in chars.
+        $ascii = '';
+
+        // If we are rendering to a terminal then we can safely use ansii codes
+        // to move the cursor and redraw the complete progress bar each time
+        // it is updated.
+        if (stream_isatty(STDOUT)) {
+            $colour = $percent == 100 ? 'green' : 'blue';
+
+            $done = $percent * $size * 0.01;
+            $whole = floor($done);
+            $bar = "<colour:$colour>";
+            $bar .= str_repeat('█', $whole);
+
+            if ($whole < $size) {
+                // By using unicode chars for partial blocks we can have higher
+                // precision progress bar.
+                $fraction = floor(($done - $whole) * 8);
+                $bar .= core_text::substr(' ▏▎▍▌▋▊▉', $fraction, 1);
+
+                // Fill the rest of the empty bar.
+                $bar .= str_repeat(' ', $size - $whole - 1);
+            }
+
+            $bar .= '<colour:normal>';
+
+            if ($estimate) {
+                $estimate = "- $estimate";
+            }
+
+            $ascii .= '<cursor:up>';
+            $ascii .= '<cursor:up>';
+            $ascii .= sprintf("[$bar] %3.1f%% %-22s\n", $percent, $estimate);
+            $ascii .= sprintf("%-80s\n", $msg);
+            return cli_ansi_format($ascii);
+        }
+
+        // If we are not rendering to a tty, ie when piped to another command
+        // or on windows we need to progressively render the progress bar
+        // which can only ever go forwards.
+        $done = round($percent * $size * 0.01);
+        $delta = max(0, $done - $this->progressmaximums[$id]);
+
+        $ascii .= str_repeat('#', $delta);
+        if ($percent >= 100 && $delta > 0) {
+            $ascii .= sprintf("] %3.1f%%", $percent) . "\n$msg\n";
+        }
+        $this->progressmaximums[$id] += $delta;
+        return $ascii;
+    }
+
+    /**
+     * Returns a template fragment representing a Heading.
+     *
+     * @param string $text The text of the heading
+     * @param int $level The level of importance of the heading
+     * @param string $classes A space-separated list of CSS classes
+     * @param string $id An optional ID
+     * @return string A template fragment for a heading
+     */
+    public function heading($text, $level = 2, $classes = 'main', $id = null) {
+        $text .= "\n";
+        switch ($level) {
+            case 1:
+                return '=>' . $text;
+            case 2:
+                return '-->' . $text;
+            default:
+                return $text;
+        }
+    }
+
+    /**
+     * Returns a template fragment representing a fatal error.
+     *
+     * @param string $message The message to output
+     * @param string $moreinfourl URL where more info can be found about the error
+     * @param string $link Link for the Continue button
+     * @param array $backtrace The execution backtrace
+     * @param string $debuginfo Debugging information
+     * @return string A template fragment for a fatal error
+     */
+    public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null, $errorcode = "") {
+        global $CFG;
+
+        $output = "!!! $message !!!\n";
+
+        if ($CFG->debugdeveloper) {
+            if (!empty($debuginfo)) {
+                $output .= $this->notification($debuginfo, 'notifytiny');
+            }
+            if (!empty($backtrace)) {
+                $output .= $this->notification('Stack trace: ' . format_backtrace($backtrace, true), 'notifytiny');
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Returns a template fragment representing a notification.
+     *
+     * @param string $message The message to print out.
+     * @param string $type    The type of notification. See constants on \core\output\notification.
+     * @param bool $closebutton Whether to show a close icon to remove the notification (default true).
+     * @return string A template fragment for a notification
+     */
+    public function notification($message, $type = null, $closebutton = true) {
+        $message = clean_text($message);
+        if ($type === 'notifysuccess' || $type === 'success') {
+            return "++ $message ++\n";
+        }
+        return "!! $message !!\n";
+    }
+
+    /**
+     * There is no footer for a cli request, however we must override the
+     * footer method to prevent the default footer.
+     */
+    public function footer() {}
+
+    /**
+     * Render a notification (that is, a status message about something that has
+     * just happened).
+     *
+     * @param \core\output\notification $notification the notification to print out
+     * @return string plain text output
+     */
+    public function render_notification(\core\output\notification $notification) {
+        return $this->notification($notification->get_message(), $notification->get_message_type());
+    }
+}
diff --git a/lib/classes/output/core_renderer_maintenance.php b/lib/classes/output/core_renderer_maintenance.php
new file mode 100644
index 00000000000..641922cb368
--- /dev/null
+++ b/lib/classes/output/core_renderer_maintenance.php
@@ -0,0 +1,229 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * The maintenance renderer.
+ *
+ * The purpose of this renderer is to block out the core renderer methods that are not usable when the site
+ * is running a maintenance related task.
+ * It must always extend the core_renderer as we switch from the core_renderer to this renderer in a couple of places.
+ *
+ * @since Moodle 2.6
+ * @package core
+ * @category output
+ * @copyright 2013 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class core_renderer_maintenance extends core_renderer {
+    /**
+     * Initialises the renderer instance.
+     *
+     * @param moodle_page $page
+     * @param string $target
+     * @throws coding_exception
+     */
+    public function __construct(moodle_page $page, $target) {
+        if ($target !== RENDERER_TARGET_MAINTENANCE || $page->pagelayout !== 'maintenance') {
+            throw new coding_exception('Invalid request for the maintenance renderer.');
+        }
+        parent::__construct($page, $target);
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce blocks.
+     *
+     * @param block_contents $bc
+     * @param string $region
+     * @return string
+     */
+    public function block(block_contents $bc, $region) {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce blocks.
+     *
+     * @param string $region
+     * @param array $classes
+     * @param string $tag
+     * @param boolean $fakeblocksonly
+     * @return string
+     */
+    public function blocks($region, $classes = array(), $tag = 'aside', $fakeblocksonly = false) {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce blocks.
+     *
+     * @param string $region
+     * @param boolean $fakeblocksonly Output fake block only.
+     * @return string
+     */
+    public function blocks_for_region($region, $fakeblocksonly = false) {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce a course content header.
+     *
+     * @param bool $onlyifnotcalledbefore
+     * @return string
+     */
+    public function course_content_header($onlyifnotcalledbefore = false) {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce a course content footer.
+     *
+     * @param bool $onlyifnotcalledbefore
+     * @return string
+     */
+    public function course_content_footer($onlyifnotcalledbefore = false) {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce a course header.
+     *
+     * @return string
+     */
+    public function course_header() {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce a course footer.
+     *
+     * @return string
+     */
+    public function course_footer() {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce a custom menu.
+     *
+     * @param string $custommenuitems
+     * @return string
+     */
+    public function custom_menu($custommenuitems = '') {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce a file picker.
+     *
+     * @param array $options
+     * @return string
+     */
+    public function file_picker($options) {
+        return '';
+    }
+
+    /**
+     * Overridden confirm message for upgrades.
+     *
+     * @param string $message The question to ask the user
+     * @param single_button|moodle_url|string $continue The single_button component representing the Continue answer.
+     * @param single_button|moodle_url|string $cancel The single_button component representing the Cancel answer.
+     * @param array $displayoptions optional extra display options
+     * @return string HTML fragment
+     */
+    public function confirm($message, $continue, $cancel, array $displayoptions = []) {
+        // We need plain styling of confirm boxes on upgrade because we don't know which stylesheet we have (it could be
+        // from any previous version of Moodle).
+        if ($continue instanceof single_button) {
+            $continue->type = single_button::BUTTON_PRIMARY;
+        } else if (is_string($continue)) {
+            $continue = new single_button(new moodle_url($continue), get_string('continue'), 'post',
+                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
+        } else if ($continue instanceof moodle_url) {
+            $continue = new single_button($continue, get_string('continue'), 'post',
+                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
+        } else {
+            throw new coding_exception('The continue param to $OUTPUT->confirm() must be either a URL' .
+                                       ' (string/moodle_url) or a single_button instance.');
+        }
+
+        if ($cancel instanceof single_button) {
+            $output = '';
+        } else if (is_string($cancel)) {
+            $cancel = new single_button(new moodle_url($cancel), get_string('cancel'), 'get');
+        } else if ($cancel instanceof moodle_url) {
+            $cancel = new single_button($cancel, get_string('cancel'), 'get');
+        } else {
+            throw new coding_exception('The cancel param to $OUTPUT->confirm() must be either a URL' .
+                                       ' (string/moodle_url) or a single_button instance.');
+        }
+
+        $output = $this->box_start('generalbox', 'notice');
+        $output .= html_writer::tag('h4', get_string('confirm'));
+        $output .= html_writer::tag('p', $message);
+        $output .= html_writer::tag('div', $this->render($cancel) . $this->render($continue), ['class' => 'buttons']);
+        $output .= $this->box_end();
+        return $output;
+    }
+
+    /**
+     * Does nothing. The maintenance renderer does not support JS.
+     *
+     * @param block_contents $bc
+     */
+    public function init_block_hider_js(block_contents $bc) {
+        // Does nothing.
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce language menus.
+     *
+     * @return string
+     */
+    public function lang_menu() {
+        return '';
+    }
+
+    /**
+     * Does nothing. The maintenance renderer has no need for login information.
+     *
+     * @param mixed $withlinks
+     * @return string
+     */
+    public function login_info($withlinks = null) {
+        return '';
+    }
+
+    /**
+     * Secure login info.
+     *
+     * @return string
+     */
+    public function secure_login_info() {
+        return $this->login_info(false);
+    }
+
+    /**
+     * Does nothing. The maintenance renderer cannot produce user pictures.
+     *
+     * @param stdClass $user
+     * @param array $options
+     * @return string
+     */
+    public function user_picture(stdClass $user, array $options = null) {
+        return '';
+    }
+}
diff --git a/lib/classes/output/custom_menu.php b/lib/classes/output/custom_menu.php
new file mode 100644
index 00000000000..1ed34eea659
--- /dev/null
+++ b/lib/classes/output/custom_menu.php
@@ -0,0 +1,179 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Custom menu class
+ *
+ * This class is used to operate a custom menu that can be rendered for the page.
+ * The custom menu is built using $CFG->custommenuitems and is a structured collection
+ * of custom_menu_item nodes that can be rendered by the core renderer.
+ *
+ * To configure the custom menu:
+ *     Settings: Administration > Appearance > Advanced theme settings
+ *
+ * @copyright 2010 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class custom_menu extends custom_menu_item {
+
+    /**
+     * @var string The language we should render for, null disables multilang support.
+     */
+    protected $currentlanguage = null;
+
+    /**
+     * Creates the custom menu
+     *
+     * @param string $definition the menu items definition in syntax required by {@link convert_text_to_menu_nodes()}
+     * @param string $currentlanguage the current language code, null disables multilang support
+     */
+    public function __construct($definition = '', $currentlanguage = null) {
+        $this->currentlanguage = $currentlanguage;
+        parent::__construct('root'); // create virtual root element of the menu
+        if (!empty($definition)) {
+            $this->override_children(self::convert_text_to_menu_nodes($definition, $currentlanguage));
+        }
+    }
+
+    /**
+     * Overrides the children of this custom menu. Useful when getting children
+     * from $CFG->custommenuitems
+     *
+     * @param array $children
+     */
+    public function override_children(array $children) {
+        $this->children = array();
+        foreach ($children as $child) {
+            if ($child instanceof custom_menu_item) {
+                $this->children[] = $child;
+            }
+        }
+    }
+
+    /**
+     * Converts a string into a structured array of custom_menu_items which can
+     * then be added to a custom menu.
+     *
+     * Structure:
+     *     text|url|title|langs
+     * The number of hyphens at the start determines the depth of the item. The
+     * languages are optional, comma separated list of languages the line is for.
+     *
+     * Example structure:
+     *     First level first item|http://www.moodle.com/
+     *     -Second level first item|http://www.moodle.com/partners/
+     *     -Second level second item|http://www.moodle.com/hq/
+     *     --Third level first item|http://www.moodle.com/jobs/
+     *     -Second level third item|http://www.moodle.com/development/
+     *     First level second item|http://www.moodle.com/feedback/
+     *     First level third item
+     *     English only|http://moodle.com|English only item|en
+     *     German only|http://moodle.de|Deutsch|de,de_du,de_kids
+     *
+     *
+     * @static
+     * @param string $text the menu items definition
+     * @param string $language the language code, null disables multilang support
+     * @return array
+     */
+    public static function convert_text_to_menu_nodes($text, $language = null) {
+        $root = new custom_menu();
+        $lastitem = $root;
+        $lastdepth = 0;
+        $hiddenitems = array();
+        $lines = explode("\n", $text);
+        foreach ($lines as $linenumber => $line) {
+            $line = trim($line);
+            if (strlen($line) == 0) {
+                continue;
+            }
+            // Parse item settings.
+            $itemtext = null;
+            $itemurl = null;
+            $itemtitle = null;
+            $itemvisible = true;
+            $settings = explode('|', $line);
+            foreach ($settings as $i => $setting) {
+                $setting = trim($setting);
+                if ($setting !== '') {
+                    switch ($i) {
+                        case 0: // Menu text.
+                            $itemtext = ltrim($setting, '-');
+                            break;
+                        case 1: // URL.
+                            try {
+                                $itemurl = new moodle_url($setting);
+                            } catch (moodle_exception $exception) {
+                                // We're not actually worried about this, we don't want to mess up the display
+                                // just for a wrongly entered URL.
+                                $itemurl = null;
+                            }
+                            break;
+                        case 2: // Title attribute.
+                            $itemtitle = $setting;
+                            break;
+                        case 3: // Language.
+                            if (!empty($language)) {
+                                $itemlanguages = array_map('trim', explode(',', $setting));
+                                $itemvisible &= in_array($language, $itemlanguages);
+                            }
+                            break;
+                    }
+                }
+            }
+            // Get depth of new item.
+            preg_match('/^(\-*)/', $line, $match);
+            $itemdepth = strlen($match[1]) + 1;
+            // Find parent item for new item.
+            while (($lastdepth - $itemdepth) >= 0) {
+                $lastitem = $lastitem->get_parent();
+                $lastdepth--;
+            }
+            $lastitem = $lastitem->add($itemtext, $itemurl, $itemtitle, $linenumber + 1);
+            $lastdepth++;
+            if (!$itemvisible) {
+                $hiddenitems[] = $lastitem;
+            }
+        }
+        foreach ($hiddenitems as $item) {
+            $item->parent->remove_child($item);
+        }
+        return $root->get_children();
+    }
+
+    /**
+     * Sorts two custom menu items
+     *
+     * This function is designed to be used with the usort method
+     *     usort($this->children, array('custom_menu','sort_custom_menu_items'));
+     *
+     * @static
+     * @param custom_menu_item $itema
+     * @param custom_menu_item $itemb
+     * @return int
+     */
+    public static function sort_custom_menu_items(custom_menu_item $itema, custom_menu_item $itemb) {
+        $itema = $itema->get_sort_order();
+        $itemb = $itemb->get_sort_order();
+        if ($itema == $itemb) {
+            return 0;
+        }
+        return ($itema > $itemb) ? +1 : -1;
+    }
+}
diff --git a/lib/classes/output/custom_menu_item.php b/lib/classes/output/custom_menu_item.php
new file mode 100644
index 00000000000..560cf2a3ec6
--- /dev/null
+++ b/lib/classes/output/custom_menu_item.php
@@ -0,0 +1,261 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Custom menu item
+ *
+ * This class is used to represent one item within a custom menu that may or may
+ * not have children.
+ *
+ * @copyright 2010 Sam Hemelryk
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class custom_menu_item implements renderable, templatable {
+
+    /**
+     * @var string The text to show for the item
+     */
+    protected $text;
+
+    /**
+     * @var moodle_url The link to give the icon if it has no children
+     */
+    protected $url;
+
+    /**
+     * @var string A title to apply to the item. By default the text
+     */
+    protected $title;
+
+    /**
+     * @var int A sort order for the item, not necessary if you order things in
+     * the CFG var.
+     */
+    protected $sort;
+
+    /**
+     * @var custom_menu_item A reference to the parent for this item or NULL if
+     * it is a top level item
+     */
+    protected $parent;
+
+    /**
+     * @var array A array in which to store children this item has.
+     */
+    protected $children = array();
+
+    /**
+     * @var int A reference to the sort var of the last child that was added
+     */
+    protected $lastsort = 0;
+
+    /** @var array Array of other HTML attributes for the custom menu item. */
+    protected $attributes = [];
+
+    /**
+     * Constructs the new custom menu item
+     *
+     * @param string $text
+     * @param moodle_url $url A moodle url to apply as the link for this item [Optional]
+     * @param string $title A title to apply to this item [Optional]
+     * @param int $sort A sort or to use if we need to sort differently [Optional]
+     * @param custom_menu_item $parent A reference to the parent custom_menu_item this child
+     *        belongs to, only if the child has a parent. [Optional]
+     * @param array $attributes Array of other HTML attributes for the custom menu item.
+     */
+    public function __construct($text, moodle_url $url = null, $title = null, $sort = null, custom_menu_item $parent = null,
+        array $attributes = []) {
+
+        // Use class setter method for text to ensure it's always a string type.
+        $this->set_text($text);
+
+        $this->url = $url;
+        $this->title = $title;
+        $this->sort = (int)$sort;
+        $this->parent = $parent;
+        $this->attributes = $attributes;
+    }
+
+    /**
+     * Adds a custom menu item as a child of this node given its properties.
+     *
+     * @param string $text
+     * @param moodle_url $url
+     * @param string $title
+     * @param int $sort
+     * @param array $attributes Array of other HTML attributes for the custom menu item.
+     * @return custom_menu_item
+     */
+    public function add($text, moodle_url $url = null, $title = null, $sort = null, $attributes = []) {
+        $key = count($this->children);
+        if (empty($sort)) {
+            $sort = $this->lastsort + 1;
+        }
+        $this->children[$key] = new custom_menu_item($text, $url, $title, $sort, $this, $attributes);
+        $this->lastsort = (int)$sort;
+        return $this->children[$key];
+    }
+
+    /**
+     * Removes a custom menu item that is a child or descendant to the current menu.
+     *
+     * Returns true if child was found and removed.
+     *
+     * @param custom_menu_item $menuitem
+     * @return bool
+     */
+    public function remove_child(custom_menu_item $menuitem) {
+        $removed = false;
+        if (($key = array_search($menuitem, $this->children)) !== false) {
+            unset($this->children[$key]);
+            $this->children = array_values($this->children);
+            $removed = true;
+        } else {
+            foreach ($this->children as $child) {
+                if ($removed = $child->remove_child($menuitem)) {
+                    break;
+                }
+            }
+        }
+        return $removed;
+    }
+
+    /**
+     * Returns the text for this item
+     * @return string
+     */
+    public function get_text() {
+        return $this->text;
+    }
+
+    /**
+     * Returns the url for this item
+     * @return moodle_url
+     */
+    public function get_url() {
+        return $this->url;
+    }
+
+    /**
+     * Returns the title for this item
+     * @return string
+     */
+    public function get_title() {
+        return $this->title;
+    }
+
+    /**
+     * Sorts and returns the children for this item
+     * @return array
+     */
+    public function get_children() {
+        $this->sort();
+        return $this->children;
+    }
+
+    /**
+     * Gets the sort order for this child
+     * @return int
+     */
+    public function get_sort_order() {
+        return $this->sort;
+    }
+
+    /**
+     * Gets the parent this child belong to
+     * @return custom_menu_item
+     */
+    public function get_parent() {
+        return $this->parent;
+    }
+
+    /**
+     * Sorts the children this item has
+     */
+    public function sort() {
+        usort($this->children, array('custom_menu','sort_custom_menu_items'));
+    }
+
+    /**
+     * Returns true if this item has any children
+     * @return bool
+     */
+    public function has_children() {
+        return (count($this->children) > 0);
+    }
+
+    /**
+     * Sets the text for the node
+     * @param string $text
+     */
+    public function set_text($text) {
+        $this->text = (string)$text;
+    }
+
+    /**
+     * Sets the title for the node
+     * @param string $title
+     */
+    public function set_title($title) {
+        $this->title = (string)$title;
+    }
+
+    /**
+     * Sets the url for the node
+     * @param moodle_url $url
+     */
+    public function set_url(moodle_url $url) {
+        $this->url = $url;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $syscontext = context_system::instance();
+
+        $context = new stdClass();
+        $context->moremenuid = uniqid();
+        $context->text = \core_external\util::format_string($this->text, $syscontext->id);
+        $context->url = $this->url ? $this->url->out() : null;
+        // No need for the title if it's the same with text.
+        if ($this->text !== $this->title) {
+            // Show the title attribute only if it's different from the text.
+            $context->title = \core_external\util::format_string($this->title, $syscontext->id);
+        }
+        $context->sort = $this->sort;
+        if (!empty($this->attributes)) {
+            $context->attributes = $this->attributes;
+        }
+        $context->children = array();
+        if (preg_match("/^#+$/", $this->text)) {
+            $context->divider = true;
+        }
+        $context->haschildren = !empty($this->children) && (count($this->children) > 0);
+        foreach ($this->children as $child) {
+            $child = $child->export_for_template($output);
+            array_push($context->children, $child);
+        }
+
+        return $context;
+    }
+}
diff --git a/lib/classes/output/file_picker.php b/lib/classes/output/file_picker.php
new file mode 100644
index 00000000000..785b0d9a69f
--- /dev/null
+++ b/lib/classes/output/file_picker.php
@@ -0,0 +1,93 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing a file picker.
+ *
+ * @copyright 2010 Dongsheng Cai
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class file_picker implements renderable {
+
+    /**
+     * @var stdClass An object containing options for the file picker
+     */
+    public $options;
+
+    /**
+     * Constructs a file picker object.
+     *
+     * The following are possible options for the filepicker:
+     *    - accepted_types  (*)
+     *    - return_types    (FILE_INTERNAL)
+     *    - env             (filepicker)
+     *    - client_id       (uniqid)
+     *    - itemid          (0)
+     *    - maxbytes        (-1)
+     *    - maxfiles        (1)
+     *    - buttonname      (false)
+     *
+     * @param stdClass $options An object containing options for the file picker.
+     */
+    public function __construct(stdClass $options) {
+        global $CFG, $USER, $PAGE;
+        require_once($CFG->dirroot. '/repository/lib.php');
+        $defaults = array(
+            'accepted_types'=>'*',
+            'return_types'=>FILE_INTERNAL,
+            'env' => 'filepicker',
+            'client_id' => uniqid(),
+            'itemid' => 0,
+            'maxbytes'=>-1,
+            'maxfiles'=>1,
+            'buttonname'=>false
+        );
+        foreach ($defaults as $key=>$value) {
+            if (empty($options->$key)) {
+                $options->$key = $value;
+            }
+        }
+
+        $options->currentfile = '';
+        if (!empty($options->itemid)) {
+            $fs = get_file_storage();
+            $usercontext = context_user::instance($USER->id);
+            if (empty($options->filename)) {
+                if ($files = $fs->get_area_files($usercontext->id, 'user', 'draft', $options->itemid, 'id DESC', false)) {
+                    $file = reset($files);
+                }
+            } else {
+                $file = $fs->get_file($usercontext->id, 'user', 'draft', $options->itemid, $options->filepath, $options->filename);
+            }
+            if (!empty($file)) {
+                $options->currentfile = html_writer::link(moodle_url::make_draftfile_url($file->get_itemid(), $file->get_filepath(), $file->get_filename()), $file->get_filename());
+            }
+        }
+
+        // initilise options, getting files in root path
+        $this->options = initialise_filepicker($options);
+
+        // copying other options
+        foreach ($options as $name=>$value) {
+            if (!isset($this->options->$name)) {
+                $this->options->$name = $value;
+            }
+        }
+    }
+}
diff --git a/lib/classes/output/help_icon.php b/lib/classes/output/help_icon.php
new file mode 100644
index 00000000000..9fee559cad5
--- /dev/null
+++ b/lib/classes/output/help_icon.php
@@ -0,0 +1,118 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing a help icon.
+ *
+ * @copyright 2010 Petr Skoda (info@skodak.org)
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class help_icon implements renderable, templatable {
+
+    /**
+     * @var string lang pack identifier (without the "_help" suffix),
+     * both get_string($identifier, $component) and get_string($identifier.'_help', $component)
+     * must exist.
+     */
+    public $identifier;
+
+    /**
+     * @var string Component name, the same as in get_string()
+     */
+    public $component;
+
+    /**
+     * @var string Extra descriptive text next to the icon
+     */
+    public $linktext = null;
+
+    /**
+     * @var mixed An object, string or number that can be used within translation strings
+     */
+    public $a = null;
+
+    /**
+     * Constructor
+     *
+     * @param string $identifier string for help page title,
+     *  string with _help suffix is used for the actual help text.
+     *  string with _link suffix is used to create a link to further info (if it exists)
+     * @param string $component
+     * @param string|object|array|int $a An object, string or number that can be used
+     *      within translation strings
+     */
+    public function __construct($identifier, $component, $a = null) {
+        $this->identifier = $identifier;
+        $this->component  = $component;
+        $this->a = $a;
+    }
+
+    /**
+     * Verifies that both help strings exists, shows debug warnings if not
+     */
+    public function diag_strings() {
+        $sm = get_string_manager();
+        if (!$sm->string_exists($this->identifier, $this->component)) {
+            debugging("Help title string does not exist: [$this->identifier, $this->component]");
+        }
+        if (!$sm->string_exists($this->identifier.'_help', $this->component)) {
+            debugging("Help contents string does not exist: [{$this->identifier}_help, $this->component]");
+        }
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        global $CFG;
+
+        $title = get_string($this->identifier, $this->component, $this->a);
+
+        if (empty($this->linktext)) {
+            $alt = get_string('helpprefix2', '', trim($title, ". \t"));
+        } else {
+            $alt = get_string('helpwiththis');
+        }
+
+        $data = get_formatted_help_string($this->identifier, $this->component, false, $this->a);
+
+        $data->alt = $alt;
+        $data->icon = (new pix_icon('help', $alt, 'core', ['class' => 'iconhelp']))->export_for_template($output);
+        $data->linktext = $this->linktext;
+        $data->title = get_string('helpprefix2', '', trim($title, ". \t"));
+
+        $options = [
+            'component' => $this->component,
+            'identifier' => $this->identifier,
+            'lang' => current_language()
+        ];
+
+        // Debugging feature lets you display string identifier and component.
+        if (isset($CFG->debugstringids) && $CFG->debugstringids && optional_param('strings', 0, PARAM_INT)) {
+            $options['strings'] = 1;
+        }
+
+        $data->url = (new moodle_url('/help.php', $options))->out(false);
+        $data->ltr = !right_to_left();
+        return $data;
+    }
+}
diff --git a/lib/classes/output/html_writer.php b/lib/classes/output/html_writer.php
new file mode 100644
index 00000000000..9d595335d32
--- /dev/null
+++ b/lib/classes/output/html_writer.php
@@ -0,0 +1,870 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Simple html output class
+ *
+ * @copyright 2009 Tim Hunt, 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class html_writer {
+
+    /**
+     * Outputs a tag with attributes and contents
+     *
+     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
+     * @param string $contents What goes between the opening and closing tags
+     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
+     * @return string HTML fragment
+     */
+    public static function tag($tagname, $contents, array $attributes = null) {
+        return self::start_tag($tagname, $attributes) . $contents . self::end_tag($tagname);
+    }
+
+    /**
+     * Outputs an opening tag with attributes
+     *
+     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
+     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
+     * @return string HTML fragment
+     */
+    public static function start_tag($tagname, array $attributes = null) {
+        return '<' . $tagname . self::attributes($attributes) . '>';
+    }
+
+    /**
+     * Outputs a closing tag
+     *
+     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
+     * @return string HTML fragment
+     */
+    public static function end_tag($tagname) {
+        return '</' . $tagname . '>';
+    }
+
+    /**
+     * Outputs an empty tag with attributes
+     *
+     * @param string $tagname The name of tag ('input', 'img', 'br' etc.)
+     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
+     * @return string HTML fragment
+     */
+    public static function empty_tag($tagname, array $attributes = null) {
+        return '<' . $tagname . self::attributes($attributes) . ' />';
+    }
+
+    /**
+     * Outputs a tag, but only if the contents are not empty
+     *
+     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
+     * @param string $contents What goes between the opening and closing tags
+     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
+     * @return string HTML fragment
+     */
+    public static function nonempty_tag($tagname, $contents, array $attributes = null) {
+        if ($contents === '' || is_null($contents)) {
+            return '';
+        }
+        return self::tag($tagname, $contents, $attributes);
+    }
+
+    /**
+     * Outputs a HTML attribute and value
+     *
+     * @param string $name The name of the attribute ('src', 'href', 'class' etc.)
+     * @param string $value The value of the attribute. The value will be escaped with {@link s()}
+     * @return string HTML fragment
+     */
+    public static function attribute($name, $value) {
+        if ($value instanceof moodle_url) {
+            return ' ' . $name . '="' . $value->out() . '"';
+        }
+
+        // special case, we do not want these in output
+        if ($value === null) {
+            return '';
+        }
+
+        // no sloppy trimming here!
+        return ' ' . $name . '="' . s($value) . '"';
+    }
+
+    /**
+     * Outputs a list of HTML attributes and values
+     *
+     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
+     *       The values will be escaped with {@link s()}
+     * @return string HTML fragment
+     */
+    public static function attributes(array $attributes = null) {
+        $attributes = (array)$attributes;
+        $output = '';
+        foreach ($attributes as $name => $value) {
+            $output .= self::attribute($name, $value);
+        }
+        return $output;
+    }
+
+    /**
+     * Generates a simple image tag with attributes.
+     *
+     * @param string $src The source of image
+     * @param string $alt The alternate text for image
+     * @param array $attributes The tag attributes (array('height' => $max_height, 'class' => 'class1') etc.)
+     * @return string HTML fragment
+     */
+    public static function img($src, $alt, array $attributes = null) {
+        $attributes = (array)$attributes;
+        $attributes['src'] = $src;
+        // In case a null alt text is provided, set it to an empty string.
+        $attributes['alt'] = $alt ?? '';
+        if (array_key_exists('role', $attributes) && core_text::strtolower($attributes['role']) === 'presentation') {
+            // A presentation role is not necessary for the img tag.
+            // If a non-empty alt text is provided, the presentation role will conflict with the alt text.
+            // An empty alt text denotes a decorative image. The presence of a presentation role is redundant.
+            unset($attributes['role']);
+            debugging('The presentation role is not necessary for an img tag.', DEBUG_DEVELOPER);
+        }
+
+        return self::empty_tag('img', $attributes);
+    }
+
+    /**
+     * Generates random html element id.
+     *
+     * @staticvar int $counter
+     * @staticvar string $uniq
+     * @param string $base A string fragment that will be included in the random ID.
+     * @return string A unique ID
+     */
+    public static function random_id($base='random') {
+        static $counter = 0;
+        static $uniq;
+
+        if (!isset($uniq)) {
+            $uniq = uniqid();
+        }
+
+        $counter++;
+        return $base.$uniq.$counter;
+    }
+
+    /**
+     * Generates a simple html link
+     *
+     * @param string|moodle_url $url The URL
+     * @param string $text The text
+     * @param array $attributes HTML attributes
+     * @return string HTML fragment
+     */
+    public static function link($url, $text, array $attributes = null) {
+        $attributes = (array)$attributes;
+        $attributes['href']  = $url;
+        return self::tag('a', $text, $attributes);
+    }
+
+    /**
+     * Generates a simple checkbox with optional label
+     *
+     * @param string $name The name of the checkbox
+     * @param string $value The value of the checkbox
+     * @param bool $checked Whether the checkbox is checked
+     * @param string $label The label for the checkbox
+     * @param array $attributes Any attributes to apply to the checkbox
+     * @param array $labelattributes Any attributes to apply to the label, if present
+     * @return string html fragment
+     */
+    public static function checkbox($name, $value, $checked = true, $label = '',
+        array $attributes = null, array $labelattributes = null) {
+        $attributes = (array) $attributes;
+        $output = '';
+
+        if ($label !== '' and !is_null($label)) {
+            if (empty($attributes['id'])) {
+                $attributes['id'] = self::random_id('checkbox_');
+            }
+        }
+        $attributes['type']    = 'checkbox';
+        $attributes['value']   = $value;
+        $attributes['name']    = $name;
+        $attributes['checked'] = $checked ? 'checked' : null;
+
+        $output .= self::empty_tag('input', $attributes);
+
+        if ($label !== '' and !is_null($label)) {
+            $labelattributes = (array) $labelattributes;
+            $labelattributes['for'] = $attributes['id'];
+            $output .= self::tag('label', $label, $labelattributes);
+        }
+
+        return $output;
+    }
+
+    /**
+     * Generates a simple select yes/no form field
+     *
+     * @param string $name name of select element
+     * @param bool $selected
+     * @param array $attributes - html select element attributes
+     * @return string HTML fragment
+     */
+    public static function select_yes_no($name, $selected=true, array $attributes = null) {
+        $options = array('1'=>get_string('yes'), '0'=>get_string('no'));
+        return self::select($options, $name, $selected, null, $attributes);
+    }
+
+    /**
+     * Generates a simple select form field
+     *
+     * Note this function does HTML escaping on the optgroup labels, but not on the choice labels.
+     *
+     * @param array $options associative array value=>label ex.:
+     *                array(1=>'One, 2=>Two)
+     *              it is also possible to specify optgroup as complex label array ex.:
+     *                array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
+     *                array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
+     * @param string $name name of select element
+     * @param string|array $selected value or array of values depending on multiple attribute
+     * @param array|bool|null $nothing add nothing selected option, or false of not added
+     * @param array $attributes html select element attributes
+     * @return string HTML fragment
+     */
+    public static function select(array $options, $name, $selected = '', $nothing = array('' => 'choosedots'), array $attributes = null) {
+        $attributes = (array)$attributes;
+        if (is_array($nothing)) {
+            foreach ($nothing as $k=>$v) {
+                if ($v === 'choose' or $v === 'choosedots') {
+                    $nothing[$k] = get_string('choosedots');
+                }
+            }
+            $options = $nothing + $options; // keep keys, do not override
+
+        } else if (is_string($nothing) and $nothing !== '') {
+            // BC
+            $options = array(''=>$nothing) + $options;
+        }
+
+        // we may accept more values if multiple attribute specified
+        $selected = (array)$selected;
+        foreach ($selected as $k=>$v) {
+            $selected[$k] = (string)$v;
+        }
+
+        if (!isset($attributes['id'])) {
+            $id = 'menu'.$name;
+            // name may contaion [], which would make an invalid id. e.g. numeric question type editing form, assignment quickgrading
+            $id = str_replace('[', '', $id);
+            $id = str_replace(']', '', $id);
+            $attributes['id'] = $id;
+        }
+
+        if (!isset($attributes['class'])) {
+            $class = 'menu'.$name;
+            // name may contaion [], which would make an invalid class. e.g. numeric question type editing form, assignment quickgrading
+            $class = str_replace('[', '', $class);
+            $class = str_replace(']', '', $class);
+            $attributes['class'] = $class;
+        }
+        $attributes['class'] = 'select custom-select ' . $attributes['class']; // Add 'select' selector always.
+
+        $attributes['name'] = $name;
+
+        if (!empty($attributes['disabled'])) {
+            $attributes['disabled'] = 'disabled';
+        } else {
+            unset($attributes['disabled']);
+        }
+
+        $output = '';
+        foreach ($options as $value=>$label) {
+            if (is_array($label)) {
+                // ignore key, it just has to be unique
+                $output .= self::select_optgroup(key($label), current($label), $selected);
+            } else {
+                $output .= self::select_option($label, $value, $selected);
+            }
+        }
+        return self::tag('select', $output, $attributes);
+    }
+
+    /**
+     * Returns HTML to display a select box option.
+     *
+     * @param string $label The label to display as the option.
+     * @param string|int $value The value the option represents
+     * @param array $selected An array of selected options
+     * @return string HTML fragment
+     */
+    private static function select_option($label, $value, array $selected) {
+        $attributes = array();
+        $value = (string)$value;
+        if (in_array($value, $selected, true)) {
+            $attributes['selected'] = 'selected';
+        }
+        $attributes['value'] = $value;
+        return self::tag('option', $label, $attributes);
+    }
+
+    /**
+     * Returns HTML to display a select box option group.
+     *
+     * @param string $groupname The label to use for the group
+     * @param array $options The options in the group
+     * @param array $selected An array of selected values.
+     * @return string HTML fragment.
+     */
+    private static function select_optgroup($groupname, $options, array $selected) {
+        if (empty($options)) {
+            return '';
+        }
+        $attributes = array('label'=>$groupname);
+        $output = '';
+        foreach ($options as $value=>$label) {
+            $output .= self::select_option($label, $value, $selected);
+        }
+        return self::tag('optgroup', $output, $attributes);
+    }
+
+    /**
+     * This is a shortcut for making an hour selector menu.
+     *
+     * @param string $type The type of selector (years, months, days, hours, minutes)
+     * @param string $name fieldname
+     * @param int $currenttime A default timestamp in GMT
+     * @param int $step minute spacing
+     * @param array $attributes - html select element attributes
+     * @param float|int|string $timezone the timezone to use to calculate the time
+     *        {@link https://moodledev.io/docs/apis/subsystems/time#timezone}
+     * @return string HTML fragment
+     */
+    public static function select_time($type, $name, $currenttime = 0, $step = 5, array $attributes = null, $timezone = 99) {
+        global $OUTPUT;
+
+        if (!$currenttime) {
+            $currenttime = time();
+        }
+        $calendartype = \core_calendar\type_factory::get_calendar_instance();
+        $currentdate = $calendartype->timestamp_to_date_array($currenttime, $timezone);
+
+        $userdatetype = $type;
+        $timeunits = array();
+
+        switch ($type) {
+            case 'years':
+                $timeunits = $calendartype->get_years();
+                $userdatetype = 'year';
+                break;
+            case 'months':
+                $timeunits = $calendartype->get_months();
+                $userdatetype = 'month';
+                $currentdate['month'] = (int)$currentdate['mon'];
+                break;
+            case 'days':
+                $timeunits = $calendartype->get_days();
+                $userdatetype = 'mday';
+                break;
+            case 'hours':
+                for ($i=0; $i<=23; $i++) {
+                    $timeunits[$i] = sprintf("%02d",$i);
+                }
+                break;
+            case 'minutes':
+                if ($step != 1) {
+                    $currentdate['minutes'] = ceil($currentdate['minutes']/$step)*$step;
+                }
+
+                for ($i=0; $i<=59; $i+=$step) {
+                    $timeunits[$i] = sprintf("%02d",$i);
+                }
+                break;
+            default:
+                throw new coding_exception("Time type $type is not supported by html_writer::select_time().");
+        }
+
+        $attributes = (array) $attributes;
+        $data = (object) [
+            'name' => $name,
+            'id' => !empty($attributes['id']) ? $attributes['id'] : self::random_id('ts_'),
+            'label' => get_string(substr($type, 0, -1), 'form'),
+            'options' => array_map(function($value) use ($timeunits, $currentdate, $userdatetype) {
+                return [
+                    'name' => $timeunits[$value],
+                    'value' => $value,
+                    'selected' => $currentdate[$userdatetype] == $value
+                ];
+            }, array_keys($timeunits)),
+        ];
+
+        unset($attributes['id']);
+        unset($attributes['name']);
+        $data->attributes = array_map(function($name) use ($attributes) {
+            return [
+                'name' => $name,
+                'value' => $attributes[$name]
+            ];
+        }, array_keys($attributes));
+
+        return $OUTPUT->render_from_template('core/select_time', $data);
+    }
+
+    /**
+     * Shortcut for quick making of lists
+     *
+     * Note: 'list' is a reserved keyword ;-)
+     *
+     * @param array $items
+     * @param array $attributes
+     * @param string $tag ul or ol
+     * @return string
+     */
+    public static function alist(array $items, array $attributes = null, $tag = 'ul') {
+        $output = html_writer::start_tag($tag, $attributes)."\n";
+        foreach ($items as $item) {
+            $output .= html_writer::tag('li', $item)."\n";
+        }
+        $output .= html_writer::end_tag($tag);
+        return $output;
+    }
+
+    /**
+     * Returns hidden input fields created from url parameters.
+     *
+     * @param moodle_url $url
+     * @param array $exclude list of excluded parameters
+     * @return string HTML fragment
+     */
+    public static function input_hidden_params(moodle_url $url, array $exclude = null) {
+        $exclude = (array)$exclude;
+        $params = $url->params();
+        foreach ($exclude as $key) {
+            unset($params[$key]);
+        }
+
+        $output = '';
+        foreach ($params as $key => $value) {
+            $attributes = array('type'=>'hidden', 'name'=>$key, 'value'=>$value);
+            $output .= self::empty_tag('input', $attributes)."\n";
+        }
+        return $output;
+    }
+
+    /**
+     * Generate a script tag containing the the specified code.
+     *
+     * @param string $jscode the JavaScript code
+     * @param moodle_url|string $url optional url of the external script, $code ignored if specified
+     * @return string HTML, the code wrapped in <script> tags.
+     */
+    public static function script($jscode, $url=null) {
+        if ($jscode) {
+            return self::tag('script', "\n//<![CDATA[\n$jscode\n//]]>\n") . "\n";
+
+        } else if ($url) {
+            return self::tag('script', '', ['src' => $url]) . "\n";
+
+        } else {
+            return '';
+        }
+    }
+
+    /**
+     * Renders HTML table
+     *
+     * This method may modify the passed instance by adding some default properties if they are not set yet.
+     * If this is not what you want, you should make a full clone of your data before passing them to this
+     * method. In most cases this is not an issue at all so we do not clone by default for performance
+     * and memory consumption reasons.
+     *
+     * @param html_table $table data to be rendered
+     * @return string HTML code
+     */
+    public static function table(html_table $table) {
+        // prepare table data and populate missing properties with reasonable defaults
+        if (!empty($table->align)) {
+            foreach ($table->align as $key => $aa) {
+                if ($aa) {
+                    $table->align[$key] = 'text-align:'. fix_align_rtl($aa) .';';  // Fix for RTL languages
+                } else {
+                    $table->align[$key] = null;
+                }
+            }
+        }
+        if (!empty($table->size)) {
+            foreach ($table->size as $key => $ss) {
+                if ($ss) {
+                    $table->size[$key] = 'width:'. $ss .';';
+                } else {
+                    $table->size[$key] = null;
+                }
+            }
+        }
+        if (!empty($table->wrap)) {
+            foreach ($table->wrap as $key => $ww) {
+                if ($ww) {
+                    $table->wrap[$key] = 'white-space:nowrap;';
+                } else {
+                    $table->wrap[$key] = '';
+                }
+            }
+        }
+        if (!empty($table->head)) {
+            foreach ($table->head as $key => $val) {
+                if (!isset($table->align[$key])) {
+                    $table->align[$key] = null;
+                }
+                if (!isset($table->size[$key])) {
+                    $table->size[$key] = null;
+                }
+                if (!isset($table->wrap[$key])) {
+                    $table->wrap[$key] = null;
+                }
+
+            }
+        }
+        if (empty($table->attributes['class'])) {
+            $table->attributes['class'] = 'generaltable';
+        }
+        if (!empty($table->tablealign)) {
+            $table->attributes['class'] .= ' boxalign' . $table->tablealign;
+        }
+
+        // explicitly assigned properties override those defined via $table->attributes
+        $table->attributes['class'] = trim($table->attributes['class']);
+        $attributes = array_merge($table->attributes, array(
+            'id'            => $table->id,
+            'width'         => $table->width,
+            'summary'       => $table->summary,
+            'cellpadding'   => $table->cellpadding,
+            'cellspacing'   => $table->cellspacing,
+        ));
+        $output = html_writer::start_tag('table', $attributes) . "\n";
+
+        $countcols = 0;
+
+        // Output a caption if present.
+        if (!empty($table->caption)) {
+            $captionattributes = array();
+            if ($table->captionhide) {
+                $captionattributes['class'] = 'accesshide';
+            }
+            $output .= html_writer::tag(
+                'caption',
+                $table->caption,
+                $captionattributes
+            );
+        }
+
+        if (!empty($table->head)) {
+            $countcols = count($table->head);
+
+            $output .= html_writer::start_tag('thead', array()) . "\n";
+            $output .= html_writer::start_tag('tr', array()) . "\n";
+            $keys = array_keys($table->head);
+            $lastkey = end($keys);
+
+            foreach ($table->head as $key => $heading) {
+                // Convert plain string headings into html_table_cell objects
+                if (!($heading instanceof html_table_cell)) {
+                    $headingtext = $heading;
+                    $heading = new html_table_cell();
+                    $heading->text = $headingtext;
+                    $heading->header = true;
+                }
+
+                if ($heading->header !== false) {
+                    $heading->header = true;
+                }
+
+                $tagtype = 'td';
+                if ($heading->header && (string)$heading->text != '') {
+                    $tagtype = 'th';
+                }
+
+                $heading->attributes['class'] .= ' header c' . $key;
+                if (isset($table->headspan[$key]) && $table->headspan[$key] > 1) {
+                    $heading->colspan = $table->headspan[$key];
+                    $countcols += $table->headspan[$key] - 1;
+                }
+
+                if ($key == $lastkey) {
+                    $heading->attributes['class'] .= ' lastcol';
+                }
+                if (isset($table->colclasses[$key])) {
+                    $heading->attributes['class'] .= ' ' . $table->colclasses[$key];
+                }
+                $heading->attributes['class'] = trim($heading->attributes['class']);
+                $attributes = array_merge($heading->attributes, [
+                    'style'     => $table->align[$key] . $table->size[$key] . $heading->style,
+                    'colspan'   => $heading->colspan,
+                ]);
+
+                if ($tagtype == 'th') {
+                    $attributes['scope'] = !empty($heading->scope) ? $heading->scope : 'col';
+                }
+
+                $output .= html_writer::tag($tagtype, $heading->text, $attributes) . "\n";
+            }
+            $output .= html_writer::end_tag('tr') . "\n";
+            $output .= html_writer::end_tag('thead') . "\n";
+
+            if (empty($table->data)) {
+                // For valid XHTML strict every table must contain either a valid tr
+                // or a valid tbody... both of which must contain a valid td
+                $output .= html_writer::start_tag('tbody', array('class' => 'empty'));
+                $output .= html_writer::tag('tr', html_writer::tag('td', '', array('colspan'=>count($table->head))));
+                $output .= html_writer::end_tag('tbody');
+            }
+        }
+
+        if (!empty($table->data)) {
+            $keys       = array_keys($table->data);
+            $lastrowkey = end($keys);
+            $output .= html_writer::start_tag('tbody', array());
+
+            foreach ($table->data as $key => $row) {
+                if (($row === 'hr') && ($countcols)) {
+                    $output .= html_writer::tag('td', html_writer::tag('div', '', array('class' => 'tabledivider')), array('colspan' => $countcols));
+                } else {
+                    // Convert array rows to html_table_rows and cell strings to html_table_cell objects
+                    if (!($row instanceof html_table_row)) {
+                        $newrow = new html_table_row();
+
+                        foreach ($row as $cell) {
+                            if (!($cell instanceof html_table_cell)) {
+                                $cell = new html_table_cell($cell);
+                            }
+                            $newrow->cells[] = $cell;
+                        }
+                        $row = $newrow;
+                    }
+
+                    if (isset($table->rowclasses[$key])) {
+                        $row->attributes['class'] .= ' ' . $table->rowclasses[$key];
+                    }
+
+                    if ($key == $lastrowkey) {
+                        $row->attributes['class'] .= ' lastrow';
+                    }
+
+                    // Explicitly assigned properties should override those defined in the attributes.
+                    $row->attributes['class'] = trim($row->attributes['class']);
+                    $trattributes = array_merge($row->attributes, array(
+                        'id'            => $row->id,
+                        'style'         => $row->style,
+                    ));
+                    $output .= html_writer::start_tag('tr', $trattributes) . "\n";
+                    $keys2 = array_keys($row->cells);
+                    $lastkey = end($keys2);
+
+                    $gotlastkey = false; //flag for sanity checking
+                    foreach ($row->cells as $key => $cell) {
+                        if ($gotlastkey) {
+                            //This should never happen. Why do we have a cell after the last cell?
+                            mtrace("A cell with key ($key) was found after the last key ($lastkey)");
+                        }
+
+                        if (!($cell instanceof html_table_cell)) {
+                            $mycell = new html_table_cell();
+                            $mycell->text = $cell;
+                            $cell = $mycell;
+                        }
+
+                        if (($cell->header === true) && empty($cell->scope)) {
+                            $cell->scope = 'row';
+                        }
+
+                        if (isset($table->colclasses[$key])) {
+                            $cell->attributes['class'] .= ' ' . $table->colclasses[$key];
+                        }
+
+                        $cell->attributes['class'] .= ' cell c' . $key;
+                        if ($key == $lastkey) {
+                            $cell->attributes['class'] .= ' lastcol';
+                            $gotlastkey = true;
+                        }
+                        $tdstyle = '';
+                        $tdstyle .= isset($table->align[$key]) ? $table->align[$key] : '';
+                        $tdstyle .= isset($table->size[$key]) ? $table->size[$key] : '';
+                        $tdstyle .= isset($table->wrap[$key]) ? $table->wrap[$key] : '';
+                        $cell->attributes['class'] = trim($cell->attributes['class']);
+                        $tdattributes = array_merge($cell->attributes, array(
+                            'style' => $tdstyle . $cell->style,
+                            'colspan' => $cell->colspan,
+                            'rowspan' => $cell->rowspan,
+                            'id' => $cell->id,
+                            'abbr' => $cell->abbr,
+                            'scope' => $cell->scope,
+                        ));
+                        $tagtype = 'td';
+                        if ($cell->header === true) {
+                            $tagtype = 'th';
+                        }
+                        $output .= html_writer::tag($tagtype, $cell->text, $tdattributes) . "\n";
+                    }
+                }
+                $output .= html_writer::end_tag('tr') . "\n";
+            }
+            $output .= html_writer::end_tag('tbody') . "\n";
+        }
+        $output .= html_writer::end_tag('table') . "\n";
+
+        if ($table->responsive) {
+            return self::div($output, 'table-responsive');
+        }
+
+        return $output;
+    }
+
+    /**
+     * Renders form element label
+     *
+     * By default, the label is suffixed with a label separator defined in the
+     * current language pack (colon by default in the English lang pack).
+     * Adding the colon can be explicitly disabled if needed. Label separators
+     * are put outside the label tag itself so they are not read by
+     * screenreaders (accessibility).
+     *
+     * Parameter $for explicitly associates the label with a form control. When
+     * set, the value of this attribute must be the same as the value of
+     * the id attribute of the form control in the same document. When null,
+     * the label being defined is associated with the control inside the label
+     * element.
+     *
+     * @param string $text content of the label tag
+     * @param string|null $for id of the element this label is associated with, null for no association
+     * @param bool $colonize add label separator (colon) to the label text, if it is not there yet
+     * @param array $attributes to be inserted in the tab, for example array('accesskey' => 'a')
+     * @return string HTML of the label element
+     */
+    public static function label($text, $for, $colonize = true, array $attributes=array()) {
+        if (!is_null($for)) {
+            $attributes = array_merge($attributes, array('for' => $for));
+        }
+        $text = trim($text ?? '');
+        $label = self::tag('label', $text, $attributes);
+
+        // TODO MDL-12192 $colonize disabled for now yet
+        // if (!empty($text) and $colonize) {
+        //     // the $text may end with the colon already, though it is bad string definition style
+        //     $colon = get_string('labelsep', 'langconfig');
+        //     if (!empty($colon)) {
+        //         $trimmed = trim($colon);
+        //         if ((substr($text, -strlen($trimmed)) == $trimmed) or (substr($text, -1) == ':')) {
+        //             //debugging('The label text should not end with colon or other label separator,
+        //             //           please fix the string definition.', DEBUG_DEVELOPER);
+        //         } else {
+        //             $label .= $colon;
+        //         }
+        //     }
+        // }
+
+        return $label;
+    }
+
+    /**
+     * Combines a class parameter with other attributes. Aids in code reduction
+     * because the class parameter is very frequently used.
+     *
+     * If the class attribute is specified both in the attributes and in the
+     * class parameter, the two values are combined with a space between.
+     *
+     * @param string $class Optional CSS class (or classes as space-separated list)
+     * @param array $attributes Optional other attributes as array
+     * @return array Attributes (or null if still none)
+     */
+    private static function add_class($class = '', array $attributes = null) {
+        if ($class !== '') {
+            $classattribute = array('class' => $class);
+            if ($attributes) {
+                if (array_key_exists('class', $attributes)) {
+                    $attributes['class'] = trim($attributes['class'] . ' ' . $class);
+                } else {
+                    $attributes = $classattribute + $attributes;
+                }
+            } else {
+                $attributes = $classattribute;
+            }
+        }
+        return $attributes;
+    }
+
+    /**
+     * Creates a <div> tag. (Shortcut function.)
+     *
+     * @param string $content HTML content of tag
+     * @param string $class Optional CSS class (or classes as space-separated list)
+     * @param array $attributes Optional other attributes as array
+     * @return string HTML code for div
+     */
+    public static function div($content, $class = '', array $attributes = null) {
+        return self::tag('div', $content, self::add_class($class, $attributes));
+    }
+
+    /**
+     * Starts a <div> tag. (Shortcut function.)
+     *
+     * @param string $class Optional CSS class (or classes as space-separated list)
+     * @param array $attributes Optional other attributes as array
+     * @return string HTML code for open div tag
+     */
+    public static function start_div($class = '', array $attributes = null) {
+        return self::start_tag('div', self::add_class($class, $attributes));
+    }
+
+    /**
+     * Ends a <div> tag. (Shortcut function.)
+     *
+     * @return string HTML code for close div tag
+     */
+    public static function end_div() {
+        return self::end_tag('div');
+    }
+
+    /**
+     * Creates a <span> tag. (Shortcut function.)
+     *
+     * @param string $content HTML content of tag
+     * @param string $class Optional CSS class (or classes as space-separated list)
+     * @param array $attributes Optional other attributes as array
+     * @return string HTML code for span
+     */
+    public static function span($content, $class = '', array $attributes = null) {
+        return self::tag('span', $content, self::add_class($class, $attributes));
+    }
+
+    /**
+     * Starts a <span> tag. (Shortcut function.)
+     *
+     * @param string $class Optional CSS class (or classes as space-separated list)
+     * @param array $attributes Optional other attributes as array
+     * @return string HTML code for open span tag
+     */
+    public static function start_span($class = '', array $attributes = null) {
+        return self::start_tag('span', self::add_class($class, $attributes));
+    }
+
+    /**
+     * Ends a <span> tag. (Shortcut function.)
+     *
+     * @return string HTML code for close span tag
+     */
+    public static function end_span() {
+        return self::end_tag('span');
+    }
+}
diff --git a/lib/classes/output/image_icon.php b/lib/classes/output/image_icon.php
new file mode 100644
index 00000000000..805b655d1b6
--- /dev/null
+++ b/lib/classes/output/image_icon.php
@@ -0,0 +1,27 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing an activity icon.
+ *
+ * The difference is that activity icons will always render with the standard icon system (no font icons).
+ *
+ * @copyright 2017 Damyon Wiese
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package core
+ */
+class image_icon extends pix_icon {
+}
diff --git a/lib/classes/output/initials_bar.php b/lib/classes/output/initials_bar.php
new file mode 100644
index 00000000000..e7c48a903ac
--- /dev/null
+++ b/lib/classes/output/initials_bar.php
@@ -0,0 +1,148 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Component representing initials bar.
+ *
+ * @copyright 2017 Ilya Tregubov
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 3.3
+ * @package core
+ * @category output
+ */
+class initials_bar implements renderable, templatable {
+
+    /**
+     * @var string Currently selected letter.
+     */
+    public $current;
+
+    /**
+     * @var string Class name to add to this initial bar.
+     */
+    public $class;
+
+    /**
+     * @var string The name to put in front of this initial bar.
+     */
+    public $title;
+
+    /**
+     * @var string URL parameter name for this initial.
+     */
+    public $urlvar;
+
+    /**
+     * @var moodle_url URL object.
+     */
+    public $url;
+
+    /**
+     * @var array An array of letters in the alphabet.
+     */
+    public $alpha;
+
+    /**
+     * @var bool Omit links if we are doing a mini render.
+     */
+    public $minirender;
+
+    /**
+     * Constructor initials_bar with only the required params.
+     *
+     * @param string $current the currently selected letter.
+     * @param string $class class name to add to this initial bar.
+     * @param string $title the name to put in front of this initial bar.
+     * @param string $urlvar URL parameter name for this initial.
+     * @param string $url URL object.
+     * @param array $alpha of letters in the alphabet.
+     * @param bool $minirender Return a trimmed down view of the initials bar.
+     */
+    public function __construct($current, $class, $title, $urlvar, $url, $alpha = null, bool $minirender = false) {
+        $this->current       = $current;
+        $this->class    = $class;
+        $this->title    = $title;
+        $this->urlvar    = $urlvar;
+        $this->url    = $url;
+        $this->alpha    = $alpha;
+        $this->minirender = $minirender;
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output The renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $data = new stdClass();
+
+        if ($this->alpha == null) {
+            $this->alpha = explode(',', get_string('alphabet', 'langconfig'));
+        }
+
+        if ($this->current == 'all') {
+            $this->current = '';
+        }
+
+        // We want to find a letter grouping size which suits the language so
+        // find the largest group size which is less than 15 chars.
+        // The choice of 15 chars is the largest number of chars that reasonably
+        // fits on the smallest supported screen size. By always using a max number
+        // of groups which is a factor of 2, we always get nice wrapping, and the
+        // last row is always the shortest.
+        $groupsize = count($this->alpha);
+        $groups = 1;
+        while ($groupsize > 15) {
+            $groups *= 2;
+            $groupsize = ceil(count($this->alpha) / $groups);
+        }
+
+        $groupsizelimit = 0;
+        $groupnumber = 0;
+        foreach ($this->alpha as $letter) {
+            if ($groupsizelimit++ > 0 && $groupsizelimit % $groupsize == 1) {
+                $groupnumber++;
+            }
+            $groupletter = new stdClass();
+            $groupletter->name = $letter;
+            if (!$this->minirender) {
+                $groupletter->url = $this->url->out(false, array($this->urlvar => $letter));
+            } else {
+                $groupletter->input = $letter;
+            }
+            if ($letter == $this->current) {
+                $groupletter->selected = $this->current;
+            }
+            if (!isset($data->group[$groupnumber])) {
+                $data->group[$groupnumber] = new stdClass();
+            }
+            $data->group[$groupnumber]->letter[] = $groupletter;
+        }
+
+        $data->class = $this->class;
+        $data->title = $this->title;
+        if (!$this->minirender) {
+            $data->url = $this->url->out(false, array($this->urlvar => ''));
+        } else {
+            $data->input = 'ALL';
+        }
+        $data->current = $this->current;
+        $data->all = get_string('all');
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/js_writer.php b/lib/classes/output/js_writer.php
new file mode 100644
index 00000000000..348fb79c0e4
--- /dev/null
+++ b/lib/classes/output/js_writer.php
@@ -0,0 +1,147 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Simple javascript output class
+ *
+ * @copyright 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class js_writer {
+
+    /**
+     * Returns javascript code calling the function
+     *
+     * @param string $function function name, can be complex like Y.Event.purgeElement
+     * @param array $arguments parameters
+     * @param int $delay execution delay in seconds
+     * @return string JS code fragment
+     */
+    public static function function_call($function, array $arguments = null, $delay=0) {
+        if ($arguments) {
+            $arguments = array_map('json_encode', convert_to_array($arguments));
+            $arguments = implode(', ', $arguments);
+        } else {
+            $arguments = '';
+        }
+        $js = "$function($arguments);";
+
+        if ($delay) {
+            $delay = $delay * 1000; // in miliseconds
+            $js = "setTimeout(function() { $js }, $delay);";
+        }
+        return $js . "\n";
+    }
+
+    /**
+     * Special function which adds Y as first argument of function call.
+     *
+     * @param string $function The function to call
+     * @param array $extraarguments Any arguments to pass to it
+     * @return string Some JS code
+     */
+    public static function function_call_with_Y($function, array $extraarguments = null) {
+        if ($extraarguments) {
+            $extraarguments = array_map('json_encode', convert_to_array($extraarguments));
+            $arguments = 'Y, ' . implode(', ', $extraarguments);
+        } else {
+            $arguments = 'Y';
+        }
+        return "$function($arguments);\n";
+    }
+
+    /**
+     * Returns JavaScript code to initialise a new object
+     *
+     * @param string $var If it is null then no var is assigned the new object.
+     * @param string $class The class to initialise an object for.
+     * @param array $arguments An array of args to pass to the init method.
+     * @param array $requirements Any modules required for this class.
+     * @param int $delay The delay before initialisation. 0 = no delay.
+     * @return string Some JS code
+     */
+    public static function object_init($var, $class, array $arguments = null, array $requirements = null, $delay=0) {
+        if (is_array($arguments)) {
+            $arguments = array_map('json_encode', convert_to_array($arguments));
+            $arguments = implode(', ', $arguments);
+        }
+
+        if ($var === null) {
+            $js = "new $class(Y, $arguments);";
+        } else if (strpos($var, '.')!==false) {
+            $js = "$var = new $class(Y, $arguments);";
+        } else {
+            $js = "var $var = new $class(Y, $arguments);";
+        }
+
+        if ($delay) {
+            $delay = $delay * 1000; // in miliseconds
+            $js = "setTimeout(function() { $js }, $delay);";
+        }
+
+        if (count($requirements) > 0) {
+            $requirements = implode("', '", $requirements);
+            $js = "Y.use('$requirements', function(Y){ $js });";
+        }
+        return $js."\n";
+    }
+
+    /**
+     * Returns code setting value to variable
+     *
+     * @param string $name
+     * @param mixed $value json serialised value
+     * @param bool $usevar add var definition, ignored for nested properties
+     * @return string JS code fragment
+     */
+    public static function set_variable($name, $value, $usevar = true) {
+        $output = '';
+
+        if ($usevar) {
+            if (strpos($name, '.')) {
+                $output .= '';
+            } else {
+                $output .= 'var ';
+            }
+        }
+
+        $output .= "$name = ".json_encode($value).";";
+
+        return $output;
+    }
+
+    /**
+     * Writes event handler attaching code
+     *
+     * @param array|string $selector standard YUI selector for elements, may be
+     *     array or string, element id is in the form "#idvalue"
+     * @param string $event A valid DOM event (click, mousedown, change etc.)
+     * @param string $function The name of the function to call
+     * @param array $arguments An optional array of argument parameters to pass to the function
+     * @return string JS code fragment
+     */
+    public static function event_handler($selector, $event, $function, array $arguments = null) {
+        $selector = json_encode($selector);
+        $output = "Y.on('$event', $function, $selector, null";
+        if (!empty($arguments)) {
+            $output .= ', ' . json_encode($arguments);
+        }
+        return $output . ");\n";
+    }
+}
diff --git a/lib/classes/output/paging_bar.php b/lib/classes/output/paging_bar.php
new file mode 100644
index 00000000000..bc6a47c632c
--- /dev/null
+++ b/lib/classes/output/paging_bar.php
@@ -0,0 +1,255 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Component representing a paging bar.
+ *
+ * @copyright 2009 Nicolas Connault
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class paging_bar implements renderable, templatable {
+
+    /**
+     * @var int The maximum number of pagelinks to display.
+     */
+    public $maxdisplay = 18;
+
+    /**
+     * @var int The total number of entries to be pages through..
+     */
+    public $totalcount;
+
+    /**
+     * @var int The page you are currently viewing.
+     */
+    public $page;
+
+    /**
+     * @var int The number of entries that should be shown per page.
+     */
+    public $perpage;
+
+    /**
+     * @var string|moodle_url If this  is a string then it is the url which will be appended with $pagevar,
+     * an equals sign and the page number.
+     * If this is a moodle_url object then the pagevar param will be replaced by
+     * the page no, for each page.
+     */
+    public $baseurl;
+
+    /**
+     * @var string This is the variable name that you use for the pagenumber in your
+     * code (ie. 'tablepage', 'blogpage', etc)
+     */
+    public $pagevar;
+
+    /**
+     * @var string A HTML link representing the "previous" page.
+     */
+    public $previouslink = null;
+
+    /**
+     * @var string A HTML link representing the "next" page.
+     */
+    public $nextlink = null;
+
+    /**
+     * @var string A HTML link representing the first page.
+     */
+    public $firstlink = null;
+
+    /**
+     * @var string A HTML link representing the last page.
+     */
+    public $lastlink = null;
+
+    /**
+     * @var array An array of strings. One of them is just a string: the current page
+     */
+    public $pagelinks = array();
+
+    /**
+     * Constructor paging_bar with only the required params.
+     *
+     * @param int $totalcount The total number of entries available to be paged through
+     * @param int $page The page you are currently viewing
+     * @param int $perpage The number of entries that should be shown per page
+     * @param string|moodle_url $baseurl url of the current page, the $pagevar parameter is added
+     * @param string $pagevar name of page parameter that holds the page number
+     */
+    public function __construct($totalcount, $page, $perpage, $baseurl, $pagevar = 'page') {
+        $this->totalcount = $totalcount;
+        $this->page       = $page;
+        $this->perpage    = $perpage;
+        $this->baseurl    = $baseurl;
+        $this->pagevar    = $pagevar;
+    }
+
+    /**
+     * Prepares the paging bar for output.
+     *
+     * This method validates the arguments set up for the paging bar and then
+     * produces fragments of HTML to assist display later on.
+     *
+     * @param renderer_base $output
+     * @param moodle_page $page
+     * @param string $target
+     * @throws coding_exception
+     */
+    public function prepare(renderer_base $output, moodle_page $page, $target) {
+        if (!isset($this->totalcount) || is_null($this->totalcount)) {
+            throw new coding_exception('paging_bar requires a totalcount value.');
+        }
+        if (!isset($this->page) || is_null($this->page)) {
+            throw new coding_exception('paging_bar requires a page value.');
+        }
+        if (empty($this->perpage)) {
+            throw new coding_exception('paging_bar requires a perpage value.');
+        }
+        if (empty($this->baseurl)) {
+            throw new coding_exception('paging_bar requires a baseurl value.');
+        }
+
+        if ($this->totalcount > $this->perpage) {
+            $pagenum = $this->page - 1;
+
+            if ($this->page > 0) {
+                $this->previouslink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$pagenum)), get_string('previous'), array('class'=>'previous'));
+            }
+
+            if ($this->perpage > 0) {
+                $lastpage = ceil($this->totalcount / $this->perpage);
+            } else {
+                $lastpage = 1;
+            }
+
+            if ($this->page > round(($this->maxdisplay/3)*2)) {
+                $currpage = $this->page - round($this->maxdisplay/3);
+
+                $this->firstlink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>0)), '1', array('class'=>'first'));
+            } else {
+                $currpage = 0;
+            }
+
+            $displaycount = $displaypage = 0;
+
+            while ($displaycount < $this->maxdisplay and $currpage < $lastpage) {
+                $displaypage = $currpage + 1;
+
+                if ($this->page == $currpage) {
+                    $this->pagelinks[] = html_writer::span($displaypage, 'current-page');
+                } else {
+                    $pagelink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$currpage)), $displaypage);
+                    $this->pagelinks[] = $pagelink;
+                }
+
+                $displaycount++;
+                $currpage++;
+            }
+
+            if ($currpage < $lastpage) {
+                $lastpageactual = $lastpage - 1;
+                $this->lastlink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$lastpageactual)), $lastpage, array('class'=>'last'));
+            }
+
+            $pagenum = $this->page + 1;
+
+            if ($pagenum != $lastpage) {
+                $this->nextlink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$pagenum)), get_string('next'), array('class'=>'next'));
+            }
+        }
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output The renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $data = new stdClass();
+        $data->previous = null;
+        $data->next = null;
+        $data->first = null;
+        $data->last = null;
+        $data->label = get_string('page');
+        $data->pages = [];
+        $data->haspages = $this->totalcount > $this->perpage;
+        $data->pagesize = $this->perpage;
+
+        if (!$data->haspages) {
+            return $data;
+        }
+
+        if ($this->page > 0) {
+            $data->previous = [
+                'page' => $this->page,
+                'url' => (new moodle_url($this->baseurl, [$this->pagevar => $this->page - 1]))->out(false)
+            ];
+        }
+
+        $currpage = 0;
+        if ($this->page > round(($this->maxdisplay / 3) * 2)) {
+            $currpage = $this->page - round($this->maxdisplay / 3);
+            $data->first = [
+                'page' => 1,
+                'url' => (new moodle_url($this->baseurl, [$this->pagevar => 0]))->out(false)
+            ];
+        }
+
+        $lastpage = 1;
+        if ($this->perpage > 0) {
+            $lastpage = ceil($this->totalcount / $this->perpage);
+        }
+
+        $displaycount = 0;
+        $displaypage = 0;
+        while ($displaycount < $this->maxdisplay and $currpage < $lastpage) {
+            $displaypage = $currpage + 1;
+
+            $iscurrent = $this->page == $currpage;
+            $link = new moodle_url($this->baseurl, [$this->pagevar => $currpage]);
+
+            $data->pages[] = [
+                'page' => $displaypage,
+                'active' => $iscurrent,
+                'url' => $iscurrent ? null : $link->out(false)
+            ];
+
+            $displaycount++;
+            $currpage++;
+        }
+
+        if ($currpage < $lastpage) {
+            $data->last = [
+                'page' => $lastpage,
+                'url' => (new moodle_url($this->baseurl, [$this->pagevar => $lastpage - 1]))->out(false)
+            ];
+        }
+
+        if ($this->page + 1 != $lastpage) {
+            $data->next = [
+                'page' => $this->page + 2,
+                'url' => (new moodle_url($this->baseurl, [$this->pagevar => $this->page + 1]))->out(false)
+            ];
+        }
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/pix_emoticon.php b/lib/classes/output/pix_emoticon.php
new file mode 100644
index 00000000000..5740c729f25
--- /dev/null
+++ b/lib/classes/output/pix_emoticon.php
@@ -0,0 +1,40 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing an emoticon image
+ *
+ * @copyright 2010 David Mudrak
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class pix_emoticon extends pix_icon implements renderable {
+    /**
+     * Constructor
+     * @param string $pix short icon name
+     * @param string $alt alternative text
+     * @param string $component emoticon image provider
+     * @param array $attributes explicit HTML attributes
+     */
+    public function __construct($pix, $alt, $component = 'moodle', array $attributes = array()) {
+        if (empty($attributes['class'])) {
+            $attributes['class'] = 'emoticon';
+        }
+        parent::__construct($pix, $alt, $component, $attributes);
+    }
+}
diff --git a/lib/classes/output/pix_icon.php b/lib/classes/output/pix_icon.php
new file mode 100644
index 00000000000..0106e7c0d52
--- /dev/null
+++ b/lib/classes/output/pix_icon.php
@@ -0,0 +1,143 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing an icon.
+ *
+ * @copyright 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class pix_icon implements renderable, templatable {
+
+    /**
+     * @var string The icon name
+     */
+    var $pix;
+
+    /**
+     * @var string The component the icon belongs to.
+     */
+    var $component;
+
+    /**
+     * @var array An array of attributes to use on the icon
+     */
+    var $attributes = array();
+
+    /**
+     * Constructor
+     *
+     * @param string $pix short icon name
+     * @param string $alt The alt text to use for the icon
+     * @param string $component component name
+     * @param array $attributes html attributes
+     */
+    public function __construct($pix, $alt, $component='moodle', array $attributes = null) {
+        global $PAGE;
+
+        $this->pix = $pix;
+        $this->component  = $component;
+        $this->attributes = (array)$attributes;
+
+        if (empty($this->attributes['class'])) {
+            $this->attributes['class'] = '';
+        }
+
+        // Set an additional class for big icons so that they can be styled properly.
+        if (substr($pix, 0, 2) === 'b/') {
+            $this->attributes['class'] .= ' iconsize-big';
+        }
+
+        // If the alt is empty, don't place it in the attributes, otherwise it will override parent alt text.
+        if (!is_null($alt)) {
+            $this->attributes['alt'] = $alt;
+
+            // If there is no title, set it to the attribute.
+            if (!isset($this->attributes['title'])) {
+                $this->attributes['title'] = $this->attributes['alt'];
+            }
+        } else {
+            unset($this->attributes['alt']);
+        }
+
+        if (empty($this->attributes['title'])) {
+            // Remove the title attribute if empty, we probably want to use the parent node's title
+            // and some browsers might overwrite it with an empty title.
+            unset($this->attributes['title']);
+        }
+
+        // Hide icons from screen readers that have no alt.
+        if (empty($this->attributes['alt'])) {
+            $this->attributes['aria-hidden'] = 'true';
+        }
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
+     * @return array
+     */
+    public function export_for_template(renderer_base $output) {
+        $attributes = $this->attributes;
+        $extraclasses = '';
+
+        foreach ($attributes as $key => $item) {
+            if ($key == 'class') {
+                $extraclasses = $item;
+                unset($attributes[$key]);
+                break;
+            }
+        }
+
+        $attributes['src'] = $output->image_url($this->pix, $this->component)->out(false);
+        $templatecontext = array();
+        foreach ($attributes as $name => $value) {
+            $templatecontext[] = array('name' => $name, 'value' => $value);
+        }
+        $title = isset($attributes['title']) ? $attributes['title'] : '';
+        if (empty($title)) {
+            $title = isset($attributes['alt']) ? $attributes['alt'] : '';
+        }
+        $data = array(
+            'attributes' => $templatecontext,
+            'extraclasses' => $extraclasses
+        );
+
+        return $data;
+    }
+
+    /**
+     * Much simpler version of export that will produce the data required to render this pix with the
+     * pix helper in a mustache tag.
+     *
+     * @return array
+     */
+    public function export_for_pix() {
+        $title = isset($this->attributes['title']) ? $this->attributes['title'] : '';
+        if (empty($title)) {
+            $title = isset($this->attributes['alt']) ? $this->attributes['alt'] : '';
+        }
+        return [
+            'key' => $this->pix,
+            'component' => $this->component,
+            'title' => (string) $title,
+        ];
+    }
+}
diff --git a/lib/classes/output/pix_icon_font.php b/lib/classes/output/pix_icon_font.php
new file mode 100644
index 00000000000..280853de86a
--- /dev/null
+++ b/lib/classes/output/pix_icon_font.php
@@ -0,0 +1,93 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing an icon font.
+ *
+ * @copyright 2016 Damyon Wiese
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package core
+ * @category output
+ */
+class pix_icon_font implements templatable {
+
+    /**
+     * @var pix_icon $pixicon The original icon.
+     */
+    private $pixicon = null;
+
+    /**
+     * @var string $key The mapped key.
+     */
+    private $key;
+
+    /**
+     * @var bool $mapped The icon could not be mapped.
+     */
+    private $mapped;
+
+    /**
+     * Constructor
+     *
+     * @param pix_icon $pixicon The original icon
+     */
+    public function __construct(pix_icon $pixicon) {
+        global $PAGE;
+
+        $this->pixicon = $pixicon;
+        $this->mapped = false;
+        $iconsystem = \core\output\icon_system::instance();
+
+        $this->key = $iconsystem->remap_icon_name($pixicon->pix, $pixicon->component);
+        if (!empty($this->key)) {
+            $this->mapped = true;
+        }
+    }
+
+    /**
+     * Return true if this pix_icon was successfully mapped to an icon font.
+     *
+     * @return bool
+     */
+    public function is_mapped() {
+        return $this->mapped;
+    }
+
+    /**
+     * Export this data so it can be used as the context for a mustache template.
+     *
+     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
+     * @return array
+     */
+    public function export_for_template(renderer_base $output) {
+
+        $pixdata = $this->pixicon->export_for_template($output);
+
+        $title = isset($this->pixicon->attributes['title']) ? $this->pixicon->attributes['title'] : '';
+        $alt = isset($this->pixicon->attributes['alt']) ? $this->pixicon->attributes['alt'] : '';
+        if (empty($title)) {
+            $title = $alt;
+        }
+        $data = array(
+            'extraclasses' => $pixdata['extraclasses'],
+            'title' => $title,
+            'alt' => $alt,
+            'key' => $this->key
+        );
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/pix_icon_fontawesome.php b/lib/classes/output/pix_icon_fontawesome.php
new file mode 100644
index 00000000000..8cab6924e5c
--- /dev/null
+++ b/lib/classes/output/pix_icon_fontawesome.php
@@ -0,0 +1,26 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing an icon subtype.
+ *
+ * @copyright 2016 Damyon Wiese
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package core
+ * @category output
+ */
+class pix_icon_fontawesome extends pix_icon_font {
+}
diff --git a/lib/classes/output/plugin_renderer_base.php b/lib/classes/output/plugin_renderer_base.php
new file mode 100644
index 00000000000..922d867a867
--- /dev/null
+++ b/lib/classes/output/plugin_renderer_base.php
@@ -0,0 +1,131 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Basis for all plugin renderers.
+ *
+ * @copyright Petr Skoda (skodak)
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class plugin_renderer_base extends renderer_base {
+
+    /**
+     * @var renderer_base|core_renderer A reference to the current renderer.
+     * The renderer provided here will be determined by the page but will in 90%
+     * of cases by the {@link core_renderer}
+     */
+    protected $output;
+
+    /**
+     * Constructor method, calls the parent constructor
+     *
+     * @param moodle_page $page
+     * @param string $target one of rendering target constants
+     */
+    public function __construct(moodle_page $page, $target) {
+        if (empty($target) && $page->pagelayout === 'maintenance') {
+            // If the page is using the maintenance layout then we're going to force the target to maintenance.
+            // This way we'll get a special maintenance renderer that is designed to block access to API's that are likely
+            // unavailable for this page layout.
+            $target = RENDERER_TARGET_MAINTENANCE;
+        }
+        $this->output = $page->get_renderer('core', null, $target);
+        parent::__construct($page, $target);
+    }
+
+    /**
+     * Renders the provided widget and returns the HTML to display it.
+     *
+     * @param renderable $widget instance with renderable interface
+     * @return string
+     */
+    public function render(renderable $widget) {
+        $classname = get_class($widget);
+
+        // Strip namespaces.
+        $classname = preg_replace('/^.*\\\/', '', $classname);
+
+        // Keep a copy at this point, we may need to look for a deprecated method.
+        $deprecatedmethod = "render_{$classname}";
+
+        // Remove _renderable suffixes.
+        $classname = preg_replace('/_renderable$/', '', $classname);
+        $rendermethod = "render_{$classname}";
+
+        if (method_exists($this, $rendermethod)) {
+            // Call the render_[widget_name] function.
+            // Note: This has a higher priority than the named_templatable to allow the theme to override the template.
+            return $this->$rendermethod($widget);
+        }
+
+        if ($widget instanceof named_templatable) {
+            // This is a named templatable.
+            // Fetch the template name from the get_template_name function instead.
+            // Note: This has higher priority than the deprecated method which is not overridable by themes anyway.
+            return $this->render_from_template(
+                $widget->get_template_name($this),
+                $widget->export_for_template($this)
+            );
+        }
+
+        if ($rendermethod !== $deprecatedmethod && method_exists($this, $deprecatedmethod)) {
+            // This is exactly where we don't want to be.
+            // If you have arrived here you have a renderable component within your plugin that has the name
+            // blah_renderable, and you have a render method render_blah_renderable on your plugin.
+            // In 2.8 we revamped output, as part of this change we changed slightly how renderables got rendered
+            // and the _renderable suffix now gets removed when looking for a render method.
+            // You need to change your renderers render_blah_renderable to render_blah.
+            // Until you do this it will not be possible for a theme to override the renderer to override your method.
+            // Please do it ASAP.
+            static $debugged = [];
+            if (!isset($debugged[$deprecatedmethod])) {
+                debugging(sprintf(
+                    'Deprecated call. Please rename your renderables render method from %s to %s.',
+                    $deprecatedmethod,
+                    $rendermethod
+                ), DEBUG_DEVELOPER);
+                $debugged[$deprecatedmethod] = true;
+            }
+            return $this->$deprecatedmethod($widget);
+        }
+
+        // Pass to core renderer if method not found here.
+        // Note: this is not a parent. This is _new_ renderer which respects the requested format, and output type.
+        return $this->output->render($widget);
+    }
+
+    /**
+     * Magic method used to pass calls otherwise meant for the standard renderer
+     * to it to ensure we don't go causing unnecessary grief.
+     *
+     * @param string $method
+     * @param array $arguments
+     * @return mixed
+     */
+    public function __call($method, $arguments) {
+        if (method_exists('renderer_base', $method)) {
+            throw new coding_exception('Protected method called against '.get_class($this).' :: '.$method);
+        }
+        if (method_exists($this->output, $method)) {
+            return call_user_func_array(array($this->output, $method), $arguments);
+        } else {
+            throw new coding_exception('Unknown method called against '.get_class($this).' :: '.$method);
+        }
+    }
+}
diff --git a/lib/classes/output/preferences_group.php b/lib/classes/output/preferences_group.php
new file mode 100644
index 00000000000..bc8a5d0d7a7
--- /dev/null
+++ b/lib/classes/output/preferences_group.php
@@ -0,0 +1,47 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Represents a group of preferences page link.
+ *
+ * @package core
+ * @category output
+ * @copyright 2015 Frédéric Massart - FMCorz.net
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class preferences_group implements renderable {
+    /**
+     * Title of the group.
+     * @var string
+     */
+    public $title;
+
+    /**
+     * Array of navigation_node.
+     * @var array
+     */
+    public $nodes;
+
+    /**
+     * Constructor.
+     * @param string $title The title.
+     * @param array $nodes of navigation_node.
+     */
+    public function __construct($title, $nodes) {
+        $this->title = $title;
+        $this->nodes = $nodes;
+    }
+}
diff --git a/lib/classes/output/preferences_groups.php b/lib/classes/output/preferences_groups.php
new file mode 100644
index 00000000000..6bdcf936fb0
--- /dev/null
+++ b/lib/classes/output/preferences_groups.php
@@ -0,0 +1,39 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Represents a set of preferences groups.
+ *
+ * @package core
+ * @category output
+ * @copyright 2015 Frédéric Massart - FMCorz.net
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ */
+class preferences_groups implements renderable {
+    /**
+     * Array of preferences_group.
+     * @var array
+     */
+    public $groups;
+
+    /**
+     * Constructor.
+     * @param array $groups of preferences_group
+     */
+    public function __construct($groups) {
+        $this->groups = $groups;
+    }
+}
diff --git a/lib/classes/output/progress_bar.php b/lib/classes/output/progress_bar.php
new file mode 100644
index 00000000000..a674ec87d28
--- /dev/null
+++ b/lib/classes/output/progress_bar.php
@@ -0,0 +1,204 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Progress bar class.
+ *
+ * Manages the display of a progress bar.
+ *
+ * To use this class.
+ * - construct
+ * - call create (or use the 3rd param to the constructor)
+ * - call update or update_full() or update() repeatedly
+ *
+ * @copyright 2008 jamiesensei
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package core
+ * @category output
+ */
+class progress_bar implements renderable, templatable {
+    /** @var string html id */
+    private $html_id;
+    /** @var int total width */
+    private $width;
+    /** @var int last percentage printed */
+    private $percent = 0;
+    /** @var int time when last printed */
+    private $lastupdate = 0;
+    /** @var int when did we start printing this */
+    private $time_start = 0;
+
+    /**
+     * Constructor
+     *
+     * Prints JS code if $autostart true.
+     *
+     * @param string $htmlid The container ID.
+     * @param int $width The suggested width.
+     * @param bool $autostart Whether to start the progress bar right away.
+     */
+    public function __construct($htmlid = '', $width = 500, $autostart = false) {
+        if (!CLI_SCRIPT && !NO_OUTPUT_BUFFERING) {
+            debugging('progress_bar used in a non-CLI script without setting NO_OUTPUT_BUFFERING.', DEBUG_DEVELOPER);
+        }
+
+        if (!empty($htmlid)) {
+            $this->html_id  = $htmlid;
+        } else {
+            $this->html_id  = 'pbar_'.uniqid();
+        }
+
+        $this->width = $width;
+
+        if ($autostart) {
+            $this->create();
+        }
+    }
+
+    /**
+     * Getter for ID
+     * @return string id
+     */
+    public function get_id(): string {
+        return $this->html_id;
+    }
+
+    /**
+     * Create a new progress bar, this function will output html.
+     *
+     * @return void Echo's output
+     */
+    public function create() {
+        global $OUTPUT;
+
+        $this->time_start = microtime(true);
+
+        flush();
+        echo $OUTPUT->render($this);
+        flush();
+    }
+
+    /**
+     * Update the progress bar.
+     *
+     * @param int $percent From 1-100.
+     * @param string $msg The message.
+     * @return void Echo's output
+     * @throws coding_exception
+     */
+    private function _update($percent, $msg) {
+        global $OUTPUT;
+
+        if (empty($this->time_start)) {
+            throw new coding_exception('You must call create() (or use the $autostart ' .
+                'argument to the constructor) before you try updating the progress bar.');
+        }
+
+        $estimate = $this->estimate($percent);
+
+        if ($estimate === null) {
+            // Always do the first and last updates.
+        } else if ($estimate == 0) {
+            // Always do the last updates.
+        } else if ($this->lastupdate + 20 < time()) {
+            // We must update otherwise browser would time out.
+        } else if (round($this->percent, 2) === round($percent, 2)) {
+            // No significant change, no need to update anything.
+            return;
+        }
+
+        $estimatemsg = '';
+        if ($estimate != 0 && is_numeric($estimate)) {
+            // Err on the conservative side and also avoid showing 'now' as the estimate.
+            $estimatemsg = format_time(ceil($estimate));
+        }
+
+        $this->percent = $percent;
+        $this->lastupdate = microtime(true);
+
+        echo $OUTPUT->render_progress_bar_update($this->html_id, $this->percent, $msg, $estimatemsg);
+        flush();
+    }
+
+    /**
+     * Estimate how much time it is going to take.
+     *
+     * @param int $pt From 1-100.
+     * @return mixed Null (unknown), or int.
+     */
+    private function estimate($pt) {
+        if ($this->lastupdate == 0) {
+            return null;
+        }
+        if ($pt < 0.00001) {
+            return null; // We do not know yet how long it will take.
+        }
+        if ($pt > 99.99999) {
+            return 0; // Nearly done, right?
+        }
+        $consumed = microtime(true) - $this->time_start;
+        if ($consumed < 0.001) {
+            return null;
+        }
+
+        return (100 - $pt) * ($consumed / $pt);
+    }
+
+    /**
+     * Update progress bar according percent.
+     *
+     * @param int $percent From 1-100.
+     * @param string $msg The message needed to be shown.
+     */
+    public function update_full($percent, $msg) {
+        $percent = max(min($percent, 100), 0);
+        $this->_update($percent, $msg);
+    }
+
+    /**
+     * Update progress bar according the number of tasks.
+     *
+     * @param int $cur Current task number.
+     * @param int $total Total task number.
+     * @param string $msg The message needed to be shown.
+     */
+    public function update($cur, $total, $msg) {
+        $percent = ($cur / $total) * 100;
+        $this->update_full($percent, $msg);
+    }
+
+    /**
+     * Restart the progress bar.
+     */
+    public function restart() {
+        $this->percent    = 0;
+        $this->lastupdate = 0;
+        $this->time_start = 0;
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param  renderer_base $output The renderer.
+     * @return array
+     */
+    public function export_for_template(renderer_base $output) {
+        return [
+            'id' => $this->html_id,
+            'width' => $this->width,
+        ];
+    }
+}
diff --git a/lib/classes/output/renderable.php b/lib/classes/output/renderable.php
new file mode 100644
index 00000000000..7c1a065146b
--- /dev/null
+++ b/lib/classes/output/renderable.php
@@ -0,0 +1,26 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Interface marking other classes as suitable for renderer_base::render()
+ *
+ * @copyright 2010 Petr Skoda (skodak) info@skodak.org
+ * @package core
+ * @category output
+ */
+interface renderable {
+    // intentionally empty
+}
diff --git a/lib/classes/output/renderer_base.php b/lib/classes/output/renderer_base.php
new file mode 100644
index 00000000000..c33c12bfafe
--- /dev/null
+++ b/lib/classes/output/renderer_base.php
@@ -0,0 +1,406 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+use core\output\named_templatable;
+
+/**
+ * Simple base class for Moodle renderers.
+ *
+ * Tracks the xhtml_container_stack to use, which is passed in in the constructor.
+ *
+ * Also has methods to facilitate generating HTML output.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class renderer_base {
+    /**
+     * @var xhtml_container_stack The xhtml_container_stack to use.
+     */
+    protected $opencontainers;
+
+    /**
+     * @var moodle_page The Moodle page the renderer has been created to assist with.
+     */
+    protected $page;
+
+    /**
+     * @var string The requested rendering target.
+     */
+    protected $target;
+
+    /**
+     * @var Mustache_Engine $mustache The mustache template compiler
+     */
+    private $mustache;
+
+    /**
+     * @var array $templatecache The mustache template cache.
+     */
+    protected $templatecache = [];
+
+    /**
+     * Return an instance of the mustache class.
+     *
+     * @since 2.9
+     * @return Mustache_Engine
+     */
+    protected function get_mustache() {
+        global $CFG;
+
+        if ($this->mustache === null) {
+            require_once("{$CFG->libdir}/filelib.php");
+
+            $themename = $this->page->theme->name;
+            $themerev = theme_get_revision();
+
+            // Create new localcache directory.
+            $cachedir = make_localcache_directory("mustache/$themerev/$themename");
+
+            // Remove old localcache directories.
+            $mustachecachedirs = glob("{$CFG->localcachedir}/mustache/*", GLOB_ONLYDIR);
+            foreach ($mustachecachedirs as $localcachedir) {
+                $cachedrev = [];
+                preg_match("/\/mustache\/([0-9]+)$/", $localcachedir, $cachedrev);
+                $cachedrev = isset($cachedrev[1]) ? intval($cachedrev[1]) : 0;
+                if ($cachedrev > 0 && $cachedrev < $themerev) {
+                    fulldelete($localcachedir);
+                }
+            }
+
+            $loader = new \core\output\mustache_filesystem_loader();
+            $stringhelper = new \core\output\mustache_string_helper();
+            $cleanstringhelper = new \core\output\mustache_clean_string_helper();
+            $quotehelper = new \core\output\mustache_quote_helper();
+            $jshelper = new \core\output\mustache_javascript_helper($this->page);
+            $pixhelper = new \core\output\mustache_pix_helper($this);
+            $shortentexthelper = new \core\output\mustache_shorten_text_helper();
+            $userdatehelper = new \core\output\mustache_user_date_helper();
+
+            // We only expose the variables that are exposed to JS templates.
+            $safeconfig = $this->page->requires->get_config_for_javascript($this->page, $this);
+
+            $helpers = array('config' => $safeconfig,
+                             'str' => array($stringhelper, 'str'),
+                             'cleanstr' => array($cleanstringhelper, 'cleanstr'),
+                             'quote' => array($quotehelper, 'quote'),
+                             'js' => array($jshelper, 'help'),
+                             'pix' => array($pixhelper, 'pix'),
+                             'shortentext' => array($shortentexthelper, 'shorten'),
+                             'userdate' => array($userdatehelper, 'transform'),
+                         );
+
+            $this->mustache = new \core\output\mustache_engine(array(
+                'cache' => $cachedir,
+                'escape' => 's',
+                'loader' => $loader,
+                'helpers' => $helpers,
+                'pragmas' => [Mustache_Engine::PRAGMA_BLOCKS],
+                // Don't allow the JavaScript helper to be executed from within another
+                // helper. If it's allowed it can be used by users to inject malicious
+                // JS into the page.
+                'disallowednestedhelpers' => ['js'],
+                // Disable lambda rendering - content in helpers is already rendered, no need to render it again.
+                'disable_lambda_rendering' => true,
+            ));
+
+        }
+
+        return $this->mustache;
+    }
+
+
+    /**
+     * Constructor
+     *
+     * The constructor takes two arguments. The first is the page that the renderer
+     * has been created to assist with, and the second is the target.
+     * The target is an additional identifier that can be used to load different
+     * renderers for different options.
+     *
+     * @param moodle_page $page the page we are doing output for.
+     * @param string $target one of rendering target constants
+     */
+    public function __construct(moodle_page $page, $target) {
+        $this->opencontainers = $page->opencontainers;
+        $this->page = $page;
+        $this->target = $target;
+    }
+
+    /**
+     * Renders a template by name with the given context.
+     *
+     * The provided data needs to be array/stdClass made up of only simple types.
+     * Simple types are array,stdClass,bool,int,float,string
+     *
+     * @since 2.9
+     * @param array|stdClass $context Context containing data for the template.
+     * @return string|boolean
+     */
+    public function render_from_template($templatename, $context) {
+        $mustache = $this->get_mustache();
+
+        if ($mustache->hasHelper('uniqid')) {
+            // Grab a copy of the existing helper to be restored later.
+            $uniqidhelper = $mustache->getHelper('uniqid');
+        } else {
+            // Helper doesn't exist.
+            $uniqidhelper = null;
+        }
+
+        // Provide 1 random value that will not change within a template
+        // but will be different from template to template. This is useful for
+        // e.g. aria attributes that only work with id attributes and must be
+        // unique in a page.
+        $mustache->addHelper('uniqid', new \core\output\mustache_uniqid_helper());
+        if (isset($this->templatecache[$templatename])) {
+            $template = $this->templatecache[$templatename];
+        } else {
+            try {
+                $template = $mustache->loadTemplate($templatename);
+                $this->templatecache[$templatename] = $template;
+            } catch (Mustache_Exception_UnknownTemplateException $e) {
+                throw new moodle_exception('Unknown template: ' . $templatename);
+            }
+        }
+
+        $renderedtemplate = trim($template->render($context));
+
+        // If we had an existing uniqid helper then we need to restore it to allow
+        // handle nested calls of render_from_template.
+        if ($uniqidhelper) {
+            $mustache->addHelper('uniqid', $uniqidhelper);
+        }
+
+        return $renderedtemplate;
+    }
+
+
+    /**
+     * Returns rendered widget.
+     *
+     * The provided widget needs to be an object that extends the renderable
+     * interface.
+     * If will then be rendered by a method based upon the classname for the widget.
+     * For instance a widget of class `crazywidget` will be rendered by a protected
+     * render_crazywidget method of this renderer.
+     * If no render_crazywidget method exists and crazywidget implements templatable,
+     * look for the 'crazywidget' template in the same component and render that.
+     *
+     * @param renderable $widget instance with renderable interface
+     * @return string
+     */
+    public function render(renderable $widget) {
+        $classparts = explode('\\', get_class($widget));
+        // Strip namespaces.
+        $classname = array_pop($classparts);
+        // Remove _renderable suffixes.
+        $classname = preg_replace('/_renderable$/', '', $classname);
+
+        $rendermethod = "render_{$classname}";
+        if (method_exists($this, $rendermethod)) {
+            // Call the render_[widget_name] function.
+            // Note: This has a higher priority than the named_templatable to allow the theme to override the template.
+            return $this->$rendermethod($widget);
+        }
+
+        if ($widget instanceof named_templatable) {
+            // This is a named templatable.
+            // Fetch the template name from the get_template_name function instead.
+            // Note: This has higher priority than the guessed template name.
+            return $this->render_from_template(
+                $widget->get_template_name($this),
+                $widget->export_for_template($this)
+            );
+        }
+
+        if ($widget instanceof templatable) {
+            // Guess the templat ename based on the class name.
+            // Note: There's no benefit to moving this aboved the named_templatable and this approach is more costly.
+            $component = array_shift($classparts);
+            if (!$component) {
+                $component = 'core';
+            }
+            $template = $component . '/' . $classname;
+            $context = $widget->export_for_template($this);
+            return $this->render_from_template($template, $context);
+        }
+        throw new coding_exception("Can not render widget, renderer method ('{$rendermethod}') not found.");
+    }
+
+    /**
+     * Adds a JS action for the element with the provided id.
+     *
+     * This method adds a JS event for the provided component action to the page
+     * and then returns the id that the event has been attached to.
+     * If no id has been provided then a new ID is generated by {@link html_writer::random_id()}
+     *
+     * @param component_action $action
+     * @param string $id
+     * @return string id of element, either original submitted or random new if not supplied
+     */
+    public function add_action_handler(component_action $action, $id = null) {
+        if (!$id) {
+            $id = html_writer::random_id($action->event);
+        }
+        $this->page->requires->event_handler("#$id", $action->event, $action->jsfunction, $action->jsfunctionargs);
+        return $id;
+    }
+
+    /**
+     * Returns true is output has already started, and false if not.
+     *
+     * @return boolean true if the header has been printed.
+     */
+    public function has_started() {
+        return $this->page->state >= moodle_page::STATE_IN_BODY;
+    }
+
+    /**
+     * Given an array or space-separated list of classes, prepares and returns the HTML class attribute value
+     *
+     * @param mixed $classes Space-separated string or array of classes
+     * @return string HTML class attribute value
+     */
+    public static function prepare_classes($classes) {
+        if (is_array($classes)) {
+            return implode(' ', array_unique($classes));
+        }
+        return $classes;
+    }
+
+    /**
+     * Return the direct URL for an image from the pix folder.
+     *
+     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.
+     *
+     * @deprecated since Moodle 3.3
+     * @param string $imagename the name of the icon.
+     * @param string $component specification of one plugin like in get_string()
+     * @return moodle_url
+     */
+    public function pix_url($imagename, $component = 'moodle') {
+        debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER);
+        return $this->page->theme->image_url($imagename, $component);
+    }
+
+    /**
+     * Return the moodle_url for an image.
+     *
+     * The exact image location and extension is determined
+     * automatically by searching for gif|png|jpg|jpeg, please
+     * note there can not be diferent images with the different
+     * extension. The imagename is for historical reasons
+     * a relative path name, it may be changed later for core
+     * images. It is recommended to not use subdirectories
+     * in plugin and theme pix directories.
+     *
+     * There are three types of images:
+     * 1/ theme images  - stored in theme/mytheme/pix/,
+     *                    use component 'theme'
+     * 2/ core images   - stored in /pix/,
+     *                    overridden via theme/mytheme/pix_core/
+     * 3/ plugin images - stored in mod/mymodule/pix,
+     *                    overridden via theme/mytheme/pix_plugins/mod/mymodule/,
+     *                    example: image_url('comment', 'mod_glossary')
+     *
+     * @param string $imagename the pathname of the image
+     * @param string $component full plugin name (aka component) or 'theme'
+     * @return moodle_url
+     */
+    public function image_url($imagename, $component = 'moodle') {
+        return $this->page->theme->image_url($imagename, $component);
+    }
+
+    /**
+     * Return the site's logo URL, if any.
+     *
+     * @param int $maxwidth The maximum width, or null when the maximum width does not matter.
+     * @param int $maxheight The maximum height, or null when the maximum height does not matter.
+     * @return moodle_url|false
+     */
+    public function get_logo_url($maxwidth = null, $maxheight = 200) {
+        global $CFG;
+        $logo = get_config('core_admin', 'logo');
+        if (empty($logo)) {
+            return false;
+        }
+
+        // 200px high is the default image size which should be displayed at 100px in the page to account for retina displays.
+        // It's not worth the overhead of detecting and serving 2 different images based on the device.
+
+        // Hide the requested size in the file path.
+        $filepath = ((int) $maxwidth . 'x' . (int) $maxheight) . '/';
+
+        // Use $CFG->themerev to prevent browser caching when the file changes.
+        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'logo', $filepath,
+            theme_get_revision(), $logo);
+    }
+
+    /**
+     * Return the site's compact logo URL, if any.
+     *
+     * @param int $maxwidth The maximum width, or null when the maximum width does not matter.
+     * @param int $maxheight The maximum height, or null when the maximum height does not matter.
+     * @return moodle_url|false
+     */
+    public function get_compact_logo_url($maxwidth = 300, $maxheight = 300) {
+        global $CFG;
+        $logo = get_config('core_admin', 'logocompact');
+        if (empty($logo)) {
+            return false;
+        }
+
+        // Hide the requested size in the file path.
+        $filepath = ((int) $maxwidth . 'x' . (int) $maxheight) . '/';
+
+        // Use $CFG->themerev to prevent browser caching when the file changes.
+        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'logocompact', $filepath,
+            theme_get_revision(), $logo);
+    }
+
+    /**
+     * Whether we should display the logo in the navbar.
+     *
+     * We will when there are no main logos, and we have compact logo.
+     *
+     * @return bool
+     */
+    public function should_display_navbar_logo() {
+        $logo = $this->get_compact_logo_url();
+        return !empty($logo);
+    }
+
+    /**
+     * @deprecated since Moodle 4.0
+     */
+    #[\core\attribute\deprecated(null, reason: 'It is no longer used', since: '4.0', final: true)]
+    public function should_display_main_logo() {
+        \core\deprecation::emit_deprecation_if_present([self::class, __FUNCTION__]);
+    }
+
+    /**
+     * Returns the moodle page object.
+     *
+     * @return moodle_page
+     */
+    public function get_page(): moodle_page {
+        return $this->page;
+    }
+}
diff --git a/lib/classes/output/renderer_factory/renderer_factory_base.php b/lib/classes/output/renderer_factory/renderer_factory_base.php
new file mode 100644
index 00000000000..73367d34bf0
--- /dev/null
+++ b/lib/classes/output/renderer_factory/renderer_factory_base.php
@@ -0,0 +1,197 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This is a base class to help you implement the renderer_factory interface.
+ *
+ * It keeps a cache of renderers that have been constructed, so you only need
+ * to construct each one once in you subclass.
+ *
+ * It also has a method to get the name of, and include the renderer.php with
+ * the definition of, the standard renderer class for a given module.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+abstract class renderer_factory_base implements renderer_factory {
+    /**
+     * @var theme_config The theme we belong to.
+     */
+    protected $theme;
+
+    /**
+     * Constructor.
+     *
+     * @param theme_config $theme the theme we belong to.
+     */
+    public function __construct(theme_config $theme) {
+        $this->theme = $theme;
+    }
+
+    /**
+     * Returns suffix of renderer class expected for given target.
+     *
+     * @param string $target one of the renderer target constants, target is guessed if null used
+     * @return array two element array, first element is target, second the target suffix string
+     */
+    protected function get_target_suffix($target) {
+        if (empty($target) || $target === RENDERER_TARGET_MAINTENANCE) {
+            // If the target hasn't been specified we need to guess the defaults.
+            // We also override the target with the default if the maintenance target has been provided.
+            // This ensures we don't use the maintenance renderer if we are processing a special target.
+            if (defined('PREFERRED_RENDERER_TARGET')) {
+                $target = PREFERRED_RENDERER_TARGET;
+            } else if (CLI_SCRIPT) {
+                $target = RENDERER_TARGET_CLI;
+            } else if (AJAX_SCRIPT) {
+                $target = RENDERER_TARGET_AJAX;
+            }
+        }
+
+        switch ($target) {
+            case RENDERER_TARGET_CLI: $suffix = '_cli'; break;
+            case RENDERER_TARGET_AJAX: $suffix = '_ajax'; break;
+            case RENDERER_TARGET_TEXTEMAIL: $suffix = '_textemail'; break;
+            case RENDERER_TARGET_HTMLEMAIL: $suffix = '_htmlemail'; break;
+            case RENDERER_TARGET_MAINTENANCE: $suffix = '_maintenance'; break;
+            default: $target = RENDERER_TARGET_GENERAL; $suffix = '';
+        }
+
+        return array($target, $suffix);
+    }
+
+    /**
+     * For a given module name, return the possible class names
+     * that defines the renderer interface for that module.
+     *
+     * Newer auto-loaded class names are returned as well as the old style _renderable classnames.
+     *
+     * Also, if it exists, include the renderer.php file for that module, so
+     * the class definition of the default renderer has been loaded.
+     *
+     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
+     * @param string $subtype optional subtype such as 'news' resulting to:
+     *              '\mod_forum\output\news_renderer'
+     *              or '\mod_forum\output\news\renderer'
+     *              or non-autoloaded 'mod_forum_news'
+     * @return array[] Each element of the array is an array with keys:
+     *                 classname - The class name to search
+     *                 autoloaded - Does this classname assume autoloading?
+     *                 validwithprefix - Is this class name valid when a prefix is added to it?
+     *                 validwithoutprefix - Is this class name valid when no prefix is added to it?
+     * @throws coding_exception
+     */
+    protected function standard_renderer_classnames($component, $subtype = null) {
+        global $CFG; // Needed in included files.
+        $classnames = array();
+
+        // Standardize component name ala frankenstyle.
+        list($plugin, $type) = core_component::normalize_component($component);
+        if ($type === null) {
+            $component = $plugin;
+        } else {
+            $component = $plugin.'_'.$type;
+        }
+
+        if ($component !== 'core') {
+            // Renderers are stored in renderer.php files.
+            if (!$compdirectory = core_component::get_component_directory($component)) {
+                throw new coding_exception('Invalid component specified in renderer request', $component);
+            }
+            $rendererfile = $compdirectory . '/renderer.php';
+            if (file_exists($rendererfile)) {
+                include_once($rendererfile);
+            }
+
+        } else if (!empty($subtype)) {
+            $coresubsystems = core_component::get_core_subsystems();
+            if (!array_key_exists($subtype, $coresubsystems)) { // There may be nulls.
+                throw new coding_exception('Invalid core subtype "' . $subtype . '" in renderer request', $subtype);
+            }
+            if ($coresubsystems[$subtype]) {
+                $rendererfile = $coresubsystems[$subtype] . '/renderer.php';
+                if (file_exists($rendererfile)) {
+                    include_once($rendererfile);
+                }
+            }
+        }
+
+        if (empty($subtype)) {
+            // Theme specific auto-loaded name (only valid when prefixed with the theme name).
+            $classnames[] = array(
+                'validwithprefix' => true,
+                'validwithoutprefix' => false,
+                'autoloaded' => true,
+                'classname' => '\\output\\' . $component . '_renderer'
+            );
+
+            // Standard autoloaded plugin name (not valid with a prefix).
+            $classnames[] = array(
+                'validwithprefix' => false,
+                'validwithoutprefix' => true,
+                'autoloaded' => true,
+                'classname' => '\\' . $component . '\\output\\renderer'
+            );
+            // Legacy class name - (valid with or without a prefix).
+            $classnames[] = array(
+                'validwithprefix' => true,
+                'validwithoutprefix' => true,
+                'autoloaded' => false,
+                'classname' => $component . '_renderer'
+            );
+        } else {
+            // Theme specific auto-loaded name (only valid when prefixed with the theme name).
+            $classnames[] = array(
+                'validwithprefix' => true,
+                'validwithoutprefix' => false,
+                'autoloaded' => true,
+                'classname' => '\\output\\' . $component . '\\' . $subtype . '_renderer'
+            );
+            // Version of the above with subtype being a namespace level on it's own.
+            $classnames[] = array(
+                'validwithprefix' => true,
+                'validwithoutprefix' => false,
+                'autoloaded' => true,
+                'classname' => '\\output\\' . $component . '\\' . $subtype . '\\renderer'
+            );
+            // Standard autoloaded plugin name (not valid with a prefix).
+            $classnames[] = array(
+                'validwithprefix' => false,
+                'validwithoutprefix' => true,
+                'autoloaded' => true,
+                'classname' => '\\' . $component . '\\output\\' . $subtype . '_renderer'
+            );
+            // Version of the above with subtype being a namespace level on it's own.
+            $classnames[] = array(
+                'validwithprefix' => false,
+                'validwithoutprefix' => true,
+                'autoloaded' => true,
+                'classname' => '\\' . $component . '\\output\\' . $subtype . '\\renderer'
+            );
+            // Legacy class name - (valid with or without a prefix).
+            $classnames[] = array(
+                'validwithprefix' => true,
+                'validwithoutprefix' => true,
+                'autoloaded' => false,
+                'classname' => $component . '_' . $subtype . '_renderer'
+            );
+        }
+        return $classnames;
+    }
+}
diff --git a/lib/classes/output/renderer_factory/renderer_factory_interface.php b/lib/classes/output/renderer_factory/renderer_factory_interface.php
new file mode 100644
index 00000000000..0b4631443ba
--- /dev/null
+++ b/lib/classes/output/renderer_factory/renderer_factory_interface.php
@@ -0,0 +1,61 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * A renderer factory is just responsible for creating an appropriate renderer
+ * for any given part of Moodle.
+ *
+ * Which renderer factory to use is chose by the current theme, and an instance
+ * if created automatically when the theme is set up.
+ *
+ * A renderer factory must also have a constructor that takes a theme_config object.
+ * (See {@link renderer_factory_base::__construct} for an example.)
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+interface renderer_factory {
+
+    /**
+     * Return the renderer for a particular part of Moodle.
+     *
+     * The renderer interfaces are defined by classes called {plugin}_renderer
+     * where {plugin} is the name of the component. The renderers for core Moodle are
+     * defined in lib/renderer.php. For plugins, they will be defined in a file
+     * called renderer.php inside the plugin.
+     *
+     * Renderers will normally want to subclass the renderer_base class.
+     * (However, if you really know what you are doing, you don't have to do that.)
+     *
+     * There is no separate interface definition for renderers. The default
+     * {plugin}_renderer implementation also serves to define the API for
+     * other implementations of the interface, whether or not they subclass it.
+     *
+     * A particular plugin can define multiple renderers if it wishes, using the
+     * $subtype parameter. For example workshop_renderer,
+     * workshop_allocation_manual_renderer etc.
+     *
+     * @param moodle_page $page the page the renderer is outputting content for.
+     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
+     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
+     * @param string $target one of rendering target constants
+     * @return renderer_base an object implementing the requested renderer interface.
+     */
+    public function get_renderer(moodle_page $page, $component, $subtype=null, $target=null);
+}
diff --git a/lib/classes/output/renderer_factory/standard_renderer_factory.php b/lib/classes/output/renderer_factory/standard_renderer_factory.php
new file mode 100644
index 00000000000..4256dd11563
--- /dev/null
+++ b/lib/classes/output/renderer_factory/standard_renderer_factory.php
@@ -0,0 +1,80 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This is the default renderer factory for Moodle.
+ *
+ * It simply returns an instance of the appropriate standard renderer class.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class standard_renderer_factory extends renderer_factory_base {
+
+    /**
+     * Implement the subclass method
+     *
+     * @param moodle_page $page the page the renderer is outputting content for.
+     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
+     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
+     * @param string $target one of rendering target constants
+     * @return renderer_base an object implementing the requested renderer interface.
+     */
+    public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) {
+        $classnames = $this->standard_renderer_classnames($component, $subtype);
+        $classname = '';
+
+        list($target, $suffix) = $this->get_target_suffix($target);
+        // First look for a version with a suffix.
+        foreach ($classnames as $classnamedetails) {
+            if ($classnamedetails['validwithoutprefix']) {
+                $newclassname = $classnamedetails['classname'] . $suffix;
+                if (class_exists($newclassname)) {
+                    $classname = $newclassname;
+                    break;
+                } else {
+                    $newclassname = $classnamedetails['classname'];
+                    if (class_exists($newclassname)) {
+                        $classname = $newclassname;
+                        break;
+                    }
+                }
+            }
+        }
+        // Now look for a non-suffixed version.
+        if (empty($classname)) {
+            foreach ($classnames as $classnamedetails) {
+                if ($classnamedetails['validwithoutprefix']) {
+                    $newclassname = $classnamedetails['classname'];
+                    if (class_exists($newclassname)) {
+                        $classname = $newclassname;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (empty($classname)) {
+            // Standard renderer must always exist.
+            throw new coding_exception('Request for an unknown renderer class. Searched for: ' . var_export($classnames, true));
+        }
+
+        return new $classname($page, $target);
+    }
+}
diff --git a/lib/classes/output/renderer_factory/theme_overridden_renderer_factory.php b/lib/classes/output/renderer_factory/theme_overridden_renderer_factory.php
new file mode 100644
index 00000000000..81487f1e6c6
--- /dev/null
+++ b/lib/classes/output/renderer_factory/theme_overridden_renderer_factory.php
@@ -0,0 +1,118 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This is renderer factory allows themes to override the standard renderers using php code.
+ *
+ * It will load any code from theme/mytheme/renderers.php and
+ * theme/parenttheme/renderers.php, if then exist. Then whenever you ask for
+ * a renderer for 'component', it will create a mytheme_component_renderer or a
+ * parenttheme_component_renderer, instead of a component_renderer,
+ * if either of those classes exist.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class theme_overridden_renderer_factory extends renderer_factory_base {
+    /**
+     * @var array An array of renderer prefixes
+     */
+    protected $prefixes = array();
+
+    /**
+     * Constructor.
+     * @param theme_config $theme the theme we are rendering for.
+     */
+    public function __construct(theme_config $theme) {
+        parent::__construct($theme);
+        // Initialise $this->prefixes.
+        $this->prefixes = $theme->renderer_prefixes();
+    }
+
+    /**
+     * Implement the subclass method
+     *
+     * @param moodle_page $page the page the renderer is outputting content for.
+     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
+     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
+     * @param string $target one of rendering target constants
+     * @return renderer_base an object implementing the requested renderer interface.
+     */
+    public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) {
+        $classnames = $this->standard_renderer_classnames($component, $subtype);
+
+        list($target, $suffix) = $this->get_target_suffix($target);
+
+        // Theme lib.php and renderers.php files are loaded automatically
+        // when loading the theme configs.
+
+        // First try the renderers with correct suffix.
+        foreach ($this->prefixes as $prefix) {
+            foreach ($classnames as $classnamedetails) {
+                if ($classnamedetails['validwithprefix']) {
+                    if ($classnamedetails['autoloaded']) {
+                        $newclassname = $prefix . $classnamedetails['classname'] . $suffix;
+                    } else {
+                        $newclassname = $prefix . '_' . $classnamedetails['classname'] . $suffix;
+                    }
+                    if (class_exists($newclassname)) {
+                        return new $newclassname($page, $target);
+                    }
+                }
+            }
+        }
+        foreach ($classnames as $classnamedetails) {
+            if ($classnamedetails['validwithoutprefix']) {
+                $newclassname = $classnamedetails['classname'] . $suffix;
+                if (class_exists($newclassname)) {
+                    // Use the specialised renderer for given target, default renderer might also decide
+                    // to implement support for more targets.
+                    return new $newclassname($page, $target);
+                }
+            }
+        }
+
+        // Then try general renderer.
+        foreach ($this->prefixes as $prefix) {
+            foreach ($classnames as $classnamedetails) {
+                if ($classnamedetails['validwithprefix']) {
+                    if ($classnamedetails['autoloaded']) {
+                        $newclassname = $prefix . $classnamedetails['classname'];
+                    } else {
+                        $newclassname = $prefix . '_' . $classnamedetails['classname'];
+                    }
+                    if (class_exists($newclassname)) {
+                        return new $newclassname($page, $target);
+                    }
+                }
+            }
+        }
+
+        // Final attempt - no prefix or suffix.
+        foreach ($classnames as $classnamedetails) {
+            if ($classnamedetails['validwithoutprefix']) {
+                $newclassname = $classnamedetails['classname'];
+                if (class_exists($newclassname)) {
+                    return new $newclassname($page, $target);
+                }
+            }
+        }
+        throw new coding_exception('Request for an unknown renderer ' . $component . ', ' . $subtype . ', ' . $target);
+    }
+}
diff --git a/lib/classes/output/requirements/fragment_requirements_manager.php b/lib/classes/output/requirements/fragment_requirements_manager.php
new file mode 100644
index 00000000000..840d3b55f2f
--- /dev/null
+++ b/lib/classes/output/requirements/fragment_requirements_manager.php
@@ -0,0 +1,118 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This requirements manager captures the appropriate html for creating a fragment to
+ * be inserted elsewhere.
+ *
+ * @copyright 2016 Adrian Greeve <adrian@moodle.com>
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 3.1
+ * @package core
+ * @category output
+ */
+class fragment_requirements_manager extends page_requirements_manager {
+
+    /**
+     * Page fragment constructor.
+     */
+    public function __construct() {
+        parent::__construct();
+        // As this is a fragment the header should already be done.
+        $this->headdone = true;
+    }
+
+    /**
+     * Returns js code to load amd module loader, then insert inline script tags
+     * that contain require() calls using RequireJS.
+     *
+     * @return string
+     */
+    protected function get_amd_footercode() {
+        global $CFG;
+        $output = '';
+
+        // First include must be to a module with no dependencies, this prevents multiple requests.
+        $prefix = 'M.util.js_pending("core/first");';
+        $prefix .= "require(['core/first'], function() {\n";
+        $suffix = "\n});";
+        $suffix .= 'M.util.js_complete("core/first");';
+        $output .= html_writer::script($prefix . implode(";\n", $this->amdjscode) . $suffix);
+        return $output;
+    }
+
+
+    /**
+     * Generate any HTML that needs to go at the end of the page.
+     *
+     * @return string the HTML code to to at the end of the page.
+     */
+    public function get_end_code() {
+        global $CFG;
+
+        $output = '';
+
+        // Call amd init functions.
+        $output .= $this->get_amd_footercode();
+
+        // Add other requested modules.
+        $output .= $this->get_extra_modules_code();
+
+        // All the other linked scripts - there should be as few as possible.
+        if ($this->jsincludes['footer']) {
+            foreach ($this->jsincludes['footer'] as $url) {
+                $output .= html_writer::script('', $url);
+            }
+        }
+
+        if (!empty($this->stringsforjs)) {
+            // Add all needed strings.
+            $strings = array();
+            foreach ($this->stringsforjs as $component => $v) {
+                foreach ($v as $indentifier => $langstring) {
+                    $strings[$component][$indentifier] = $langstring->out();
+                }
+            }
+            // Append don't overwrite.
+            $output .= html_writer::script('require(["jquery"], function($) {
+                M.str = $.extend(true, M.str, ' . json_encode($strings) . ');
+            });');
+        }
+
+        // Add variables.
+        if ($this->jsinitvariables['footer']) {
+            $js = '';
+            foreach ($this->jsinitvariables['footer'] as $data) {
+                list($var, $value) = $data;
+                $js .= js_writer::set_variable($var, $value, true);
+            }
+            $output .= html_writer::script($js);
+        }
+
+        $inyuijs = $this->get_javascript_code(false);
+        $ondomreadyjs = $this->get_javascript_code(true);
+        // See if this is still needed when we get to the ajax page.
+        $jsinit = $this->get_javascript_init_code();
+        $handlersjs = $this->get_event_handler_code();
+
+        // There is a global Y, make sure it is available in your scope.
+        $js = "(function() {{$inyuijs}{$ondomreadyjs}{$jsinit}{$handlersjs}})();";
+
+        $output .= html_writer::script($js);
+
+        return $output;
+    }
+}
diff --git a/lib/classes/output/requirements/page_requirements_manager.php b/lib/classes/output/requirements/page_requirements_manager.php
new file mode 100644
index 00000000000..5e68103dfd5
--- /dev/null
+++ b/lib/classes/output/requirements/page_requirements_manager.php
@@ -0,0 +1,1814 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This class tracks all the things that are needed by the current page.
+ *
+ * Normally, the only instance of this  class you will need to work with is the
+ * one accessible via $PAGE->requires.
+ *
+ * Typical usage would be
+ * <pre>
+ *     $PAGE->requires->js_call_amd('mod_forum/view', 'init');
+ * </pre>
+ *
+ * It also supports obsoleted coding style with/without YUI3 modules.
+ * <pre>
+ *     $PAGE->requires->js_init_call('M.mod_forum.init_view');
+ *     $PAGE->requires->css('/mod/mymod/userstyles.php?id='.$id); // not overridable via themes!
+ *     $PAGE->requires->js('/mod/mymod/script.js');
+ *     $PAGE->requires->js('/mod/mymod/small_but_urgent.js', true);
+ *     $PAGE->requires->js_function_call('init_mymod', array($data), true);
+ * </pre>
+ *
+ * There are some natural restrictions on some methods. For example, {@link css()}
+ * can only be called before the <head> tag is output. See the comments on the
+ * individual methods for details.
+ *
+ * @copyright 2009 Tim Hunt, 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class page_requirements_manager {
+
+    /**
+     * @var array List of string available from JS
+     */
+    protected $stringsforjs = array();
+
+    /**
+     * @var array List of get_string $a parameters - used for validation only.
+     */
+    protected $stringsforjs_as = array();
+
+    /**
+     * @var array List of JS variables to be initialised
+     */
+    protected $jsinitvariables = array('head'=>array(), 'footer'=>array());
+
+    /**
+     * @var array Included JS scripts
+     */
+    protected $jsincludes = array('head'=>array(), 'footer'=>array());
+
+    /**
+     * @var array Inline scripts using RequireJS module loading.
+     */
+    protected $amdjscode = array('');
+
+    /**
+     * @var array List of needed function calls
+     */
+    protected $jscalls = array('normal'=>array(), 'ondomready'=>array());
+
+    /**
+     * @var array List of skip links, those are needed for accessibility reasons
+     */
+    protected $skiplinks = array();
+
+    /**
+     * @var array Javascript code used for initialisation of page, it should
+     * be relatively small
+     */
+    protected $jsinitcode = array();
+
+    /**
+     * @var array of moodle_url Theme sheets, initialised only from core_renderer
+     */
+    protected $cssthemeurls = array();
+
+    /**
+     * @var array of moodle_url List of custom theme sheets, these are strongly discouraged!
+     * Useful mostly only for CSS submitted by teachers that is not part of the theme.
+     */
+    protected $cssurls = array();
+
+    /**
+     * @var array List of requested event handlers
+     */
+    protected $eventhandlers = array();
+
+    /**
+     * @var array Extra modules
+     */
+    protected $extramodules = array();
+
+    /**
+     * @var array trackes the names of bits of HTML that are only required once
+     * per page. See {@link has_one_time_item_been_created()},
+     * {@link set_one_time_item_created()} and {@link should_create_one_time_item_now()}.
+     */
+    protected $onetimeitemsoutput = array();
+
+    /**
+     * @var bool Flag indicated head stuff already printed
+     */
+    protected $headdone = false;
+
+    /**
+     * @var bool Flag indicating top of body already printed
+     */
+    protected $topofbodydone = false;
+
+    /**
+     * @var stdClass YUI PHPLoader instance responsible for YUI3 loading from PHP only
+     */
+    protected $yui3loader;
+
+    /**
+     * @var YUI_config default YUI loader configuration
+     */
+    protected $YUI_config;
+
+    /**
+     * @var array $yuicssmodules
+     */
+    protected $yuicssmodules = array();
+
+    /**
+     * @var array Some config vars exposed in JS, please no secret stuff there
+     */
+    protected $M_cfg;
+
+    /**
+     * @var array list of requested jQuery plugins
+     */
+    protected $jqueryplugins = array();
+
+    /**
+     * @var array list of jQuery plugin overrides
+     */
+    protected $jquerypluginoverrides = array();
+
+    /**
+     * Page requirements constructor.
+     */
+    public function __construct() {
+        global $CFG;
+
+        // You may need to set up URL rewrite rule because oversized URLs might not be allowed by web server.
+        $sep = empty($CFG->yuislasharguments) ? '?' : '/';
+
+        $this->yui3loader = new stdClass();
+        $this->YUI_config = new YUI_config();
+
+        // Set up some loader options.
+        $this->yui3loader->local_base = $CFG->wwwroot . '/lib/yuilib/'. $CFG->yui3version . '/';
+        $this->yui3loader->local_comboBase = $CFG->wwwroot . '/theme/yui_combo.php'.$sep;
+
+        $this->yui3loader->base = $this->yui3loader->local_base;
+        $this->yui3loader->comboBase = $this->yui3loader->local_comboBase;
+
+        // Enable combo loader? This significantly helps with caching and performance!
+        $this->yui3loader->combine = !empty($CFG->yuicomboloading);
+
+        $jsrev = $this->get_jsrev();
+
+        // Set up JS YUI loader helper object.
+        $this->YUI_config->base         = $this->yui3loader->base;
+        $this->YUI_config->comboBase    = $this->yui3loader->comboBase;
+        $this->YUI_config->combine      = $this->yui3loader->combine;
+
+        // If we've had to patch any YUI modules between releases, we must override the YUI configuration to include them.
+        if (!empty($CFG->yuipatchedmodules) && !empty($CFG->yuipatchlevel)) {
+            $this->YUI_config->define_patched_core_modules($this->yui3loader->local_comboBase,
+                    $CFG->yui3version,
+                    $CFG->yuipatchlevel,
+                    $CFG->yuipatchedmodules);
+        }
+
+        $configname = $this->YUI_config->set_config_source('lib/yui/config/yui2.js');
+        $this->YUI_config->add_group('yui2', array(
+            // Loader configuration for our 2in3.
+            'base' => $CFG->wwwroot . '/lib/yuilib/2in3/' . $CFG->yui2version . '/build/',
+            'comboBase' => $CFG->wwwroot . '/theme/yui_combo.php'.$sep,
+            'combine' => $this->yui3loader->combine,
+            'ext' => false,
+            'root' => '2in3/' . $CFG->yui2version .'/build/',
+            'patterns' => array(
+                'yui2-' => array(
+                    'group' => 'yui2',
+                    'configFn' => $configname,
+                )
+            )
+        ));
+        $configname = $this->YUI_config->set_config_source('lib/yui/config/moodle.js');
+        $this->YUI_config->add_group('moodle', array(
+            'name' => 'moodle',
+            'base' => $CFG->wwwroot . '/theme/yui_combo.php' . $sep . 'm/' . $jsrev . '/',
+            'combine' => $this->yui3loader->combine,
+            'comboBase' => $CFG->wwwroot . '/theme/yui_combo.php'.$sep,
+            'ext' => false,
+            'root' => 'm/'.$jsrev.'/', // Add the rev to the root path so that we can control caching.
+            'patterns' => array(
+                'moodle-' => array(
+                    'group' => 'moodle',
+                    'configFn' => $configname,
+                )
+            )
+        ));
+
+        $this->YUI_config->add_group('gallery', array(
+            'name' => 'gallery',
+            'base' => $CFG->wwwroot . '/lib/yuilib/gallery/',
+            'combine' => $this->yui3loader->combine,
+            'comboBase' => $CFG->wwwroot . '/theme/yui_combo.php' . $sep,
+            'ext' => false,
+            'root' => 'gallery/' . $jsrev . '/',
+            'patterns' => array(
+                'gallery-' => array(
+                    'group' => 'gallery',
+                )
+            )
+        ));
+
+        // Set some more loader options applying to groups too.
+        if ($CFG->debugdeveloper) {
+            // When debugging is enabled, we want to load the non-minified (RAW) versions of YUI library modules rather
+            // than the DEBUG versions as these generally generate too much logging for our purposes.
+            // However we do want the DEBUG versions of our Moodle-specific modules.
+            // To debug a YUI-specific issue, change the yui3loader->filter value to DEBUG.
+            $this->YUI_config->filter = 'RAW';
+            $this->YUI_config->groups['moodle']['filter'] = 'DEBUG';
+
+            // We use the yui3loader->filter setting when writing the YUI3 seed scripts into the header.
+            $this->yui3loader->filter = $this->YUI_config->filter;
+            $this->YUI_config->debug = true;
+        } else {
+            $this->yui3loader->filter = null;
+            $this->YUI_config->groups['moodle']['filter'] = null;
+            $this->YUI_config->debug = false;
+        }
+
+        // Include the YUI config log filters.
+        if (!empty($CFG->yuilogexclude) && is_array($CFG->yuilogexclude)) {
+            $this->YUI_config->logExclude = $CFG->yuilogexclude;
+        }
+        if (!empty($CFG->yuiloginclude) && is_array($CFG->yuiloginclude)) {
+            $this->YUI_config->logInclude = $CFG->yuiloginclude;
+        }
+        if (!empty($CFG->yuiloglevel)) {
+            $this->YUI_config->logLevel = $CFG->yuiloglevel;
+        }
+
+        // Add the moodle group's module data.
+        $this->YUI_config->add_moodle_metadata();
+
+        // Every page should include definition of following modules.
+        $this->js_module($this->find_module('core_filepicker'));
+        $this->js_module($this->find_module('core_comment'));
+    }
+
+    /**
+     * Return the safe config values that get set for javascript in "M.cfg".
+     *
+     * @since 2.9
+     * @return array List of safe config values that are available to javascript.
+     */
+    public function get_config_for_javascript(moodle_page $page, renderer_base $renderer) {
+        global $CFG;
+
+        if (empty($this->M_cfg)) {
+
+            $iconsystem = \core\output\icon_system::instance();
+
+            // It is possible that the $page->context is null, so we can't use $page->context->id.
+            $contextid = null;
+            $contextinstanceid = null;
+            if (!is_null($page->context)) {
+                $contextid = $page->context->id;
+                $contextinstanceid = $page->context->instanceid;
+                $courseid = $page->course->id;
+                $coursecontext = context_course::instance($courseid);
+            }
+
+            $this->M_cfg = array(
+                'wwwroot'               => $CFG->wwwroot,
+                'homeurl'               => $page->navigation->action,
+                'sesskey'               => sesskey(),
+                'sessiontimeout'        => $CFG->sessiontimeout,
+                'sessiontimeoutwarning' => $CFG->sessiontimeoutwarning,
+                'themerev'              => theme_get_revision(),
+                'slasharguments'        => (int)(!empty($CFG->slasharguments)),
+                'theme'                 => $page->theme->name,
+                'iconsystemmodule'      => $iconsystem->get_amd_name(),
+                'jsrev'                 => $this->get_jsrev(),
+                'admin'                 => $CFG->admin,
+                'svgicons'              => $page->theme->use_svg_icons(),
+                'usertimezone'          => usertimezone(),
+                'language'              => current_language(),
+                'courseId'              => isset($courseid) ? (int) $courseid : 0,
+                'courseContextId'       => isset($coursecontext) ? $coursecontext->id : 0,
+                'contextid'             => $contextid,
+                'contextInstanceId'     => (int) $contextinstanceid,
+                'langrev'               => get_string_manager()->get_revision(),
+                'templaterev'           => $this->get_templaterev(),
+                'siteId'                => (int) SITEID,
+            );
+            if ($CFG->debugdeveloper) {
+                $this->M_cfg['developerdebug'] = true;
+            }
+            if (defined('BEHAT_SITE_RUNNING')) {
+                $this->M_cfg['behatsiterunning'] = true;
+            }
+
+        }
+        return $this->M_cfg;
+    }
+
+    /**
+     * Initialise with the bits of JavaScript that every Moodle page should have.
+     *
+     * @param moodle_page $page
+     * @param core_renderer $renderer
+     */
+    protected function init_requirements_data(moodle_page $page, core_renderer $renderer) {
+        global $CFG;
+
+        // Init the js config.
+        $this->get_config_for_javascript($page, $renderer);
+
+        // Accessibility stuff.
+        $this->skip_link_to('maincontent', get_string('tocontent', 'access'));
+
+        // Add strings used on many pages.
+        $this->string_for_js('confirmation', 'admin');
+        $this->string_for_js('cancel', 'moodle');
+        $this->string_for_js('yes', 'moodle');
+
+        // Alter links in top frame to break out of frames.
+        if ($page->pagelayout === 'frametop') {
+            $this->js_init_call('M.util.init_frametop');
+        }
+
+        // Include block drag/drop if editing is on
+        if ($page->user_is_editing()) {
+            $params = array(
+                'regions' => $page->blocks->get_regions(),
+                'pagehash' => $page->get_edited_page_hash(),
+            );
+            if (!empty($page->cm->id)) {
+                $params['cmid'] = $page->cm->id;
+            }
+            // Strings for drag and drop.
+            $this->strings_for_js(array('movecontent',
+                                        'tocontent',
+                                        'emptydragdropregion'),
+                                  'moodle');
+            $page->requires->yui_module('moodle-core-blocks', 'M.core_blocks.init_dragdrop', array($params), null, true);
+            $page->requires->js_call_amd('core_block/edit', 'init', ['pagehash' => $page->get_edited_page_hash()]);
+        }
+
+        // Include the YUI CSS Modules.
+        $page->requires->set_yuicssmodules($page->theme->yuicssmodules);
+    }
+
+    /**
+     * Determine the correct JS Revision to use for this load.
+     *
+     * @return int the jsrev to use.
+     */
+    public function get_jsrev() {
+        global $CFG;
+
+        if (empty($CFG->cachejs)) {
+            $jsrev = -1;
+        } else if (empty($CFG->jsrev)) {
+            $jsrev = 1;
+        } else {
+            $jsrev = $CFG->jsrev;
+        }
+
+        return $jsrev;
+    }
+
+    /**
+     * Determine the correct Template revision to use for this load.
+     *
+     * @return int the templaterev to use.
+     */
+    protected function get_templaterev() {
+        global $CFG;
+
+        if (empty($CFG->cachetemplates)) {
+            $templaterev = -1;
+        } else if (empty($CFG->templaterev)) {
+            $templaterev = 1;
+        } else {
+            $templaterev = $CFG->templaterev;
+        }
+
+        return $templaterev;
+    }
+
+    /**
+     * Ensure that the specified JavaScript file is linked to from this page.
+     *
+     * NOTE: This function is to be used in RARE CASES ONLY, please store your JS in module.js file
+     * and use $PAGE->requires->js_init_call() instead or use /yui/ subdirectories for YUI modules.
+     *
+     * By default the link is put at the end of the page, since this gives best page-load performance.
+     *
+     * Even if a particular script is requested more than once, it will only be linked
+     * to once.
+     *
+     * @param string|moodle_url $url The path to the .js file, relative to $CFG->dirroot / $CFG->wwwroot.
+     *      For example '/mod/mymod/customscripts.js'; use moodle_url for external scripts
+     * @param bool $inhead initialise in head
+     */
+    public function js($url, $inhead = false) {
+        if ($url == '/question/qengine.js') {
+            debugging('The question/qengine.js has been deprecated. ' .
+                'Please use core_question/question_engine', DEBUG_DEVELOPER);
+        }
+        $url = $this->js_fix_url($url);
+        $where = $inhead ? 'head' : 'footer';
+        $this->jsincludes[$where][$url->out()] = $url;
+    }
+
+    /**
+     * Request inclusion of jQuery library in the page.
+     *
+     * NOTE: this should not be used in official Moodle distribution!
+     *
+     * {@link https://moodledev.io/docs/guides/javascript/jquery}
+     */
+    public function jquery() {
+        $this->jquery_plugin('jquery');
+    }
+
+    /**
+     * Request inclusion of jQuery plugin.
+     *
+     * NOTE: this should not be used in official Moodle distribution!
+     *
+     * jQuery plugins are located in plugin/jquery/* subdirectory,
+     * plugin/jquery/plugins.php lists all available plugins.
+     *
+     * Included core plugins:
+     *   - jQuery UI
+     *
+     * Add-ons may include extra jQuery plugins in jquery/ directory,
+     * plugins.php file defines the mapping between plugin names and
+     * necessary page includes.
+     *
+     * Examples:
+     * <code>
+     *   // file: mod/xxx/view.php
+     *   $PAGE->requires->jquery();
+     *   $PAGE->requires->jquery_plugin('ui');
+     *   $PAGE->requires->jquery_plugin('ui-css');
+     * </code>
+     *
+     * <code>
+     *   // file: theme/yyy/lib.php
+     *   function theme_yyy_page_init(moodle_page $page) {
+     *       $page->requires->jquery();
+     *       $page->requires->jquery_plugin('ui');
+     *       $page->requires->jquery_plugin('ui-css');
+     *   }
+     * </code>
+     *
+     * <code>
+     *   // file: blocks/zzz/block_zzz.php
+     *   public function get_required_javascript() {
+     *       parent::get_required_javascript();
+     *       $this->page->requires->jquery();
+     *       $page->requires->jquery_plugin('ui');
+     *       $page->requires->jquery_plugin('ui-css');
+     *   }
+     * </code>
+     *
+     * {@link https://moodledev.io/docs/guides/javascript/jquery}
+     *
+     * @param string $plugin name of the jQuery plugin as defined in jquery/plugins.php
+     * @param string $component name of the component
+     * @return bool success
+     */
+    public function jquery_plugin($plugin, $component = 'core') {
+        global $CFG;
+
+        if ($this->headdone) {
+            debugging('Can not add jQuery plugins after starting page output!');
+            return false;
+        }
+
+        if ($component !== 'core' and in_array($plugin, array('jquery', 'ui', 'ui-css'))) {
+            debugging("jQuery plugin '$plugin' is included in Moodle core, other components can not use the same name.", DEBUG_DEVELOPER);
+            $component = 'core';
+        } else if ($component !== 'core' and strpos($component, '_') === false) {
+            // Let's normalise the legacy activity names, Frankenstyle rulez!
+            $component = 'mod_' . $component;
+        }
+
+        if (empty($this->jqueryplugins) and ($component !== 'core' or $plugin !== 'jquery')) {
+            // Make sure the jQuery itself is always loaded first,
+            // the order of all other plugins depends on order of $PAGE_>requires->.
+            $this->jquery_plugin('jquery', 'core');
+        }
+
+        if (isset($this->jqueryplugins[$plugin])) {
+            // No problem, we already have something, first Moodle plugin to register the jQuery plugin wins.
+            return true;
+        }
+
+        $componentdir = core_component::get_component_directory($component);
+        if (!file_exists($componentdir) or !file_exists("$componentdir/jquery/plugins.php")) {
+            debugging("Can not load jQuery plugin '$plugin', missing plugins.php in component '$component'.", DEBUG_DEVELOPER);
+            return false;
+        }
+
+        $plugins = array();
+        require("$componentdir/jquery/plugins.php");
+
+        if (!isset($plugins[$plugin])) {
+            debugging("jQuery plugin '$plugin' can not be found in component '$component'.", DEBUG_DEVELOPER);
+            return false;
+        }
+
+        $this->jqueryplugins[$plugin] = new stdClass();
+        $this->jqueryplugins[$plugin]->plugin    = $plugin;
+        $this->jqueryplugins[$plugin]->component = $component;
+        $this->jqueryplugins[$plugin]->urls      = array();
+
+        foreach ($plugins[$plugin]['files'] as $file) {
+            if ($CFG->debugdeveloper) {
+                if (!file_exists("$componentdir/jquery/$file")) {
+                    debugging("Invalid file '$file' specified in jQuery plugin '$plugin' in component '$component'");
+                    continue;
+                }
+                $file = str_replace('.min.css', '.css', $file);
+                $file = str_replace('.min.js', '.js', $file);
+            }
+            if (!file_exists("$componentdir/jquery/$file")) {
+                debugging("Invalid file '$file' specified in jQuery plugin '$plugin' in component '$component'");
+                continue;
+            }
+            if (!empty($CFG->slasharguments)) {
+                $url = new moodle_url("/theme/jquery.php");
+                $url->set_slashargument("/$component/$file");
+
+            } else {
+                // This is not really good, we need slasharguments for relative links, this means no caching...
+                $path = realpath("$componentdir/jquery/$file");
+                if (strpos($path, $CFG->dirroot) === 0) {
+                    $url = $CFG->wwwroot.preg_replace('/^'.preg_quote($CFG->dirroot, '/').'/', '', $path);
+                    // Replace all occurences of backslashes characters in url to forward slashes.
+                    $url = str_replace('\\', '/', $url);
+                    $url = new moodle_url($url);
+                } else {
+                    // Bad luck, fix your server!
+                    debugging("Moodle jQuery integration requires 'slasharguments' setting to be enabled.");
+                    continue;
+                }
+            }
+            $this->jqueryplugins[$plugin]->urls[] = $url;
+        }
+
+        return true;
+    }
+
+    /**
+     * Request replacement of one jQuery plugin by another.
+     *
+     * This is useful when themes want to replace the jQuery UI theme,
+     * the problem is that theme can not prevent others from including the core ui-css plugin.
+     *
+     * Example:
+     *  1/ generate new jQuery UI theme and place it into theme/yourtheme/jquery/
+     *  2/ write theme/yourtheme/jquery/plugins.php
+     *  3/ init jQuery from theme
+     *
+     * <code>
+     *   // file theme/yourtheme/lib.php
+     *   function theme_yourtheme_page_init($page) {
+     *       $page->requires->jquery_plugin('yourtheme-ui-css', 'theme_yourtheme');
+     *       $page->requires->jquery_override_plugin('ui-css', 'yourtheme-ui-css');
+     *   }
+     * </code>
+     *
+     * This code prevents loading of standard 'ui-css' which my be requested by other plugins,
+     * the 'yourtheme-ui-css' gets loaded only if some other code requires jquery.
+     *
+     * {@link https://moodledev.io/docs/guides/javascript/jquery}
+     *
+     * @param string $oldplugin original plugin
+     * @param string $newplugin the replacement
+     */
+    public function jquery_override_plugin($oldplugin, $newplugin) {
+        if ($this->headdone) {
+            debugging('Can not override jQuery plugins after starting page output!');
+            return;
+        }
+        $this->jquerypluginoverrides[$oldplugin] = $newplugin;
+    }
+
+    /**
+     * Return jQuery related markup for page start.
+     * @return string
+     */
+    protected function get_jquery_headcode() {
+        if (empty($this->jqueryplugins['jquery'])) {
+            // If nobody requested jQuery then do not bother to load anything.
+            // This may be useful for themes that want to override 'ui-css' only if requested by something else.
+            return '';
+        }
+
+        $included = array();
+        $urls = array();
+
+        foreach ($this->jqueryplugins as $name => $unused) {
+            if (isset($included[$name])) {
+                continue;
+            }
+            if (array_key_exists($name, $this->jquerypluginoverrides)) {
+                // The following loop tries to resolve the replacements,
+                // use max 100 iterations to prevent infinite loop resulting
+                // in blank page.
+                $cyclic = true;
+                $oldname = $name;
+                for ($i=0; $i<100; $i++) {
+                    $name = $this->jquerypluginoverrides[$name];
+                    if (!array_key_exists($name, $this->jquerypluginoverrides)) {
+                        $cyclic = false;
+                        break;
+                    }
+                }
+                if ($cyclic) {
+                    // We can not do much with cyclic references here, let's use the old plugin.
+                    $name = $oldname;
+                    debugging("Cyclic overrides detected for jQuery plugin '$name'");
+
+                } else if (empty($name)) {
+                    // Developer requested removal of the plugin.
+                    continue;
+
+                } else if (!isset($this->jqueryplugins[$name])) {
+                    debugging("Unknown jQuery override plugin '$name' detected");
+                    $name = $oldname;
+
+                } else if (isset($included[$name])) {
+                    // The plugin was already included, easy.
+                    continue;
+                }
+            }
+
+            $plugin = $this->jqueryplugins[$name];
+            $urls = array_merge($urls, $plugin->urls);
+            $included[$name] = true;
+        }
+
+        $output = '';
+        $attributes = array('rel' => 'stylesheet', 'type' => 'text/css');
+        foreach ($urls as $url) {
+            if (preg_match('/\.js$/', $url)) {
+                $output .= html_writer::script('', $url);
+            } else if (preg_match('/\.css$/', $url)) {
+                $attributes['href'] = $url;
+                $output .= html_writer::empty_tag('link', $attributes) . "\n";
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Returns the actual url through which a JavaScript file is served.
+     *
+     * @param moodle_url|string $url full moodle url, or shortened path to script.
+     * @throws coding_exception if the given $url isn't a shortened url starting with / or a moodle_url instance.
+     * @return moodle_url
+     */
+    protected function js_fix_url($url) {
+        global $CFG;
+
+        if ($url instanceof moodle_url) {
+            // If the URL is external to Moodle, it won't be handled by Moodle (!).
+            if ($url->is_local_url()) {
+                $localurl = $url->out_as_local_url();
+                // Check if the URL points to a Moodle PHP resource.
+                if (strpos($localurl, '.php') !== false) {
+                    // It's a Moodle PHP resource e.g. a resource already served by the proper Moodle Handler.
+                    return $url;
+                }
+                // It's a local resource: we need to further examine it.
+                return $this->js_fix_url($url->out_as_local_url(false));
+            }
+            // The URL is not a Moodle resource.
+            return $url;
+        } else if (null !== $url && strpos($url, '/') === 0) {
+            // Fix the admin links if needed.
+            if ($CFG->admin !== 'admin') {
+                if (strpos($url, "/admin/") === 0) {
+                    $url = preg_replace("|^/admin/|", "/$CFG->admin/", $url);
+                }
+            }
+            if (debugging()) {
+                // Check file existence only when in debug mode.
+                if (!file_exists($CFG->dirroot . strtok($url, '?'))) {
+                    throw new coding_exception('Attempt to require a JavaScript file that does not exist.', $url);
+                }
+            }
+            if (substr($url, -3) === '.js') {
+                $jsrev = $this->get_jsrev();
+                if (empty($CFG->slasharguments)) {
+                    return new moodle_url('/lib/javascript.php', ['rev' => $jsrev, 'jsfile' => $url]);
+                } else {
+                    $returnurl = new moodle_url('/lib/javascript.php');
+                    $returnurl->set_slashargument('/'.$jsrev.$url);
+                    return $returnurl;
+                }
+            } else {
+                return new moodle_url($url);
+            }
+        } else {
+            throw new coding_exception('Invalid JS url, it has to be shortened url starting with / or moodle_url instance.', $url);
+        }
+    }
+
+    /**
+     * Find out if JS module present and return details.
+     *
+     * @param string $component name of component in frankenstyle, ex: core_group, mod_forum
+     * @return array description of module or null if not found
+     */
+    protected function find_module($component) {
+        global $CFG, $PAGE;
+
+        $module = null;
+
+        if (strpos($component, 'core_') === 0) {
+            // Must be some core stuff - list here is not complete, this is just the stuff used from multiple places
+            // so that we do nto have to repeat the definition of these modules over and over again.
+            switch($component) {
+                case 'core_filepicker':
+                    $module = array('name'     => 'core_filepicker',
+                                    'fullpath' => '/repository/filepicker.js',
+                                    'requires' => array(
+                                        'base', 'node', 'node-event-simulate', 'json', 'async-queue', 'io-base', 'io-upload-iframe', 'io-form',
+                                        'yui2-treeview', 'panel', 'cookie', 'datatable', 'datatable-sort', 'resize-plugin', 'dd-plugin',
+                                        'escape', 'moodle-core_filepicker', 'moodle-core-notification-dialogue'
+                                    ),
+                                    'strings'  => array(array('lastmodified', 'moodle'), array('name', 'moodle'), array('type', 'repository'), array('size', 'repository'),
+                                                        array('invalidjson', 'repository'), array('error', 'moodle'), array('info', 'moodle'),
+                                                        array('nofilesattached', 'repository'), array('filepicker', 'repository'), array('logout', 'repository'),
+                                                        array('nofilesavailable', 'repository'), array('norepositoriesavailable', 'repository'),
+                                                        array('fileexistsdialogheader', 'repository'), array('fileexistsdialog_editor', 'repository'),
+                                                        array('fileexistsdialog_filemanager', 'repository'), array('renameto', 'repository'),
+                                                        array('referencesexist', 'repository'), array('select', 'repository')
+                                                    ));
+                    break;
+                case 'core_comment':
+                    $module = array('name'     => 'core_comment',
+                                    'fullpath' => '/comment/comment.js',
+                                    'requires' => array('base', 'io-base', 'node', 'json', 'yui2-animation', 'overlay', 'escape'),
+                                    'strings' => array(array('confirmdeletecomments', 'admin'), array('yes', 'moodle'), array('no', 'moodle'))
+                                );
+                    break;
+                case 'core_role':
+                    $module = array('name'     => 'core_role',
+                                    'fullpath' => '/admin/roles/module.js',
+                                    'requires' => array('node', 'cookie'));
+                    break;
+                case 'core_completion':
+                    break;
+                case 'core_message':
+                    $module = array('name'     => 'core_message',
+                                    'requires' => array('base', 'node', 'event', 'node-event-simulate'),
+                                    'fullpath' => '/message/module.js');
+                    break;
+                case 'core_group':
+                    $module = array('name'     => 'core_group',
+                                    'fullpath' => '/group/module.js',
+                                    'requires' => array('node', 'overlay', 'event-mouseenter'));
+                    break;
+                case 'core_question_engine':
+                    $module = array('name'     => 'core_question_engine',
+                                    'fullpath' => '/question/qengine.js',
+                                    'requires' => array('node', 'event'));
+                    break;
+                case 'core_rating':
+                    $module = array('name'     => 'core_rating',
+                                    'fullpath' => '/rating/module.js',
+                                    'requires' => array('node', 'event', 'overlay', 'io-base', 'json'));
+                    break;
+                case 'core_dndupload':
+                    $module = array('name'     => 'core_dndupload',
+                                    'fullpath' => '/lib/form/dndupload.js',
+                                    'requires' => array('node', 'event', 'json', 'core_filepicker'),
+                                    'strings'  => array(array('uploadformlimit', 'moodle'), array('droptoupload', 'moodle'), array('maxfilesreached', 'moodle'),
+                                                        array('dndenabled_inbox', 'moodle'), array('fileexists', 'moodle'), array('maxbytesfile', 'error'),
+                                                        array('sizegb', 'moodle'), array('sizemb', 'moodle'), array('sizekb', 'moodle'), array('sizeb', 'moodle'),
+                                                        array('maxareabytesreached', 'moodle'), array('serverconnection', 'error'),
+                                                        array('changesmadereallygoaway', 'moodle'), array('complete', 'moodle')
+                                                    ));
+                    break;
+            }
+
+        } else {
+            if ($dir = core_component::get_component_directory($component)) {
+                if (file_exists("$dir/module.js")) {
+                    if (strpos($dir, $CFG->dirroot.'/') === 0) {
+                        $dir = substr($dir, strlen($CFG->dirroot));
+                        $module = array('name'=>$component, 'fullpath'=>"$dir/module.js", 'requires' => array());
+                    }
+                }
+            }
+        }
+
+        return $module;
+    }
+
+    /**
+     * Append YUI3 module to default YUI3 JS loader.
+     * The structure of module array is described at {@link http://developer.yahoo.com/yui/3/yui/}
+     *
+     * @param string|array $module name of module (details are autodetected), or full module specification as array
+     * @return void
+     */
+    public function js_module($module) {
+        global $CFG;
+
+        if (empty($module)) {
+            throw new coding_exception('Missing YUI3 module name or full description.');
+        }
+
+        if (is_string($module)) {
+            $module = $this->find_module($module);
+        }
+
+        if (empty($module) or empty($module['name']) or empty($module['fullpath'])) {
+            throw new coding_exception('Missing YUI3 module details.');
+        }
+
+        $module['fullpath'] = $this->js_fix_url($module['fullpath'])->out(false);
+        // Add all needed strings.
+        if (!empty($module['strings'])) {
+            foreach ($module['strings'] as $string) {
+                $identifier = $string[0];
+                $component = isset($string[1]) ? $string[1] : 'moodle';
+                $a = isset($string[2]) ? $string[2] : null;
+                $this->string_for_js($identifier, $component, $a);
+            }
+        }
+        unset($module['strings']);
+
+        // Process module requirements and attempt to load each. This allows
+        // moodle modules to require each other.
+        if (!empty($module['requires'])){
+            foreach ($module['requires'] as $requirement) {
+                $rmodule = $this->find_module($requirement);
+                if (is_array($rmodule)) {
+                    $this->js_module($rmodule);
+                }
+            }
+        }
+
+        if ($this->headdone) {
+            $this->extramodules[$module['name']] = $module;
+        } else {
+            $this->YUI_config->add_module_config($module['name'], $module);
+        }
+    }
+
+    /**
+     * Returns true if the module has already been loaded.
+     *
+     * @param string|array $module
+     * @return bool True if the module has already been loaded
+     */
+    protected function js_module_loaded($module) {
+        if (is_string($module)) {
+            $modulename = $module;
+        } else {
+            $modulename = $module['name'];
+        }
+        return array_key_exists($modulename, $this->YUI_config->modules) ||
+               array_key_exists($modulename, $this->extramodules);
+    }
+
+    /**
+     * Ensure that the specified CSS file is linked to from this page.
+     *
+     * Because stylesheet links must go in the <head> part of the HTML, you must call
+     * this function before {@link get_head_code()} is called. That normally means before
+     * the call to print_header. If you call it when it is too late, an exception
+     * will be thrown.
+     *
+     * Even if a particular style sheet is requested more than once, it will only
+     * be linked to once.
+     *
+     * Please note use of this feature is strongly discouraged,
+     * it is suitable only for places where CSS is submitted directly by teachers.
+     * (Students must not be allowed to submit any external CSS because it may
+     * contain embedded javascript!). Example of correct use is mod/data.
+     *
+     * @param string $stylesheet The path to the .css file, relative to $CFG->wwwroot.
+     *   For example:
+     *      $PAGE->requires->css('mod/data/css.php?d='.$data->id);
+     */
+    public function css($stylesheet) {
+        global $CFG;
+
+        if ($this->headdone) {
+            throw new coding_exception('Cannot require a CSS file after &lt;head> has been printed.', $stylesheet);
+        }
+
+        if ($stylesheet instanceof moodle_url) {
+            // ok
+        } else if (strpos($stylesheet, '/') === 0) {
+            $stylesheet = new moodle_url($stylesheet);
+        } else {
+            throw new coding_exception('Invalid stylesheet parameter.', $stylesheet);
+        }
+
+        $this->cssurls[$stylesheet->out()] = $stylesheet;
+    }
+
+    /**
+     * Add theme stylesheet to page - do not use from plugin code,
+     * this should be called only from the core renderer!
+     *
+     * @param moodle_url $stylesheet
+     * @return void
+     */
+    public function css_theme(moodle_url $stylesheet) {
+        $this->cssthemeurls[] = $stylesheet;
+    }
+
+    /**
+     * Ensure that a skip link to a given target is printed at the top of the <body>.
+     *
+     * You must call this function before {@link get_top_of_body_code()}, (if not, an exception
+     * will be thrown). That normally means you must call this before the call to print_header.
+     *
+     * If you ask for a particular skip link to be printed, it is then your responsibility
+     * to ensure that the appropriate <a name="..."> tag is printed in the body of the
+     * page, so that the skip link goes somewhere.
+     *
+     * Even if a particular skip link is requested more than once, only one copy of it will be output.
+     *
+     * @param string $target the name of anchor this link should go to. For example 'maincontent'.
+     * @param string $linktext The text to use for the skip link. Normally get_string('skipto', 'access', ...);
+     */
+    public function skip_link_to($target, $linktext) {
+        if ($this->topofbodydone) {
+            debugging('Page header already printed, can not add skip links any more, code needs to be fixed.');
+            return;
+        }
+        $this->skiplinks[$target] = $linktext;
+    }
+
+    /**
+     * !!!DEPRECATED!!! please use js_init_call() if possible
+     * Ensure that the specified JavaScript function is called from an inline script
+     * somewhere on this page.
+     *
+     * By default the call will be put in a script tag at the
+     * end of the page after initialising Y instance, since this gives best page-load
+     * performance and allows you to use YUI3 library.
+     *
+     * If you request that a particular function is called several times, then
+     * that is what will happen (unlike linking to a CSS or JS file, where only
+     * one link will be output).
+     *
+     * The main benefit of the method is the automatic encoding of all function parameters.
+     *
+     * @deprecated
+     *
+     * @param string $function the name of the JavaScritp function to call. Can
+     *      be a compound name like 'Y.Event.purgeElement'. Can also be
+     *      used to create and object by using a 'function name' like 'new user_selector'.
+     * @param array $arguments and array of arguments to be passed to the function.
+     *      When generating the function call, this will be escaped using json_encode,
+     *      so passing objects and arrays should work.
+     * @param bool $ondomready If tru the function is only called when the dom is
+     *      ready for manipulation.
+     * @param int $delay The delay before the function is called.
+     */
+    public function js_function_call($function, array $arguments = null, $ondomready = false, $delay = 0) {
+        $where = $ondomready ? 'ondomready' : 'normal';
+        $this->jscalls[$where][] = array($function, $arguments, $delay);
+    }
+
+    /**
+     * This function appends a block of code to the AMD specific javascript block executed
+     * in the page footer, just after loading the requirejs library.
+     *
+     * The code passed here can rely on AMD module loading, e.g. require('jquery', function($) {...});
+     *
+     * @param string $code The JS code to append.
+     */
+    public function js_amd_inline($code) {
+        $this->amdjscode[] = $code;
+    }
+
+    /**
+     * Load an AMD module and eventually call its method.
+     *
+     * This function creates a minimal inline JS snippet that requires an AMD module and eventually calls a single
+     * function from the module with given arguments. If it is called multiple times, it will be create multiple
+     * snippets.
+     *
+     * @param string $fullmodule The name of the AMD module to load, formatted as <component name>/<module name>.
+     * @param string $func Optional function from the module to call, defaults to just loading the AMD module.
+     * @param array $params The params to pass to the function (will be serialized into JSON).
+     */
+    public function js_call_amd($fullmodule, $func = null, $params = array()) {
+        global $CFG;
+
+        $modulepath = explode('/', $fullmodule);
+
+        $modname = clean_param(array_shift($modulepath), PARAM_COMPONENT);
+        foreach ($modulepath as $module) {
+            $modname .= '/' . clean_param($module, PARAM_ALPHANUMEXT);
+        }
+
+        $functioncode = [];
+        if ($func !== null) {
+            $func = clean_param($func, PARAM_ALPHANUMEXT);
+
+            $jsonparams = array();
+            foreach ($params as $param) {
+                $jsonparams[] = json_encode($param);
+            }
+            $strparams = implode(', ', $jsonparams);
+            if ($CFG->debugdeveloper) {
+                $toomanyparamslimit = 1024;
+                if (strlen($strparams) > $toomanyparamslimit) {
+                    debugging('Too much data passed as arguments to js_call_amd("' . $fullmodule . '", "' . $func .
+                        '"). Generally there are better ways to pass lots of data from PHP to JavaScript, for example via Ajax, ' .
+                        'data attributes, ... . This warning is triggered if the argument string becomes longer than ' .
+                        $toomanyparamslimit . ' characters.', DEBUG_DEVELOPER);
+                }
+            }
+
+            $functioncode[] = "amd.{$func}({$strparams});";
+        }
+
+        $functioncode[] = "M.util.js_complete('{$modname}');";
+
+        $initcode = implode(' ', $functioncode);
+        $js = "M.util.js_pending('{$modname}'); require(['{$modname}'], function(amd) {{$initcode}});";
+
+        $this->js_amd_inline($js);
+    }
+
+    /**
+     * Creates a JavaScript function call that requires one or more modules to be loaded.
+     *
+     * This function can be used to include all of the standard YUI module types within JavaScript:
+     *     - YUI3 modules    [node, event, io]
+     *     - YUI2 modules    [yui2-*]
+     *     - Moodle modules  [moodle-*]
+     *     - Gallery modules [gallery-*]
+     *
+     * Before writing new code that makes extensive use of YUI, you should consider it's replacement AMD/JQuery.
+     * @see js_call_amd()
+     *
+     * @param array|string $modules One or more modules
+     * @param string $function The function to call once modules have been loaded
+     * @param array $arguments An array of arguments to pass to the function
+     * @param string $galleryversion Deprecated: The gallery version to use
+     * @param bool $ondomready
+     */
+    public function yui_module($modules, $function, array $arguments = null, $galleryversion = null, $ondomready = false) {
+        if (!is_array($modules)) {
+            $modules = array($modules);
+        }
+
+        if ($galleryversion != null) {
+            debugging('The galleryversion parameter to yui_module has been deprecated since Moodle 2.3.');
+        }
+
+        $jscode = 'Y.use('.join(',', array_map('json_encode', convert_to_array($modules))).',function() {'.js_writer::function_call($function, $arguments).'});';
+        if ($ondomready) {
+            $jscode = "Y.on('domready', function() { $jscode });";
+        }
+        $this->jsinitcode[] = $jscode;
+    }
+
+    /**
+     * Set the CSS Modules to be included from YUI.
+     *
+     * @param array $modules The list of YUI CSS Modules to include.
+     */
+    public function set_yuicssmodules(array $modules = array()) {
+        $this->yuicssmodules = $modules;
+    }
+
+    /**
+     * Ensure that the specified JavaScript function is called from an inline script
+     * from page footer.
+     *
+     * @param string $function the name of the JavaScritp function to with init code,
+     *      usually something like 'M.mod_mymodule.init'
+     * @param array $extraarguments and array of arguments to be passed to the function.
+     *      The first argument is always the YUI3 Y instance with all required dependencies
+     *      already loaded.
+     * @param bool $ondomready wait for dom ready (helps with some IE problems when modifying DOM)
+     * @param array $module JS module specification array
+     */
+    public function js_init_call($function, array $extraarguments = null, $ondomready = false, array $module = null) {
+        $jscode = js_writer::function_call_with_Y($function, $extraarguments);
+        if (!$module) {
+            // Detect module automatically.
+            if (preg_match('/M\.([a-z0-9]+_[^\.]+)/', $function, $matches)) {
+                $module = $this->find_module($matches[1]);
+            }
+        }
+
+        $this->js_init_code($jscode, $ondomready, $module);
+    }
+
+    /**
+     * Add short static javascript code fragment to page footer.
+     * This is intended primarily for loading of js modules and initialising page layout.
+     * Ideally the JS code fragment should be stored in plugin renderer so that themes
+     * may override it.
+     *
+     * @param string $jscode
+     * @param bool $ondomready wait for dom ready (helps with some IE problems when modifying DOM)
+     * @param array $module JS module specification array
+     */
+    public function js_init_code($jscode, $ondomready = false, array $module = null) {
+        $jscode = trim($jscode, " ;\n"). ';';
+
+        $uniqid = html_writer::random_id();
+        $startjs = " M.util.js_pending('" . $uniqid . "');";
+        $endjs = " M.util.js_complete('" . $uniqid . "');";
+
+        if ($module) {
+            $this->js_module($module);
+            $modulename = $module['name'];
+            $jscode = "$startjs Y.use('$modulename', function(Y) { $jscode $endjs });";
+        }
+
+        if ($ondomready) {
+            $jscode = "$startjs Y.on('domready', function() { $jscode $endjs });";
+        }
+
+        $this->jsinitcode[] = $jscode;
+    }
+
+    /**
+     * Make a language string available to JavaScript.
+     *
+     * All the strings will be available in a M.str object in the global namespace.
+     * So, for example, after a call to $PAGE->requires->string_for_js('course', 'moodle');
+     * then the JavaScript variable M.str.moodle.course will be 'Course', or the
+     * equivalent in the current language.
+     *
+     * The arguments to this function are just like the arguments to get_string
+     * except that $component is not optional, and there are some aspects to consider
+     * when the string contains {$a} placeholder.
+     *
+     * If the string does not contain any {$a} placeholder, you can simply use
+     * M.str.component.identifier to obtain it. If you prefer, you can call
+     * M.util.get_string(identifier, component) to get the same result.
+     *
+     * If you need to use {$a} placeholders, there are two options. Either the
+     * placeholder should be substituted in PHP on server side or it should
+     * be substituted in Javascript at client side.
+     *
+     * To substitute the placeholder at server side, just provide the required
+     * value for the placeholder when you require the string. Because each string
+     * is only stored once in the JavaScript (based on $identifier and $module)
+     * you cannot get the same string with two different values of $a. If you try,
+     * an exception will be thrown. Once the placeholder is substituted, you can
+     * use M.str or M.util.get_string() as shown above:
+     *
+     *     // Require the string in PHP and replace the placeholder.
+     *     $PAGE->requires->string_for_js('fullnamedisplay', 'moodle', $USER);
+     *     // Use the result of the substitution in Javascript.
+     *     alert(M.str.moodle.fullnamedisplay);
+     *
+     * To substitute the placeholder at client side, use M.util.get_string()
+     * function. It implements the same logic as {@link get_string()}:
+     *
+     *     // Require the string in PHP but keep {$a} as it is.
+     *     $PAGE->requires->string_for_js('fullnamedisplay', 'moodle');
+     *     // Provide the values on the fly in Javascript.
+     *     user = { firstname : 'Harry', lastname : 'Potter' }
+     *     alert(M.util.get_string('fullnamedisplay', 'moodle', user);
+     *
+     * If you do need the same string expanded with different $a values in PHP
+     * on server side, then the solution is to put them in your own data structure
+     * (e.g. and array) that you pass to JavaScript with {@link data_for_js()}.
+     *
+     * @param string $identifier the desired string.
+     * @param string $component the language file to look in.
+     * @param mixed $a any extra data to add into the string (optional).
+     */
+    public function string_for_js($identifier, $component, $a = null) {
+        if (!$component) {
+            throw new coding_exception('The $component parameter is required for page_requirements_manager::string_for_js().');
+        }
+        if (isset($this->stringsforjs_as[$component][$identifier]) and $this->stringsforjs_as[$component][$identifier] !== $a) {
+            throw new coding_exception("Attempt to re-define already required string '$identifier' " .
+                    "from lang file '$component' with different \$a parameter?");
+        }
+        if (!isset($this->stringsforjs[$component][$identifier])) {
+            $this->stringsforjs[$component][$identifier] = new lang_string($identifier, $component, $a);
+            $this->stringsforjs_as[$component][$identifier] = $a;
+        }
+    }
+
+    /**
+     * Make an array of language strings available for JS.
+     *
+     * This function calls the above function {@link string_for_js()} for each requested
+     * string in the $identifiers array that is passed to the argument for a single module
+     * passed in $module.
+     *
+     * <code>
+     * $PAGE->requires->strings_for_js(array('one', 'two', 'three'), 'mymod', array('a', null, 3));
+     *
+     * // The above is identical to calling:
+     *
+     * $PAGE->requires->string_for_js('one', 'mymod', 'a');
+     * $PAGE->requires->string_for_js('two', 'mymod');
+     * $PAGE->requires->string_for_js('three', 'mymod', 3);
+     * </code>
+     *
+     * @param array $identifiers An array of desired strings
+     * @param string $component The module to load for
+     * @param mixed $a This can either be a single variable that gets passed as extra
+     *         information for every string or it can be an array of mixed data where the
+     *         key for the data matches that of the identifier it is meant for.
+     *
+     */
+    public function strings_for_js($identifiers, $component, $a = null) {
+        foreach ($identifiers as $key => $identifier) {
+            if (is_array($a) && array_key_exists($key, $a)) {
+                $extra = $a[$key];
+            } else {
+                $extra = $a;
+            }
+            $this->string_for_js($identifier, $component, $extra);
+        }
+    }
+
+    /**
+     * !!!!!!DEPRECATED!!!!!! please use js_init_call() for everything now.
+     *
+     * Make some data from PHP available to JavaScript code.
+     *
+     * For example, if you call
+     * <pre>
+     *      $PAGE->requires->data_for_js('mydata', array('name' => 'Moodle'));
+     * </pre>
+     * then in JavsScript mydata.name will be 'Moodle'.
+     *
+     * @deprecated
+     * @param string $variable the the name of the JavaScript variable to assign the data to.
+     *      Will probably work if you use a compound name like 'mybuttons.button[1]', but this
+     *      should be considered an experimental feature.
+     * @param mixed $data The data to pass to JavaScript. This will be escaped using json_encode,
+     *      so passing objects and arrays should work.
+     * @param bool $inhead initialise in head
+     * @return void
+     */
+    public function data_for_js($variable, $data, $inhead=false) {
+        $where = $inhead ? 'head' : 'footer';
+        $this->jsinitvariables[$where][] = array($variable, $data);
+    }
+
+    /**
+     * Creates a YUI event handler.
+     *
+     * @param mixed $selector standard YUI selector for elements, may be array or string, element id is in the form "#idvalue"
+     * @param string $event A valid DOM event (click, mousedown, change etc.)
+     * @param string $function The name of the function to call
+     * @param array  $arguments An optional array of argument parameters to pass to the function
+     */
+    public function event_handler($selector, $event, $function, array $arguments = null) {
+        $this->eventhandlers[] = array('selector'=>$selector, 'event'=>$event, 'function'=>$function, 'arguments'=>$arguments);
+    }
+
+    /**
+     * Returns code needed for registering of event handlers.
+     * @return string JS code
+     */
+    protected function get_event_handler_code() {
+        $output = '';
+        foreach ($this->eventhandlers as $h) {
+            $output .= js_writer::event_handler($h['selector'], $h['event'], $h['function'], $h['arguments']);
+        }
+        return $output;
+    }
+
+    /**
+     * Get the inline JavaScript code that need to appear in a particular place.
+     * @param bool $ondomready
+     * @return string
+     */
+    protected function get_javascript_code($ondomready) {
+        $where = $ondomready ? 'ondomready' : 'normal';
+        $output = '';
+        if ($this->jscalls[$where]) {
+            foreach ($this->jscalls[$where] as $data) {
+                $output .= js_writer::function_call($data[0], $data[1], $data[2]);
+            }
+            if (!empty($ondomready)) {
+                $output = "    Y.on('domready', function() {\n$output\n});";
+            }
+        }
+        return $output;
+    }
+
+    /**
+     * Returns js code to be executed when Y is available.
+     * @return string
+     */
+    protected function get_javascript_init_code() {
+        if (count($this->jsinitcode)) {
+            return implode("\n", $this->jsinitcode) . "\n";
+        }
+        return '';
+    }
+
+    /**
+     * Returns js code to load amd module loader, then insert inline script tags
+     * that contain require() calls using RequireJS.
+     * @return string
+     */
+    protected function get_amd_footercode() {
+        global $CFG;
+        $output = '';
+
+        // We will cache JS if cachejs is not set, or it is true.
+        $cachejs = !isset($CFG->cachejs) || $CFG->cachejs;
+        $jsrev = $this->get_jsrev();
+
+        $jsloader = new moodle_url('/lib/javascript.php');
+        $jsloader->set_slashargument('/' . $jsrev . '/');
+        $requirejsloader = new moodle_url('/lib/requirejs.php');
+        $requirejsloader->set_slashargument('/' . $jsrev . '/');
+
+        $requirejsconfig = file_get_contents($CFG->dirroot . '/lib/requirejs/moodle-config.js');
+
+        // No extension required unless slash args is disabled.
+        $jsextension = '.js';
+        if (!empty($CFG->slasharguments)) {
+            $jsextension = '';
+        }
+
+        $minextension = '.min';
+        if (!$cachejs) {
+            $minextension = '';
+        }
+
+        $requirejsconfig = str_replace('[BASEURL]', $requirejsloader, $requirejsconfig);
+        $requirejsconfig = str_replace('[JSURL]', $jsloader, $requirejsconfig);
+        $requirejsconfig = str_replace('[JSMIN]', $minextension, $requirejsconfig);
+        $requirejsconfig = str_replace('[JSEXT]', $jsextension, $requirejsconfig);
+
+        $output .= html_writer::script($requirejsconfig);
+        if ($cachejs) {
+            $output .= html_writer::script('', $this->js_fix_url('/lib/requirejs/require.min.js'));
+        } else {
+            $output .= html_writer::script('', $this->js_fix_url('/lib/requirejs/require.js'));
+        }
+
+        // First include must be to a module with no dependencies, this prevents multiple requests.
+        $prefix = <<<EOF
+M.util.js_pending("core/first");
+require(['core/first'], function() {
+
+EOF;
+
+        if (during_initial_install()) {
+            // Do not run a prefetch during initial install as the DB is not available to service WS calls.
+            $prefetch = '';
+        } else {
+            $prefetch = "require(['core/prefetch'])\n";
+        }
+
+        $suffix = <<<EOF
+
+    M.util.js_complete("core/first");
+});
+EOF;
+
+        $output .= html_writer::script($prefix . $prefetch . implode(";\n", $this->amdjscode) . $suffix);
+        return $output;
+    }
+
+    /**
+     * Returns basic YUI3 CSS code.
+     *
+     * @return string
+     */
+    protected function get_yui3lib_headcss() {
+        global $CFG;
+
+        $yuiformat = '-min';
+        if ($this->yui3loader->filter === 'RAW') {
+            $yuiformat = '';
+        }
+
+        $code = '';
+        if ($this->yui3loader->combine) {
+            if (!empty($this->yuicssmodules)) {
+                $modules = array();
+                foreach ($this->yuicssmodules as $module) {
+                    $modules[] = "$CFG->yui3version/$module/$module-min.css";
+                }
+                $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->comboBase.implode('&amp;', $modules).'" />';
+            }
+            $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->local_comboBase.'rollup/'.$CFG->yui3version.'/yui-moodlesimple' . $yuiformat . '.css" />';
+
+        } else {
+            if (!empty($this->yuicssmodules)) {
+                foreach ($this->yuicssmodules as $module) {
+                    $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->base.$module.'/'.$module.'-min.css" />';
+                }
+            }
+            $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->local_comboBase.'rollup/'.$CFG->yui3version.'/yui-moodlesimple' . $yuiformat . '.css" />';
+        }
+
+        if ($this->yui3loader->filter === 'RAW') {
+            $code = str_replace('-min.css', '.css', $code);
+        } else if ($this->yui3loader->filter === 'DEBUG') {
+            $code = str_replace('-min.css', '.css', $code);
+        }
+        return $code;
+    }
+
+    /**
+     * Returns basic YUI3 JS loading code.
+     *
+     * @return string
+     */
+    protected function get_yui3lib_headcode() {
+        global $CFG;
+
+        $jsrev = $this->get_jsrev();
+
+        $yuiformat = '-min';
+        if ($this->yui3loader->filter === 'RAW') {
+            $yuiformat = '';
+        }
+
+        $format = '-min';
+        if ($this->YUI_config->groups['moodle']['filter'] === 'DEBUG') {
+            $format = '-debug';
+        }
+
+        $rollupversion = $CFG->yui3version;
+        if (!empty($CFG->yuipatchlevel)) {
+            $rollupversion .= '_' . $CFG->yuipatchlevel;
+        }
+
+        $baserollups = array(
+            'rollup/' . $rollupversion . "/yui-moodlesimple{$yuiformat}.js",
+        );
+
+        if ($this->yui3loader->combine) {
+            return '<script src="' .
+                    $this->yui3loader->local_comboBase .
+                    implode('&amp;', $baserollups) .
+                    '"></script>';
+        } else {
+            $code = '';
+            foreach ($baserollups as $rollup) {
+                $code .= '<script src="'.$this->yui3loader->local_comboBase.$rollup.'"></script>';
+            }
+            return $code;
+        }
+
+    }
+
+    /**
+     * Returns html tags needed for inclusion of theme CSS.
+     *
+     * @return string
+     */
+    protected function get_css_code() {
+        // First of all the theme CSS, then any custom CSS
+        // Please note custom CSS is strongly discouraged,
+        // because it can not be overridden by themes!
+        // It is suitable only for things like mod/data which accepts CSS from teachers.
+        $attributes = array('rel'=>'stylesheet', 'type'=>'text/css');
+
+        // Add the YUI code first. We want this to be overridden by any Moodle CSS.
+        $code = $this->get_yui3lib_headcss();
+
+        // This line of code may look funny but it is currently required in order
+        // to avoid MASSIVE display issues in Internet Explorer.
+        // As of IE8 + YUI3.1.1 the reference stylesheet (firstthemesheet) gets
+        // ignored whenever another resource is added until such time as a redraw
+        // is forced, usually by moving the mouse over the affected element.
+        $code .= html_writer::tag('script', '/** Required in order to fix style inclusion problems in IE with YUI **/', array('id'=>'firstthemesheet', 'type'=>'text/css'));
+
+        $urls = $this->cssthemeurls + $this->cssurls;
+        foreach ($urls as $url) {
+            $attributes['href'] = $url;
+            $code .= html_writer::empty_tag('link', $attributes) . "\n";
+            // This id is needed in first sheet only so that theme may override YUI sheets loaded on the fly.
+            unset($attributes['id']);
+        }
+
+        return $code;
+    }
+
+    /**
+     * Adds extra modules specified after printing of page header.
+     *
+     * @return string
+     */
+    protected function get_extra_modules_code() {
+        if (empty($this->extramodules)) {
+            return '';
+        }
+        return html_writer::script(js_writer::function_call('M.yui.add_module', array($this->extramodules)));
+    }
+
+    /**
+     * Generate any HTML that needs to go inside the <head> tag.
+     *
+     * Normally, this method is called automatically by the code that prints the
+     * <head> tag. You should not normally need to call it in your own code.
+     *
+     * @param moodle_page $page
+     * @param core_renderer $renderer
+     * @return string the HTML code to to inside the <head> tag.
+     */
+    public function get_head_code(moodle_page $page, core_renderer $renderer) {
+        global $CFG;
+
+        // Note: the $page and $output are not stored here because it would
+        // create circular references in memory which prevents garbage collection.
+        $this->init_requirements_data($page, $renderer);
+
+        $output = '';
+
+        // Add all standard CSS for this page.
+        $output .= $this->get_css_code();
+
+        // Set up the M namespace.
+        $js = "var M = {}; M.yui = {};\n";
+
+        // Capture the time now ASAP during page load. This minimises the lag when
+        // we try to relate times on the server to times in the browser.
+        // An example of where this is used is the quiz countdown timer.
+        $js .= "M.pageloadstarttime = new Date();\n";
+
+        // Add a subset of Moodle configuration to the M namespace.
+        $js .= js_writer::set_variable('M.cfg', $this->M_cfg, false);
+
+        // Set up global YUI3 loader object - this should contain all code needed by plugins.
+        // Note: in JavaScript just use "YUI().use('overlay', function(Y) { .... });",
+        //       this needs to be done before including any other script.
+        $js .= $this->YUI_config->get_config_functions();
+        $js .= js_writer::set_variable('YUI_config', $this->YUI_config, false) . "\n";
+        $js .= "M.yui.loader = {modules: {}};\n"; // Backwards compatibility only, not used any more.
+        $js = $this->YUI_config->update_header_js($js);
+
+        $output .= html_writer::script($js);
+
+        // Add variables.
+        if ($this->jsinitvariables['head']) {
+            $js = '';
+            foreach ($this->jsinitvariables['head'] as $data) {
+                list($var, $value) = $data;
+                $js .= js_writer::set_variable($var, $value, true);
+            }
+            $output .= html_writer::script($js);
+        }
+
+        // Mark head sending done, it is not possible to anything there.
+        $this->headdone = true;
+
+        return $output;
+    }
+
+    /**
+     * Generate any HTML that needs to go at the start of the <body> tag.
+     *
+     * Normally, this method is called automatically by the code that prints the
+     * <head> tag. You should not normally need to call it in your own code.
+     *
+     * @param renderer_base $renderer
+     * @return string the HTML code to go at the start of the <body> tag.
+     */
+    public function get_top_of_body_code(renderer_base $renderer) {
+        global $CFG;
+
+        // First the skip links.
+        $output = $renderer->render_skip_links($this->skiplinks);
+
+        // Include the Polyfills.
+        $output .= html_writer::script('', $this->js_fix_url('/lib/polyfills/polyfill.js'));
+
+        // YUI3 JS needs to be loaded early in the body. It should be cached well by the browser.
+        $output .= $this->get_yui3lib_headcode();
+
+        // Add hacked jQuery support, it is not intended for standard Moodle distribution!
+        $output .= $this->get_jquery_headcode();
+
+        // Link our main JS file, all core stuff should be there.
+        $output .= html_writer::script('', $this->js_fix_url('/lib/javascript-static.js'));
+
+        // All the other linked things from HEAD - there should be as few as possible.
+        if ($this->jsincludes['head']) {
+            foreach ($this->jsincludes['head'] as $url) {
+                $output .= html_writer::script('', $url);
+            }
+        }
+
+        // Then the clever trick for hiding of things not needed when JS works.
+        $output .= html_writer::script("document.body.className += ' jsenabled';") . "\n";
+        $this->topofbodydone = true;
+        return $output;
+    }
+
+    /**
+     * Generate any HTML that needs to go at the end of the page.
+     *
+     * Normally, this method is called automatically by the code that prints the
+     * page footer. You should not normally need to call it in your own code.
+     *
+     * @return string the HTML code to to at the end of the page.
+     */
+    public function get_end_code() {
+        global $CFG;
+        $output = '';
+
+        // Set the log level for the JS logging.
+        $logconfig = new stdClass();
+        $logconfig->level = 'warn';
+        if ($CFG->debugdeveloper) {
+            $logconfig->level = 'trace';
+        }
+        $this->js_call_amd('core/log', 'setConfig', array($logconfig));
+        // Add any global JS that needs to run on all pages.
+        $this->js_call_amd('core/page_global', 'init');
+        $this->js_call_amd('core/utility');
+
+        // Call amd init functions.
+        $output .= $this->get_amd_footercode();
+
+        // Add other requested modules.
+        $output .= $this->get_extra_modules_code();
+
+        $this->js_init_code('M.util.js_complete("init");', true);
+
+        // All the other linked scripts - there should be as few as possible.
+        if ($this->jsincludes['footer']) {
+            foreach ($this->jsincludes['footer'] as $url) {
+                $output .= html_writer::script('', $url);
+            }
+        }
+
+        // Add all needed strings.
+        // First add core strings required for some dialogues.
+        $this->strings_for_js(array(
+            'confirm',
+            'yes',
+            'no',
+            'areyousure',
+            'closebuttontitle',
+            'unknownerror',
+            'error',
+            'file',
+            'url',
+            // TODO MDL-70830 shortforms should preload the collapseall/expandall strings properly.
+            'collapseall',
+            'expandall',
+        ), 'moodle');
+        $this->strings_for_js(array(
+            'debuginfo',
+            'line',
+            'stacktrace',
+        ), 'debug');
+        $this->string_for_js('labelsep', 'langconfig');
+        if (!empty($this->stringsforjs)) {
+            $strings = array();
+            foreach ($this->stringsforjs as $component=>$v) {
+                foreach($v as $indentifier => $langstring) {
+                    $strings[$component][$indentifier] = $langstring->out();
+                }
+            }
+            $output .= html_writer::script(js_writer::set_variable('M.str', $strings));
+        }
+
+        // Add variables.
+        if ($this->jsinitvariables['footer']) {
+            $js = '';
+            foreach ($this->jsinitvariables['footer'] as $data) {
+                list($var, $value) = $data;
+                $js .= js_writer::set_variable($var, $value, true);
+            }
+            $output .= html_writer::script($js);
+        }
+
+        $inyuijs = $this->get_javascript_code(false);
+        $ondomreadyjs = $this->get_javascript_code(true);
+        $jsinit = $this->get_javascript_init_code();
+        $handlersjs = $this->get_event_handler_code();
+
+        // There is a global Y, make sure it is available in your scope.
+        $js = "(function() {{$inyuijs}{$ondomreadyjs}{$jsinit}{$handlersjs}})();";
+
+        $output .= html_writer::script($js);
+
+        return $output;
+    }
+
+    /**
+     * Have we already output the code in the <head> tag?
+     *
+     * @return bool
+     */
+    public function is_head_done() {
+        return $this->headdone;
+    }
+
+    /**
+     * Have we already output the code at the start of the <body> tag?
+     *
+     * @return bool
+     */
+    public function is_top_of_body_done() {
+        return $this->topofbodydone;
+    }
+
+    /**
+     * Should we generate a bit of content HTML that is only required once  on
+     * this page (e.g. the contents of the modchooser), now? Basically, we call
+     * {@link has_one_time_item_been_created()}, and if the thing has not already
+     * been output, we return true to tell the caller to generate it, and also
+     * call {@link set_one_time_item_created()} to record the fact that it is
+     * about to be generated.
+     *
+     * That is, a typical usage pattern (in a renderer method) is:
+     * <pre>
+     * if (!$this->page->requires->should_create_one_time_item_now($thing)) {
+     *     return '';
+     * }
+     * // Else generate it.
+     * </pre>
+     *
+     * @param string $thing identifier for the bit of content. Should be of the form
+     *      frankenstyle_things, e.g. core_course_modchooser.
+     * @return bool if true, the caller should generate that bit of output now, otherwise don't.
+     */
+    public function should_create_one_time_item_now($thing) {
+        if ($this->has_one_time_item_been_created($thing)) {
+            return false;
+        }
+
+        $this->set_one_time_item_created($thing);
+        return true;
+    }
+
+    /**
+     * Has a particular bit of HTML that is only required once  on this page
+     * (e.g. the contents of the modchooser) already been generated?
+     *
+     * Normally, you can use the {@link should_create_one_time_item_now()} helper
+     * method rather than calling this method directly.
+     *
+     * @param string $thing identifier for the bit of content. Should be of the form
+     *      frankenstyle_things, e.g. core_course_modchooser.
+     * @return bool whether that bit of output has been created.
+     */
+    public function has_one_time_item_been_created($thing) {
+        return isset($this->onetimeitemsoutput[$thing]);
+    }
+
+    /**
+     * Indicate that a particular bit of HTML that is only required once on this
+     * page (e.g. the contents of the modchooser) has been generated (or is about to be)?
+     *
+     * Normally, you can use the {@link should_create_one_time_item_now()} helper
+     * method rather than calling this method directly.
+     *
+     * @param string $thing identifier for the bit of content. Should be of the form
+     *      frankenstyle_things, e.g. core_course_modchooser.
+     */
+    public function set_one_time_item_created($thing) {
+        if ($this->has_one_time_item_been_created($thing)) {
+            throw new coding_exception($thing . ' is only supposed to be ouput ' .
+                    'once per page, but it seems to be being output again.');
+        }
+        return $this->onetimeitemsoutput[$thing] = true;
+    }
+}
diff --git a/lib/classes/output/requirements/yui.php b/lib/classes/output/requirements/yui.php
new file mode 100644
index 00000000000..272753aa4fe
--- /dev/null
+++ b/lib/classes/output/requirements/yui.php
@@ -0,0 +1,351 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This class represents the YUI configuration.
+ *
+ * @copyright 2013 Andrew Nicols
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.5
+ * @package core
+ * @category output
+ */
+class YUI_config {
+    /**
+     * These settings must be public so that when the object is converted to json they are exposed.
+     * Note: Some of these are camelCase because YUI uses camelCase variable names.
+     *
+     * The settings are described and documented in the YUI API at:
+     * - http://yuilibrary.com/yui/docs/api/classes/config.html
+     * - http://yuilibrary.com/yui/docs/api/classes/Loader.html
+     */
+    public $debug = false;
+    public $base;
+    public $comboBase;
+    public $combine;
+    public $filter = null;
+    public $insertBefore = 'firstthemesheet';
+    public $groups = array();
+    public $modules = array();
+    /** @var array The log sources that should be not be logged. */
+    public $logInclude = [];
+    /** @var array Tog sources that should be logged. */
+    public $logExclude = [];
+    /** @var string The minimum log level for YUI logging statements. */
+    public $logLevel;
+
+    /**
+     * @var array List of functions used by the YUI Loader group pattern recognition.
+     */
+    protected $jsconfigfunctions = array();
+
+    /**
+     * Create a new group within the YUI_config system.
+     *
+     * @param string $name The name of the group. This must be unique and
+     * not previously used.
+     * @param array $config The configuration for this group.
+     * @return void
+     */
+    public function add_group($name, $config) {
+        if (isset($this->groups[$name])) {
+            throw new coding_exception("A YUI configuration group for '{$name}' already exists. To make changes to this group use YUI_config->update_group().");
+        }
+        $this->groups[$name] = $config;
+    }
+
+    /**
+     * Update an existing group configuration
+     *
+     * Note, any existing configuration for that group will be wiped out.
+     * This includes module configuration.
+     *
+     * @param string $name The name of the group. This must be unique and
+     * not previously used.
+     * @param array $config The configuration for this group.
+     * @return void
+     */
+    public function update_group($name, $config) {
+        if (!isset($this->groups[$name])) {
+            throw new coding_exception('The Moodle YUI module does not exist. You must define the moodle module config using YUI_config->add_module_config first.');
+        }
+        $this->groups[$name] = $config;
+    }
+
+    /**
+     * Set the value of a configuration function used by the YUI Loader's pattern testing.
+     *
+     * Only the body of the function should be passed, and not the whole function wrapper.
+     *
+     * The JS function your write will be passed a single argument 'name' containing the
+     * name of the module being loaded.
+     *
+     * @param $function String the body of the JavaScript function. This should be used i
+     * @return string the name of the function to use in the group pattern configuration.
+     */
+    public function set_config_function($function) {
+        $configname = 'yui' . (count($this->jsconfigfunctions) + 1) . 'ConfigFn';
+        if (isset($this->jsconfigfunctions[$configname])) {
+            throw new coding_exception("A YUI config function with this name already exists. Config function names must be unique.");
+        }
+        $this->jsconfigfunctions[$configname] = $function;
+        return '@' . $configname . '@';
+    }
+
+    /**
+     * Allow setting of the config function described in {@see set_config_function} from a file.
+     * The contents of this file are then passed to set_config_function.
+     *
+     * When jsrev is positive, the function is minified and stored in a MUC cache for subsequent uses.
+     *
+     * @param $file The path to the JavaScript function used for YUI configuration.
+     * @return string the name of the function to use in the group pattern configuration.
+     */
+    public function set_config_source($file) {
+        global $CFG;
+        $cache = cache::make('core', 'yuimodules');
+
+        // Attempt to get the metadata from the cache.
+        $keyname = 'configfn_' . $file;
+        $fullpath = $CFG->dirroot . '/' . $file;
+        if (!isset($CFG->jsrev) || $CFG->jsrev == -1) {
+            $cache->delete($keyname);
+            $configfn = file_get_contents($fullpath);
+        } else {
+            $configfn = $cache->get($keyname);
+            if ($configfn === false) {
+                require_once($CFG->libdir . '/jslib.php');
+                $configfn = core_minify::js_files(array($fullpath));
+                $cache->set($keyname, $configfn);
+            }
+        }
+        return $this->set_config_function($configfn);
+    }
+
+    /**
+     * Retrieve the list of JavaScript functions for YUI_config groups.
+     *
+     * @return string The complete set of config functions
+     */
+    public function get_config_functions() {
+        $configfunctions = '';
+        foreach ($this->jsconfigfunctions as $functionname => $function) {
+            $configfunctions .= "var {$functionname} = function(me) {";
+            $configfunctions .= $function;
+            $configfunctions .= "};\n";
+        }
+        return $configfunctions;
+    }
+
+    /**
+     * Update the header JavaScript with any required modification for the YUI Loader.
+     *
+     * @param $js String The JavaScript to manipulate.
+     * @return string the modified JS string.
+     */
+    public function update_header_js($js) {
+        // Update the names of the the configFn variables.
+        // The PHP json_encode function cannot handle literal names so we have to wrap
+        // them in @ and then replace them with literals of the same function name.
+        foreach ($this->jsconfigfunctions as $functionname => $function) {
+            $js = str_replace('"@' . $functionname . '@"', $functionname, $js);
+        }
+        return $js;
+    }
+
+    /**
+     * Add configuration for a specific module.
+     *
+     * @param string $name The name of the module to add configuration for.
+     * @param array $config The configuration for the specified module.
+     * @param string $group The name of the group to add configuration for.
+     * If not specified, then this module is added to the global
+     * configuration.
+     * @return void
+     */
+    public function add_module_config($name, $config, $group = null) {
+        if ($group) {
+            if (!isset($this->groups[$name])) {
+                throw new coding_exception('The Moodle YUI module does not exist. You must define the moodle module config using YUI_config->add_module_config first.');
+            }
+            if (!isset($this->groups[$group]['modules'])) {
+                $this->groups[$group]['modules'] = array();
+            }
+            $modules = &$this->groups[$group]['modules'];
+        } else {
+            $modules = &$this->modules;
+        }
+        $modules[$name] = $config;
+    }
+
+    /**
+     * Add the moodle YUI module metadata for the moodle group to the YUI_config instance.
+     *
+     * If js caching is disabled, metadata will not be served causing YUI to calculate
+     * module dependencies as each module is loaded.
+     *
+     * If metadata does not exist it will be created and stored in a MUC entry.
+     *
+     * @return void
+     */
+    public function add_moodle_metadata() {
+        global $CFG;
+        if (!isset($this->groups['moodle'])) {
+            throw new coding_exception('The Moodle YUI module does not exist. You must define the moodle module config using YUI_config->add_module_config first.');
+        }
+
+        if (!isset($this->groups['moodle']['modules'])) {
+            $this->groups['moodle']['modules'] = array();
+        }
+
+        $cache = cache::make('core', 'yuimodules');
+        if (!isset($CFG->jsrev) || $CFG->jsrev == -1) {
+            $metadata = array();
+            $metadata = $this->get_moodle_metadata();
+            $cache->delete('metadata');
+        } else {
+            // Attempt to get the metadata from the cache.
+            if (!$metadata = $cache->get('metadata')) {
+                $metadata = $this->get_moodle_metadata();
+                $cache->set('metadata', $metadata);
+            }
+        }
+
+        // Merge with any metadata added specific to this page which was added manually.
+        $this->groups['moodle']['modules'] = array_merge($this->groups['moodle']['modules'],
+                $metadata);
+    }
+
+    /**
+     * Determine the module metadata for all moodle YUI modules.
+     *
+     * This works through all modules capable of serving YUI modules, and attempts to get
+     * metadata for each of those modules.
+     *
+     * @return array of module metadata
+     */
+    private function get_moodle_metadata() {
+        $moodlemodules = array();
+        // Core isn't a plugin type or subsystem - handle it seperately.
+        if ($module = $this->get_moodle_path_metadata(core_component::get_component_directory('core'))) {
+            $moodlemodules = array_merge($moodlemodules, $module);
+        }
+
+        // Handle other core subsystems.
+        $subsystems = core_component::get_core_subsystems();
+        foreach ($subsystems as $subsystem => $path) {
+            if (is_null($path)) {
+                continue;
+            }
+            if ($module = $this->get_moodle_path_metadata($path)) {
+                $moodlemodules = array_merge($moodlemodules, $module);
+            }
+        }
+
+        // And finally the plugins.
+        $plugintypes = core_component::get_plugin_types();
+        foreach ($plugintypes as $plugintype => $pathroot) {
+            $pluginlist = core_component::get_plugin_list($plugintype);
+            foreach ($pluginlist as $plugin => $path) {
+                if ($module = $this->get_moodle_path_metadata($path)) {
+                    $moodlemodules = array_merge($moodlemodules, $module);
+                }
+            }
+        }
+
+        return $moodlemodules;
+    }
+
+    /**
+     * Helper function process and return the YUI metadata for all of the modules under the specified path.
+     *
+     * @param string $path the UNC path to the YUI src directory.
+     * @return array the complete array for frankenstyle directory.
+     */
+    private function get_moodle_path_metadata($path) {
+        // Add module metadata is stored in frankenstyle_modname/yui/src/yui_modname/meta/yui_modname.json.
+        $baseyui = $path . '/yui/src';
+        $modules = array();
+        if (is_dir($baseyui)) {
+            $items = new DirectoryIterator($baseyui);
+            foreach ($items as $item) {
+                if ($item->isDot() or !$item->isDir()) {
+                    continue;
+                }
+                $metafile = realpath($baseyui . '/' . $item . '/meta/' . $item . '.json');
+                if (!is_readable($metafile)) {
+                    continue;
+                }
+                $metadata = file_get_contents($metafile);
+                $modules = array_merge($modules, (array) json_decode($metadata));
+            }
+        }
+        return $modules;
+    }
+
+    /**
+     * Define YUI modules which we have been required to patch between releases.
+     *
+     * We must do this because we aggressively cache content on the browser, and we must also override use of the
+     * external CDN which will serve the true authoritative copy of the code without our patches.
+     *
+     * @param string $combobase The local combobase
+     * @param string $yuiversion The current YUI version
+     * @param int $patchlevel The patch level we're working to for YUI
+     * @param array $patchedmodules An array containing the names of the patched modules
+     * @return void
+     */
+    public function define_patched_core_modules($combobase, $yuiversion, $patchlevel, $patchedmodules) {
+        // The version we use is suffixed with a patchlevel so that we can get additional revisions between YUI releases.
+        $subversion = $yuiversion . '_' . $patchlevel;
+
+        if ($this->comboBase == $combobase) {
+            // If we are using the local combobase in the loader, we can add a group and still make use of the combo
+            // loader. We just need to specify a different root which includes a slightly different YUI version number
+            // to include our patchlevel.
+            $patterns = array();
+            $modules = array();
+            foreach ($patchedmodules as $modulename) {
+                // We must define the pattern and module here so that the loader uses our group configuration instead of
+                // the standard module definition. We may lose some metadata provided by upstream but this will be
+                // loaded when the module is loaded anyway.
+                $patterns[$modulename] = array(
+                    'group' => 'yui-patched',
+                );
+                $modules[$modulename] = array();
+            }
+
+            // Actually add the patch group here.
+            $this->add_group('yui-patched', array(
+                'combine' => true,
+                'root' => $subversion . '/',
+                'patterns' => $patterns,
+                'modules' => $modules,
+            ));
+
+        } else {
+            // The CDN is in use - we need to instead use the local combobase for this module and override the modules
+            // definition. We cannot use the local base - we must use the combobase because we cannot invalidate the
+            // local base in browser caches.
+            $fullpathbase = $combobase . $subversion . '/';
+            foreach ($patchedmodules as $modulename) {
+                $this->modules[$modulename] = array(
+                    'fullpath' => $fullpathbase . $modulename . '/' . $modulename . '-min.js'
+                );
+            }
+        }
+    }
+}
diff --git a/lib/classes/output/single_button.php b/lib/classes/output/single_button.php
new file mode 100644
index 00000000000..83de95439b3
--- /dev/null
+++ b/lib/classes/output/single_button.php
@@ -0,0 +1,266 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing a simple form with only one button.
+ *
+ * @copyright 2009 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class single_button implements renderable {
+
+    /**
+     * Possible button types. From boostrap.
+     */
+    const BUTTON_TYPES = [
+        self::BUTTON_PRIMARY,
+        self::BUTTON_SECONDARY,
+        self::BUTTON_SUCCESS,
+        self::BUTTON_DANGER,
+        self::BUTTON_WARNING,
+        self::BUTTON_INFO
+    ];
+
+    /**
+     * Possible button types - Primary.
+     */
+    const BUTTON_PRIMARY = 'primary';
+    /**
+     * Possible button types - Secondary.
+     */
+    const BUTTON_SECONDARY = 'secondary';
+    /**
+     * Possible button types - Danger.
+     */
+    const BUTTON_DANGER = 'danger';
+    /**
+     * Possible button types - Success.
+     */
+    const BUTTON_SUCCESS = 'success';
+    /**
+     * Possible button types - Warning.
+     */
+    const BUTTON_WARNING = 'warning';
+    /**
+     * Possible button types - Info.
+     */
+    const BUTTON_INFO = 'info';
+
+    /**
+     * @var moodle_url Target url
+     */
+    public $url;
+
+    /**
+     * @var string Button label
+     */
+    public $label;
+
+    /**
+     * @var string Form submit method post or get
+     */
+    public $method = 'post';
+
+    /**
+     * @var string Wrapping div class
+     */
+    public $class = 'singlebutton';
+
+    /**
+     * @var string Type of button (from defined types). Used for styling.
+     */
+    protected $type;
+
+    /**
+     * @var bool True if button is primary button. Used for styling.
+     * @deprecated since Moodle 4.2
+     */
+    private $primary = false;
+
+    /**
+     * @var bool True if button disabled, false if normal
+     */
+    public $disabled = false;
+
+    /**
+     * @var string Button tooltip
+     */
+    public $tooltip = null;
+
+    /**
+     * @var string Form id
+     */
+    public $formid;
+
+    /**
+     * @var array List of attached actions
+     */
+    public $actions = array();
+
+    /**
+     * @var array $params URL Params
+     */
+    public $params;
+
+    /**
+     * @var string Action id
+     */
+    public $actionid;
+
+    /**
+     * @var array
+     */
+    protected $attributes = [];
+
+    /**
+     * Constructor
+     *
+     * @param moodle_url $url
+     * @param string $label button text
+     * @param string $method get or post submit method
+     * @param string $type whether this is a primary button or another type, used for styling
+     * @param array $attributes Attributes for the HTML button tag
+     */
+    public function __construct(moodle_url $url, $label, $method = 'post', $type = self::BUTTON_SECONDARY,
+        $attributes = []) {
+        if (is_bool($type)) {
+            debugging('The boolean $primary is deprecated and replaced by $type,
+            use single_button::BUTTON_PRIMARY or self::BUTTON_SECONDARY instead');
+            $type = $type ? self::BUTTON_PRIMARY : self::BUTTON_SECONDARY;
+        }
+        $this->url = clone($url);
+        $this->label = $label;
+        $this->method = $method;
+        $this->type = $type;
+        $this->attributes = $attributes;
+    }
+
+    /**
+     * Shortcut for adding a JS confirm dialog when the button is clicked.
+     * The message must be a yes/no question.
+     *
+     * @param string $confirmmessage The yes/no confirmation question. If "Yes" is clicked, the original action will occur.
+     */
+    public function add_confirm_action($confirmmessage) {
+        $this->add_action(new confirm_action($confirmmessage));
+    }
+
+    /**
+     * Add action to the button.
+     * @param component_action $action
+     */
+    public function add_action(component_action $action) {
+        $this->actions[] = $action;
+    }
+
+    /**
+     * Sets an attribute for the HTML button tag.
+     *
+     * @param  string $name  The attribute name
+     * @param  mixed  $value The value
+     * @return null
+     */
+    public function set_attribute($name, $value) {
+        $this->attributes[$name] = $value;
+    }
+
+    /**
+     * Magic setter method.
+     *
+     * This method manages access to some properties and will display deprecation message when accessing 'primary' property.
+     *
+     * @param string $name
+     * @param mixed $value
+     */
+    public function __set($name, $value) {
+        switch ($name) {
+            case 'primary':
+                debugging('The primary field is deprecated, use the type field instead');
+                // Here just in case we modified the primary field from outside {@see \mod_quiz_renderer::summary_page_controls}.
+                $this->type = $value ? self::BUTTON_PRIMARY : self::BUTTON_SECONDARY;
+                break;
+            case 'type':
+                $this->type = in_array($value, self::BUTTON_TYPES) ? $value : self::BUTTON_SECONDARY;
+                break;
+            default:
+                $this->$name = $value;
+        }
+    }
+
+    /**
+     * Magic method getter.
+     *
+     * This method manages access to some properties and will display deprecation message when accessing 'primary' property.
+     *
+     * @param string $name
+     * @return mixed
+     */
+    public function __get($name) {
+        switch ($name) {
+            case 'primary':
+                debugging('The primary field is deprecated, use type field instead');
+                return $this->type == self::BUTTON_PRIMARY;
+            case 'type':
+                return $this->type;
+            default:
+                return $this->$name;
+        }
+    }
+
+    /**
+     * Export data.
+     *
+     * @param renderer_base $output Renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $url = $this->method === 'get' ? $this->url->out_omit_querystring(true) : $this->url->out_omit_querystring();
+
+        $data = new stdClass();
+        $data->id = html_writer::random_id('single_button');
+        $data->formid = $this->formid;
+        $data->method = $this->method;
+        $data->url = $url === '' ? '#' : $url;
+        $data->label = $this->label;
+        $data->classes = $this->class;
+        $data->disabled = $this->disabled;
+        $data->tooltip = $this->tooltip;
+        $data->type = $this->type;
+        $data->attributes = [];
+        foreach ($this->attributes as $key => $value) {
+            $data->attributes[] = ['name' => $key, 'value' => $value];
+        }
+
+        // Form parameters.
+        $actionurl = new moodle_url($this->url);
+        if ($this->method === 'post') {
+            $actionurl->param('sesskey', sesskey());
+        }
+        $data->params = $actionurl->export_params_for_template();
+
+        // Button actions.
+        $actions = $this->actions;
+        $data->actions = array_map(function($action) use ($output) {
+            return $action->export_for_template($output);
+        }, $actions);
+        $data->hasactions = !empty($data->actions);
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/single_select.php b/lib/classes/output/single_select.php
new file mode 100644
index 00000000000..4645e7bd8b7
--- /dev/null
+++ b/lib/classes/output/single_select.php
@@ -0,0 +1,289 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Simple form with just one select field that gets submitted automatically.
+ *
+ * If JS not enabled small go button is printed too.
+ *
+ * @copyright 2009 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class single_select implements renderable, templatable {
+
+    /**
+     * @var moodle_url Target url - includes hidden fields
+     */
+    var $url;
+
+    /**
+     * @var string Name of the select element.
+     */
+    var $name;
+
+    /**
+     * @var array $options associative array value=>label ex.: array(1=>'One, 2=>Two)
+     *     it is also possible to specify optgroup as complex label array ex.:
+     *         array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
+     *         array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
+     */
+    var $options;
+
+    /**
+     * @var string Selected option
+     */
+    var $selected;
+
+    /**
+     * @var array Nothing selected
+     */
+    var $nothing;
+
+    /**
+     * @var array Extra select field attributes
+     */
+    var $attributes = array();
+
+    /**
+     * @var string Button label
+     */
+    var $label = '';
+
+    /**
+     * @var array Button label's attributes
+     */
+    var $labelattributes = array();
+
+    /**
+     * @var string Form submit method post or get
+     */
+    var $method = 'get';
+
+    /**
+     * @var string Wrapping div class
+     */
+    var $class = 'singleselect';
+
+    /**
+     * @var bool True if button disabled, false if normal
+     */
+    var $disabled = false;
+
+    /**
+     * @var string Button tooltip
+     */
+    var $tooltip = null;
+
+    /**
+     * @var string Form id
+     */
+    var $formid = null;
+
+    /**
+     * @var help_icon The help icon for this element.
+     */
+    var $helpicon = null;
+
+    /** @var component_action[] component action. */
+    public $actions = [];
+
+    /**
+     * Constructor
+     * @param moodle_url $url form action target, includes hidden fields
+     * @param string $name name of selection field - the changing parameter in url
+     * @param array $options list of options
+     * @param string $selected selected element
+     * @param ?array $nothing
+     * @param string $formid
+     */
+    public function __construct(moodle_url $url, $name, array $options, $selected = '', $nothing = array('' => 'choosedots'), $formid = null) {
+        $this->url      = $url;
+        $this->name     = $name;
+        $this->options  = $options;
+        $this->selected = $selected;
+        $this->nothing  = $nothing;
+        $this->formid   = $formid;
+    }
+
+    /**
+     * Shortcut for adding a JS confirm dialog when the button is clicked.
+     * The message must be a yes/no question.
+     *
+     * @param string $confirmmessage The yes/no confirmation question. If "Yes" is clicked, the original action will occur.
+     */
+    public function add_confirm_action($confirmmessage) {
+        $this->add_action(new component_action('submit', 'M.util.show_confirm_dialog', array('message' => $confirmmessage)));
+    }
+
+    /**
+     * Add action to the button.
+     *
+     * @param component_action $action
+     */
+    public function add_action(component_action $action) {
+        $this->actions[] = $action;
+    }
+
+    /**
+     * Adds help icon.
+     *
+     * @deprecated since Moodle 2.0
+     */
+    public function set_old_help_icon($helppage, $title, $component = 'moodle') {
+        throw new coding_exception('set_old_help_icon() can not be used any more, please see set_help_icon().');
+    }
+
+    /**
+     * Adds help icon.
+     *
+     * @param string $identifier The keyword that defines a help page
+     * @param string $component
+     */
+    public function set_help_icon($identifier, $component = 'moodle') {
+        $this->helpicon = new help_icon($identifier, $component);
+    }
+
+    /**
+     * Sets select's label
+     *
+     * @param string $label
+     * @param array $attributes (optional)
+     */
+    public function set_label($label, $attributes = array()) {
+        $this->label = $label;
+        $this->labelattributes = $attributes;
+
+    }
+
+    /**
+     * Export data.
+     *
+     * @param renderer_base $output Renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $attributes = $this->attributes;
+
+        $data = new stdClass();
+        $data->name = $this->name;
+        $data->method = $this->method;
+        $data->action = $this->method === 'get' ? $this->url->out_omit_querystring(true) : $this->url->out_omit_querystring();
+        $data->classes = $this->class;
+        $data->label = $this->label;
+        $data->disabled = $this->disabled;
+        $data->title = $this->tooltip;
+        $data->formid = !empty($this->formid) ? $this->formid : html_writer::random_id('single_select_f');
+        $data->id = !empty($attributes['id']) ? $attributes['id'] : html_writer::random_id('single_select');
+
+        // Select element attributes.
+        // Unset attributes that are already predefined in the template.
+        unset($attributes['id']);
+        unset($attributes['class']);
+        unset($attributes['name']);
+        unset($attributes['title']);
+        unset($attributes['disabled']);
+
+        // Map the attributes.
+        $data->attributes = array_map(function($key) use ($attributes) {
+            return ['name' => $key, 'value' => $attributes[$key]];
+        }, array_keys($attributes));
+
+        // Form parameters.
+        $actionurl = new moodle_url($this->url);
+        if ($this->method === 'post') {
+            $actionurl->param('sesskey', sesskey());
+        }
+        $data->params = $actionurl->export_params_for_template();
+
+        // Select options.
+        $hasnothing = false;
+        if (is_string($this->nothing) && $this->nothing !== '') {
+            $nothing = ['' => $this->nothing];
+            $hasnothing = true;
+            $nothingkey = '';
+        } else if (is_array($this->nothing)) {
+            $nothingvalue = reset($this->nothing);
+            if ($nothingvalue === 'choose' || $nothingvalue === 'choosedots') {
+                $nothing = [key($this->nothing) => get_string('choosedots')];
+            } else {
+                $nothing = $this->nothing;
+            }
+            $hasnothing = true;
+            $nothingkey = key($this->nothing);
+        }
+        if ($hasnothing) {
+            $options = $nothing + $this->options;
+        } else {
+            $options = $this->options;
+        }
+
+        foreach ($options as $value => $name) {
+            if (is_array($options[$value])) {
+                foreach ($options[$value] as $optgroupname => $optgroupvalues) {
+                    $sublist = [];
+                    foreach ($optgroupvalues as $optvalue => $optname) {
+                        $option = [
+                            'value' => $optvalue,
+                            'name' => $optname,
+                            'selected' => strval($this->selected) === strval($optvalue),
+                        ];
+
+                        if ($hasnothing && $nothingkey === $optvalue) {
+                            $option['ignore'] = 'data-ignore';
+                        }
+
+                        $sublist[] = $option;
+                    }
+                    $data->options[] = [
+                        'name' => $optgroupname,
+                        'optgroup' => true,
+                        'options' => $sublist
+                    ];
+                }
+            } else {
+                $option = [
+                    'value' => $value,
+                    'name' => $options[$value],
+                    'selected' => strval($this->selected) === strval($value),
+                    'optgroup' => false
+                ];
+
+                if ($hasnothing && $nothingkey === $value) {
+                    $option['ignore'] = 'data-ignore';
+                }
+
+                $data->options[] = $option;
+            }
+        }
+
+        // Label attributes.
+        $data->labelattributes = [];
+        // Unset label attributes that are already in the template.
+        unset($this->labelattributes['for']);
+        // Map the label attributes.
+        foreach ($this->labelattributes as $key => $value) {
+            $data->labelattributes[] = ['name' => $key, 'value' => $value];
+        }
+
+        // Help icon.
+        $data->helpicon = !empty($this->helpicon) ? $this->helpicon->export_for_template($output) : false;
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/tabobject.php b/lib/classes/output/tabobject.php
new file mode 100644
index 00000000000..305d5b30a75
--- /dev/null
+++ b/lib/classes/output/tabobject.php
@@ -0,0 +1,140 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Stores one tab
+ *
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package core
+ */
+class tabobject implements renderable, templatable {
+    /** @var string unique id of the tab in this tree, it is used to find selected and/or inactive tabs */
+    var $id;
+    /** @var moodle_url|string link */
+    var $link;
+    /** @var string text on the tab */
+    var $text;
+    /** @var string title under the link, by defaul equals to text */
+    var $title;
+    /** @var bool whether to display a link under the tab name when it's selected */
+    var $linkedwhenselected = false;
+    /** @var bool whether the tab is inactive */
+    var $inactive = false;
+    /** @var bool indicates that this tab's child is selected */
+    var $activated = false;
+    /** @var bool indicates that this tab is selected */
+    var $selected = false;
+    /** @var array stores children tabobjects */
+    var $subtree = array();
+    /** @var int level of tab in the tree, 0 for root (instance of tabtree), 1 for the first row of tabs */
+    var $level = 1;
+
+    /**
+     * Constructor
+     *
+     * @param string $id unique id of the tab in this tree, it is used to find selected and/or inactive tabs
+     * @param string|moodle_url $link
+     * @param string $text text on the tab
+     * @param string $title title under the link, by defaul equals to text
+     * @param bool $linkedwhenselected whether to display a link under the tab name when it's selected
+     */
+    public function __construct($id, $link = null, $text = '', $title = '', $linkedwhenselected = false) {
+        $this->id = $id;
+        $this->link = $link;
+        $this->text = $text;
+        $this->title = $title ? $title : $text;
+        $this->linkedwhenselected = $linkedwhenselected;
+    }
+
+    /**
+     * Travels through tree and finds the tab to mark as selected, all parents are automatically marked as activated
+     *
+     * @param string $selected the id of the selected tab (whatever row it's on),
+     *    if null marks all tabs as unselected
+     * @return bool whether this tab is selected or contains selected tab in its subtree
+     */
+    protected function set_selected($selected) {
+        if ((string)$selected === (string)$this->id) {
+            $this->selected = true;
+            // This tab is selected. No need to travel through subtree.
+            return true;
+        }
+        foreach ($this->subtree as $subitem) {
+            if ($subitem->set_selected($selected)) {
+                // This tab has child that is selected. Mark it as activated. No need to check other children.
+                $this->activated = true;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Travels through tree and finds a tab with specified id
+     *
+     * @param string $id
+     * @return tabtree|null
+     */
+    public function find($id) {
+        if ((string)$this->id === (string)$id) {
+            return $this;
+        }
+        foreach ($this->subtree as $tab) {
+            if ($obj = $tab->find($id)) {
+                return $obj;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Allows to mark each tab's level in the tree before rendering.
+     *
+     * @param int $level
+     */
+    protected function set_level($level) {
+        $this->level = $level;
+        foreach ($this->subtree as $tab) {
+            $tab->set_level($level + 1);
+        }
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output Renderer.
+     * @return object
+     */
+    public function export_for_template(renderer_base $output) {
+        if ($this->inactive || ($this->selected && !$this->linkedwhenselected) || $this->activated) {
+            $link = null;
+        } else {
+            $link = $this->link;
+        }
+        $active = $this->activated || $this->selected;
+
+        return (object) [
+            'id' => $this->id,
+            'link' => is_object($link) ? $link->out(false) : $link,
+            'text' => $this->text,
+            'title' => $this->title,
+            'inactive' => !$active && $this->inactive,
+            'active' => $active,
+            'level' => $this->level,
+        ];
+    }
+
+}
diff --git a/lib/classes/output/tabtree.php b/lib/classes/output/tabtree.php
new file mode 100644
index 00000000000..ca31e32ea7e
--- /dev/null
+++ b/lib/classes/output/tabtree.php
@@ -0,0 +1,91 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Stores tabs list
+ *
+ * Example how to print a single line tabs:
+ * $rows = array(
+ *    new tabobject(...),
+ *    new tabobject(...)
+ * );
+ * echo $OUTPUT->tabtree($rows, $selectedid);
+ *
+ * Multiple row tabs may not look good on some devices but if you want to use them
+ * you can specify ->subtree for the active tabobject.
+ *
+ * @copyright 2013 Marina Glancy
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.5
+ * @package core
+ * @category output
+ */
+class tabtree extends tabobject {
+    /**
+     * Constuctor
+     *
+     * It is highly recommended to call constructor when list of tabs is already
+     * populated, this way you ensure that selected and inactive tabs are located
+     * and attribute level is set correctly.
+     *
+     * @param array $tabs array of tabs, each of them may have it's own ->subtree
+     * @param string|null $selected which tab to mark as selected, all parent tabs will
+     *     automatically be marked as activated
+     * @param array|string|null $inactive list of ids of inactive tabs, regardless of
+     *     their level. Note that you can as weel specify tabobject::$inactive for separate instances
+     */
+    public function __construct($tabs, $selected = null, $inactive = null) {
+        $this->subtree = $tabs;
+        if ($selected !== null) {
+            $this->set_selected($selected);
+        }
+        if ($inactive !== null) {
+            if (is_array($inactive)) {
+                foreach ($inactive as $id) {
+                    if ($tab = $this->find($id)) {
+                        $tab->inactive = true;
+                    }
+                }
+            } else if ($tab = $this->find($inactive)) {
+                $tab->inactive = true;
+            }
+        }
+        $this->set_level(0);
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output Renderer.
+     * @return object
+     */
+    public function export_for_template(renderer_base $output) {
+        $tabs = [];
+        $secondrow = false;
+
+        foreach ($this->subtree as $tab) {
+            $tabs[] = $tab->export_for_template($output);
+            if (!empty($tab->subtree) && ($tab->level == 0 || $tab->selected || $tab->activated)) {
+                $secondrow = new tabtree($tab->subtree);
+            }
+        }
+
+        return (object) [
+            'tabs' => $tabs,
+            'secondrow' => $secondrow ? $secondrow->export_for_template($output) : false
+        ];
+    }
+}
diff --git a/lib/classes/output/templatable.php b/lib/classes/output/templatable.php
new file mode 100644
index 00000000000..8a05b61e43e
--- /dev/null
+++ b/lib/classes/output/templatable.php
@@ -0,0 +1,37 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Interface marking other classes having the ability to export their data for use by templates.
+ *
+ * @copyright 2015 Damyon Wiese
+ * @package core
+ * @category output
+ * @since 2.9
+ */
+interface templatable {
+
+    /**
+     * Function to export the renderer data in a format that is suitable for a
+     * mustache template. This means:
+     * 1. No complex types - only stdClass, array, int, string, float, bool
+     * 2. Any additional info that is required for the template is pre-calculated (e.g. capability checks).
+     *
+     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
+     * @return stdClass|array
+     */
+    public function export_for_template(renderer_base $output);
+}
diff --git a/lib/classes/output/theme_config.php b/lib/classes/output/theme_config.php
new file mode 100644
index 00000000000..d162a454fea
--- /dev/null
+++ b/lib/classes/output/theme_config.php
@@ -0,0 +1,2312 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This class represents the configuration variables of a Moodle theme.
+ *
+ * All the variables with access: public below (with a few exceptions that are marked)
+ * are the properties you can set in your themes config.php file.
+ *
+ * There are also some methods and protected variables that are part of the inner
+ * workings of Moodle's themes system. If you are just editing a themes config.php
+ * file, you can just ignore those, and the following information for developers.
+ *
+ * Normally, to create an instance of this class, you should use the
+ * {@link theme_config::load()} factory method to load a themes config.php file.
+ * However, normally you don't need to bother, because moodle_page (that is, $PAGE)
+ * will create one for you, accessible as $PAGE->theme.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @package core
+ * @category output
+ */
+class theme_config {
+
+    /**
+     * @var string Default theme, used when requested theme not found.
+     */
+    const DEFAULT_THEME = 'boost';
+
+    /** The key under which the SCSS file is stored amongst the CSS files. */
+    const SCSS_KEY = '__SCSS__';
+
+    /**
+     * @var array You can base your theme on other themes by linking to the other theme as
+     * parents. This lets you use the CSS and layouts from the other themes
+     * (see {@link theme_config::$layouts}).
+     * That makes it easy to create a new theme that is similar to another one
+     * but with a few changes. In this themes CSS you only need to override
+     * those rules you want to change.
+     */
+    public $parents;
+
+    /**
+     * @var array The names of all the stylesheets from this theme that you would
+     * like included, in order. Give the names of the files without .css.
+     */
+    public $sheets = array();
+
+    /**
+     * @var array The names of all the stylesheets from parents that should be excluded.
+     * true value may be used to specify all parents or all themes from one parent.
+     * If no value specified value from parent theme used.
+     */
+    public $parents_exclude_sheets = null;
+
+    /**
+     * @var array List of plugin sheets to be excluded.
+     * If no value specified value from parent theme used.
+     */
+    public $plugins_exclude_sheets = null;
+
+    /**
+     * @var array List of style sheets that are included in the text editor bodies.
+     * Sheets from parent themes are used automatically and can not be excluded.
+     */
+    public $editor_sheets = array();
+
+    /**
+     * @var bool Whether a fallback version of the stylesheet will be used
+     * whilst the final version is generated.
+     */
+    public $usefallback = false;
+
+    /**
+     * @var array The names of all the javascript files this theme that you would
+     * like included from head, in order. Give the names of the files without .js.
+     */
+    public $javascripts = array();
+
+    /**
+     * @var array The names of all the javascript files this theme that you would
+     * like included from footer, in order. Give the names of the files without .js.
+     */
+    public $javascripts_footer = array();
+
+    /**
+     * @var array The names of all the javascript files from parents that should
+     * be excluded. true value may be used to specify all parents or all themes
+     * from one parent.
+     * If no value specified value from parent theme used.
+     */
+    public $parents_exclude_javascripts = null;
+
+    /**
+     * @var array Which file to use for each page layout.
+     *
+     * This is an array of arrays. The keys of the outer array are the different layouts.
+     * Pages in Moodle are using several different layouts like 'normal', 'course', 'home',
+     * 'popup', 'form', .... The most reliable way to get a complete list is to look at
+     * {@link http://cvs.moodle.org/moodle/theme/base/config.php?view=markup the base theme config.php file}.
+     * That file also has a good example of how to set this setting.
+     *
+     * For each layout, the value in the outer array is an array that describes
+     * how you want that type of page to look. For example
+     * <pre>
+     *   $THEME->layouts = array(
+     *       // Most pages - if we encounter an unknown or a missing page type, this one is used.
+     *       'standard' => array(
+     *           'theme' = 'mytheme',
+     *           'file' => 'normal.php',
+     *           'regions' => array('side-pre', 'side-post'),
+     *           'defaultregion' => 'side-post'
+     *       ),
+     *       // The site home page.
+     *       'home' => array(
+     *           'theme' = 'mytheme',
+     *           'file' => 'home.php',
+     *           'regions' => array('side-pre', 'side-post'),
+     *           'defaultregion' => 'side-post'
+     *       ),
+     *       // ...
+     *   );
+     * </pre>
+     *
+     * 'theme' name of the theme where is the layout located
+     * 'file' is the layout file to use for this type of page.
+     * layout files are stored in layout subfolder
+     * 'regions' This lists the regions on the page where blocks may appear. For
+     * each region you list here, your layout file must include a call to
+     * <pre>
+     *   echo $OUTPUT->blocks_for_region($regionname);
+     * </pre>
+     * or equivalent so that the blocks are actually visible.
+     *
+     * 'defaultregion' If the list of regions is non-empty, then you must pick
+     * one of the one of them as 'default'. This has two meanings. First, this is
+     * where new blocks are added. Second, if there are any blocks associated with
+     * the page, but in non-existent regions, they appear here. (Imaging, for example,
+     * that someone added blocks using a different theme that used different region
+     * names, and then switched to this theme.)
+     */
+    public $layouts = array();
+
+    /**
+     * @var string Name of the renderer factory class to use. Must implement the
+     * {@link renderer_factory} interface.
+     *
+     * This is an advanced feature. Moodle output is generated by 'renderers',
+     * you can customise the HTML that is output by writing custom renderers,
+     * and then you need to specify 'renderer factory' so that Moodle can find
+     * your renderers.
+     *
+     * There are some renderer factories supplied with Moodle. Please follow these
+     * links to see what they do.
+     * <ul>
+     * <li>{@link standard_renderer_factory} - the default.</li>
+     * <li>{@link theme_overridden_renderer_factory} - use this if you want to write
+     *      your own custom renderers in a lib.php file in this theme (or the parent theme).</li>
+     * </ul>
+     */
+    public $rendererfactory = 'standard_renderer_factory';
+
+    /**
+     * @var string Function to do custom CSS post-processing.
+     *
+     * This is an advanced feature. If you want to do custom post-processing on the
+     * CSS before it is output (for example, to replace certain variable names
+     * with particular values) you can give the name of a function here.
+     */
+    public $csspostprocess = null;
+
+    /**
+     * @var string Function to do custom CSS post-processing on a parsed CSS tree.
+     *
+     * This is an advanced feature. If you want to do custom post-processing on the
+     * CSS before it is output, you can provide the name of the function here. The
+     * function will receive a CSS tree document as first parameter, and the theme_config
+     * object as second parameter. A return value is not required, the tree can
+     * be edited in place.
+     */
+    public $csstreepostprocessor = null;
+
+    /**
+     * @var string Accessibility: Right arrow-like character is
+     * used in the breadcrumb trail, course navigation menu
+     * (previous/next activity), calendar, and search forum block.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically. Please DO NOT
+     * use &lt; &gt; &raquo; - these are confusing for blind users.
+     */
+    public $rarrow = null;
+
+    /**
+     * @var string Accessibility: Left arrow-like character is
+     * used in the breadcrumb trail, course navigation menu
+     * (previous/next activity), calendar, and search forum block.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically. Please DO NOT
+     * use &lt; &gt; &raquo; - these are confusing for blind users.
+     */
+    public $larrow = null;
+
+    /**
+     * @var string Accessibility: Up arrow-like character is used in
+     * the book heirarchical navigation.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically. Please DO NOT
+     * use ^ - this is confusing for blind users.
+     */
+    public $uarrow = null;
+
+    /**
+     * @var string Accessibility: Down arrow-like character.
+     * If the theme does not set characters, appropriate defaults
+     * are set automatically.
+     */
+    public $darrow = null;
+
+    /**
+     * @var bool Some themes may want to disable ajax course editing.
+     */
+    public $enablecourseajax = true;
+
+    /**
+     * @var string Determines served document types
+     *  - 'html5' the only officially supported doctype in Moodle
+     *  - 'xhtml5' may be used in development for validation (not intended for production servers!)
+     *  - 'xhtml' XHTML 1.0 Strict for legacy themes only
+     */
+    public $doctype = 'html5';
+
+    /**
+     * @var string|false requiredblocks If set to a string, will list the block types that cannot be deleted. Defaults to
+     *                                   navigation and settings.
+     */
+    public $requiredblocks = false;
+
+    //==Following properties are not configurable from theme config.php==
+
+    /**
+     * @var string The name of this theme. Set automatically when this theme is
+     * loaded. This can not be set in theme config.php
+     */
+    public $name;
+
+    /**
+     * @var string The folder where this themes files are stored. This is set
+     * automatically. This can not be set in theme config.php
+     */
+    public $dir;
+
+    /**
+     * @var stdClass Theme settings stored in config_plugins table.
+     * This can not be set in theme config.php
+     */
+    public $settings = null;
+
+    /**
+     * @var bool If set to true and the theme enables the dock then  blocks will be able
+     * to be moved to the special dock
+     */
+    public $enable_dock = false;
+
+    /**
+     * @var bool If set to true then this theme will not be shown in the theme selector unless
+     * theme designer mode is turned on.
+     */
+    public $hidefromselector = false;
+
+    /**
+     * @var array list of YUI CSS modules to be included on each page. This may be used
+     * to remove cssreset and use cssnormalise module instead.
+     */
+    public $yuicssmodules = array('cssreset', 'cssfonts', 'cssgrids', 'cssbase');
+
+    /**
+     * An associative array of block manipulations that should be made if the user is using an rtl language.
+     * The key is the original block region, and the value is the block region to change to.
+     * This is used when displaying blocks for regions only.
+     * @var array
+     */
+    public $blockrtlmanipulations = array();
+
+    /**
+     * @var renderer_factory Instance of the renderer_factory implementation
+     * we are using. Implementation detail.
+     */
+    protected $rf = null;
+
+    /**
+     * @var array List of parent config objects.
+     **/
+    protected $parent_configs = array();
+
+    /**
+     * Used to determine whether we can serve SVG images or not.
+     * @var bool
+     */
+    private $usesvg = null;
+
+    /**
+     * Whether in RTL mode or not.
+     * @var bool
+     */
+    protected $rtlmode = false;
+
+    /**
+     * The SCSS file to compile (without .scss), located in the scss/ folder of the theme.
+     * Or a Closure, which receives the theme_config as argument and must
+     * return the SCSS content.
+     * @var string|Closure
+     */
+    public $scss = false;
+
+    /**
+     * Local cache of the SCSS property.
+     * @var false|array
+     */
+    protected $scsscache = null;
+
+    /**
+     * The name of the function to call to get the SCSS code to inject.
+     * @var string
+     */
+    public $extrascsscallback = null;
+
+    /**
+     * The name of the function to call to get SCSS to prepend.
+     * @var string
+     */
+    public $prescsscallback = null;
+
+    /**
+     * Sets the render method that should be used for rendering custom block regions by scripts such as my/index.php
+     * Defaults to {@link core_renderer::blocks_for_region()}
+     * @var string
+     */
+    public $blockrendermethod = null;
+
+    /**
+     * Remember the results of icon remapping for the current page.
+     * @var array
+     */
+    public $remapiconcache = [];
+
+    /**
+     * The name of the function to call to get precompiled CSS.
+     * @var string
+     */
+    public $precompiledcsscallback = null;
+
+    /**
+     * Whether the theme uses course index.
+     * @var bool
+     */
+    public $usescourseindex = false;
+
+    /**
+     * Configuration for the page activity header
+     * @var array
+     */
+    public $activityheaderconfig = [];
+
+    /**
+     * For backward compatibility with old themes.
+     * BLOCK_ADDBLOCK_POSITION_DEFAULT, BLOCK_ADDBLOCK_POSITION_FLATNAV.
+     * @var int
+     */
+    public $addblockposition;
+
+    /**
+     * editor_scss file(s) provided by this theme.
+     * @var array
+     */
+    public $editor_scss;
+
+    /**
+     * Name of the class extending \core\output\icon_system.
+     * @var string
+     */
+    public $iconsystem;
+
+    /**
+     * Theme defines its own editing mode switch.
+     * @var bool
+     */
+    public $haseditswitch = false;
+
+    /**
+     * Allows a theme to customise primary navigation by specifying the list of items to remove.
+     * @var array
+     */
+    public $removedprimarynavitems = [];
+
+    /**
+     * Load the config.php file for a particular theme, and return an instance
+     * of this class. (That is, this is a factory method.)
+     *
+     * @param string $themename the name of the theme.
+     * @return theme_config an instance of this class.
+     */
+    public static function load($themename) {
+        global $CFG;
+
+        // load theme settings from db
+        try {
+            $settings = get_config('theme_'.$themename);
+        } catch (dml_exception $e) {
+            // most probably moodle tables not created yet
+            $settings = new stdClass();
+        }
+
+        if ($config = theme_config::find_theme_config($themename, $settings)) {
+            return new theme_config($config);
+
+        } else if ($themename == theme_config::DEFAULT_THEME) {
+            throw new coding_exception('Default theme '.theme_config::DEFAULT_THEME.' not available or broken!');
+
+        } else if ($config = theme_config::find_theme_config($CFG->theme, $settings)) {
+            debugging('This page should be using theme ' . $themename .
+                    ' which cannot be initialised. Falling back to the site theme ' . $CFG->theme, DEBUG_NORMAL);
+            return new theme_config($config);
+
+        } else {
+            // bad luck, the requested theme has some problems - admin see details in theme config
+            debugging('This page should be using theme ' . $themename .
+                    ' which cannot be initialised. Nor can the site theme ' . $CFG->theme .
+                    '. Falling back to ' . theme_config::DEFAULT_THEME, DEBUG_NORMAL);
+            return new theme_config(theme_config::find_theme_config(theme_config::DEFAULT_THEME, $settings));
+        }
+    }
+
+    /**
+     * Theme diagnostic code. It is very problematic to send debug output
+     * to the actual CSS file, instead this functions is supposed to
+     * diagnose given theme and highlights all potential problems.
+     * This information should be available from the theme selection page
+     * or some other debug page for theme designers.
+     *
+     * @param string $themename
+     * @return array description of problems
+     */
+    public static function diagnose($themename) {
+        //TODO: MDL-21108
+        return array();
+    }
+
+    /**
+     * Private constructor, can be called only from the factory method.
+     * @param stdClass $config
+     */
+    private function __construct($config) {
+        global $CFG; //needed for included lib.php files
+
+        $this->settings = $config->settings;
+        $this->name     = $config->name;
+        $this->dir      = $config->dir;
+
+        if ($this->name != self::DEFAULT_THEME) {
+            $baseconfig = self::find_theme_config(self::DEFAULT_THEME, $this->settings);
+        } else {
+            $baseconfig = $config;
+        }
+
+        // Ensure that each of the configurable properties defined below are also defined at the class level.
+        $configurable = [
+            'parents', 'sheets', 'parents_exclude_sheets', 'plugins_exclude_sheets', 'usefallback',
+            'javascripts', 'javascripts_footer', 'parents_exclude_javascripts',
+            'layouts', 'enablecourseajax', 'requiredblocks',
+            'rendererfactory', 'csspostprocess', 'editor_sheets', 'editor_scss', 'rarrow', 'larrow', 'uarrow', 'darrow',
+            'hidefromselector', 'doctype', 'yuicssmodules', 'blockrtlmanipulations', 'blockrendermethod',
+            'scss', 'extrascsscallback', 'prescsscallback', 'csstreepostprocessor', 'addblockposition',
+            'iconsystem', 'precompiledcsscallback', 'haseditswitch', 'usescourseindex', 'activityheaderconfig',
+            'removedprimarynavitems',
+        ];
+
+        foreach ($config as $key=>$value) {
+            if (in_array($key, $configurable)) {
+                $this->$key = $value;
+            }
+        }
+
+        // verify all parents and load configs and renderers
+        foreach ($this->parents as $parent) {
+            if (!$parent_config = theme_config::find_theme_config($parent, $this->settings)) {
+                // this is not good - better exclude faulty parents
+                continue;
+            }
+            $libfile = $parent_config->dir.'/lib.php';
+            if (is_readable($libfile)) {
+                // theme may store various function here
+                include_once($libfile);
+            }
+            $renderersfile = $parent_config->dir.'/renderers.php';
+            if (is_readable($renderersfile)) {
+                // may contain core and plugin renderers and renderer factory
+                include_once($renderersfile);
+            }
+            $this->parent_configs[$parent] = $parent_config;
+        }
+        $libfile = $this->dir.'/lib.php';
+        if (is_readable($libfile)) {
+            // theme may store various function here
+            include_once($libfile);
+        }
+        $rendererfile = $this->dir.'/renderers.php';
+        if (is_readable($rendererfile)) {
+            // may contain core and plugin renderers and renderer factory
+            include_once($rendererfile);
+        } else {
+            // check if renderers.php file is missnamed renderer.php
+            if (is_readable($this->dir.'/renderer.php')) {
+                debugging('Developer hint: '.$this->dir.'/renderer.php should be renamed to ' . $this->dir."/renderers.php.
+                    See: http://docs.moodle.org/dev/Output_renderers#Theme_renderers.", DEBUG_DEVELOPER);
+            }
+        }
+
+        // cascade all layouts properly
+        foreach ($baseconfig->layouts as $layout=>$value) {
+            if (!isset($this->layouts[$layout])) {
+                foreach ($this->parent_configs as $parent_config) {
+                    if (isset($parent_config->layouts[$layout])) {
+                        $this->layouts[$layout] = $parent_config->layouts[$layout];
+                        continue 2;
+                    }
+                }
+                $this->layouts[$layout] = $value;
+            }
+        }
+
+        //fix arrows if needed
+        $this->check_theme_arrows();
+    }
+
+    /**
+     * Let the theme initialise the page object (usually $PAGE).
+     *
+     * This may be used for example to request jQuery in add-ons.
+     *
+     * @param moodle_page $page
+     */
+    public function init_page(moodle_page $page) {
+        $themeinitfunction = 'theme_'.$this->name.'_page_init';
+        if (function_exists($themeinitfunction)) {
+            $themeinitfunction($page);
+        }
+    }
+
+    /**
+     * Checks if arrows $THEME->rarrow, $THEME->larrow, $THEME->uarrow, $THEME->darrow have been set (theme/-/config.php).
+     * If not it applies sensible defaults.
+     *
+     * Accessibility: right and left arrow Unicode characters for breadcrumb, calendar,
+     * search forum block, etc. Important: these are 'silent' in a screen-reader
+     * (unlike &gt; &raquo;), and must be accompanied by text.
+     */
+    private function check_theme_arrows() {
+        if (!isset($this->rarrow) and !isset($this->larrow)) {
+            // Default, looks good in Win XP/IE 6, Win/Firefox 1.5, Win/Netscape 8...
+            // Also OK in Win 9x/2K/IE 5.x
+            $this->rarrow = '&#x25BA;';
+            $this->larrow = '&#x25C4;';
+            $this->uarrow = '&#x25B2;';
+            $this->darrow = '&#x25BC;';
+            if (empty($_SERVER['HTTP_USER_AGENT'])) {
+                $uagent = '';
+            } else {
+                $uagent = $_SERVER['HTTP_USER_AGENT'];
+            }
+            if (false !== strpos($uagent, 'Opera')
+                || false !== strpos($uagent, 'Mac')) {
+                // Looks good in Win XP/Mac/Opera 8/9, Mac/Firefox 2, Camino, Safari.
+                // Not broken in Mac/IE 5, Mac/Netscape 7 (?).
+                $this->rarrow = '&#x25B6;&#xFE0E;';
+                $this->larrow = '&#x25C0;&#xFE0E;';
+            }
+            elseif ((false !== strpos($uagent, 'Konqueror'))
+                || (false !== strpos($uagent, 'Android')))  {
+                // The fonts on Android don't include the characters required for this to work as expected.
+                // So we use the same ones Konqueror uses.
+                $this->rarrow = '&rarr;';
+                $this->larrow = '&larr;';
+                $this->uarrow = '&uarr;';
+                $this->darrow = '&darr;';
+            }
+            elseif (isset($_SERVER['HTTP_ACCEPT_CHARSET'])
+                && false === stripos($_SERVER['HTTP_ACCEPT_CHARSET'], 'utf-8')) {
+                // (Win/IE 5 doesn't set ACCEPT_CHARSET, but handles Unicode.)
+                // To be safe, non-Unicode browsers!
+                $this->rarrow = '&gt;';
+                $this->larrow = '&lt;';
+                $this->uarrow = '^';
+                $this->darrow = 'v';
+            }
+
+            // RTL support - in RTL languages, swap r and l arrows
+            if (right_to_left()) {
+                $t = $this->rarrow;
+                $this->rarrow = $this->larrow;
+                $this->larrow = $t;
+            }
+        }
+    }
+
+    /**
+     * Returns output renderer prefixes, these are used when looking
+     * for the overridden renderers in themes.
+     *
+     * @return array
+     */
+    public function renderer_prefixes() {
+        global $CFG; // just in case the included files need it
+
+        $prefixes = array('theme_'.$this->name);
+
+        foreach ($this->parent_configs as $parent) {
+            $prefixes[] = 'theme_'.$parent->name;
+        }
+
+        return $prefixes;
+    }
+
+    /**
+     * Returns the stylesheet URL of this editor content
+     *
+     * @param bool $encoded false means use & and true use &amp; in URLs
+     * @return moodle_url
+     */
+    public function editor_css_url($encoded=true) {
+        global $CFG;
+        $rev = theme_get_revision();
+        $type = 'editor';
+        if (right_to_left()) {
+            $type .= '-rtl';
+        }
+
+        if ($rev > -1) {
+            $themesubrevision = theme_get_sub_revision_for_theme($this->name);
+
+            // Provide the sub revision to allow us to invalidate cached theme CSS
+            // on a per theme basis, rather than globally.
+            if ($themesubrevision && $themesubrevision > 0) {
+                $rev .= "_{$themesubrevision}";
+            }
+
+            $url = new moodle_url("/theme/styles.php");
+            if (!empty($CFG->slasharguments)) {
+                $url->set_slashargument("/{$this->name}/{$rev}/{$type}", 'noparam', true);
+            } else {
+                $url->params([
+                    'theme' => $this->name,
+                    'rev' => $rev,
+                    'type' => $type,
+                ]);
+            }
+        } else {
+            $url = new moodle_url('/theme/styles_debug.php', [
+                'theme' => $this->name,
+                'type' => $type,
+            ]);
+        }
+        return $url;
+    }
+
+    /**
+     * Returns the content of the CSS to be used in editor content
+     *
+     * @return array
+     */
+    public function editor_css_files() {
+        $files = array();
+
+        // First editor plugins.
+        $plugins = core_component::get_plugin_list('editor');
+        foreach ($plugins as $plugin => $fulldir) {
+            $sheetfile = "$fulldir/editor_styles.css";
+            if (is_readable($sheetfile)) {
+                $files['plugin_'.$plugin] = $sheetfile;
+            }
+
+            $subplugintypes = core_component::get_subplugins("editor_{$plugin}") ?? [];
+            // Fetch sheets for any editor subplugins.
+            foreach ($subplugintypes as $plugintype => $subplugins) {
+                foreach ($subplugins as $subplugin) {
+                    $plugindir = core_component::get_plugin_directory($plugintype, $subplugin);
+                    $sheetfile = "{$plugindir}/editor_styles.css";
+                    if (is_readable($sheetfile)) {
+                        $files["{$plugintype}_{$subplugin}"] = $sheetfile;
+                    }
+                }
+            }
+        }
+
+        // Then parent themes - base first, the immediate parent last.
+        foreach (array_reverse($this->parent_configs) as $parent_config) {
+            if (empty($parent_config->editor_sheets)) {
+                continue;
+            }
+            foreach ($parent_config->editor_sheets as $sheet) {
+                $sheetfile = "$parent_config->dir/style/$sheet.css";
+                if (is_readable($sheetfile)) {
+                    $files['parent_'.$parent_config->name.'_'.$sheet] = $sheetfile;
+                }
+            }
+        }
+        // Finally this theme.
+        if (!empty($this->editor_sheets)) {
+            foreach ($this->editor_sheets as $sheet) {
+                $sheetfile = "$this->dir/style/$sheet.css";
+                if (is_readable($sheetfile)) {
+                    $files['theme_'.$sheet] = $sheetfile;
+                }
+            }
+        }
+
+        return $files;
+    }
+
+    /**
+     * Compiles and returns the content of the SCSS to be used in editor content
+     *
+     * @return string Compiled CSS from the editor SCSS
+     */
+    public function editor_scss_to_css() {
+        $css = '';
+        $dir = $this->dir;
+        $filenames = [];
+
+        // Use editor_scss file(s) provided by this theme if set.
+        if (!empty($this->editor_scss)) {
+            $filenames = $this->editor_scss;
+        } else {
+            // If no editor_scss set, move up theme hierarchy until one is found (if at all).
+            // This is so child themes only need to set editor_scss if an override is required.
+            foreach (array_reverse($this->parent_configs) as $parentconfig) {
+                if (!empty($parentconfig->editor_scss)) {
+                    $dir = $parentconfig->dir;
+                    $filenames = $parentconfig->editor_scss;
+
+                    // Config found, stop looking.
+                    break;
+                }
+            }
+        }
+
+        if (!empty($filenames)) {
+            $compiler = new core_scss();
+
+            foreach ($filenames as $filename) {
+                $compiler->set_file("{$dir}/scss/{$filename}.scss");
+
+                try {
+                    $css .= $compiler->to_css();
+                } catch (\Exception $e) {
+                    debugging('Error while compiling editor SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER);
+                }
+            }
+        }
+
+        return $css;
+    }
+
+    /**
+     * Get the stylesheet URL of this theme.
+     *
+     * @param moodle_page $page Not used... deprecated?
+     * @return moodle_url[]
+     */
+    public function css_urls(moodle_page $page) {
+        global $CFG;
+
+        $rev = theme_get_revision();
+
+        $urls = array();
+
+        $svg = $this->use_svg_icons();
+        $separate = (core_useragent::is_ie() && !core_useragent::check_ie_version('10'));
+
+        if ($rev > -1) {
+            $filename = right_to_left() ? 'all-rtl' : 'all';
+            $url = new moodle_url("/theme/styles.php");
+            $themesubrevision = theme_get_sub_revision_for_theme($this->name);
+
+            // Provide the sub revision to allow us to invalidate cached theme CSS
+            // on a per theme basis, rather than globally.
+            if ($themesubrevision && $themesubrevision > 0) {
+                $rev .= "_{$themesubrevision}";
+            }
+
+            if (!empty($CFG->slasharguments)) {
+                $slashargs = '';
+                if (!$svg) {
+                    // We add a simple /_s to the start of the path.
+                    // The underscore is used to ensure that it isn't a valid theme name.
+                    $slashargs .= '/_s'.$slashargs;
+                }
+                $slashargs .= '/'.$this->name.'/'.$rev.'/'.$filename;
+                if ($separate) {
+                    $slashargs .= '/chunk0';
+                }
+                $url->set_slashargument($slashargs, 'noparam', true);
+            } else {
+                $params = array('theme' => $this->name, 'rev' => $rev, 'type' => $filename);
+                if (!$svg) {
+                    // We add an SVG param so that we know not to serve SVG images.
+                    // We do this because all modern browsers support SVG and this param will one day be removed.
+                    $params['svg'] = '0';
+                }
+                if ($separate) {
+                    $params['chunk'] = '0';
+                }
+                $url->params($params);
+            }
+            $urls[] = $url;
+
+        } else {
+            $baseurl = new moodle_url('/theme/styles_debug.php');
+
+            $css = $this->get_css_files(true);
+            if (!$svg) {
+                // We add an SVG param so that we know not to serve SVG images.
+                // We do this because all modern browsers support SVG and this param will one day be removed.
+                $baseurl->param('svg', '0');
+            }
+            if (right_to_left()) {
+                $baseurl->param('rtl', 1);
+            }
+            if ($separate) {
+                // We might need to chunk long files.
+                $baseurl->param('chunk', '0');
+            }
+            if (core_useragent::is_ie()) {
+                // Lalala, IE does not allow more than 31 linked CSS files from main document.
+                $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'plugins'));
+                foreach ($css['parents'] as $parent=>$sheets) {
+                    // We need to serve parents individually otherwise we may easily exceed the style limit IE imposes (4096).
+                    $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'ie', 'subtype'=>'parents', 'sheet'=>$parent));
+                }
+                if ($this->get_scss_property()) {
+                    // No need to define the type as IE here.
+                    $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss'));
+                }
+                $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'theme'));
+
+            } else {
+                foreach ($css['plugins'] as $plugin=>$unused) {
+                    $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'plugin', 'subtype'=>$plugin));
+                }
+                foreach ($css['parents'] as $parent=>$sheets) {
+                    foreach ($sheets as $sheet=>$unused2) {
+                        $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'parent', 'subtype'=>$parent, 'sheet'=>$sheet));
+                    }
+                }
+                foreach ($css['theme'] as $sheet => $filename) {
+                    if ($sheet === self::SCSS_KEY) {
+                        // This is the theme SCSS file.
+                        $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss'));
+                    } else {
+                        // Sheet first in order to make long urls easier to read.
+                        $urls[] = new moodle_url($baseurl, array('sheet'=>$sheet, 'theme'=>$this->name, 'type'=>'theme'));
+                    }
+                }
+            }
+        }
+
+        // Allow themes to change the css url to something like theme/mytheme/mycss.php.
+        component_callback('theme_' . $this->name, 'alter_css_urls', [&$urls]);
+        return $urls;
+    }
+
+    /**
+     * Get the whole css stylesheet for production mode.
+     *
+     * NOTE: this method is not expected to be used from any addons.
+     *
+     * @return string CSS markup compressed
+     */
+    public function get_css_content() {
+
+        $csscontent = '';
+        foreach ($this->get_css_files(false) as $type => $value) {
+            foreach ($value as $identifier => $val) {
+                if (is_array($val)) {
+                    foreach ($val as $v) {
+                        $csscontent .= file_get_contents($v) . "\n";
+                    }
+                } else {
+                    if ($type === 'theme' && $identifier === self::SCSS_KEY) {
+                        // We need the content from SCSS because this is the SCSS file from the theme.
+                        if ($compiled = $this->get_css_content_from_scss(false)) {
+                            $csscontent .= $compiled;
+                        } else {
+                            // The compiler failed so default back to any precompiled css that might
+                            // exist.
+                            $csscontent .= $this->get_precompiled_css_content();
+                        }
+                    } else {
+                        $csscontent .= file_get_contents($val) . "\n";
+                    }
+                }
+            }
+        }
+        $csscontent = $this->post_process($csscontent);
+        $csscontent = core_minify::css($csscontent);
+
+        return $csscontent;
+    }
+    /**
+     * Set post processed CSS content cache.
+     *
+     * @param string $csscontent The post processed CSS content.
+     * @return bool True if the content was successfully cached.
+     */
+    public function set_css_content_cache($csscontent) {
+
+        $cache = cache::make('core', 'postprocessedcss');
+        $key = $this->get_css_cache_key();
+
+        return $cache->set($key, $csscontent);
+    }
+
+    /**
+     * Return whether the post processed CSS content has been cached.
+     *
+     * @return bool Whether the post-processed CSS is available in the cache.
+     */
+    public function has_css_cached_content() {
+
+        $key = $this->get_css_cache_key();
+        $cache = cache::make('core', 'postprocessedcss');
+
+        return $cache->has($key);
+    }
+
+    /**
+     * Return cached post processed CSS content.
+     *
+     * @return bool|string The cached css content or false if not found.
+     */
+    public function get_css_cached_content() {
+
+        $key = $this->get_css_cache_key();
+        $cache = cache::make('core', 'postprocessedcss');
+
+        return $cache->get($key);
+    }
+
+    /**
+     * Generate the css content cache key.
+     *
+     * @return string The post processed css cache key.
+     */
+    public function get_css_cache_key() {
+        $nosvg = (!$this->use_svg_icons()) ? 'nosvg_' : '';
+        $rtlmode = ($this->rtlmode == true) ? 'rtl' : 'ltr';
+
+        return $nosvg . $this->name . '_' . $rtlmode;
+    }
+
+    /**
+     * Get the theme designer css markup,
+     * the parameters are coming from css_urls().
+     *
+     * NOTE: this method is not expected to be used from any addons.
+     *
+     * @param string $type
+     * @param string $subtype
+     * @param string $sheet
+     * @return string CSS markup
+     */
+    public function get_css_content_debug($type, $subtype, $sheet) {
+        if ($type === 'scss') {
+            // The SCSS file of the theme is requested.
+            $csscontent = $this->get_css_content_from_scss(true);
+            if ($csscontent !== false) {
+                return $this->post_process($csscontent);
+            }
+            return '';
+        }
+
+        $cssfiles = array();
+        $css = $this->get_css_files(true);
+
+        if ($type === 'ie') {
+            // IE is a sloppy browser with weird limits, sorry.
+            if ($subtype === 'plugins') {
+                $cssfiles = $css['plugins'];
+
+            } else if ($subtype === 'parents') {
+                if (empty($sheet)) {
+                    // Do not bother with the empty parent here.
+                } else {
+                    // Build up the CSS for that parent so we can serve it as one file.
+                    foreach ($css[$subtype][$sheet] as $parent => $css) {
+                        $cssfiles[] = $css;
+                    }
+                }
+            } else if ($subtype === 'theme') {
+                $cssfiles = $css['theme'];
+                foreach ($cssfiles as $key => $value) {
+                    if (in_array($key, [self::SCSS_KEY])) {
+                        // Remove the SCSS file from the theme CSS files.
+                        // The SCSS files use the type 'scss', not 'ie'.
+                        unset($cssfiles[$key]);
+                    }
+                }
+            }
+
+        } else if ($type === 'plugin') {
+            if (isset($css['plugins'][$subtype])) {
+                $cssfiles[] = $css['plugins'][$subtype];
+            }
+
+        } else if ($type === 'parent') {
+            if (isset($css['parents'][$subtype][$sheet])) {
+                $cssfiles[] = $css['parents'][$subtype][$sheet];
+            }
+
+        } else if ($type === 'theme') {
+            if (isset($css['theme'][$sheet])) {
+                $cssfiles[] = $css['theme'][$sheet];
+            }
+        }
+
+        $csscontent = '';
+        foreach ($cssfiles as $file) {
+            $contents = file_get_contents($file);
+            $contents = $this->post_process($contents);
+            $comment = "/** Path: $type $subtype $sheet.' **/\n";
+            $stats = '';
+            $csscontent .= $comment.$stats.$contents."\n\n";
+        }
+
+        return $csscontent;
+    }
+
+    /**
+     * Get the whole css stylesheet for editor iframe.
+     *
+     * NOTE: this method is not expected to be used from any addons.
+     *
+     * @return string CSS markup
+     */
+    public function get_css_content_editor() {
+        $css = '';
+        $cssfiles = $this->editor_css_files();
+
+        // If editor has static CSS, include it.
+        foreach ($cssfiles as $file) {
+            $css .= file_get_contents($file)."\n";
+        }
+
+        // If editor has SCSS, compile and include it.
+        if (($convertedscss = $this->editor_scss_to_css())) {
+            $css .= $convertedscss;
+        }
+
+        $output = $this->post_process($css);
+
+        return $output;
+    }
+
+    /**
+     * Returns an array of organised CSS files required for this output.
+     *
+     * @param bool $themedesigner
+     * @return array nested array of file paths
+     */
+    protected function get_css_files($themedesigner) {
+        global $CFG;
+
+        $cache = null;
+        $cachekey = 'cssfiles';
+        if ($themedesigner) {
+            require_once($CFG->dirroot.'/lib/csslib.php');
+            // We need some kind of caching here because otherwise the page navigation becomes
+            // way too slow in theme designer mode. Feel free to create full cache definition later...
+            $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'core', 'themedesigner', array('theme' => $this->name));
+            if ($files = $cache->get($cachekey)) {
+                if ($files['created'] > time() - THEME_DESIGNER_CACHE_LIFETIME) {
+                    unset($files['created']);
+                    return $files;
+                }
+            }
+        }
+
+        $cssfiles = array('plugins'=>array(), 'parents'=>array(), 'theme'=>array());
+
+        // Get all plugin sheets.
+        $excludes = $this->resolve_excludes('plugins_exclude_sheets');
+        if ($excludes !== true) {
+            foreach (core_component::get_plugin_types() as $type=>$unused) {
+                if ($type === 'theme' || (!empty($excludes[$type]) and $excludes[$type] === true)) {
+                    continue;
+                }
+                $plugins = core_component::get_plugin_list($type);
+                foreach ($plugins as $plugin=>$fulldir) {
+                    if (!empty($excludes[$type]) and is_array($excludes[$type])
+                            and in_array($plugin, $excludes[$type])) {
+                        continue;
+                    }
+
+                    // Get the CSS from the plugin.
+                    $sheetfile = "$fulldir/styles.css";
+                    if (is_readable($sheetfile)) {
+                        $cssfiles['plugins'][$type.'_'.$plugin] = $sheetfile;
+                    }
+
+                    // Create a list of candidate sheets from parents (direct parent last) and current theme.
+                    $candidates = array();
+                    foreach (array_reverse($this->parent_configs) as $parent_config) {
+                        $candidates[] = $parent_config->name;
+                    }
+                    $candidates[] = $this->name;
+
+                    // Add the sheets found.
+                    foreach ($candidates as $candidate) {
+                        $sheetthemefile = "$fulldir/styles_{$candidate}.css";
+                        if (is_readable($sheetthemefile)) {
+                            $cssfiles['plugins'][$type.'_'.$plugin.'_'.$candidate] = $sheetthemefile;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Find out wanted parent sheets.
+        $excludes = $this->resolve_excludes('parents_exclude_sheets');
+        if ($excludes !== true) {
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
+                $parent = $parent_config->name;
+                if (empty($parent_config->sheets) || (!empty($excludes[$parent]) and $excludes[$parent] === true)) {
+                    continue;
+                }
+                foreach ($parent_config->sheets as $sheet) {
+                    if (!empty($excludes[$parent]) && is_array($excludes[$parent])
+                            && in_array($sheet, $excludes[$parent])) {
+                        continue;
+                    }
+
+                    // We never refer to the parent LESS files.
+                    $sheetfile = "$parent_config->dir/style/$sheet.css";
+                    if (is_readable($sheetfile)) {
+                        $cssfiles['parents'][$parent][$sheet] = $sheetfile;
+                    }
+                }
+            }
+        }
+
+
+        // Current theme sheets.
+        // We first add the SCSS file because we want the CSS ones to
+        // be included after the SCSS code.
+        if ($this->get_scss_property()) {
+            $cssfiles['theme'][self::SCSS_KEY] = true;
+        }
+        if (is_array($this->sheets)) {
+            foreach ($this->sheets as $sheet) {
+                $sheetfile = "$this->dir/style/$sheet.css";
+                if (is_readable($sheetfile) && !isset($cssfiles['theme'][$sheet])) {
+                    $cssfiles['theme'][$sheet] = $sheetfile;
+                }
+            }
+        }
+
+        if ($cache) {
+            $files = $cssfiles;
+            $files['created'] = time();
+            $cache->set($cachekey, $files);
+        }
+        return $cssfiles;
+    }
+
+    /**
+     * Return the CSS content generated from the SCSS file.
+     *
+     * @param bool $themedesigner True if theme designer is enabled.
+     * @return bool|string Return false when the compilation failed. Else the compiled string.
+     */
+    protected function get_css_content_from_scss($themedesigner) {
+        global $CFG;
+
+        list($paths, $scss) = $this->get_scss_property();
+        if (!$scss) {
+            throw new coding_exception('The theme did not define a SCSS file, or it is not readable.');
+        }
+
+        // We might need more memory/time to do this, so let's play safe.
+        raise_memory_limit(MEMORY_EXTRA);
+        core_php_time_limit::raise(300);
+
+        // TODO: MDL-62757 When changing anything in this method please do not forget to check
+        // if the validate() method in class admin_setting_configthemepreset needs updating too.
+
+        $cachedir = make_localcache_directory('scsscache-' . $this->name, false);
+        $cacheoptions = [];
+        if ($themedesigner) {
+            $cacheoptions = array(
+                  'cacheDir' => $cachedir,
+                  'prefix' => 'scssphp_',
+                  'forceRefresh' => false,
+            );
+        } else {
+            if (file_exists($cachedir)) {
+                remove_dir($cachedir);
+            }
+        }
+
+        // Set-up the compiler.
+        $compiler = new core_scss($cacheoptions);
+
+        if ($this->supports_source_maps($themedesigner)) {
+            // Enable source maps.
+            $compiler->setSourceMapOptions([
+                'sourceMapBasepath' => str_replace('\\', '/', $CFG->dirroot),
+                'sourceMapRootpath' => $CFG->wwwroot . '/'
+            ]);
+            $compiler->setSourceMap($compiler::SOURCE_MAP_INLINE);
+        }
+
+        $compiler->prepend_raw_scss($this->get_pre_scss_code());
+        if (is_string($scss)) {
+            $compiler->set_file($scss);
+        } else {
+            $compiler->append_raw_scss($scss($this));
+            $compiler->setImportPaths($paths);
+        }
+        $compiler->append_raw_scss($this->get_extra_scss_code());
+
+        try {
+            // Compile!
+            $compiled = $compiler->to_css();
+
+        } catch (\Exception $e) {
+            $compiled = false;
+            debugging('Error while compiling SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER);
+        }
+
+        // Try to save memory.
+        $compiler = null;
+        unset($compiler);
+
+        return $compiled;
+    }
+
+    /**
+     * Return the precompiled CSS if the precompiledcsscallback exists.
+     *
+     * @return string Return compiled css.
+     */
+    public function get_precompiled_css_content() {
+        $configs = array_reverse($this->parent_configs) + [$this];
+        $css = '';
+
+        foreach ($configs as $config) {
+            if (isset($config->precompiledcsscallback)) {
+                $function = $config->precompiledcsscallback;
+                if (function_exists($function)) {
+                    $css .= $function($this);
+                }
+            }
+        }
+        return $css;
+    }
+
+    /**
+     * Get the icon system to use.
+     *
+     * @return string
+     */
+    public function get_icon_system() {
+
+        // Getting all the candidate functions.
+        $system = false;
+        if (isset($this->iconsystem) && \core\output\icon_system::is_valid_system($this->iconsystem)) {
+            return $this->iconsystem;
+        }
+        foreach ($this->parent_configs as $parent_config) {
+            if (isset($parent_config->iconsystem) && \core\output\icon_system::is_valid_system($parent_config->iconsystem)) {
+                return $parent_config->iconsystem;
+            }
+        }
+        return \core\output\icon_system::STANDARD;
+    }
+
+    /**
+     * Return extra SCSS code to add when compiling.
+     *
+     * This is intended to be used by themes to inject some SCSS code
+     * before it gets compiled. If you want to inject variables you
+     * should use {@link self::get_scss_variables()}.
+     *
+     * @return string The SCSS code to inject.
+     */
+    public function get_extra_scss_code() {
+        $content = '';
+
+        // Getting all the candidate functions.
+        $candidates = array();
+        foreach (array_reverse($this->parent_configs) as $parent_config) {
+            if (!isset($parent_config->extrascsscallback)) {
+                continue;
+            }
+            $candidates[] = $parent_config->extrascsscallback;
+        }
+
+        if (isset($this->extrascsscallback)) {
+            $candidates[] = $this->extrascsscallback;
+        }
+
+        // Calling the functions.
+        foreach ($candidates as $function) {
+            if (function_exists($function)) {
+                $content .= "\n/** Extra SCSS from $function **/\n" . $function($this) . "\n";
+            }
+        }
+
+        return $content;
+    }
+
+    /**
+     * SCSS code to prepend when compiling.
+     *
+     * This is intended to be used by themes to inject SCSS code before it gets compiled.
+     *
+     * @return string The SCSS code to inject.
+     */
+    public function get_pre_scss_code() {
+        $content = '';
+
+        // Getting all the candidate functions.
+        $candidates = array();
+        foreach (array_reverse($this->parent_configs) as $parent_config) {
+            if (!isset($parent_config->prescsscallback)) {
+                continue;
+            }
+            $candidates[] = $parent_config->prescsscallback;
+        }
+
+        if (isset($this->prescsscallback)) {
+            $candidates[] = $this->prescsscallback;
+        }
+
+        // Calling the functions.
+        foreach ($candidates as $function) {
+            if (function_exists($function)) {
+                $content .= "\n/** Pre-SCSS from $function **/\n" . $function($this) . "\n";
+            }
+        }
+
+        return $content;
+    }
+
+    /**
+     * Get the SCSS property.
+     *
+     * This resolves whether a SCSS file (or content) has to be used when generating
+     * the stylesheet for the theme. It will look at parents themes and check the
+     * SCSS properties there.
+     *
+     * @return array|false False when SCSS is not used.
+     *         An array with the import paths, and the path to the SCSS file or Closure as second.
+     */
+    public function get_scss_property() {
+        if ($this->scsscache === null) {
+            $configs = [$this] + $this->parent_configs;
+            $scss = null;
+
+            foreach ($configs as $config) {
+                $path = "{$config->dir}/scss";
+
+                // We collect the SCSS property until we've found one.
+                if (empty($scss) && !empty($config->scss)) {
+                    $candidate = is_string($config->scss) ? "{$path}/{$config->scss}.scss" : $config->scss;
+                    if ($candidate instanceof Closure) {
+                        $scss = $candidate;
+                    } else if (is_string($candidate) && is_readable($candidate)) {
+                        $scss = $candidate;
+                    }
+                }
+
+                // We collect the import paths once we've found a SCSS property.
+                if ($scss && is_dir($path)) {
+                    $paths[] = $path;
+                }
+
+            }
+
+            $this->scsscache = $scss !== null ? [$paths, $scss] : false;
+        }
+
+        return $this->scsscache;
+    }
+
+    /**
+     * Generate a URL to the file that serves theme JavaScript files.
+     *
+     * If we determine that the theme has no relevant files, then we return
+     * early with a null value.
+     *
+     * @param bool $inhead true means head url, false means footer
+     * @return moodle_url|null
+     */
+    public function javascript_url($inhead) {
+        global $CFG;
+
+        $rev = theme_get_revision();
+        $params = array('theme'=>$this->name,'rev'=>$rev);
+        $params['type'] = $inhead ? 'head' : 'footer';
+
+        // Return early if there are no files to serve
+        if (count($this->javascript_files($params['type'])) === 0) {
+            return null;
+        }
+
+        if (!empty($CFG->slasharguments) and $rev > 0) {
+            $url = new moodle_url("/theme/javascript.php");
+            $url->set_slashargument('/'.$this->name.'/'.$rev.'/'.$params['type'], 'noparam', true);
+            return $url;
+        } else {
+            return new moodle_url('/theme/javascript.php', $params);
+        }
+    }
+
+    /**
+     * Get the URL's for the JavaScript files used by this theme.
+     * They won't be served directly, instead they'll be mediated through
+     * theme/javascript.php.
+     *
+     * @param string $type Either javascripts_footer, or javascripts
+     * @return array
+     */
+    public function javascript_files($type) {
+        if ($type === 'footer') {
+            $type = 'javascripts_footer';
+        } else {
+            $type = 'javascripts';
+        }
+
+        $js = array();
+        // find out wanted parent javascripts
+        $excludes = $this->resolve_excludes('parents_exclude_javascripts');
+        if ($excludes !== true) {
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last
+                $parent = $parent_config->name;
+                if (empty($parent_config->$type)) {
+                    continue;
+                }
+                if (!empty($excludes[$parent]) and $excludes[$parent] === true) {
+                    continue;
+                }
+                foreach ($parent_config->$type as $javascript) {
+                    if (!empty($excludes[$parent]) and is_array($excludes[$parent])
+                        and in_array($javascript, $excludes[$parent])) {
+                        continue;
+                    }
+                    $javascriptfile = "$parent_config->dir/javascript/$javascript.js";
+                    if (is_readable($javascriptfile)) {
+                        $js[] = $javascriptfile;
+                    }
+                }
+            }
+        }
+
+        // current theme javascripts
+        if (is_array($this->$type)) {
+            foreach ($this->$type as $javascript) {
+                $javascriptfile = "$this->dir/javascript/$javascript.js";
+                if (is_readable($javascriptfile)) {
+                    $js[] = $javascriptfile;
+                }
+            }
+        }
+        return $js;
+    }
+
+    /**
+     * Resolves an exclude setting to the themes setting is applicable or the
+     * setting of its closest parent.
+     *
+     * @param string $variable The name of the setting the exclude setting to resolve
+     * @param string $default
+     * @return mixed
+     */
+    protected function resolve_excludes($variable, $default = null) {
+        $setting = $default;
+        if (is_array($this->{$variable}) or $this->{$variable} === true) {
+            $setting = $this->{$variable};
+        } else {
+            foreach ($this->parent_configs as $parent_config) { // the immediate parent first, base last
+                if (!isset($parent_config->{$variable})) {
+                    continue;
+                }
+                if (is_array($parent_config->{$variable}) or $parent_config->{$variable} === true) {
+                    $setting = $parent_config->{$variable};
+                    break;
+                }
+            }
+        }
+        return $setting;
+    }
+
+    /**
+     * Returns the content of the one huge javascript file merged from all theme javascript files.
+     *
+     * @param bool $type
+     * @return string
+     */
+    public function javascript_content($type) {
+        $jsfiles = $this->javascript_files($type);
+        $js = '';
+        foreach ($jsfiles as $jsfile) {
+            $js .= file_get_contents($jsfile)."\n";
+        }
+        return $js;
+    }
+
+    /**
+     * Post processes CSS.
+     *
+     * This method post processes all of the CSS before it is served for this theme.
+     * This is done so that things such as image URL's can be swapped in and to
+     * run any specific CSS post process method the theme has requested.
+     * This allows themes to use CSS settings.
+     *
+     * @param string $css The CSS to process.
+     * @return string The processed CSS.
+     */
+    public function post_process($css) {
+        // now resolve all image locations
+        if (preg_match_all('/\[\[pix:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) {
+            $replaced = array();
+            foreach ($matches as $match) {
+                if (isset($replaced[$match[0]])) {
+                    continue;
+                }
+                $replaced[$match[0]] = true;
+                $imagename = $match[2];
+                $component = rtrim($match[1], '|');
+                $imageurl = $this->image_url($imagename, $component)->out(false);
+                 // we do not need full url because the image.php is always in the same dir
+                $imageurl = preg_replace('|^http.?://[^/]+|', '', $imageurl);
+                $css = str_replace($match[0], $imageurl, $css);
+            }
+        }
+
+        // Now resolve all font locations.
+        if (preg_match_all('/\[\[font:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) {
+            $replaced = array();
+            foreach ($matches as $match) {
+                if (isset($replaced[$match[0]])) {
+                    continue;
+                }
+                $replaced[$match[0]] = true;
+                $fontname = $match[2];
+                $component = rtrim($match[1], '|');
+                $fonturl = $this->font_url($fontname, $component)->out(false);
+                // We do not need full url because the font.php is always in the same dir.
+                $fonturl = preg_replace('|^http.?://[^/]+|', '', $fonturl);
+                $css = str_replace($match[0], $fonturl, $css);
+            }
+        }
+
+        // Now resolve all theme settings or do any other postprocessing.
+        // This needs to be done before calling core parser, since the parser strips [[settings]] tags.
+        $csspostprocess = $this->csspostprocess;
+        if ($csspostprocess && function_exists($csspostprocess)) {
+            $css = $csspostprocess($css, $this);
+        }
+
+        // Post processing using an object representation of CSS.
+        $treeprocessor = $this->get_css_tree_post_processor();
+        $needsparsing = !empty($treeprocessor) || !empty($this->rtlmode);
+        if ($needsparsing) {
+
+            // We might need more memory/time to do this, so let's play safe.
+            raise_memory_limit(MEMORY_EXTRA);
+            core_php_time_limit::raise(300);
+
+            $parser = new core_cssparser($css);
+            $csstree = $parser->parse();
+            unset($parser);
+
+            if ($this->rtlmode) {
+                $this->rtlize($csstree);
+            }
+
+            if ($treeprocessor) {
+                $treeprocessor($csstree, $this);
+            }
+
+            $css = $csstree->render();
+            unset($csstree);
+        }
+
+        return $css;
+    }
+
+    /**
+     * Flip a stylesheet to RTL.
+     *
+     * @param mixed $csstree The parsed CSS tree structure to flip.
+     * @return void
+     */
+    protected function rtlize($csstree) {
+        $rtlcss = new core_rtlcss($csstree);
+        $rtlcss->flip();
+    }
+
+    /**
+     * Return the direct URL for an image from the pix folder.
+     *
+     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.
+     *
+     * @deprecated since Moodle 3.3
+     * @param string $imagename the name of the icon.
+     * @param string $component specification of one plugin like in get_string()
+     * @return moodle_url
+     */
+    public function pix_url($imagename, $component) {
+        debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER);
+        return $this->image_url($imagename, $component);
+    }
+
+    /**
+     * Return the direct URL for an image from the pix folder.
+     *
+     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.
+     *
+     * @param string $imagename the name of the icon.
+     * @param string $component specification of one plugin like in get_string()
+     * @return moodle_url
+     */
+    public function image_url($imagename, $component) {
+        global $CFG;
+
+        $params = array('theme'=>$this->name);
+        $svg = $this->use_svg_icons();
+
+        if (empty($component) or $component === 'moodle' or $component === 'core') {
+            $params['component'] = 'core';
+        } else {
+            $params['component'] = $component;
+        }
+
+        $rev = theme_get_revision();
+        if ($rev != -1) {
+            $params['rev'] = $rev;
+        }
+
+        $params['image'] = $imagename;
+
+        $url = new moodle_url("/theme/image.php");
+        if (!empty($CFG->slasharguments) and $rev > 0) {
+            $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['image'];
+            if (!$svg) {
+                // We add a simple /_s to the start of the path.
+                // The underscore is used to ensure that it isn't a valid theme name.
+                $path = '/_s'.$path;
+            }
+            $url->set_slashargument($path, 'noparam', true);
+        } else {
+            if (!$svg) {
+                // We add an SVG param so that we know not to serve SVG images.
+                // We do this because all modern browsers support SVG and this param will one day be removed.
+                $params['svg'] = '0';
+            }
+            $url->params($params);
+        }
+
+        return $url;
+    }
+
+    /**
+     * Return the URL for a font
+     *
+     * @param string $font the name of the font (including extension).
+     * @param string $component specification of one plugin like in get_string()
+     * @return moodle_url
+     */
+    public function font_url($font, $component) {
+        global $CFG;
+
+        $params = array('theme'=>$this->name);
+
+        if (empty($component) or $component === 'moodle' or $component === 'core') {
+            $params['component'] = 'core';
+        } else {
+            $params['component'] = $component;
+        }
+
+        $rev = theme_get_revision();
+        if ($rev != -1) {
+            $params['rev'] = $rev;
+        }
+
+        $params['font'] = $font;
+
+        $url = new moodle_url("/theme/font.php");
+        if (!empty($CFG->slasharguments) and $rev > 0) {
+            $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['font'];
+            $url->set_slashargument($path, 'noparam', true);
+        } else {
+            $url->params($params);
+        }
+
+        return $url;
+    }
+
+    /**
+     * Returns URL to the stored file via pluginfile.php.
+     *
+     * Note the theme must also implement pluginfile.php handler,
+     * theme revision is used instead of the itemid.
+     *
+     * @param string $setting
+     * @param string $filearea
+     * @return string protocol relative URL or null if not present
+     */
+    public function setting_file_url($setting, $filearea) {
+        global $CFG;
+
+        if (empty($this->settings->$setting)) {
+            return null;
+        }
+
+        $component = 'theme_'.$this->name;
+        $itemid = theme_get_revision();
+        $filepath = $this->settings->$setting;
+        $syscontext = context_system::instance();
+
+        $url = moodle_url::make_file_url("$CFG->wwwroot/pluginfile.php", "/$syscontext->id/$component/$filearea/$itemid".$filepath);
+
+        // Now this is tricky because the we can not hardcode http or https here, lets use the relative link.
+        // Note: unfortunately moodle_url does not support //urls yet.
+
+        $url = preg_replace('|^https?://|i', '//', $url->out(false));
+
+        return $url;
+    }
+
+    /**
+     * Serve the theme setting file.
+     *
+     * @param string $filearea
+     * @param array $args
+     * @param bool $forcedownload
+     * @param array $options
+     * @return bool may terminate if file not found or donotdie not specified
+     */
+    public function setting_file_serve($filearea, $args, $forcedownload, $options) {
+        global $CFG;
+        require_once("$CFG->libdir/filelib.php");
+
+        $syscontext = context_system::instance();
+        $component = 'theme_'.$this->name;
+
+        $revision = array_shift($args);
+        if ($revision < 0) {
+            $lifetime = 0;
+        } else {
+            $lifetime = 60*60*24*60;
+            // By default, theme files must be cache-able by both browsers and proxies.
+            if (!array_key_exists('cacheability', $options)) {
+                $options['cacheability'] = 'public';
+            }
+        }
+
+        $fs = get_file_storage();
+        $relativepath = implode('/', $args);
+
+        $fullpath = "/{$syscontext->id}/{$component}/{$filearea}/0/{$relativepath}";
+        $fullpath = rtrim($fullpath, '/');
+        if ($file = $fs->get_file_by_hash(sha1($fullpath))) {
+            send_stored_file($file, $lifetime, 0, $forcedownload, $options);
+            return true;
+        } else {
+            send_file_not_found();
+        }
+    }
+
+    /**
+     * Resolves the real image location.
+     *
+     * $svg was introduced as an arg in 2.4. It is important because not all supported browsers support the use of SVG
+     * and we need a way in which to turn it off.
+     * By default SVG won't be used unless asked for. This is done for two reasons:
+     *   1. It ensures that we don't serve svg images unless we really want to. The admin has selected to force them, of the users
+     *      browser supports SVG.
+     *   2. We only serve SVG images from locations we trust. This must NOT include any areas where the image may have been uploaded
+     *      by the user due to security concerns.
+     *
+     * @param string $image name of image, may contain relative path
+     * @param string $component
+     * @param bool|null $svg Should SVG images also be looked for? If null, falls back to auto-detection of browser support
+     * @return string full file path
+     */
+    public function resolve_image_location($image, $component, $svg = false) {
+        global $CFG;
+
+        if (!is_bool($svg)) {
+            // If $svg isn't a bool then we need to decide for ourselves.
+            $svg = $this->use_svg_icons();
+        }
+
+        if ($component === 'moodle' or $component === 'core' or empty($component)) {
+            if ($imagefile = $this->image_exists("$this->dir/pix_core/$image", $svg)) {
+                return $imagefile;
+            }
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last
+                if ($imagefile = $this->image_exists("$parent_config->dir/pix_core/$image", $svg)) {
+                    return $imagefile;
+                }
+            }
+            if ($imagefile = $this->image_exists("$CFG->dataroot/pix/$image", $svg)) {
+                return $imagefile;
+            }
+            if ($imagefile = $this->image_exists("$CFG->dirroot/pix/$image", $svg)) {
+                return $imagefile;
+            }
+            return null;
+
+        } else if ($component === 'theme') { //exception
+            if ($image === 'favicon') {
+                return "$this->dir/pix/favicon.ico";
+            }
+            if ($imagefile = $this->image_exists("$this->dir/pix/$image", $svg)) {
+                return $imagefile;
+            }
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last
+                if ($imagefile = $this->image_exists("$parent_config->dir/pix/$image", $svg)) {
+                    return $imagefile;
+                }
+            }
+            return null;
+
+        } else {
+            if (strpos($component, '_') === false) {
+                $component = "mod_{$component}";
+            }
+            list($type, $plugin) = explode('_', $component, 2);
+
+            // In Moodle 4.0 we introduced a new image format.
+            // Support that image format here.
+            $candidates = [$image];
+
+            if ($type === 'mod') {
+                if ($image === 'icon' || $image === 'monologo') {
+                    $candidates = ['monologo', 'icon'];
+                    if ($image === 'icon') {
+                        debugging(
+                            "The 'icon' image for activity modules has been replaced with a new 'monologo'. " .
+                                "Please update your calling code to fetch the new icon where possible. " .
+                                "Called for component {$component}.",
+                            DEBUG_DEVELOPER
+                        );
+                    }
+                }
+            }
+            foreach ($candidates as $image) {
+                if ($imagefile = $this->image_exists("$this->dir/pix_plugins/$type/$plugin/$image", $svg)) {
+                    return $imagefile;
+                }
+
+                // Base first, the immediate parent last.
+                foreach (array_reverse($this->parent_configs) as $parentconfig) {
+                    if ($imagefile = $this->image_exists("$parentconfig->dir/pix_plugins/$type/$plugin/$image", $svg)) {
+                        return $imagefile;
+                    }
+                }
+                if ($imagefile = $this->image_exists("$CFG->dataroot/pix_plugins/$type/$plugin/$image", $svg)) {
+                    return $imagefile;
+                }
+                $dir = core_component::get_plugin_directory($type, $plugin);
+                if ($imagefile = $this->image_exists("$dir/pix/$image", $svg)) {
+                    return $imagefile;
+                }
+            }
+            return null;
+        }
+    }
+
+    /**
+     * Resolves the real font location.
+     *
+     * @param string $font name of font file
+     * @param string $component
+     * @return string full file path
+     */
+    public function resolve_font_location($font, $component) {
+        global $CFG;
+
+        if ($component === 'moodle' or $component === 'core' or empty($component)) {
+            if (file_exists("$this->dir/fonts_core/$font")) {
+                return "$this->dir/fonts_core/$font";
+            }
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
+                if (file_exists("$parent_config->dir/fonts_core/$font")) {
+                    return "$parent_config->dir/fonts_core/$font";
+                }
+            }
+            if (file_exists("$CFG->dataroot/fonts/$font")) {
+                return "$CFG->dataroot/fonts/$font";
+            }
+            if (file_exists("$CFG->dirroot/lib/fonts/$font")) {
+                return "$CFG->dirroot/lib/fonts/$font";
+            }
+            return null;
+
+        } else if ($component === 'theme') { // Exception.
+            if (file_exists("$this->dir/fonts/$font")) {
+                return "$this->dir/fonts/$font";
+            }
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
+                if (file_exists("$parent_config->dir/fonts/$font")) {
+                    return "$parent_config->dir/fonts/$font";
+                }
+            }
+            return null;
+
+        } else {
+            if (strpos($component, '_') === false) {
+                $component = 'mod_'.$component;
+            }
+            list($type, $plugin) = explode('_', $component, 2);
+
+            if (file_exists("$this->dir/fonts_plugins/$type/$plugin/$font")) {
+                return "$this->dir/fonts_plugins/$type/$plugin/$font";
+            }
+            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
+                if (file_exists("$parent_config->dir/fonts_plugins/$type/$plugin/$font")) {
+                    return "$parent_config->dir/fonts_plugins/$type/$plugin/$font";
+                }
+            }
+            if (file_exists("$CFG->dataroot/fonts_plugins/$type/$plugin/$font")) {
+                return "$CFG->dataroot/fonts_plugins/$type/$plugin/$font";
+            }
+            $dir = core_component::get_plugin_directory($type, $plugin);
+            if (file_exists("$dir/fonts/$font")) {
+                return "$dir/fonts/$font";
+            }
+            return null;
+        }
+    }
+
+    /**
+     * Return true if we should look for SVG images as well.
+     *
+     * @return bool
+     */
+    public function use_svg_icons() {
+        if ($this->usesvg === null) {
+            $this->usesvg = core_useragent::supports_svg();
+        }
+
+        return $this->usesvg;
+    }
+
+    /**
+     * Forces the usesvg setting to either true or false, avoiding any decision making.
+     *
+     * This function should only ever be used when absolutely required, and before any generation of image URL's has occurred.
+     * DO NOT ABUSE THIS FUNCTION... not that you'd want to right ;)
+     *
+     * @param bool $setting True to force the use of svg when available, null otherwise.
+     */
+    public function force_svg_use($setting) {
+        $this->usesvg = (bool)$setting;
+    }
+
+    /**
+     * Set to be in RTL mode.
+     *
+     * This will likely be used when post processing the CSS before serving it.
+     *
+     * @param bool $inrtl True when in RTL mode.
+     */
+    public function set_rtl_mode($inrtl = true) {
+        $this->rtlmode = $inrtl;
+    }
+
+    /**
+     * Checks if source maps are supported
+     *
+     * @param bool $themedesigner True if theme designer is enabled.
+     * @return boolean True if source maps are supported.
+     */
+    public function supports_source_maps($themedesigner): bool {
+        if (empty($this->rtlmode) && $themedesigner) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Whether the theme is being served in RTL mode.
+     *
+     * @return bool True when in RTL mode.
+     */
+    public function get_rtl_mode() {
+        return $this->rtlmode;
+    }
+
+    /**
+     * Checks if file with any image extension exists.
+     *
+     * The order to these images was adjusted prior to the release of 2.4
+     * At that point the were the following image counts in Moodle core:
+     *
+     *     - png = 667 in pix dirs (1499 total)
+     *     - gif = 385 in pix dirs (606 total)
+     *     - jpg = 62  in pix dirs (74 total)
+     *     - jpeg = 0  in pix dirs (1 total)
+     *
+     * There is work in progress to move towards SVG presently hence that has been prioritiesed.
+     *
+     * @param string $filepath
+     * @param bool $svg If set to true SVG images will also be looked for.
+     * @return string image name with extension
+     */
+    private static function image_exists($filepath, $svg = false) {
+        if ($svg && file_exists("$filepath.svg")) {
+            return "$filepath.svg";
+        } else  if (file_exists("$filepath.png")) {
+            return "$filepath.png";
+        } else if (file_exists("$filepath.gif")) {
+            return "$filepath.gif";
+        } else  if (file_exists("$filepath.jpg")) {
+            return "$filepath.jpg";
+        } else  if (file_exists("$filepath.jpeg")) {
+            return "$filepath.jpeg";
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Loads the theme config from config.php file.
+     *
+     * @param string $themename
+     * @param stdClass $settings from config_plugins table
+     * @param boolean $parentscheck true to also check the parents.    .
+     * @return ?stdClass The theme configuration
+     */
+    private static function find_theme_config($themename, $settings, $parentscheck = true) {
+        // We have to use the variable name $THEME (upper case) because that
+        // is what is used in theme config.php files.
+
+        if (!$dir = theme_config::find_theme_location($themename)) {
+            return null;
+        }
+
+        $THEME = new stdClass();
+        $THEME->name     = $themename;
+        $THEME->dir      = $dir;
+        $THEME->settings = $settings;
+
+        global $CFG; // just in case somebody tries to use $CFG in theme config
+        include("$THEME->dir/config.php");
+
+        // verify the theme configuration is OK
+        if (!is_array($THEME->parents)) {
+            // parents option is mandatory now
+            return null;
+        } else {
+            // We use $parentscheck to only check the direct parents (avoid infinite loop).
+            if ($parentscheck) {
+                // Find all parent theme configs.
+                foreach ($THEME->parents as $parent) {
+                    $parentconfig = theme_config::find_theme_config($parent, $settings, false);
+                    if (empty($parentconfig)) {
+                        return null;
+                    }
+                }
+            }
+        }
+
+        return $THEME;
+    }
+
+    /**
+     * Finds the theme location and verifies the theme has all needed files
+     * and is not obsoleted.
+     *
+     * @param string $themename
+     * @return string full dir path or null if not found
+     */
+    private static function find_theme_location($themename) {
+        global $CFG;
+
+        if (file_exists("$CFG->dirroot/theme/$themename/config.php")) {
+            $dir = "$CFG->dirroot/theme/$themename";
+
+        } else if (!empty($CFG->themedir) and file_exists("$CFG->themedir/$themename/config.php")) {
+            $dir = "$CFG->themedir/$themename";
+
+        } else {
+            return null;
+        }
+
+        if (file_exists("$dir/styles.php")) {
+            //legacy theme - needs to be upgraded - upgrade info is displayed on the admin settings page
+            return null;
+        }
+
+        return $dir;
+    }
+
+    /**
+     * Get the renderer for a part of Moodle for this theme.
+     *
+     * @param moodle_page $page the page we are rendering
+     * @param string $component the name of part of moodle. E.g. 'core', 'quiz', 'qtype_multichoice'.
+     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
+     * @param string $target one of rendering target constants
+     * @return renderer_base the requested renderer.
+     */
+    public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) {
+        if (is_null($this->rf)) {
+            $classname = $this->rendererfactory;
+            $this->rf = new $classname($this);
+        }
+
+        return $this->rf->get_renderer($page, $component, $subtype, $target);
+    }
+
+    /**
+     * Get the information from {@link $layouts} for this type of page.
+     *
+     * @param string $pagelayout the the page layout name.
+     * @return array the appropriate part of {@link $layouts}.
+     */
+    protected function layout_info_for_page($pagelayout) {
+        if (array_key_exists($pagelayout, $this->layouts)) {
+            return $this->layouts[$pagelayout];
+        } else {
+            debugging('Invalid page layout specified: ' . $pagelayout);
+            return $this->layouts['standard'];
+        }
+    }
+
+    /**
+     * Given the settings of this theme, and the page pagelayout, return the
+     * full path of the page layout file to use.
+     *
+     * Used by {@link core_renderer::header()}.
+     *
+     * @param string $pagelayout the the page layout name.
+     * @return string Full path to the lyout file to use
+     */
+    public function layout_file($pagelayout) {
+        global $CFG;
+
+        $layoutinfo = $this->layout_info_for_page($pagelayout);
+        $layoutfile = $layoutinfo['file'];
+
+        if (array_key_exists('theme', $layoutinfo)) {
+            $themes = array($layoutinfo['theme']);
+        } else {
+            $themes = array_merge(array($this->name),$this->parents);
+        }
+
+        foreach ($themes as $theme) {
+            if ($dir = $this->find_theme_location($theme)) {
+                $path = "$dir/layout/$layoutfile";
+
+                // Check the template exists, return general base theme template if not.
+                if (is_readable($path)) {
+                    return $path;
+                }
+            }
+        }
+
+        throw new coding_exception('Can not find layout file for: ' . $pagelayout . ' (' . $layoutfile . ')');
+    }
+
+    /**
+     * Returns auxiliary page layout options specified in layout configuration array.
+     *
+     * @param string $pagelayout
+     * @return array
+     */
+    public function pagelayout_options($pagelayout) {
+        $info = $this->layout_info_for_page($pagelayout);
+        if (!empty($info['options'])) {
+            return $info['options'];
+        }
+        return array();
+    }
+
+    /**
+     * Inform a block_manager about the block regions this theme wants on this
+     * page layout.
+     *
+     * @param string $pagelayout the general type of the page.
+     * @param block_manager $blockmanager the block_manger to set up.
+     */
+    public function setup_blocks($pagelayout, $blockmanager) {
+        $layoutinfo = $this->layout_info_for_page($pagelayout);
+        if (!empty($layoutinfo['regions'])) {
+            $blockmanager->add_regions($layoutinfo['regions'], false);
+            $blockmanager->set_default_region($layoutinfo['defaultregion']);
+        }
+    }
+
+    /**
+     * Gets the visible name for the requested block region.
+     *
+     * @param string $region The region name to get
+     * @param string $theme The theme the region belongs to (may come from the parent theme)
+     * @return string
+     */
+    protected function get_region_name($region, $theme) {
+
+        $stringman = get_string_manager();
+
+        // Check if the name is defined in the theme.
+        if ($stringman->string_exists('region-' . $region, 'theme_' . $theme)) {
+            return get_string('region-' . $region, 'theme_' . $theme);
+        }
+
+        // Check the theme parents.
+        foreach ($this->parents as $parentthemename) {
+            if ($stringman->string_exists('region-' . $region, 'theme_' . $parentthemename)) {
+                return get_string('region-' . $region, 'theme_' . $parentthemename);
+            }
+        }
+
+        // Last resort, try the boost theme for names.
+        return get_string('region-' . $region, 'theme_boost');
+    }
+
+    /**
+     * Get the list of all block regions known to this theme in all templates.
+     *
+     * @return array internal region name => human readable name.
+     */
+    public function get_all_block_regions() {
+        $regions = array();
+        foreach ($this->layouts as $layoutinfo) {
+            foreach ($layoutinfo['regions'] as $region) {
+                $regions[$region] = $this->get_region_name($region, $this->name);
+            }
+        }
+        return $regions;
+    }
+
+    /**
+     * Returns the human readable name of the theme
+     *
+     * @return string
+     */
+    public function get_theme_name() {
+        return get_string('pluginname', 'theme_'.$this->name);
+    }
+
+    /**
+     * Returns the block render method.
+     *
+     * It is set by the theme via:
+     *     $THEME->blockrendermethod = '...';
+     *
+     * It can be one of two values, blocks or blocks_for_region.
+     * It should be set to the method being used by the theme layouts.
+     *
+     * @return string
+     */
+    public function get_block_render_method() {
+        if ($this->blockrendermethod) {
+            // Return the specified block render method.
+            return $this->blockrendermethod;
+        }
+        // Its not explicitly set, check the parent theme configs.
+        foreach ($this->parent_configs as $config) {
+            if (isset($config->blockrendermethod)) {
+                return $config->blockrendermethod;
+            }
+        }
+        // Default it to blocks.
+        return 'blocks';
+    }
+
+    /**
+     * Get the callable for CSS tree post processing.
+     *
+     * @return string|null
+     */
+    public function get_css_tree_post_processor() {
+        $configs = [$this] + $this->parent_configs;
+        foreach ($configs as $config) {
+            if (!empty($config->csstreepostprocessor) && is_callable($config->csstreepostprocessor)) {
+                return $config->csstreepostprocessor;
+            }
+        }
+        return null;
+    }
+
+}
diff --git a/lib/classes/output/url_select.php b/lib/classes/output/url_select.php
new file mode 100644
index 00000000000..9051e83d0a4
--- /dev/null
+++ b/lib/classes/output/url_select.php
@@ -0,0 +1,282 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Simple URL selection widget description.
+ *
+ * @copyright 2009 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class url_select implements renderable, templatable {
+    /**
+     * @var array $urls associative array value=>label ex.: array(1=>'One, 2=>Two)
+     *     it is also possible to specify optgroup as complex label array ex.:
+     *         array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
+     *         array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
+     */
+    var $urls;
+
+    /**
+     * @var string Selected option
+     */
+    var $selected;
+
+    /**
+     * @var array Nothing selected
+     */
+    var $nothing;
+
+    /**
+     * @var array Extra select field attributes
+     */
+    var $attributes = array();
+
+    /**
+     * @var string Button label
+     */
+    var $label = '';
+
+    /**
+     * @var array Button label's attributes
+     */
+    var $labelattributes = array();
+
+    /**
+     * @var string Wrapping div class
+     */
+    var $class = 'urlselect';
+
+    /**
+     * @var bool True if button disabled, false if normal
+     */
+    var $disabled = false;
+
+    /**
+     * @var string Button tooltip
+     */
+    var $tooltip = null;
+
+    /**
+     * @var string Form id
+     */
+    var $formid = null;
+
+    /**
+     * @var help_icon The help icon for this element.
+     */
+    var $helpicon = null;
+
+    /**
+     * @var string If set, makes button visible with given name for button
+     */
+    var $showbutton = null;
+
+    /**
+     * Constructor
+     * @param array $urls list of options
+     * @param string $selected selected element
+     * @param array $nothing
+     * @param string $formid
+     * @param string $showbutton Set to text of button if it should be visible
+     *   or null if it should be hidden (hidden version always has text 'go')
+     */
+    public function __construct(array $urls, $selected = '', $nothing = array('' => 'choosedots'), $formid = null, $showbutton = null) {
+        $this->urls       = $urls;
+        $this->selected   = $selected;
+        $this->nothing    = $nothing;
+        $this->formid     = $formid;
+        $this->showbutton = $showbutton;
+    }
+
+    /**
+     * Adds help icon.
+     *
+     * @deprecated since Moodle 2.0
+     */
+    public function set_old_help_icon($helppage, $title, $component = 'moodle') {
+        throw new coding_exception('set_old_help_icon() can not be used any more, please see set_help_icon().');
+    }
+
+    /**
+     * Adds help icon.
+     *
+     * @param string $identifier The keyword that defines a help page
+     * @param string $component
+     */
+    public function set_help_icon($identifier, $component = 'moodle') {
+        $this->helpicon = new help_icon($identifier, $component);
+    }
+
+    /**
+     * Sets select's label
+     *
+     * @param string $label
+     * @param array $attributes (optional)
+     */
+    public function set_label($label, $attributes = array()) {
+        $this->label = $label;
+        $this->labelattributes = $attributes;
+    }
+
+    /**
+     * Clean a URL.
+     *
+     * @param string $value The URL.
+     * @return string The cleaned URL.
+     */
+    protected function clean_url($value) {
+        global $CFG;
+
+        if (empty($value)) {
+            // Nothing.
+
+        } else if (strpos($value, $CFG->wwwroot . '/') === 0) {
+            $value = str_replace($CFG->wwwroot, '', $value);
+
+        } else if (strpos($value, '/') !== 0) {
+            debugging("Invalid url_select urls parameter: url '$value' is not local relative url!", DEBUG_DEVELOPER);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Flatten the options for Mustache.
+     *
+     * This also cleans the URLs.
+     *
+     * @param array $options The options.
+     * @param array $nothing The nothing option.
+     * @return array
+     */
+    protected function flatten_options($options, $nothing) {
+        $flattened = [];
+
+        foreach ($options as $value => $option) {
+            if (is_array($option)) {
+                foreach ($option as $groupname => $optoptions) {
+                    if (!isset($flattened[$groupname])) {
+                        $flattened[$groupname] = [
+                            'name' => $groupname,
+                            'isgroup' => true,
+                            'options' => []
+                        ];
+                    }
+                    foreach ($optoptions as $optvalue => $optoption) {
+                        $cleanedvalue = $this->clean_url($optvalue);
+                        $flattened[$groupname]['options'][$cleanedvalue] = [
+                            'name' => $optoption,
+                            'value' => $cleanedvalue,
+                            'selected' => $this->selected == $optvalue,
+                        ];
+                    }
+                }
+
+            } else {
+                $cleanedvalue = $this->clean_url($value);
+                $flattened[$cleanedvalue] = [
+                    'name' => $option,
+                    'value' => $cleanedvalue,
+                    'selected' => $this->selected == $value,
+                ];
+            }
+        }
+
+        if (!empty($nothing)) {
+            $value = key($nothing);
+            $name = reset($nothing);
+            $flattened = [
+                    $value => ['name' => $name, 'value' => $value, 'selected' => $this->selected == $value]
+                ] + $flattened;
+        }
+
+        // Make non-associative array.
+        foreach ($flattened as $key => $value) {
+            if (!empty($value['options'])) {
+                $flattened[$key]['options'] = array_values($value['options']);
+            }
+        }
+        $flattened = array_values($flattened);
+
+        return $flattened;
+    }
+
+    /**
+     * Export for template.
+     *
+     * @param renderer_base $output Renderer.
+     * @return stdClass
+     */
+    public function export_for_template(renderer_base $output) {
+        $attributes = $this->attributes;
+
+        $data = new stdClass();
+        $data->formid = !empty($this->formid) ? $this->formid : html_writer::random_id('url_select_f');
+        $data->classes = $this->class;
+        $data->label = $this->label;
+        $data->disabled = $this->disabled;
+        $data->title = $this->tooltip;
+        $data->id = !empty($attributes['id']) ? $attributes['id'] : html_writer::random_id('url_select');
+        $data->sesskey = sesskey();
+        $data->action = (new moodle_url('/course/jumpto.php'))->out(false);
+
+        // Remove attributes passed as property directly.
+        unset($attributes['class']);
+        unset($attributes['id']);
+        unset($attributes['name']);
+        unset($attributes['title']);
+        unset($attributes['disabled']);
+
+        $data->showbutton = $this->showbutton;
+
+        // Select options.
+        $nothing = false;
+        if (is_string($this->nothing) && $this->nothing !== '') {
+            $nothing = ['' => $this->nothing];
+        } else if (is_array($this->nothing)) {
+            $nothingvalue = reset($this->nothing);
+            if ($nothingvalue === 'choose' || $nothingvalue === 'choosedots') {
+                $nothing = [key($this->nothing) => get_string('choosedots')];
+            } else {
+                $nothing = $this->nothing;
+            }
+        }
+        $data->options = $this->flatten_options($this->urls, $nothing);
+
+        // Label attributes.
+        $data->labelattributes = [];
+        // Unset label attributes that are already in the template.
+        unset($this->labelattributes['for']);
+        // Map the label attributes.
+        foreach ($this->labelattributes as $key => $value) {
+            $data->labelattributes[] = ['name' => $key, 'value' => $value];
+        }
+
+        // Help icon.
+        $data->helpicon = !empty($this->helpicon) ? $this->helpicon->export_for_template($output) : false;
+
+        // Finally all the remaining attributes.
+        $data->attributes = [];
+        foreach ($attributes as $key => $value) {
+            $data->attributes[] = ['name' => $key, 'value' => $value];
+        }
+
+        return $data;
+    }
+}
diff --git a/lib/classes/output/user_picture.php b/lib/classes/output/user_picture.php
new file mode 100644
index 00000000000..d278e4d2c10
--- /dev/null
+++ b/lib/classes/output/user_picture.php
@@ -0,0 +1,302 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Data structure representing a user picture.
+ *
+ * @copyright 2009 Nicolas Connault, 2010 Petr Skoda
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Modle 2.0
+ * @package core
+ * @category output
+ */
+class user_picture implements renderable {
+    /**
+     * @var stdClass A user object with at least fields all columns specified
+     * in $fields array constant set.
+     */
+    public $user;
+
+    /**
+     * @var int The course id. Used when constructing the link to the user's
+     * profile, page course id used if not specified.
+     */
+    public $courseid;
+
+    /**
+     * @var bool Add course profile link to image
+     */
+    public $link = true;
+
+    /**
+     * @var int Size in pixels. Special values are (true/1 = 100px) and (false/0 = 35px) for backward compatibility.
+     * Recommended values (supporting user initials too): 16, 35, 64 and 100.
+     */
+    public $size = 35;
+
+    /**
+     * @var bool Add non-blank alt-text to the image.
+     * Default true, set to false when image alt just duplicates text in screenreaders.
+     */
+    public $alttext = true;
+
+    /**
+     * @var bool Whether or not to open the link in a popup window.
+     */
+    public $popup = false;
+
+    /**
+     * @var string Image class attribute
+     */
+    public $class = 'userpicture';
+
+    /**
+     * @var bool Whether to be visible to screen readers.
+     */
+    public $visibletoscreenreaders = true;
+
+    /**
+     * @var bool Whether to include the fullname in the user picture link.
+     */
+    public $includefullname = false;
+
+    /**
+     * @var mixed Include user authentication token. True indicates to generate a token for current user, and integer value
+     * indicates to generate a token for the user whose id is the value indicated.
+     */
+    public $includetoken = false;
+
+    /**
+     * User picture constructor.
+     *
+     * @param stdClass $user user record with at least id, picture, imagealt, firstname and lastname set.
+     *                 It is recommended to add also contextid of the user for performance reasons.
+     */
+    public function __construct(stdClass $user) {
+        global $DB;
+
+        if (empty($user->id)) {
+            throw new coding_exception('User id is required when printing user avatar image.');
+        }
+
+        // only touch the DB if we are missing data and complain loudly...
+        $needrec = false;
+        foreach (\core_user\fields::get_picture_fields() as $field) {
+            if (!property_exists($user, $field)) {
+                $needrec = true;
+                debugging('Missing '.$field.' property in $user object, this is a performance problem that needs to be fixed by a developer. '
+                    .'Please use the \core_user\fields API to get the full list of required fields.', DEBUG_DEVELOPER);
+                break;
+            }
+        }
+
+        if ($needrec) {
+            $this->user = $DB->get_record('user', array('id' => $user->id),
+                implode(',', \core_user\fields::get_picture_fields()), MUST_EXIST);
+        } else {
+            $this->user = clone($user);
+        }
+    }
+
+    /**
+     * Returns a list of required user fields, useful when fetching required user info from db.
+     *
+     * In some cases we have to fetch the user data together with some other information,
+     * the idalias is useful there because the id would otherwise override the main
+     * id of the result record. Please note it has to be converted back to id before rendering.
+     *
+     * @param string $tableprefix name of database table prefix in query
+     * @param array $extrafields extra fields to be included in result (do not include TEXT columns because it would break SELECT DISTINCT in MSSQL and ORACLE)
+     * @param string $idalias alias of id field
+     * @param string $fieldprefix prefix to add to all columns in their aliases, does not apply to 'id'
+     * @return string
+     * @deprecated since Moodle 3.11 MDL-45242
+     * @see \core_user\fields
+     */
+    public static function fields($tableprefix = '', array $extrafields = NULL, $idalias = 'id', $fieldprefix = '') {
+        debugging('user_picture::fields() is deprecated. Please use the \core_user\fields API instead.', DEBUG_DEVELOPER);
+        $userfields = \core_user\fields::for_userpic();
+        if ($extrafields) {
+            $userfields->including(...$extrafields);
+        }
+        $selects = $userfields->get_sql($tableprefix, false, $fieldprefix, $idalias, false)->selects;
+        if ($tableprefix === '') {
+            // If no table alias is specified, don't add {user}. in front of fields.
+            $selects = str_replace('{user}.', '', $selects);
+        }
+        // Maintain legacy behaviour where the field list was done with 'implode' and no spaces.
+        $selects = str_replace(', ', ',', $selects);
+        return $selects;
+    }
+
+    /**
+     * Extract the aliased user fields from a given record
+     *
+     * Given a record that was previously obtained using {@link self::fields()} with aliases,
+     * this method extracts user related unaliased fields.
+     *
+     * @param stdClass $record containing user picture fields
+     * @param array $extrafields extra fields included in the $record
+     * @param string $idalias alias of the id field
+     * @param string $fieldprefix prefix added to all columns in their aliases, does not apply to 'id'
+     * @return stdClass object with unaliased user fields
+     */
+    public static function unalias(stdClass $record, array $extrafields = null, $idalias = 'id', $fieldprefix = '') {
+
+        if (empty($idalias)) {
+            $idalias = 'id';
+        }
+
+        $return = new stdClass();
+
+        foreach (\core_user\fields::get_picture_fields() as $field) {
+            if ($field === 'id') {
+                if (property_exists($record, $idalias)) {
+                    $return->id = $record->{$idalias};
+                }
+            } else {
+                if (property_exists($record, $fieldprefix.$field)) {
+                    $return->{$field} = $record->{$fieldprefix.$field};
+                }
+            }
+        }
+        // add extra fields if not already there
+        if ($extrafields) {
+            foreach ($extrafields as $e) {
+                if ($e === 'id' or property_exists($return, $e)) {
+                    continue;
+                }
+                $return->{$e} = $record->{$fieldprefix.$e};
+            }
+        }
+
+        return $return;
+    }
+
+    /**
+     * Works out the URL for the users picture.
+     *
+     * This method is recommended as it avoids costly redirects of user pictures
+     * if requests are made for non-existent files etc.
+     *
+     * @param moodle_page $page
+     * @param renderer_base $renderer
+     * @return moodle_url
+     */
+    public function get_url(moodle_page $page, renderer_base $renderer = null) {
+        global $CFG;
+
+        if (is_null($renderer)) {
+            $renderer = $page->get_renderer('core');
+        }
+
+        // Sort out the filename and size. Size is only required for the gravatar
+        // implementation presently.
+        if (empty($this->size)) {
+            $filename = 'f2';
+            $size = 35;
+        } else if ($this->size === true or $this->size == 1) {
+            $filename = 'f1';
+            $size = 100;
+        } else if ($this->size > 100) {
+            $filename = 'f3';
+            $size = (int)$this->size;
+        } else if ($this->size >= 50) {
+            $filename = 'f1';
+            $size = (int)$this->size;
+        } else {
+            $filename = 'f2';
+            $size = (int)$this->size;
+        }
+
+        $defaulturl = $renderer->image_url('u/'.$filename); // default image
+
+        if ((!empty($CFG->forcelogin) and !isloggedin()) ||
+            (!empty($CFG->forceloginforprofileimage) && (!isloggedin() || isguestuser()))) {
+            // Protect images if login required and not logged in;
+            // also if login is required for profile images and is not logged in or guest
+            // do not use require_login() because it is expensive and not suitable here anyway.
+            return $defaulturl;
+        }
+
+        // First try to detect deleted users - but do not read from database for performance reasons!
+        if (!empty($this->user->deleted) or strpos($this->user->email, '@') === false) {
+            // All deleted users should have email replaced by md5 hash,
+            // all active users are expected to have valid email.
+            return $defaulturl;
+        }
+
+        // Did the user upload a picture?
+        if ($this->user->picture > 0) {
+            if (!empty($this->user->contextid)) {
+                $contextid = $this->user->contextid;
+            } else {
+                $context = context_user::instance($this->user->id, IGNORE_MISSING);
+                if (!$context) {
+                    // This must be an incorrectly deleted user, all other users have context.
+                    return $defaulturl;
+                }
+                $contextid = $context->id;
+            }
+
+            $path = '/';
+            if (clean_param($page->theme->name, PARAM_THEME) == $page->theme->name) {
+                // We append the theme name to the file path if we have it so that
+                // in the circumstance that the profile picture is not available
+                // when the user actually requests it they still get the profile
+                // picture for the correct theme.
+                $path .= $page->theme->name.'/';
+            }
+            // Set the image URL to the URL for the uploaded file and return.
+            $url = moodle_url::make_pluginfile_url(
+                $contextid, 'user', 'icon', null, $path, $filename, false, $this->includetoken);
+            $url->param('rev', $this->user->picture);
+            return $url;
+        }
+
+        if ($this->user->picture == 0 and !empty($CFG->enablegravatar)) {
+            // Normalise the size variable to acceptable bounds
+            if ($size < 1 || $size > 512) {
+                $size = 35;
+            }
+            // Hash the users email address
+            $md5 = md5(strtolower(trim($this->user->email)));
+            // Build a gravatar URL with what we know.
+
+            // Find the best default image URL we can (MDL-35669)
+            if (empty($CFG->gravatardefaulturl)) {
+                $absoluteimagepath = $page->theme->resolve_image_location('u/'.$filename, 'core');
+                if (strpos($absoluteimagepath, $CFG->dirroot) === 0) {
+                    $gravatardefault = $CFG->wwwroot . substr($absoluteimagepath, strlen($CFG->dirroot));
+                } else {
+                    $gravatardefault = $CFG->wwwroot . '/pix/u/' . $filename . '.png';
+                }
+            } else {
+                $gravatardefault = $CFG->gravatardefaulturl;
+            }
+
+            // If the currently requested page is https then we'll return an
+            // https gravatar page.
+            if (is_https()) {
+                return new moodle_url("https://secure.gravatar.com/avatar/{$md5}", array('s' => $size, 'd' => $gravatardefault));
+            } else {
+                return new moodle_url("http://www.gravatar.com/avatar/{$md5}", array('s' => $size, 'd' => $gravatardefault));
+            }
+        }
+
+        return $defaulturl;
+    }
+}
diff --git a/lib/classes/output/xhtml_container_stack.php b/lib/classes/output/xhtml_container_stack.php
new file mode 100644
index 00000000000..193b90ab36b
--- /dev/null
+++ b/lib/classes/output/xhtml_container_stack.php
@@ -0,0 +1,153 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * This class keeps track of which HTML tags are currently open.
+ *
+ * This makes it much easier to always generate well formed XHTML output, even
+ * if execution terminates abruptly. Any time you output some opening HTML
+ * without the matching closing HTML, you should push the necessary close tags
+ * onto the stack.
+ *
+ * @copyright 2009 Tim Hunt
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class xhtml_container_stack {
+    /**
+     * @var array Stores the list of open containers.
+     */
+    protected $opencontainers = array();
+
+    /**
+     * @var array In developer debug mode, stores a stack trace of all opens and
+     * closes, so we can output helpful error messages when there is a mismatch.
+     */
+    protected $log = array();
+
+    /**
+     * @var boolean Store whether we are developer debug mode. We need this in
+     * several places including in the destructor where we may not have access to $CFG.
+     */
+    protected $isdebugging;
+
+    /**
+     * Constructor
+     */
+    public function __construct() {
+        global $CFG;
+        $this->isdebugging = $CFG->debugdeveloper;
+    }
+
+    /**
+     * Push the close HTML for a recently opened container onto the stack.
+     *
+     * @param string $type The type of container. This is checked when {@link pop()}
+     *      is called and must match, otherwise a developer debug warning is output.
+     * @param string $closehtml The HTML required to close the container.
+     */
+    public function push($type, $closehtml) {
+        $container = new stdClass;
+        $container->type = $type;
+        $container->closehtml = $closehtml;
+        if ($this->isdebugging) {
+            $this->log('Open', $type);
+        }
+        array_push($this->opencontainers, $container);
+    }
+
+    /**
+     * Pop the HTML for the next closing container from the stack. The $type
+     * must match the type passed when the container was opened, otherwise a
+     * warning will be output.
+     *
+     * @param string $type The type of container.
+     * @return ?string the HTML required to close the container.
+     */
+    public function pop($type) {
+        if (empty($this->opencontainers)) {
+            debugging('<p>There are no more open containers. This suggests there is a nesting problem.</p>' .
+                    $this->output_log(), DEBUG_DEVELOPER);
+            return;
+        }
+
+        $container = array_pop($this->opencontainers);
+        if ($container->type != $type) {
+            debugging('<p>The type of container to be closed (' . $container->type .
+                    ') does not match the type of the next open container (' . $type .
+                    '). This suggests there is a nesting problem.</p>' .
+                    $this->output_log(), DEBUG_DEVELOPER);
+        }
+        if ($this->isdebugging) {
+            $this->log('Close', $type);
+        }
+        return $container->closehtml;
+    }
+
+    /**
+     * Close all but the last open container. This is useful in places like error
+     * handling, where you want to close all the open containers (apart from <body>)
+     * before outputting the error message.
+     *
+     * @param bool $shouldbenone assert that the stack should be empty now - causes a
+     *      developer debug warning if it isn't.
+     * @return string the HTML required to close any open containers inside <body>.
+     */
+    public function pop_all_but_last($shouldbenone = false) {
+        if ($shouldbenone && count($this->opencontainers) != 1) {
+            debugging('<p>Some HTML tags were opened in the body of the page but not closed.</p>' .
+                    $this->output_log(), DEBUG_DEVELOPER);
+        }
+        $output = '';
+        while (count($this->opencontainers) > 1) {
+            $container = array_pop($this->opencontainers);
+            $output .= $container->closehtml;
+        }
+        return $output;
+    }
+
+    /**
+     * You can call this function if you want to throw away an instance of this
+     * class without properly emptying the stack (for example, in a unit test).
+     * Calling this method stops the destruct method from outputting a developer
+     * debug warning. After calling this method, the instance can no longer be used.
+     */
+    public function discard() {
+        $this->opencontainers = null;
+    }
+
+    /**
+     * Adds an entry to the log.
+     *
+     * @param string $action The name of the action
+     * @param string $type The type of action
+     */
+    protected function log($action, $type) {
+        $this->log[] = '<li>' . $action . ' ' . $type . ' at:' .
+                format_backtrace(debug_backtrace()) . '</li>';
+    }
+
+    /**
+     * Outputs the log's contents as a HTML list.
+     *
+     * @return string HTML list of the log
+     */
+    protected function output_log() {
+        return '<ul>' . implode("\n", $this->log) . '</ul>';
+    }
+}
diff --git a/lib/db/legacyclasses.php b/lib/db/legacyclasses.php
index 75076d95c32..696ba07dfa0 100644
--- a/lib/db/legacyclasses.php
+++ b/lib/db/legacyclasses.php
@@ -30,6 +30,7 @@ defined('MOODLE_INTERNAL') || die();
 // The old class name is the key, the path to the file containing the class is the vlaue.
 // The array must be called $legacyclasses.
 $legacyclasses = [
+    // Exception API.
     \bootstrap_renderer::class => 'output/bootstrap_renderer.php',
     \coding_exception::class => 'exception/coding_exception.php',
     \file_serving_exception::class => 'exception/file_serving_exception.php',
@@ -42,4 +43,86 @@ $legacyclasses = [
     \require_login_session_timeout_exception::class => 'exception/require_login_session_timeout_exception.php',
     \required_capability_exception::class => 'exception/required_capability_exception.php',
     \webservice_parameter_exception::class => 'exception/webservice_parameter_exception.php',
+
+    // Output API.
+    \theme_config::class => 'output/theme_config.php',
+    \xhtml_container_stack::class => 'output/xhtml_container_stack.php',
+
+    \renderable::class => 'output/renderable.php',
+    \templatable::class => 'output/templatable.php',
+
+    // Output API: Renderer Factories.
+    \renderer_factory::class => 'output/renderer_factory/renderer_factory_interface.php',
+    \renderer_factory_base::class => 'output/renderer_factory/renderer_factory_base.php',
+    \standard_renderer_factory::class => 'output/renderer_factory/standard_renderer_factory.php',
+    \theme_overridden_renderer_factory::class => 'output/renderer_factory/theme_overridden_renderer_factory.php',
+
+    // Output API: Renderers.
+    \renderer_base::class => 'output/renderer_base.php',
+    \plugin_renderer_base::class => 'output/plugin_renderer_base.php',
+    \core_renderer::class => 'output/core_renderer.php',
+    \core_renderer_cli::class => 'output/core_renderer_cli.php',
+    \core_renderer_ajax::class => 'output/core_renderer_ajax.php',
+    \core_renderer_maintenance::class => 'output/core_renderer_maintenance.php',
+    \page_requirements_manager::class => 'output/requirements/page_requirements_manager.php',
+    \YUI_config::class => 'output/requirements/yui.php',
+    \fragment_requirements_manager::class => 'output/requirements/fragment_requirements_manager.php',
+
+    // Output API: components.
+    \file_picker::class => 'output/file_picker.php',
+    \user_picture::class => 'output/user_picture.php',
+    \help_icon::class => 'output/help_icon.php',
+    \pix_icon_font::class => 'output/pix_icon_font.php',
+    \pix_icon_fontawesome::class => 'output/pix_icon_fontawesome.php',
+    \pix_icon::class => 'output/pix_icon.php',
+    \image_icon::class => 'output/image_icon.php',
+    \pix_emoticon::class => 'output/pix_emoticon.php',
+    \single_button::class => 'output/single_button.php',
+    \single_select::class => 'output/single_select.php',
+    \url_select::class => 'output/url_select.php',
+    \action_link::class => 'output/action_link.php',
+    \html_writer::class => 'output/html_writer.php',
+    \js_writer::class => 'output/js_writer.php',
+    \paging_bar::class => 'output/paging_bar.php',
+    \initials_bar::class => 'output/initials_bar.php',
+    \custom_menu_item::class => 'output/custom_menu_item.php',
+    \custom_menu::class => 'output/custom_menu.php',
+    \tabobject::class => 'output/tabobject.php',
+    \context_header::class => 'output/context_header.php',
+    \tabtree::class => 'output/tabtree.php',
+    \action_menu::class => 'output/action_menu.php',
+    \action_menu_filler::class => 'output/action_menu/filler.php',
+    \action_menu_link::class => 'output/action_menu/link.php',
+    \action_menu_link_primary::class => 'output/action_menu/link_primary.php',
+    \action_menu_link_secondary::class => 'output/action_menu/link_secondary.php',
+    \preferences_groups::class => 'output/preferences_groups.php',
+    \preferences_group::class => 'output/preferences_group.php',
+    \progress_bar::class => 'output/progress_bar.php',
+    \component_action::class => 'output/actions/component_action.php',
+    \confirm_action::class => 'output/actions/confirm_action.php',
+    \popup_action::class => 'output/actions/popup_action.php',
+
+    // Block Subsystem.
+    \block_contents::class => [
+        'core_block',
+        'output/block_contents.php',
+    ],
+    \block_move_target::class => [
+        'core_block',
+        'output/block_move_target.php',
+    ],
+
+    // Table Subsystem.
+    \html_table::class => [
+        'core_table',
+        'output/html_table.php',
+    ],
+    \html_table_row::class => [
+        'core_table',
+        'output/html_table_row.php',
+    ],
+    \html_table_cell::class => [
+        'core_table',
+        'output/html_table_cell.php',
+    ],
 ];
diff --git a/lib/form/button.php b/lib/form/button.php
index fdbb4ffe1ea..b5a44aab17d 100644
--- a/lib/form/button.php
+++ b/lib/form/button.php
@@ -26,7 +26,6 @@
  */
 
 require_once("HTML/QuickForm/button.php");
-require_once(__DIR__ . '/../outputcomponents.php');
 require_once('templatable_form_element.php');
 
 /**
diff --git a/lib/form/templatable_form_element.php b/lib/form/templatable_form_element.php
index 07fb98e2d7f..e94e5baf5bc 100644
--- a/lib/form/templatable_form_element.php
+++ b/lib/form/templatable_form_element.php
@@ -21,18 +21,6 @@
  * @copyright 2016 Damyon Wiese
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-defined('MOODLE_INTERNAL') || die();
-
-// Some form elements are used before $CFG is created - do not rely on it here.
-require_once(__DIR__ . '/../outputcomponents.php');
-
-/**
- * templatable_form_element trait.
- *
- * @package   core_form
- * @copyright 2016 Damyon Wiese
- * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
 trait templatable_form_element {
 
     /**
diff --git a/lib/outputactions.php b/lib/outputactions.php
index 04bf469af06..0fdca282e68 100644
--- a/lib/outputactions.php
+++ b/lib/outputactions.php
@@ -14,207 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Classes representing JS event handlers, used by output components.
- *
- * Please see http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML
- * for an overview.
- *
- * @package core
- * @category output
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-
-defined('MOODLE_INTERNAL') || die();
-
-/**
- * Helper class used by other components that involve an action on the page (URL or JS).
- *
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class component_action implements templatable {
-
-    /**
-     * @var string $event The DOM event that will trigger this action when caught
-     */
-    public $event;
-
-    /**
-     * @var string A function name to call when the button is clicked
-     * The JS function you create must have two arguments:
-     *      1. The event object
-     *      2. An object/array of arguments ($jsfunctionargs)
-     */
-    public $jsfunction = false;
-
-    /**
-     * @var array An array of arguments to pass to the JS function
-     */
-    public $jsfunctionargs = array();
-
-    /**
-     * Constructor
-     * @param string $event DOM event
-     * @param string $jsfunction An optional JS function. Required if jsfunctionargs is given
-     * @param array $jsfunctionargs An array of arguments to pass to the jsfunction
-     */
-    public function __construct($event, $jsfunction, $jsfunctionargs=array()) {
-        $this->event = $event;
-
-        $this->jsfunction = $jsfunction;
-        $this->jsfunctionargs = $jsfunctionargs;
-
-        if (!empty($this->jsfunctionargs)) {
-            if (empty($this->jsfunction)) {
-                throw new coding_exception('The component_action object needs a jsfunction value to pass the jsfunctionargs to.');
-            }
-        }
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output The renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $args = !empty($this->jsfunctionargs) ? json_encode($this->jsfunctionargs) : false;
-        return (object) [
-            'event' => $this->event,
-            'jsfunction' => $this->jsfunction,
-            'jsfunctionargs' => $args,
-        ];
-    }
-}
-
-
-/**
- * Confirm action
- *
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class confirm_action extends component_action {
-    /**
-     * Constructs the confirm action object
-     *
-     * @param string $message The message to display to the user when they are shown
-     *    the confirm dialogue.
-     * @param string $callback Deprecated since 2.7
-     * @param string $continuelabel The string to use for he continue button
-     * @param string $cancellabel The string to use for the cancel button
-     */
-    public function __construct($message, $callback = null, $continuelabel = null, $cancellabel = null) {
-        if ($callback !== null) {
-            debugging('The callback argument to new confirm_action() has been deprecated.' .
-                    ' If you need to use a callback, please write Javascript to use moodle-core-notification-confirmation ' .
-                    'and attach to the provided events.',
-                    DEBUG_DEVELOPER);
-        }
-        parent::__construct('click', 'M.util.show_confirm_dialog', array(
-                'message' => $message,
-                'continuelabel' => $continuelabel, 'cancellabel' => $cancellabel));
-    }
-}
-
-
-/**
- * Component action for a popup window.
- *
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class popup_action extends component_action {
-
-    /**
-     * @var string The JS function to call for the popup
-     */
-    public $jsfunction = 'openpopup';
-
-    /**
-     * @var array An array of parameters that will be passed to the openpopup JS function
-     */
-    public $params = array(
-            'height' =>  400,
-            'width' => 500,
-            'top' => 0,
-            'left' => 0,
-            'menubar' => false,
-            'location' => false,
-            'scrollbars' => true,
-            'resizable' => true,
-            'toolbar' => true,
-            'status' => true,
-            'directories' => false,
-            'fullscreen' => false,
-            'dependent' => true);
-
-    /**
-     * Constructor
-     *
-     * @param string $event DOM event
-     * @param moodle_url|string $url A moodle_url object, required if no jsfunction is given
-     * @param string $name The JS function to call for the popup (default 'popup')
-     * @param array  $params An array of popup parameters
-     */
-    public function __construct($event, $url, $name='popup', $params=array()) {
-        global $CFG;
-
-        $url = new moodle_url($url);
-
-        if ($name) {
-            $_name = $name;
-            if (($_name = preg_replace("/\s/", '_', $_name)) != $name) {
-                throw new coding_exception('The $name of a popup window shouldn\'t contain spaces - string modified. '. $name .' changed to '. $_name);
-                $name = $_name;
-            }
-        } else {
-            $name = 'popup';
-        }
-
-        foreach ($this->params as $var => $val) {
-            if (array_key_exists($var, $params)) {
-                $this->params[$var] = $params[$var];
-            }
-        }
-
-        $attributes = array('url' => $url->out(false), 'name' => $name, 'options' => $this->get_js_options($params));
-        if (!empty($params['fullscreen'])) {
-            $attributes['fullscreen'] = 1;
-        }
-        parent::__construct($event, $this->jsfunction, $attributes);
-    }
-
-    /**
-     * Returns a string of concatenated option->value pairs used by JS to call the popup window,
-     * based on this object's variables
-     *
-     * @return string String of option->value pairs for JS popup function.
-     */
-    public function get_js_options() {
-        $jsoptions = '';
-
-        foreach ($this->params as $var => $val) {
-            if (is_string($val) || is_int($val)) {
-                $jsoptions .= "$var=$val,";
-            } elseif (is_bool($val)) {
-                $jsoptions .= ($val) ? "$var," : "$var=0,";
-            }
-        }
-
-        $jsoptions = substr($jsoptions, 0, strlen($jsoptions) - 1);
-
-        return $jsoptions;
-    }
-}
+// This file is deprecated, but it should never have been manually included by anything outside of lib/outputlib.php.
+// Throwing an exception here should be fine because removing the manual inclusion should have no impact.
+throw new \core\exception\coding_exception(
+    'This file should not be manually included by any component.',
+);
diff --git a/lib/outputcomponents.php b/lib/outputcomponents.php
index 99d22f8e21c..0fdca282e68 100644
--- a/lib/outputcomponents.php
+++ b/lib/outputcomponents.php
@@ -14,5353 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Classes representing HTML elements, used by $OUTPUT methods
- *
- * Please see http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML
- * for an overview.
- *
- * @package core
- * @category output
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-
-use core\output\local\action_menu\subpanel;
-
-defined('MOODLE_INTERNAL') || die();
-
-/**
- * Interface marking other classes as suitable for renderer_base::render()
- *
- * @copyright 2010 Petr Skoda (skodak) info@skodak.org
- * @package core
- * @category output
- */
-interface renderable {
-    // intentionally empty
-}
-
-/**
- * Interface marking other classes having the ability to export their data for use by templates.
- *
- * @copyright 2015 Damyon Wiese
- * @package core
- * @category output
- * @since 2.9
- */
-interface templatable {
-
-    /**
-     * Function to export the renderer data in a format that is suitable for a
-     * mustache template. This means:
-     * 1. No complex types - only stdClass, array, int, string, float, bool
-     * 2. Any additional info that is required for the template is pre-calculated (e.g. capability checks).
-     *
-     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
-     * @return stdClass|array
-     */
-    public function export_for_template(renderer_base $output);
-}
-
-/**
- * Data structure representing a file picker.
- *
- * @copyright 2010 Dongsheng Cai
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class file_picker implements renderable {
-
-    /**
-     * @var stdClass An object containing options for the file picker
-     */
-    public $options;
-
-    /**
-     * Constructs a file picker object.
-     *
-     * The following are possible options for the filepicker:
-     *    - accepted_types  (*)
-     *    - return_types    (FILE_INTERNAL)
-     *    - env             (filepicker)
-     *    - client_id       (uniqid)
-     *    - itemid          (0)
-     *    - maxbytes        (-1)
-     *    - maxfiles        (1)
-     *    - buttonname      (false)
-     *
-     * @param stdClass $options An object containing options for the file picker.
-     */
-    public function __construct(stdClass $options) {
-        global $CFG, $USER, $PAGE;
-        require_once($CFG->dirroot. '/repository/lib.php');
-        $defaults = array(
-            'accepted_types'=>'*',
-            'return_types'=>FILE_INTERNAL,
-            'env' => 'filepicker',
-            'client_id' => uniqid(),
-            'itemid' => 0,
-            'maxbytes'=>-1,
-            'maxfiles'=>1,
-            'buttonname'=>false
-        );
-        foreach ($defaults as $key=>$value) {
-            if (empty($options->$key)) {
-                $options->$key = $value;
-            }
-        }
-
-        $options->currentfile = '';
-        if (!empty($options->itemid)) {
-            $fs = get_file_storage();
-            $usercontext = context_user::instance($USER->id);
-            if (empty($options->filename)) {
-                if ($files = $fs->get_area_files($usercontext->id, 'user', 'draft', $options->itemid, 'id DESC', false)) {
-                    $file = reset($files);
-                }
-            } else {
-                $file = $fs->get_file($usercontext->id, 'user', 'draft', $options->itemid, $options->filepath, $options->filename);
-            }
-            if (!empty($file)) {
-                $options->currentfile = html_writer::link(moodle_url::make_draftfile_url($file->get_itemid(), $file->get_filepath(), $file->get_filename()), $file->get_filename());
-            }
-        }
-
-        // initilise options, getting files in root path
-        $this->options = initialise_filepicker($options);
-
-        // copying other options
-        foreach ($options as $name=>$value) {
-            if (!isset($this->options->$name)) {
-                $this->options->$name = $value;
-            }
-        }
-    }
-}
-
-/**
- * Data structure representing a user picture.
- *
- * @copyright 2009 Nicolas Connault, 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Modle 2.0
- * @package core
- * @category output
- */
-class user_picture implements renderable {
-    /**
-     * @var stdClass A user object with at least fields all columns specified
-     * in $fields array constant set.
-     */
-    public $user;
-
-    /**
-     * @var int The course id. Used when constructing the link to the user's
-     * profile, page course id used if not specified.
-     */
-    public $courseid;
-
-    /**
-     * @var bool Add course profile link to image
-     */
-    public $link = true;
-
-    /**
-     * @var int Size in pixels. Special values are (true/1 = 100px) and (false/0 = 35px) for backward compatibility.
-     * Recommended values (supporting user initials too): 16, 35, 64 and 100.
-     */
-    public $size = 35;
-
-    /**
-     * @var bool Add non-blank alt-text to the image.
-     * Default true, set to false when image alt just duplicates text in screenreaders.
-     */
-    public $alttext = true;
-
-    /**
-     * @var bool Whether or not to open the link in a popup window.
-     */
-    public $popup = false;
-
-    /**
-     * @var string Image class attribute
-     */
-    public $class = 'userpicture';
-
-    /**
-     * @var bool Whether to be visible to screen readers.
-     */
-    public $visibletoscreenreaders = true;
-
-    /**
-     * @var bool Whether to include the fullname in the user picture link.
-     */
-    public $includefullname = false;
-
-    /**
-     * @var mixed Include user authentication token. True indicates to generate a token for current user, and integer value
-     * indicates to generate a token for the user whose id is the value indicated.
-     */
-    public $includetoken = false;
-
-    /**
-     * User picture constructor.
-     *
-     * @param stdClass $user user record with at least id, picture, imagealt, firstname and lastname set.
-     *                 It is recommended to add also contextid of the user for performance reasons.
-     */
-    public function __construct(stdClass $user) {
-        global $DB;
-
-        if (empty($user->id)) {
-            throw new coding_exception('User id is required when printing user avatar image.');
-        }
-
-        // only touch the DB if we are missing data and complain loudly...
-        $needrec = false;
-        foreach (\core_user\fields::get_picture_fields() as $field) {
-            if (!property_exists($user, $field)) {
-                $needrec = true;
-                debugging('Missing '.$field.' property in $user object, this is a performance problem that needs to be fixed by a developer. '
-                    .'Please use the \core_user\fields API to get the full list of required fields.', DEBUG_DEVELOPER);
-                break;
-            }
-        }
-
-        if ($needrec) {
-            $this->user = $DB->get_record('user', array('id' => $user->id),
-                implode(',', \core_user\fields::get_picture_fields()), MUST_EXIST);
-        } else {
-            $this->user = clone($user);
-        }
-    }
-
-    /**
-     * Returns a list of required user fields, useful when fetching required user info from db.
-     *
-     * In some cases we have to fetch the user data together with some other information,
-     * the idalias is useful there because the id would otherwise override the main
-     * id of the result record. Please note it has to be converted back to id before rendering.
-     *
-     * @param string $tableprefix name of database table prefix in query
-     * @param array $extrafields extra fields to be included in result (do not include TEXT columns because it would break SELECT DISTINCT in MSSQL and ORACLE)
-     * @param string $idalias alias of id field
-     * @param string $fieldprefix prefix to add to all columns in their aliases, does not apply to 'id'
-     * @return string
-     * @deprecated since Moodle 3.11 MDL-45242
-     * @see \core_user\fields
-     */
-    public static function fields($tableprefix = '', array $extrafields = NULL, $idalias = 'id', $fieldprefix = '') {
-        debugging('user_picture::fields() is deprecated. Please use the \core_user\fields API instead.', DEBUG_DEVELOPER);
-        $userfields = \core_user\fields::for_userpic();
-        if ($extrafields) {
-            $userfields->including(...$extrafields);
-        }
-        $selects = $userfields->get_sql($tableprefix, false, $fieldprefix, $idalias, false)->selects;
-        if ($tableprefix === '') {
-            // If no table alias is specified, don't add {user}. in front of fields.
-            $selects = str_replace('{user}.', '', $selects);
-        }
-        // Maintain legacy behaviour where the field list was done with 'implode' and no spaces.
-        $selects = str_replace(', ', ',', $selects);
-        return $selects;
-    }
-
-    /**
-     * Extract the aliased user fields from a given record
-     *
-     * Given a record that was previously obtained using {@link self::fields()} with aliases,
-     * this method extracts user related unaliased fields.
-     *
-     * @param stdClass $record containing user picture fields
-     * @param array $extrafields extra fields included in the $record
-     * @param string $idalias alias of the id field
-     * @param string $fieldprefix prefix added to all columns in their aliases, does not apply to 'id'
-     * @return stdClass object with unaliased user fields
-     */
-    public static function unalias(stdClass $record, array $extrafields = null, $idalias = 'id', $fieldprefix = '') {
-
-        if (empty($idalias)) {
-            $idalias = 'id';
-        }
-
-        $return = new stdClass();
-
-        foreach (\core_user\fields::get_picture_fields() as $field) {
-            if ($field === 'id') {
-                if (property_exists($record, $idalias)) {
-                    $return->id = $record->{$idalias};
-                }
-            } else {
-                if (property_exists($record, $fieldprefix.$field)) {
-                    $return->{$field} = $record->{$fieldprefix.$field};
-                }
-            }
-        }
-        // add extra fields if not already there
-        if ($extrafields) {
-            foreach ($extrafields as $e) {
-                if ($e === 'id' or property_exists($return, $e)) {
-                    continue;
-                }
-                $return->{$e} = $record->{$fieldprefix.$e};
-            }
-        }
-
-        return $return;
-    }
-
-    /**
-     * Works out the URL for the users picture.
-     *
-     * This method is recommended as it avoids costly redirects of user pictures
-     * if requests are made for non-existent files etc.
-     *
-     * @param moodle_page $page
-     * @param renderer_base $renderer
-     * @return moodle_url
-     */
-    public function get_url(moodle_page $page, renderer_base $renderer = null) {
-        global $CFG;
-
-        if (is_null($renderer)) {
-            $renderer = $page->get_renderer('core');
-        }
-
-        // Sort out the filename and size. Size is only required for the gravatar
-        // implementation presently.
-        if (empty($this->size)) {
-            $filename = 'f2';
-            $size = 35;
-        } else if ($this->size === true or $this->size == 1) {
-            $filename = 'f1';
-            $size = 100;
-        } else if ($this->size > 100) {
-            $filename = 'f3';
-            $size = (int)$this->size;
-        } else if ($this->size >= 50) {
-            $filename = 'f1';
-            $size = (int)$this->size;
-        } else {
-            $filename = 'f2';
-            $size = (int)$this->size;
-        }
-
-        $defaulturl = $renderer->image_url('u/'.$filename); // default image
-
-        if ((!empty($CFG->forcelogin) and !isloggedin()) ||
-            (!empty($CFG->forceloginforprofileimage) && (!isloggedin() || isguestuser()))) {
-            // Protect images if login required and not logged in;
-            // also if login is required for profile images and is not logged in or guest
-            // do not use require_login() because it is expensive and not suitable here anyway.
-            return $defaulturl;
-        }
-
-        // First try to detect deleted users - but do not read from database for performance reasons!
-        if (!empty($this->user->deleted) or strpos($this->user->email, '@') === false) {
-            // All deleted users should have email replaced by md5 hash,
-            // all active users are expected to have valid email.
-            return $defaulturl;
-        }
-
-        // Did the user upload a picture?
-        if ($this->user->picture > 0) {
-            if (!empty($this->user->contextid)) {
-                $contextid = $this->user->contextid;
-            } else {
-                $context = context_user::instance($this->user->id, IGNORE_MISSING);
-                if (!$context) {
-                    // This must be an incorrectly deleted user, all other users have context.
-                    return $defaulturl;
-                }
-                $contextid = $context->id;
-            }
-
-            $path = '/';
-            if (clean_param($page->theme->name, PARAM_THEME) == $page->theme->name) {
-                // We append the theme name to the file path if we have it so that
-                // in the circumstance that the profile picture is not available
-                // when the user actually requests it they still get the profile
-                // picture for the correct theme.
-                $path .= $page->theme->name.'/';
-            }
-            // Set the image URL to the URL for the uploaded file and return.
-            $url = moodle_url::make_pluginfile_url(
-                $contextid, 'user', 'icon', null, $path, $filename, false, $this->includetoken);
-            $url->param('rev', $this->user->picture);
-            return $url;
-        }
-
-        if ($this->user->picture == 0 and !empty($CFG->enablegravatar)) {
-            // Normalise the size variable to acceptable bounds
-            if ($size < 1 || $size > 512) {
-                $size = 35;
-            }
-            // Hash the users email address
-            $md5 = md5(strtolower(trim($this->user->email)));
-            // Build a gravatar URL with what we know.
-
-            // Find the best default image URL we can (MDL-35669)
-            if (empty($CFG->gravatardefaulturl)) {
-                $absoluteimagepath = $page->theme->resolve_image_location('u/'.$filename, 'core');
-                if (strpos($absoluteimagepath, $CFG->dirroot) === 0) {
-                    $gravatardefault = $CFG->wwwroot . substr($absoluteimagepath, strlen($CFG->dirroot));
-                } else {
-                    $gravatardefault = $CFG->wwwroot . '/pix/u/' . $filename . '.png';
-                }
-            } else {
-                $gravatardefault = $CFG->gravatardefaulturl;
-            }
-
-            // If the currently requested page is https then we'll return an
-            // https gravatar page.
-            if (is_https()) {
-                return new moodle_url("https://secure.gravatar.com/avatar/{$md5}", array('s' => $size, 'd' => $gravatardefault));
-            } else {
-                return new moodle_url("http://www.gravatar.com/avatar/{$md5}", array('s' => $size, 'd' => $gravatardefault));
-            }
-        }
-
-        return $defaulturl;
-    }
-}
-
-/**
- * Data structure representing a help icon.
- *
- * @copyright 2010 Petr Skoda (info@skodak.org)
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class help_icon implements renderable, templatable {
-
-    /**
-     * @var string lang pack identifier (without the "_help" suffix),
-     * both get_string($identifier, $component) and get_string($identifier.'_help', $component)
-     * must exist.
-     */
-    public $identifier;
-
-    /**
-     * @var string Component name, the same as in get_string()
-     */
-    public $component;
-
-    /**
-     * @var string Extra descriptive text next to the icon
-     */
-    public $linktext = null;
-
-    /**
-     * @var mixed An object, string or number that can be used within translation strings
-     */
-    public $a = null;
-
-    /**
-     * Constructor
-     *
-     * @param string $identifier string for help page title,
-     *  string with _help suffix is used for the actual help text.
-     *  string with _link suffix is used to create a link to further info (if it exists)
-     * @param string $component
-     * @param string|object|array|int $a An object, string or number that can be used
-     *      within translation strings
-     */
-    public function __construct($identifier, $component, $a = null) {
-        $this->identifier = $identifier;
-        $this->component  = $component;
-        $this->a = $a;
-    }
-
-    /**
-     * Verifies that both help strings exists, shows debug warnings if not
-     */
-    public function diag_strings() {
-        $sm = get_string_manager();
-        if (!$sm->string_exists($this->identifier, $this->component)) {
-            debugging("Help title string does not exist: [$this->identifier, $this->component]");
-        }
-        if (!$sm->string_exists($this->identifier.'_help', $this->component)) {
-            debugging("Help contents string does not exist: [{$this->identifier}_help, $this->component]");
-        }
-    }
-
-    /**
-     * Export this data so it can be used as the context for a mustache template.
-     *
-     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        global $CFG;
-
-        $title = get_string($this->identifier, $this->component, $this->a);
-
-        if (empty($this->linktext)) {
-            $alt = get_string('helpprefix2', '', trim($title, ". \t"));
-        } else {
-            $alt = get_string('helpwiththis');
-        }
-
-        $data = get_formatted_help_string($this->identifier, $this->component, false, $this->a);
-
-        $data->alt = $alt;
-        $data->icon = (new pix_icon('help', $alt, 'core', ['class' => 'iconhelp']))->export_for_template($output);
-        $data->linktext = $this->linktext;
-        $data->title = get_string('helpprefix2', '', trim($title, ". \t"));
-
-        $options = [
-            'component' => $this->component,
-            'identifier' => $this->identifier,
-            'lang' => current_language()
-        ];
-
-        // Debugging feature lets you display string identifier and component.
-        if (isset($CFG->debugstringids) && $CFG->debugstringids && optional_param('strings', 0, PARAM_INT)) {
-            $options['strings'] = 1;
-        }
-
-        $data->url = (new moodle_url('/help.php', $options))->out(false);
-        $data->ltr = !right_to_left();
-        return $data;
-    }
-}
-
-
-/**
- * Data structure representing an icon font.
- *
- * @copyright 2016 Damyon Wiese
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- * @category output
- */
-class pix_icon_font implements templatable {
-
-    /**
-     * @var pix_icon $pixicon The original icon.
-     */
-    private $pixicon = null;
-
-    /**
-     * @var string $key The mapped key.
-     */
-    private $key;
-
-    /**
-     * @var bool $mapped The icon could not be mapped.
-     */
-    private $mapped;
-
-    /**
-     * Constructor
-     *
-     * @param pix_icon $pixicon The original icon
-     */
-    public function __construct(pix_icon $pixicon) {
-        global $PAGE;
-
-        $this->pixicon = $pixicon;
-        $this->mapped = false;
-        $iconsystem = \core\output\icon_system::instance();
-
-        $this->key = $iconsystem->remap_icon_name($pixicon->pix, $pixicon->component);
-        if (!empty($this->key)) {
-            $this->mapped = true;
-        }
-    }
-
-    /**
-     * Return true if this pix_icon was successfully mapped to an icon font.
-     *
-     * @return bool
-     */
-    public function is_mapped() {
-        return $this->mapped;
-    }
-
-    /**
-     * Export this data so it can be used as the context for a mustache template.
-     *
-     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
-     * @return array
-     */
-    public function export_for_template(renderer_base $output) {
-
-        $pixdata = $this->pixicon->export_for_template($output);
-
-        $title = isset($this->pixicon->attributes['title']) ? $this->pixicon->attributes['title'] : '';
-        $alt = isset($this->pixicon->attributes['alt']) ? $this->pixicon->attributes['alt'] : '';
-        if (empty($title)) {
-            $title = $alt;
-        }
-        $data = array(
-            'extraclasses' => $pixdata['extraclasses'],
-            'title' => $title,
-            'alt' => $alt,
-            'key' => $this->key
-        );
-
-        return $data;
-    }
-}
-
-/**
- * Data structure representing an icon subtype.
- *
- * @copyright 2016 Damyon Wiese
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- * @category output
- */
-class pix_icon_fontawesome extends pix_icon_font {
-
-}
-
-/**
- * Data structure representing an icon.
- *
- * @copyright 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class pix_icon implements renderable, templatable {
-
-    /**
-     * @var string The icon name
-     */
-    var $pix;
-
-    /**
-     * @var string The component the icon belongs to.
-     */
-    var $component;
-
-    /**
-     * @var array An array of attributes to use on the icon
-     */
-    var $attributes = array();
-
-    /**
-     * Constructor
-     *
-     * @param string $pix short icon name
-     * @param string $alt The alt text to use for the icon
-     * @param string $component component name
-     * @param array $attributes html attributes
-     */
-    public function __construct($pix, $alt, $component='moodle', array $attributes = null) {
-        global $PAGE;
-
-        $this->pix = $pix;
-        $this->component  = $component;
-        $this->attributes = (array)$attributes;
-
-        if (empty($this->attributes['class'])) {
-            $this->attributes['class'] = '';
-        }
-
-        // Set an additional class for big icons so that they can be styled properly.
-        if (substr($pix, 0, 2) === 'b/') {
-            $this->attributes['class'] .= ' iconsize-big';
-        }
-
-        // If the alt is empty, don't place it in the attributes, otherwise it will override parent alt text.
-        if (!is_null($alt)) {
-            $this->attributes['alt'] = $alt;
-
-            // If there is no title, set it to the attribute.
-            if (!isset($this->attributes['title'])) {
-                $this->attributes['title'] = $this->attributes['alt'];
-            }
-        } else {
-            unset($this->attributes['alt']);
-        }
-
-        if (empty($this->attributes['title'])) {
-            // Remove the title attribute if empty, we probably want to use the parent node's title
-            // and some browsers might overwrite it with an empty title.
-            unset($this->attributes['title']);
-        }
-
-        // Hide icons from screen readers that have no alt.
-        if (empty($this->attributes['alt'])) {
-            $this->attributes['aria-hidden'] = 'true';
-        }
-    }
-
-    /**
-     * Export this data so it can be used as the context for a mustache template.
-     *
-     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
-     * @return array
-     */
-    public function export_for_template(renderer_base $output) {
-        $attributes = $this->attributes;
-        $extraclasses = '';
-
-        foreach ($attributes as $key => $item) {
-            if ($key == 'class') {
-                $extraclasses = $item;
-                unset($attributes[$key]);
-                break;
-            }
-        }
-
-        $attributes['src'] = $output->image_url($this->pix, $this->component)->out(false);
-        $templatecontext = array();
-        foreach ($attributes as $name => $value) {
-            $templatecontext[] = array('name' => $name, 'value' => $value);
-        }
-        $title = isset($attributes['title']) ? $attributes['title'] : '';
-        if (empty($title)) {
-            $title = isset($attributes['alt']) ? $attributes['alt'] : '';
-        }
-        $data = array(
-            'attributes' => $templatecontext,
-            'extraclasses' => $extraclasses
-        );
-
-        return $data;
-    }
-
-    /**
-     * Much simpler version of export that will produce the data required to render this pix with the
-     * pix helper in a mustache tag.
-     *
-     * @return array
-     */
-    public function export_for_pix() {
-        $title = isset($this->attributes['title']) ? $this->attributes['title'] : '';
-        if (empty($title)) {
-            $title = isset($this->attributes['alt']) ? $this->attributes['alt'] : '';
-        }
-        return [
-            'key' => $this->pix,
-            'component' => $this->component,
-            'title' => (string) $title,
-        ];
-    }
-}
-
-/**
- * Data structure representing an activity icon.
- *
- * The difference is that activity icons will always render with the standard icon system (no font icons).
- *
- * @copyright 2017 Damyon Wiese
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- */
-class image_icon extends pix_icon {
-}
-
-/**
- * Data structure representing an emoticon image
- *
- * @copyright 2010 David Mudrak
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class pix_emoticon extends pix_icon implements renderable {
-
-    /**
-     * Constructor
-     * @param string $pix short icon name
-     * @param string $alt alternative text
-     * @param string $component emoticon image provider
-     * @param array $attributes explicit HTML attributes
-     */
-    public function __construct($pix, $alt, $component = 'moodle', array $attributes = array()) {
-        if (empty($attributes['class'])) {
-            $attributes['class'] = 'emoticon';
-        }
-        parent::__construct($pix, $alt, $component, $attributes);
-    }
-}
-
-/**
- * Data structure representing a simple form with only one button.
- *
- * @copyright 2009 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class single_button implements renderable {
-
-    /**
-     * Possible button types. From boostrap.
-     */
-    const BUTTON_TYPES = [
-        self::BUTTON_PRIMARY,
-        self::BUTTON_SECONDARY,
-        self::BUTTON_SUCCESS,
-        self::BUTTON_DANGER,
-        self::BUTTON_WARNING,
-        self::BUTTON_INFO
-    ];
-
-    /**
-     * Possible button types - Primary.
-     */
-    const BUTTON_PRIMARY = 'primary';
-    /**
-     * Possible button types - Secondary.
-     */
-    const BUTTON_SECONDARY = 'secondary';
-    /**
-     * Possible button types - Danger.
-     */
-    const BUTTON_DANGER = 'danger';
-    /**
-     * Possible button types - Success.
-     */
-    const BUTTON_SUCCESS = 'success';
-    /**
-     * Possible button types - Warning.
-     */
-    const BUTTON_WARNING = 'warning';
-    /**
-     * Possible button types - Info.
-     */
-    const BUTTON_INFO = 'info';
-
-    /**
-     * @var moodle_url Target url
-     */
-    public $url;
-
-    /**
-     * @var string Button label
-     */
-    public $label;
-
-    /**
-     * @var string Form submit method post or get
-     */
-    public $method = 'post';
-
-    /**
-     * @var string Wrapping div class
-     */
-    public $class = 'singlebutton';
-
-    /**
-     * @var string Type of button (from defined types). Used for styling.
-     */
-    protected $type;
-
-    /**
-     * @var bool True if button is primary button. Used for styling.
-     * @deprecated since Moodle 4.2
-     */
-    private $primary = false;
-
-    /**
-     * @var bool True if button disabled, false if normal
-     */
-    public $disabled = false;
-
-    /**
-     * @var string Button tooltip
-     */
-    public $tooltip = null;
-
-    /**
-     * @var string Form id
-     */
-    public $formid;
-
-    /**
-     * @var array List of attached actions
-     */
-    public $actions = array();
-
-    /**
-     * @var array $params URL Params
-     */
-    public $params;
-
-    /**
-     * @var string Action id
-     */
-    public $actionid;
-
-    /**
-     * @var array
-     */
-    protected $attributes = [];
-
-    /**
-     * Constructor
-     *
-     * @param moodle_url $url
-     * @param string $label button text
-     * @param string $method get or post submit method
-     * @param string $type whether this is a primary button or another type, used for styling
-     * @param array $attributes Attributes for the HTML button tag
-     */
-    public function __construct(moodle_url $url, $label, $method = 'post', $type = self::BUTTON_SECONDARY,
-        $attributes = []) {
-        if (is_bool($type)) {
-            debugging('The boolean $primary is deprecated and replaced by $type,
-            use single_button::BUTTON_PRIMARY or self::BUTTON_SECONDARY instead');
-            $type = $type ? self::BUTTON_PRIMARY : self::BUTTON_SECONDARY;
-        }
-        $this->url = clone($url);
-        $this->label = $label;
-        $this->method = $method;
-        $this->type = $type;
-        $this->attributes = $attributes;
-    }
-
-    /**
-     * Shortcut for adding a JS confirm dialog when the button is clicked.
-     * The message must be a yes/no question.
-     *
-     * @param string $confirmmessage The yes/no confirmation question. If "Yes" is clicked, the original action will occur.
-     */
-    public function add_confirm_action($confirmmessage) {
-        $this->add_action(new confirm_action($confirmmessage));
-    }
-
-    /**
-     * Add action to the button.
-     * @param component_action $action
-     */
-    public function add_action(component_action $action) {
-        $this->actions[] = $action;
-    }
-
-    /**
-     * Sets an attribute for the HTML button tag.
-     *
-     * @param  string $name  The attribute name
-     * @param  mixed  $value The value
-     * @return null
-     */
-    public function set_attribute($name, $value) {
-        $this->attributes[$name] = $value;
-    }
-
-    /**
-     * Magic setter method.
-     *
-     * This method manages access to some properties and will display deprecation message when accessing 'primary' property.
-     *
-     * @param string $name
-     * @param mixed $value
-     */
-    public function __set($name, $value) {
-        switch ($name) {
-            case 'primary':
-                debugging('The primary field is deprecated, use the type field instead');
-                // Here just in case we modified the primary field from outside {@see \mod_quiz_renderer::summary_page_controls}.
-                $this->type = $value ? self::BUTTON_PRIMARY : self::BUTTON_SECONDARY;
-                break;
-            case 'type':
-                $this->type = in_array($value, self::BUTTON_TYPES) ? $value : self::BUTTON_SECONDARY;
-                break;
-            default:
-                $this->$name = $value;
-        }
-    }
-
-    /**
-     * Magic method getter.
-     *
-     * This method manages access to some properties and will display deprecation message when accessing 'primary' property.
-     *
-     * @param string $name
-     * @return mixed
-     */
-    public function __get($name) {
-        switch ($name) {
-            case 'primary':
-                debugging('The primary field is deprecated, use type field instead');
-                return $this->type == self::BUTTON_PRIMARY;
-            case 'type':
-                return $this->type;
-            default:
-                return $this->$name;
-        }
-    }
-
-    /**
-     * Export data.
-     *
-     * @param renderer_base $output Renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $url = $this->method === 'get' ? $this->url->out_omit_querystring(true) : $this->url->out_omit_querystring();
-
-        $data = new stdClass();
-        $data->id = html_writer::random_id('single_button');
-        $data->formid = $this->formid;
-        $data->method = $this->method;
-        $data->url = $url === '' ? '#' : $url;
-        $data->label = $this->label;
-        $data->classes = $this->class;
-        $data->disabled = $this->disabled;
-        $data->tooltip = $this->tooltip;
-        $data->type = $this->type;
-        $data->attributes = [];
-        foreach ($this->attributes as $key => $value) {
-            $data->attributes[] = ['name' => $key, 'value' => $value];
-        }
-
-        // Form parameters.
-        $actionurl = new moodle_url($this->url);
-        if ($this->method === 'post') {
-            $actionurl->param('sesskey', sesskey());
-        }
-        $data->params = $actionurl->export_params_for_template();
-
-        // Button actions.
-        $actions = $this->actions;
-        $data->actions = array_map(function($action) use ($output) {
-            return $action->export_for_template($output);
-        }, $actions);
-        $data->hasactions = !empty($data->actions);
-
-        return $data;
-    }
-}
-
-
-/**
- * Simple form with just one select field that gets submitted automatically.
- *
- * If JS not enabled small go button is printed too.
- *
- * @copyright 2009 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class single_select implements renderable, templatable {
-
-    /**
-     * @var moodle_url Target url - includes hidden fields
-     */
-    var $url;
-
-    /**
-     * @var string Name of the select element.
-     */
-    var $name;
-
-    /**
-     * @var array $options associative array value=>label ex.: array(1=>'One, 2=>Two)
-     *     it is also possible to specify optgroup as complex label array ex.:
-     *         array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
-     *         array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
-     */
-    var $options;
-
-    /**
-     * @var string Selected option
-     */
-    var $selected;
-
-    /**
-     * @var array Nothing selected
-     */
-    var $nothing;
-
-    /**
-     * @var array Extra select field attributes
-     */
-    var $attributes = array();
-
-    /**
-     * @var string Button label
-     */
-    var $label = '';
-
-    /**
-     * @var array Button label's attributes
-     */
-    var $labelattributes = array();
-
-    /**
-     * @var string Form submit method post or get
-     */
-    var $method = 'get';
-
-    /**
-     * @var string Wrapping div class
-     */
-    var $class = 'singleselect';
-
-    /**
-     * @var bool True if button disabled, false if normal
-     */
-    var $disabled = false;
-
-    /**
-     * @var string Button tooltip
-     */
-    var $tooltip = null;
-
-    /**
-     * @var string Form id
-     */
-    var $formid = null;
-
-    /**
-     * @var help_icon The help icon for this element.
-     */
-    var $helpicon = null;
-
-    /** @var component_action[] component action. */
-    public $actions = [];
-
-    /**
-     * Constructor
-     * @param moodle_url $url form action target, includes hidden fields
-     * @param string $name name of selection field - the changing parameter in url
-     * @param array $options list of options
-     * @param string $selected selected element
-     * @param ?array $nothing
-     * @param string $formid
-     */
-    public function __construct(moodle_url $url, $name, array $options, $selected = '', $nothing = array('' => 'choosedots'), $formid = null) {
-        $this->url      = $url;
-        $this->name     = $name;
-        $this->options  = $options;
-        $this->selected = $selected;
-        $this->nothing  = $nothing;
-        $this->formid   = $formid;
-    }
-
-    /**
-     * Shortcut for adding a JS confirm dialog when the button is clicked.
-     * The message must be a yes/no question.
-     *
-     * @param string $confirmmessage The yes/no confirmation question. If "Yes" is clicked, the original action will occur.
-     */
-    public function add_confirm_action($confirmmessage) {
-        $this->add_action(new component_action('submit', 'M.util.show_confirm_dialog', array('message' => $confirmmessage)));
-    }
-
-    /**
-     * Add action to the button.
-     *
-     * @param component_action $action
-     */
-    public function add_action(component_action $action) {
-        $this->actions[] = $action;
-    }
-
-    /**
-     * Adds help icon.
-     *
-     * @deprecated since Moodle 2.0
-     */
-    public function set_old_help_icon($helppage, $title, $component = 'moodle') {
-        throw new coding_exception('set_old_help_icon() can not be used any more, please see set_help_icon().');
-    }
-
-    /**
-     * Adds help icon.
-     *
-     * @param string $identifier The keyword that defines a help page
-     * @param string $component
-     */
-    public function set_help_icon($identifier, $component = 'moodle') {
-        $this->helpicon = new help_icon($identifier, $component);
-    }
-
-    /**
-     * Sets select's label
-     *
-     * @param string $label
-     * @param array $attributes (optional)
-     */
-    public function set_label($label, $attributes = array()) {
-        $this->label = $label;
-        $this->labelattributes = $attributes;
-
-    }
-
-    /**
-     * Export data.
-     *
-     * @param renderer_base $output Renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $attributes = $this->attributes;
-
-        $data = new stdClass();
-        $data->name = $this->name;
-        $data->method = $this->method;
-        $data->action = $this->method === 'get' ? $this->url->out_omit_querystring(true) : $this->url->out_omit_querystring();
-        $data->classes = $this->class;
-        $data->label = $this->label;
-        $data->disabled = $this->disabled;
-        $data->title = $this->tooltip;
-        $data->formid = !empty($this->formid) ? $this->formid : html_writer::random_id('single_select_f');
-        $data->id = !empty($attributes['id']) ? $attributes['id'] : html_writer::random_id('single_select');
-
-        // Select element attributes.
-        // Unset attributes that are already predefined in the template.
-        unset($attributes['id']);
-        unset($attributes['class']);
-        unset($attributes['name']);
-        unset($attributes['title']);
-        unset($attributes['disabled']);
-
-        // Map the attributes.
-        $data->attributes = array_map(function($key) use ($attributes) {
-            return ['name' => $key, 'value' => $attributes[$key]];
-        }, array_keys($attributes));
-
-        // Form parameters.
-        $actionurl = new moodle_url($this->url);
-        if ($this->method === 'post') {
-            $actionurl->param('sesskey', sesskey());
-        }
-        $data->params = $actionurl->export_params_for_template();
-
-        // Select options.
-        $hasnothing = false;
-        if (is_string($this->nothing) && $this->nothing !== '') {
-            $nothing = ['' => $this->nothing];
-            $hasnothing = true;
-            $nothingkey = '';
-        } else if (is_array($this->nothing)) {
-            $nothingvalue = reset($this->nothing);
-            if ($nothingvalue === 'choose' || $nothingvalue === 'choosedots') {
-                $nothing = [key($this->nothing) => get_string('choosedots')];
-            } else {
-                $nothing = $this->nothing;
-            }
-            $hasnothing = true;
-            $nothingkey = key($this->nothing);
-        }
-        if ($hasnothing) {
-            $options = $nothing + $this->options;
-        } else {
-            $options = $this->options;
-        }
-
-        foreach ($options as $value => $name) {
-            if (is_array($options[$value])) {
-                foreach ($options[$value] as $optgroupname => $optgroupvalues) {
-                    $sublist = [];
-                    foreach ($optgroupvalues as $optvalue => $optname) {
-                        $option = [
-                            'value' => $optvalue,
-                            'name' => $optname,
-                            'selected' => strval($this->selected) === strval($optvalue),
-                        ];
-
-                        if ($hasnothing && $nothingkey === $optvalue) {
-                            $option['ignore'] = 'data-ignore';
-                        }
-
-                        $sublist[] = $option;
-                    }
-                    $data->options[] = [
-                        'name' => $optgroupname,
-                        'optgroup' => true,
-                        'options' => $sublist
-                    ];
-                }
-            } else {
-                $option = [
-                    'value' => $value,
-                    'name' => $options[$value],
-                    'selected' => strval($this->selected) === strval($value),
-                    'optgroup' => false
-                ];
-
-                if ($hasnothing && $nothingkey === $value) {
-                    $option['ignore'] = 'data-ignore';
-                }
-
-                $data->options[] = $option;
-            }
-        }
-
-        // Label attributes.
-        $data->labelattributes = [];
-        // Unset label attributes that are already in the template.
-        unset($this->labelattributes['for']);
-        // Map the label attributes.
-        foreach ($this->labelattributes as $key => $value) {
-            $data->labelattributes[] = ['name' => $key, 'value' => $value];
-        }
-
-        // Help icon.
-        $data->helpicon = !empty($this->helpicon) ? $this->helpicon->export_for_template($output) : false;
-
-        return $data;
-    }
-}
-
-/**
- * Simple URL selection widget description.
- *
- * @copyright 2009 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class url_select implements renderable, templatable {
-    /**
-     * @var array $urls associative array value=>label ex.: array(1=>'One, 2=>Two)
-     *     it is also possible to specify optgroup as complex label array ex.:
-     *         array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
-     *         array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
-     */
-    var $urls;
-
-    /**
-     * @var string Selected option
-     */
-    var $selected;
-
-    /**
-     * @var array Nothing selected
-     */
-    var $nothing;
-
-    /**
-     * @var array Extra select field attributes
-     */
-    var $attributes = array();
-
-    /**
-     * @var string Button label
-     */
-    var $label = '';
-
-    /**
-     * @var array Button label's attributes
-     */
-    var $labelattributes = array();
-
-    /**
-     * @var string Wrapping div class
-     */
-    var $class = 'urlselect';
-
-    /**
-     * @var bool True if button disabled, false if normal
-     */
-    var $disabled = false;
-
-    /**
-     * @var string Button tooltip
-     */
-    var $tooltip = null;
-
-    /**
-     * @var string Form id
-     */
-    var $formid = null;
-
-    /**
-     * @var help_icon The help icon for this element.
-     */
-    var $helpicon = null;
-
-    /**
-     * @var string If set, makes button visible with given name for button
-     */
-    var $showbutton = null;
-
-    /**
-     * Constructor
-     * @param array $urls list of options
-     * @param string $selected selected element
-     * @param array $nothing
-     * @param string $formid
-     * @param string $showbutton Set to text of button if it should be visible
-     *   or null if it should be hidden (hidden version always has text 'go')
-     */
-    public function __construct(array $urls, $selected = '', $nothing = array('' => 'choosedots'), $formid = null, $showbutton = null) {
-        $this->urls       = $urls;
-        $this->selected   = $selected;
-        $this->nothing    = $nothing;
-        $this->formid     = $formid;
-        $this->showbutton = $showbutton;
-    }
-
-    /**
-     * Adds help icon.
-     *
-     * @deprecated since Moodle 2.0
-     */
-    public function set_old_help_icon($helppage, $title, $component = 'moodle') {
-        throw new coding_exception('set_old_help_icon() can not be used any more, please see set_help_icon().');
-    }
-
-    /**
-     * Adds help icon.
-     *
-     * @param string $identifier The keyword that defines a help page
-     * @param string $component
-     */
-    public function set_help_icon($identifier, $component = 'moodle') {
-        $this->helpicon = new help_icon($identifier, $component);
-    }
-
-    /**
-     * Sets select's label
-     *
-     * @param string $label
-     * @param array $attributes (optional)
-     */
-    public function set_label($label, $attributes = array()) {
-        $this->label = $label;
-        $this->labelattributes = $attributes;
-    }
-
-    /**
-     * Clean a URL.
-     *
-     * @param string $value The URL.
-     * @return string The cleaned URL.
-     */
-    protected function clean_url($value) {
-        global $CFG;
-
-        if (empty($value)) {
-            // Nothing.
-
-        } else if (strpos($value, $CFG->wwwroot . '/') === 0) {
-            $value = str_replace($CFG->wwwroot, '', $value);
-
-        } else if (strpos($value, '/') !== 0) {
-            debugging("Invalid url_select urls parameter: url '$value' is not local relative url!", DEBUG_DEVELOPER);
-        }
-
-        return $value;
-    }
-
-    /**
-     * Flatten the options for Mustache.
-     *
-     * This also cleans the URLs.
-     *
-     * @param array $options The options.
-     * @param array $nothing The nothing option.
-     * @return array
-     */
-    protected function flatten_options($options, $nothing) {
-        $flattened = [];
-
-        foreach ($options as $value => $option) {
-            if (is_array($option)) {
-                foreach ($option as $groupname => $optoptions) {
-                    if (!isset($flattened[$groupname])) {
-                        $flattened[$groupname] = [
-                            'name' => $groupname,
-                            'isgroup' => true,
-                            'options' => []
-                        ];
-                    }
-                    foreach ($optoptions as $optvalue => $optoption) {
-                        $cleanedvalue = $this->clean_url($optvalue);
-                        $flattened[$groupname]['options'][$cleanedvalue] = [
-                            'name' => $optoption,
-                            'value' => $cleanedvalue,
-                            'selected' => $this->selected == $optvalue,
-                        ];
-                    }
-                }
-
-            } else {
-                $cleanedvalue = $this->clean_url($value);
-                $flattened[$cleanedvalue] = [
-                    'name' => $option,
-                    'value' => $cleanedvalue,
-                    'selected' => $this->selected == $value,
-                ];
-            }
-        }
-
-        if (!empty($nothing)) {
-            $value = key($nothing);
-            $name = reset($nothing);
-            $flattened = [
-                    $value => ['name' => $name, 'value' => $value, 'selected' => $this->selected == $value]
-                ] + $flattened;
-        }
-
-        // Make non-associative array.
-        foreach ($flattened as $key => $value) {
-            if (!empty($value['options'])) {
-                $flattened[$key]['options'] = array_values($value['options']);
-            }
-        }
-        $flattened = array_values($flattened);
-
-        return $flattened;
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output Renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $attributes = $this->attributes;
-
-        $data = new stdClass();
-        $data->formid = !empty($this->formid) ? $this->formid : html_writer::random_id('url_select_f');
-        $data->classes = $this->class;
-        $data->label = $this->label;
-        $data->disabled = $this->disabled;
-        $data->title = $this->tooltip;
-        $data->id = !empty($attributes['id']) ? $attributes['id'] : html_writer::random_id('url_select');
-        $data->sesskey = sesskey();
-        $data->action = (new moodle_url('/course/jumpto.php'))->out(false);
-
-        // Remove attributes passed as property directly.
-        unset($attributes['class']);
-        unset($attributes['id']);
-        unset($attributes['name']);
-        unset($attributes['title']);
-        unset($attributes['disabled']);
-
-        $data->showbutton = $this->showbutton;
-
-        // Select options.
-        $nothing = false;
-        if (is_string($this->nothing) && $this->nothing !== '') {
-            $nothing = ['' => $this->nothing];
-        } else if (is_array($this->nothing)) {
-            $nothingvalue = reset($this->nothing);
-            if ($nothingvalue === 'choose' || $nothingvalue === 'choosedots') {
-                $nothing = [key($this->nothing) => get_string('choosedots')];
-            } else {
-                $nothing = $this->nothing;
-            }
-        }
-        $data->options = $this->flatten_options($this->urls, $nothing);
-
-        // Label attributes.
-        $data->labelattributes = [];
-        // Unset label attributes that are already in the template.
-        unset($this->labelattributes['for']);
-        // Map the label attributes.
-        foreach ($this->labelattributes as $key => $value) {
-            $data->labelattributes[] = ['name' => $key, 'value' => $value];
-        }
-
-        // Help icon.
-        $data->helpicon = !empty($this->helpicon) ? $this->helpicon->export_for_template($output) : false;
-
-        // Finally all the remaining attributes.
-        $data->attributes = [];
-        foreach ($attributes as $key => $value) {
-            $data->attributes[] = ['name' => $key, 'value' => $value];
-        }
-
-        return $data;
-    }
-}
-
-/**
- * Data structure describing html link with special action attached.
- *
- * @copyright 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class action_link implements renderable {
-
-    /**
-     * @var moodle_url Href url
-     */
-    public $url;
-
-    /**
-     * @var string Link text HTML fragment
-     */
-    public $text;
-
-    /**
-     * @var array HTML attributes
-     */
-    public $attributes;
-
-    /**
-     * @var array List of actions attached to link
-     */
-    public $actions;
-
-    /**
-     * @var pix_icon Optional pix icon to render with the link
-     */
-    public $icon;
-
-    /**
-     * Constructor
-     * @param moodle_url $url
-     * @param string $text HTML fragment
-     * @param component_action $action
-     * @param array $attributes associative array of html link attributes + disabled
-     * @param pix_icon $icon optional pix_icon to render with the link text
-     */
-    public function __construct(moodle_url $url,
-        $text,
-        component_action $action=null,
-        array $attributes=null,
-        pix_icon $icon=null) {
-        $this->url = clone($url);
-        $this->text = $text;
-        if (empty($attributes['id'])) {
-            $attributes['id'] = html_writer::random_id('action_link');
-        }
-        $this->attributes = (array)$attributes;
-        if ($action) {
-            $this->add_action($action);
-        }
-        $this->icon = $icon;
-    }
-
-    /**
-     * Add action to the link.
-     *
-     * @param component_action $action
-     */
-    public function add_action(component_action $action) {
-        $this->actions[] = $action;
-    }
-
-    /**
-     * Adds a CSS class to this action link object
-     * @param string $class
-     */
-    public function add_class($class) {
-        if (empty($this->attributes['class'])) {
-            $this->attributes['class'] = $class;
-        } else {
-            $this->attributes['class'] .= ' ' . $class;
-        }
-    }
-
-    /**
-     * Returns true if the specified class has been added to this link.
-     * @param string $class
-     * @return bool
-     */
-    public function has_class($class) {
-        return strpos(' ' . $this->attributes['class'] . ' ', ' ' . $class . ' ') !== false;
-    }
-
-    /**
-     * Return the rendered HTML for the icon. Useful for rendering action links in a template.
-     * @return string
-     */
-    public function get_icon_html() {
-        global $OUTPUT;
-        if (!$this->icon) {
-            return '';
-        }
-        return $OUTPUT->render($this->icon);
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output The renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $data = new stdClass();
-        $attributes = $this->attributes;
-
-        $data->id = $attributes['id'];
-        unset($attributes['id']);
-
-        $data->disabled = !empty($attributes['disabled']);
-        unset($attributes['disabled']);
-
-        $data->text = $this->text instanceof renderable ? $output->render($this->text) : (string) $this->text;
-        $data->url = $this->url ? $this->url->out(false) : '';
-        $data->icon = $this->icon ? $this->icon->export_for_pix() : null;
-        $data->classes = isset($attributes['class']) ? $attributes['class'] : '';
-        unset($attributes['class']);
-
-        $data->attributes = array_map(function($key, $value) {
-            return [
-                'name' => $key,
-                'value' => $value
-            ];
-        }, array_keys($attributes), $attributes);
-
-        $data->actions = array_map(function($action) use ($output) {
-            return $action->export_for_template($output);
-        }, !empty($this->actions) ? $this->actions : []);
-        $data->hasactions = !empty($this->actions);
-
-        return $data;
-    }
-}
-
-/**
- * Simple html output class
- *
- * @copyright 2009 Tim Hunt, 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class html_writer {
-
-    /**
-     * Outputs a tag with attributes and contents
-     *
-     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
-     * @param string $contents What goes between the opening and closing tags
-     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
-     * @return string HTML fragment
-     */
-    public static function tag($tagname, $contents, array $attributes = null) {
-        return self::start_tag($tagname, $attributes) . $contents . self::end_tag($tagname);
-    }
-
-    /**
-     * Outputs an opening tag with attributes
-     *
-     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
-     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
-     * @return string HTML fragment
-     */
-    public static function start_tag($tagname, array $attributes = null) {
-        return '<' . $tagname . self::attributes($attributes) . '>';
-    }
-
-    /**
-     * Outputs a closing tag
-     *
-     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
-     * @return string HTML fragment
-     */
-    public static function end_tag($tagname) {
-        return '</' . $tagname . '>';
-    }
-
-    /**
-     * Outputs an empty tag with attributes
-     *
-     * @param string $tagname The name of tag ('input', 'img', 'br' etc.)
-     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
-     * @return string HTML fragment
-     */
-    public static function empty_tag($tagname, array $attributes = null) {
-        return '<' . $tagname . self::attributes($attributes) . ' />';
-    }
-
-    /**
-     * Outputs a tag, but only if the contents are not empty
-     *
-     * @param string $tagname The name of tag ('a', 'img', 'span' etc.)
-     * @param string $contents What goes between the opening and closing tags
-     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
-     * @return string HTML fragment
-     */
-    public static function nonempty_tag($tagname, $contents, array $attributes = null) {
-        if ($contents === '' || is_null($contents)) {
-            return '';
-        }
-        return self::tag($tagname, $contents, $attributes);
-    }
-
-    /**
-     * Outputs a HTML attribute and value
-     *
-     * @param string $name The name of the attribute ('src', 'href', 'class' etc.)
-     * @param string $value The value of the attribute. The value will be escaped with {@link s()}
-     * @return string HTML fragment
-     */
-    public static function attribute($name, $value) {
-        if ($value instanceof moodle_url) {
-            return ' ' . $name . '="' . $value->out() . '"';
-        }
-
-        // special case, we do not want these in output
-        if ($value === null) {
-            return '';
-        }
-
-        // no sloppy trimming here!
-        return ' ' . $name . '="' . s($value) . '"';
-    }
-
-    /**
-     * Outputs a list of HTML attributes and values
-     *
-     * @param array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
-     *       The values will be escaped with {@link s()}
-     * @return string HTML fragment
-     */
-    public static function attributes(array $attributes = null) {
-        $attributes = (array)$attributes;
-        $output = '';
-        foreach ($attributes as $name => $value) {
-            $output .= self::attribute($name, $value);
-        }
-        return $output;
-    }
-
-    /**
-     * Generates a simple image tag with attributes.
-     *
-     * @param string $src The source of image
-     * @param string $alt The alternate text for image
-     * @param array $attributes The tag attributes (array('height' => $max_height, 'class' => 'class1') etc.)
-     * @return string HTML fragment
-     */
-    public static function img($src, $alt, array $attributes = null) {
-        $attributes = (array)$attributes;
-        $attributes['src'] = $src;
-        // In case a null alt text is provided, set it to an empty string.
-        $attributes['alt'] = $alt ?? '';
-        if (array_key_exists('role', $attributes) && core_text::strtolower($attributes['role']) === 'presentation') {
-            // A presentation role is not necessary for the img tag.
-            // If a non-empty alt text is provided, the presentation role will conflict with the alt text.
-            // An empty alt text denotes a decorative image. The presence of a presentation role is redundant.
-            unset($attributes['role']);
-            debugging('The presentation role is not necessary for an img tag.', DEBUG_DEVELOPER);
-        }
-
-        return self::empty_tag('img', $attributes);
-    }
-
-    /**
-     * Generates random html element id.
-     *
-     * @staticvar int $counter
-     * @staticvar string $uniq
-     * @param string $base A string fragment that will be included in the random ID.
-     * @return string A unique ID
-     */
-    public static function random_id($base='random') {
-        static $counter = 0;
-        static $uniq;
-
-        if (!isset($uniq)) {
-            $uniq = uniqid();
-        }
-
-        $counter++;
-        return $base.$uniq.$counter;
-    }
-
-    /**
-     * Generates a simple html link
-     *
-     * @param string|moodle_url $url The URL
-     * @param string $text The text
-     * @param array $attributes HTML attributes
-     * @return string HTML fragment
-     */
-    public static function link($url, $text, array $attributes = null) {
-        $attributes = (array)$attributes;
-        $attributes['href']  = $url;
-        return self::tag('a', $text, $attributes);
-    }
-
-    /**
-     * Generates a simple checkbox with optional label
-     *
-     * @param string $name The name of the checkbox
-     * @param string $value The value of the checkbox
-     * @param bool $checked Whether the checkbox is checked
-     * @param string $label The label for the checkbox
-     * @param array $attributes Any attributes to apply to the checkbox
-     * @param array $labelattributes Any attributes to apply to the label, if present
-     * @return string html fragment
-     */
-    public static function checkbox($name, $value, $checked = true, $label = '',
-        array $attributes = null, array $labelattributes = null) {
-        $attributes = (array) $attributes;
-        $output = '';
-
-        if ($label !== '' and !is_null($label)) {
-            if (empty($attributes['id'])) {
-                $attributes['id'] = self::random_id('checkbox_');
-            }
-        }
-        $attributes['type']    = 'checkbox';
-        $attributes['value']   = $value;
-        $attributes['name']    = $name;
-        $attributes['checked'] = $checked ? 'checked' : null;
-
-        $output .= self::empty_tag('input', $attributes);
-
-        if ($label !== '' and !is_null($label)) {
-            $labelattributes = (array) $labelattributes;
-            $labelattributes['for'] = $attributes['id'];
-            $output .= self::tag('label', $label, $labelattributes);
-        }
-
-        return $output;
-    }
-
-    /**
-     * Generates a simple select yes/no form field
-     *
-     * @param string $name name of select element
-     * @param bool $selected
-     * @param array $attributes - html select element attributes
-     * @return string HTML fragment
-     */
-    public static function select_yes_no($name, $selected=true, array $attributes = null) {
-        $options = array('1'=>get_string('yes'), '0'=>get_string('no'));
-        return self::select($options, $name, $selected, null, $attributes);
-    }
-
-    /**
-     * Generates a simple select form field
-     *
-     * Note this function does HTML escaping on the optgroup labels, but not on the choice labels.
-     *
-     * @param array $options associative array value=>label ex.:
-     *                array(1=>'One, 2=>Two)
-     *              it is also possible to specify optgroup as complex label array ex.:
-     *                array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
-     *                array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
-     * @param string $name name of select element
-     * @param string|array $selected value or array of values depending on multiple attribute
-     * @param array|bool|null $nothing add nothing selected option, or false of not added
-     * @param array $attributes html select element attributes
-     * @return string HTML fragment
-     */
-    public static function select(array $options, $name, $selected = '', $nothing = array('' => 'choosedots'), array $attributes = null) {
-        $attributes = (array)$attributes;
-        if (is_array($nothing)) {
-            foreach ($nothing as $k=>$v) {
-                if ($v === 'choose' or $v === 'choosedots') {
-                    $nothing[$k] = get_string('choosedots');
-                }
-            }
-            $options = $nothing + $options; // keep keys, do not override
-
-        } else if (is_string($nothing) and $nothing !== '') {
-            // BC
-            $options = array(''=>$nothing) + $options;
-        }
-
-        // we may accept more values if multiple attribute specified
-        $selected = (array)$selected;
-        foreach ($selected as $k=>$v) {
-            $selected[$k] = (string)$v;
-        }
-
-        if (!isset($attributes['id'])) {
-            $id = 'menu'.$name;
-            // name may contaion [], which would make an invalid id. e.g. numeric question type editing form, assignment quickgrading
-            $id = str_replace('[', '', $id);
-            $id = str_replace(']', '', $id);
-            $attributes['id'] = $id;
-        }
-
-        if (!isset($attributes['class'])) {
-            $class = 'menu'.$name;
-            // name may contaion [], which would make an invalid class. e.g. numeric question type editing form, assignment quickgrading
-            $class = str_replace('[', '', $class);
-            $class = str_replace(']', '', $class);
-            $attributes['class'] = $class;
-        }
-        $attributes['class'] = 'select custom-select ' . $attributes['class']; // Add 'select' selector always.
-
-        $attributes['name'] = $name;
-
-        if (!empty($attributes['disabled'])) {
-            $attributes['disabled'] = 'disabled';
-        } else {
-            unset($attributes['disabled']);
-        }
-
-        $output = '';
-        foreach ($options as $value=>$label) {
-            if (is_array($label)) {
-                // ignore key, it just has to be unique
-                $output .= self::select_optgroup(key($label), current($label), $selected);
-            } else {
-                $output .= self::select_option($label, $value, $selected);
-            }
-        }
-        return self::tag('select', $output, $attributes);
-    }
-
-    /**
-     * Returns HTML to display a select box option.
-     *
-     * @param string $label The label to display as the option.
-     * @param string|int $value The value the option represents
-     * @param array $selected An array of selected options
-     * @return string HTML fragment
-     */
-    private static function select_option($label, $value, array $selected) {
-        $attributes = array();
-        $value = (string)$value;
-        if (in_array($value, $selected, true)) {
-            $attributes['selected'] = 'selected';
-        }
-        $attributes['value'] = $value;
-        return self::tag('option', $label, $attributes);
-    }
-
-    /**
-     * Returns HTML to display a select box option group.
-     *
-     * @param string $groupname The label to use for the group
-     * @param array $options The options in the group
-     * @param array $selected An array of selected values.
-     * @return string HTML fragment.
-     */
-    private static function select_optgroup($groupname, $options, array $selected) {
-        if (empty($options)) {
-            return '';
-        }
-        $attributes = array('label'=>$groupname);
-        $output = '';
-        foreach ($options as $value=>$label) {
-            $output .= self::select_option($label, $value, $selected);
-        }
-        return self::tag('optgroup', $output, $attributes);
-    }
-
-    /**
-     * This is a shortcut for making an hour selector menu.
-     *
-     * @param string $type The type of selector (years, months, days, hours, minutes)
-     * @param string $name fieldname
-     * @param int $currenttime A default timestamp in GMT
-     * @param int $step minute spacing
-     * @param array $attributes - html select element attributes
-     * @param float|int|string $timezone the timezone to use to calculate the time
-     *        {@link https://moodledev.io/docs/apis/subsystems/time#timezone}
-     * @return string HTML fragment
-     */
-    public static function select_time($type, $name, $currenttime = 0, $step = 5, array $attributes = null, $timezone = 99) {
-        global $OUTPUT;
-
-        if (!$currenttime) {
-            $currenttime = time();
-        }
-        $calendartype = \core_calendar\type_factory::get_calendar_instance();
-        $currentdate = $calendartype->timestamp_to_date_array($currenttime, $timezone);
-
-        $userdatetype = $type;
-        $timeunits = array();
-
-        switch ($type) {
-            case 'years':
-                $timeunits = $calendartype->get_years();
-                $userdatetype = 'year';
-                break;
-            case 'months':
-                $timeunits = $calendartype->get_months();
-                $userdatetype = 'month';
-                $currentdate['month'] = (int)$currentdate['mon'];
-                break;
-            case 'days':
-                $timeunits = $calendartype->get_days();
-                $userdatetype = 'mday';
-                break;
-            case 'hours':
-                for ($i=0; $i<=23; $i++) {
-                    $timeunits[$i] = sprintf("%02d",$i);
-                }
-                break;
-            case 'minutes':
-                if ($step != 1) {
-                    $currentdate['minutes'] = ceil($currentdate['minutes']/$step)*$step;
-                }
-
-                for ($i=0; $i<=59; $i+=$step) {
-                    $timeunits[$i] = sprintf("%02d",$i);
-                }
-                break;
-            default:
-                throw new coding_exception("Time type $type is not supported by html_writer::select_time().");
-        }
-
-        $attributes = (array) $attributes;
-        $data = (object) [
-            'name' => $name,
-            'id' => !empty($attributes['id']) ? $attributes['id'] : self::random_id('ts_'),
-            'label' => get_string(substr($type, 0, -1), 'form'),
-            'options' => array_map(function($value) use ($timeunits, $currentdate, $userdatetype) {
-                return [
-                    'name' => $timeunits[$value],
-                    'value' => $value,
-                    'selected' => $currentdate[$userdatetype] == $value
-                ];
-            }, array_keys($timeunits)),
-        ];
-
-        unset($attributes['id']);
-        unset($attributes['name']);
-        $data->attributes = array_map(function($name) use ($attributes) {
-            return [
-                'name' => $name,
-                'value' => $attributes[$name]
-            ];
-        }, array_keys($attributes));
-
-        return $OUTPUT->render_from_template('core/select_time', $data);
-    }
-
-    /**
-     * Shortcut for quick making of lists
-     *
-     * Note: 'list' is a reserved keyword ;-)
-     *
-     * @param array $items
-     * @param array $attributes
-     * @param string $tag ul or ol
-     * @return string
-     */
-    public static function alist(array $items, array $attributes = null, $tag = 'ul') {
-        $output = html_writer::start_tag($tag, $attributes)."\n";
-        foreach ($items as $item) {
-            $output .= html_writer::tag('li', $item)."\n";
-        }
-        $output .= html_writer::end_tag($tag);
-        return $output;
-    }
-
-    /**
-     * Returns hidden input fields created from url parameters.
-     *
-     * @param moodle_url $url
-     * @param array $exclude list of excluded parameters
-     * @return string HTML fragment
-     */
-    public static function input_hidden_params(moodle_url $url, array $exclude = null) {
-        $exclude = (array)$exclude;
-        $params = $url->params();
-        foreach ($exclude as $key) {
-            unset($params[$key]);
-        }
-
-        $output = '';
-        foreach ($params as $key => $value) {
-            $attributes = array('type'=>'hidden', 'name'=>$key, 'value'=>$value);
-            $output .= self::empty_tag('input', $attributes)."\n";
-        }
-        return $output;
-    }
-
-    /**
-     * Generate a script tag containing the the specified code.
-     *
-     * @param string $jscode the JavaScript code
-     * @param moodle_url|string $url optional url of the external script, $code ignored if specified
-     * @return string HTML, the code wrapped in <script> tags.
-     */
-    public static function script($jscode, $url=null) {
-        if ($jscode) {
-            return self::tag('script', "\n//<![CDATA[\n$jscode\n//]]>\n") . "\n";
-
-        } else if ($url) {
-            return self::tag('script', '', ['src' => $url]) . "\n";
-
-        } else {
-            return '';
-        }
-    }
-
-    /**
-     * Renders HTML table
-     *
-     * This method may modify the passed instance by adding some default properties if they are not set yet.
-     * If this is not what you want, you should make a full clone of your data before passing them to this
-     * method. In most cases this is not an issue at all so we do not clone by default for performance
-     * and memory consumption reasons.
-     *
-     * @param html_table $table data to be rendered
-     * @return string HTML code
-     */
-    public static function table(html_table $table) {
-        // prepare table data and populate missing properties with reasonable defaults
-        if (!empty($table->align)) {
-            foreach ($table->align as $key => $aa) {
-                if ($aa) {
-                    $table->align[$key] = 'text-align:'. fix_align_rtl($aa) .';';  // Fix for RTL languages
-                } else {
-                    $table->align[$key] = null;
-                }
-            }
-        }
-        if (!empty($table->size)) {
-            foreach ($table->size as $key => $ss) {
-                if ($ss) {
-                    $table->size[$key] = 'width:'. $ss .';';
-                } else {
-                    $table->size[$key] = null;
-                }
-            }
-        }
-        if (!empty($table->wrap)) {
-            foreach ($table->wrap as $key => $ww) {
-                if ($ww) {
-                    $table->wrap[$key] = 'white-space:nowrap;';
-                } else {
-                    $table->wrap[$key] = '';
-                }
-            }
-        }
-        if (!empty($table->head)) {
-            foreach ($table->head as $key => $val) {
-                if (!isset($table->align[$key])) {
-                    $table->align[$key] = null;
-                }
-                if (!isset($table->size[$key])) {
-                    $table->size[$key] = null;
-                }
-                if (!isset($table->wrap[$key])) {
-                    $table->wrap[$key] = null;
-                }
-
-            }
-        }
-        if (empty($table->attributes['class'])) {
-            $table->attributes['class'] = 'generaltable';
-        }
-        if (!empty($table->tablealign)) {
-            $table->attributes['class'] .= ' boxalign' . $table->tablealign;
-        }
-
-        // explicitly assigned properties override those defined via $table->attributes
-        $table->attributes['class'] = trim($table->attributes['class']);
-        $attributes = array_merge($table->attributes, array(
-            'id'            => $table->id,
-            'width'         => $table->width,
-            'summary'       => $table->summary,
-            'cellpadding'   => $table->cellpadding,
-            'cellspacing'   => $table->cellspacing,
-        ));
-        $output = html_writer::start_tag('table', $attributes) . "\n";
-
-        $countcols = 0;
-
-        // Output a caption if present.
-        if (!empty($table->caption)) {
-            $captionattributes = array();
-            if ($table->captionhide) {
-                $captionattributes['class'] = 'accesshide';
-            }
-            $output .= html_writer::tag(
-                'caption',
-                $table->caption,
-                $captionattributes
-            );
-        }
-
-        if (!empty($table->head)) {
-            $countcols = count($table->head);
-
-            $output .= html_writer::start_tag('thead', array()) . "\n";
-            $output .= html_writer::start_tag('tr', array()) . "\n";
-            $keys = array_keys($table->head);
-            $lastkey = end($keys);
-
-            foreach ($table->head as $key => $heading) {
-                // Convert plain string headings into html_table_cell objects
-                if (!($heading instanceof html_table_cell)) {
-                    $headingtext = $heading;
-                    $heading = new html_table_cell();
-                    $heading->text = $headingtext;
-                    $heading->header = true;
-                }
-
-                if ($heading->header !== false) {
-                    $heading->header = true;
-                }
-
-                $tagtype = 'td';
-                if ($heading->header && (string)$heading->text != '') {
-                    $tagtype = 'th';
-                }
-
-                $heading->attributes['class'] .= ' header c' . $key;
-                if (isset($table->headspan[$key]) && $table->headspan[$key] > 1) {
-                    $heading->colspan = $table->headspan[$key];
-                    $countcols += $table->headspan[$key] - 1;
-                }
-
-                if ($key == $lastkey) {
-                    $heading->attributes['class'] .= ' lastcol';
-                }
-                if (isset($table->colclasses[$key])) {
-                    $heading->attributes['class'] .= ' ' . $table->colclasses[$key];
-                }
-                $heading->attributes['class'] = trim($heading->attributes['class']);
-                $attributes = array_merge($heading->attributes, [
-                    'style'     => $table->align[$key] . $table->size[$key] . $heading->style,
-                    'colspan'   => $heading->colspan,
-                ]);
-
-                if ($tagtype == 'th') {
-                    $attributes['scope'] = !empty($heading->scope) ? $heading->scope : 'col';
-                }
-
-                $output .= html_writer::tag($tagtype, $heading->text, $attributes) . "\n";
-            }
-            $output .= html_writer::end_tag('tr') . "\n";
-            $output .= html_writer::end_tag('thead') . "\n";
-
-            if (empty($table->data)) {
-                // For valid XHTML strict every table must contain either a valid tr
-                // or a valid tbody... both of which must contain a valid td
-                $output .= html_writer::start_tag('tbody', array('class' => 'empty'));
-                $output .= html_writer::tag('tr', html_writer::tag('td', '', array('colspan'=>count($table->head))));
-                $output .= html_writer::end_tag('tbody');
-            }
-        }
-
-        if (!empty($table->data)) {
-            $keys       = array_keys($table->data);
-            $lastrowkey = end($keys);
-            $output .= html_writer::start_tag('tbody', array());
-
-            foreach ($table->data as $key => $row) {
-                if (($row === 'hr') && ($countcols)) {
-                    $output .= html_writer::tag('td', html_writer::tag('div', '', array('class' => 'tabledivider')), array('colspan' => $countcols));
-                } else {
-                    // Convert array rows to html_table_rows and cell strings to html_table_cell objects
-                    if (!($row instanceof html_table_row)) {
-                        $newrow = new html_table_row();
-
-                        foreach ($row as $cell) {
-                            if (!($cell instanceof html_table_cell)) {
-                                $cell = new html_table_cell($cell);
-                            }
-                            $newrow->cells[] = $cell;
-                        }
-                        $row = $newrow;
-                    }
-
-                    if (isset($table->rowclasses[$key])) {
-                        $row->attributes['class'] .= ' ' . $table->rowclasses[$key];
-                    }
-
-                    if ($key == $lastrowkey) {
-                        $row->attributes['class'] .= ' lastrow';
-                    }
-
-                    // Explicitly assigned properties should override those defined in the attributes.
-                    $row->attributes['class'] = trim($row->attributes['class']);
-                    $trattributes = array_merge($row->attributes, array(
-                        'id'            => $row->id,
-                        'style'         => $row->style,
-                    ));
-                    $output .= html_writer::start_tag('tr', $trattributes) . "\n";
-                    $keys2 = array_keys($row->cells);
-                    $lastkey = end($keys2);
-
-                    $gotlastkey = false; //flag for sanity checking
-                    foreach ($row->cells as $key => $cell) {
-                        if ($gotlastkey) {
-                            //This should never happen. Why do we have a cell after the last cell?
-                            mtrace("A cell with key ($key) was found after the last key ($lastkey)");
-                        }
-
-                        if (!($cell instanceof html_table_cell)) {
-                            $mycell = new html_table_cell();
-                            $mycell->text = $cell;
-                            $cell = $mycell;
-                        }
-
-                        if (($cell->header === true) && empty($cell->scope)) {
-                            $cell->scope = 'row';
-                        }
-
-                        if (isset($table->colclasses[$key])) {
-                            $cell->attributes['class'] .= ' ' . $table->colclasses[$key];
-                        }
-
-                        $cell->attributes['class'] .= ' cell c' . $key;
-                        if ($key == $lastkey) {
-                            $cell->attributes['class'] .= ' lastcol';
-                            $gotlastkey = true;
-                        }
-                        $tdstyle = '';
-                        $tdstyle .= isset($table->align[$key]) ? $table->align[$key] : '';
-                        $tdstyle .= isset($table->size[$key]) ? $table->size[$key] : '';
-                        $tdstyle .= isset($table->wrap[$key]) ? $table->wrap[$key] : '';
-                        $cell->attributes['class'] = trim($cell->attributes['class']);
-                        $tdattributes = array_merge($cell->attributes, array(
-                            'style' => $tdstyle . $cell->style,
-                            'colspan' => $cell->colspan,
-                            'rowspan' => $cell->rowspan,
-                            'id' => $cell->id,
-                            'abbr' => $cell->abbr,
-                            'scope' => $cell->scope,
-                        ));
-                        $tagtype = 'td';
-                        if ($cell->header === true) {
-                            $tagtype = 'th';
-                        }
-                        $output .= html_writer::tag($tagtype, $cell->text, $tdattributes) . "\n";
-                    }
-                }
-                $output .= html_writer::end_tag('tr') . "\n";
-            }
-            $output .= html_writer::end_tag('tbody') . "\n";
-        }
-        $output .= html_writer::end_tag('table') . "\n";
-
-        if ($table->responsive) {
-            return self::div($output, 'table-responsive');
-        }
-
-        return $output;
-    }
-
-    /**
-     * Renders form element label
-     *
-     * By default, the label is suffixed with a label separator defined in the
-     * current language pack (colon by default in the English lang pack).
-     * Adding the colon can be explicitly disabled if needed. Label separators
-     * are put outside the label tag itself so they are not read by
-     * screenreaders (accessibility).
-     *
-     * Parameter $for explicitly associates the label with a form control. When
-     * set, the value of this attribute must be the same as the value of
-     * the id attribute of the form control in the same document. When null,
-     * the label being defined is associated with the control inside the label
-     * element.
-     *
-     * @param string $text content of the label tag
-     * @param string|null $for id of the element this label is associated with, null for no association
-     * @param bool $colonize add label separator (colon) to the label text, if it is not there yet
-     * @param array $attributes to be inserted in the tab, for example array('accesskey' => 'a')
-     * @return string HTML of the label element
-     */
-    public static function label($text, $for, $colonize = true, array $attributes=array()) {
-        if (!is_null($for)) {
-            $attributes = array_merge($attributes, array('for' => $for));
-        }
-        $text = trim($text ?? '');
-        $label = self::tag('label', $text, $attributes);
-
-        // TODO MDL-12192 $colonize disabled for now yet
-        // if (!empty($text) and $colonize) {
-        //     // the $text may end with the colon already, though it is bad string definition style
-        //     $colon = get_string('labelsep', 'langconfig');
-        //     if (!empty($colon)) {
-        //         $trimmed = trim($colon);
-        //         if ((substr($text, -strlen($trimmed)) == $trimmed) or (substr($text, -1) == ':')) {
-        //             //debugging('The label text should not end with colon or other label separator,
-        //             //           please fix the string definition.', DEBUG_DEVELOPER);
-        //         } else {
-        //             $label .= $colon;
-        //         }
-        //     }
-        // }
-
-        return $label;
-    }
-
-    /**
-     * Combines a class parameter with other attributes. Aids in code reduction
-     * because the class parameter is very frequently used.
-     *
-     * If the class attribute is specified both in the attributes and in the
-     * class parameter, the two values are combined with a space between.
-     *
-     * @param string $class Optional CSS class (or classes as space-separated list)
-     * @param array $attributes Optional other attributes as array
-     * @return array Attributes (or null if still none)
-     */
-    private static function add_class($class = '', array $attributes = null) {
-        if ($class !== '') {
-            $classattribute = array('class' => $class);
-            if ($attributes) {
-                if (array_key_exists('class', $attributes)) {
-                    $attributes['class'] = trim($attributes['class'] . ' ' . $class);
-                } else {
-                    $attributes = $classattribute + $attributes;
-                }
-            } else {
-                $attributes = $classattribute;
-            }
-        }
-        return $attributes;
-    }
-
-    /**
-     * Creates a <div> tag. (Shortcut function.)
-     *
-     * @param string $content HTML content of tag
-     * @param string $class Optional CSS class (or classes as space-separated list)
-     * @param array $attributes Optional other attributes as array
-     * @return string HTML code for div
-     */
-    public static function div($content, $class = '', array $attributes = null) {
-        return self::tag('div', $content, self::add_class($class, $attributes));
-    }
-
-    /**
-     * Starts a <div> tag. (Shortcut function.)
-     *
-     * @param string $class Optional CSS class (or classes as space-separated list)
-     * @param array $attributes Optional other attributes as array
-     * @return string HTML code for open div tag
-     */
-    public static function start_div($class = '', array $attributes = null) {
-        return self::start_tag('div', self::add_class($class, $attributes));
-    }
-
-    /**
-     * Ends a <div> tag. (Shortcut function.)
-     *
-     * @return string HTML code for close div tag
-     */
-    public static function end_div() {
-        return self::end_tag('div');
-    }
-
-    /**
-     * Creates a <span> tag. (Shortcut function.)
-     *
-     * @param string $content HTML content of tag
-     * @param string $class Optional CSS class (or classes as space-separated list)
-     * @param array $attributes Optional other attributes as array
-     * @return string HTML code for span
-     */
-    public static function span($content, $class = '', array $attributes = null) {
-        return self::tag('span', $content, self::add_class($class, $attributes));
-    }
-
-    /**
-     * Starts a <span> tag. (Shortcut function.)
-     *
-     * @param string $class Optional CSS class (or classes as space-separated list)
-     * @param array $attributes Optional other attributes as array
-     * @return string HTML code for open span tag
-     */
-    public static function start_span($class = '', array $attributes = null) {
-        return self::start_tag('span', self::add_class($class, $attributes));
-    }
-
-    /**
-     * Ends a <span> tag. (Shortcut function.)
-     *
-     * @return string HTML code for close span tag
-     */
-    public static function end_span() {
-        return self::end_tag('span');
-    }
-}
-
-/**
- * Simple javascript output class
- *
- * @copyright 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class js_writer {
-
-    /**
-     * Returns javascript code calling the function
-     *
-     * @param string $function function name, can be complex like Y.Event.purgeElement
-     * @param array $arguments parameters
-     * @param int $delay execution delay in seconds
-     * @return string JS code fragment
-     */
-    public static function function_call($function, array $arguments = null, $delay=0) {
-        if ($arguments) {
-            $arguments = array_map('json_encode', convert_to_array($arguments));
-            $arguments = implode(', ', $arguments);
-        } else {
-            $arguments = '';
-        }
-        $js = "$function($arguments);";
-
-        if ($delay) {
-            $delay = $delay * 1000; // in miliseconds
-            $js = "setTimeout(function() { $js }, $delay);";
-        }
-        return $js . "\n";
-    }
-
-    /**
-     * Special function which adds Y as first argument of function call.
-     *
-     * @param string $function The function to call
-     * @param array $extraarguments Any arguments to pass to it
-     * @return string Some JS code
-     */
-    public static function function_call_with_Y($function, array $extraarguments = null) {
-        if ($extraarguments) {
-            $extraarguments = array_map('json_encode', convert_to_array($extraarguments));
-            $arguments = 'Y, ' . implode(', ', $extraarguments);
-        } else {
-            $arguments = 'Y';
-        }
-        return "$function($arguments);\n";
-    }
-
-    /**
-     * Returns JavaScript code to initialise a new object
-     *
-     * @param string $var If it is null then no var is assigned the new object.
-     * @param string $class The class to initialise an object for.
-     * @param array $arguments An array of args to pass to the init method.
-     * @param array $requirements Any modules required for this class.
-     * @param int $delay The delay before initialisation. 0 = no delay.
-     * @return string Some JS code
-     */
-    public static function object_init($var, $class, array $arguments = null, array $requirements = null, $delay=0) {
-        if (is_array($arguments)) {
-            $arguments = array_map('json_encode', convert_to_array($arguments));
-            $arguments = implode(', ', $arguments);
-        }
-
-        if ($var === null) {
-            $js = "new $class(Y, $arguments);";
-        } else if (strpos($var, '.')!==false) {
-            $js = "$var = new $class(Y, $arguments);";
-        } else {
-            $js = "var $var = new $class(Y, $arguments);";
-        }
-
-        if ($delay) {
-            $delay = $delay * 1000; // in miliseconds
-            $js = "setTimeout(function() { $js }, $delay);";
-        }
-
-        if (count($requirements) > 0) {
-            $requirements = implode("', '", $requirements);
-            $js = "Y.use('$requirements', function(Y){ $js });";
-        }
-        return $js."\n";
-    }
-
-    /**
-     * Returns code setting value to variable
-     *
-     * @param string $name
-     * @param mixed $value json serialised value
-     * @param bool $usevar add var definition, ignored for nested properties
-     * @return string JS code fragment
-     */
-    public static function set_variable($name, $value, $usevar = true) {
-        $output = '';
-
-        if ($usevar) {
-            if (strpos($name, '.')) {
-                $output .= '';
-            } else {
-                $output .= 'var ';
-            }
-        }
-
-        $output .= "$name = ".json_encode($value).";";
-
-        return $output;
-    }
-
-    /**
-     * Writes event handler attaching code
-     *
-     * @param array|string $selector standard YUI selector for elements, may be
-     *     array or string, element id is in the form "#idvalue"
-     * @param string $event A valid DOM event (click, mousedown, change etc.)
-     * @param string $function The name of the function to call
-     * @param array $arguments An optional array of argument parameters to pass to the function
-     * @return string JS code fragment
-     */
-    public static function event_handler($selector, $event, $function, array $arguments = null) {
-        $selector = json_encode($selector);
-        $output = "Y.on('$event', $function, $selector, null";
-        if (!empty($arguments)) {
-            $output .= ', ' . json_encode($arguments);
-        }
-        return $output . ");\n";
-    }
-}
-
-/**
- * Holds all the information required to render a <table> by {@link core_renderer::table()}
- *
- * Example of usage:
- * $t = new html_table();
- * ... // set various properties of the object $t as described below
- * echo html_writer::table($t);
- *
- * @copyright 2009 David Mudrak <david.mudrak@gmail.com>
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class html_table {
-
-    /**
-     * @var string Value to use for the id attribute of the table
-     */
-    public $id = null;
-
-    /**
-     * @var array Attributes of HTML attributes for the <table> element
-     */
-    public $attributes = array();
-
-    /**
-     * @var array An array of headings. The n-th array item is used as a heading of the n-th column.
-     * For more control over the rendering of the headers, an array of html_table_cell objects
-     * can be passed instead of an array of strings.
-     *
-     * Example of usage:
-     * $t->head = array('Student', 'Grade');
-     */
-    public $head;
-
-    /**
-     * @var array An array that can be used to make a heading span multiple columns.
-     * In this example, {@link html_table:$data} is supposed to have three columns. For the first two columns,
-     * the same heading is used. Therefore, {@link html_table::$head} should consist of two items.
-     *
-     * Example of usage:
-     * $t->headspan = array(2,1);
-     */
-    public $headspan;
-
-    /**
-     * @var array An array of column alignments.
-     * The value is used as CSS 'text-align' property. Therefore, possible
-     * values are 'left', 'right', 'center' and 'justify'. Specify 'right' or 'left' from the perspective
-     * of a left-to-right (LTR) language. For RTL, the values are flipped automatically.
-     *
-     * Examples of usage:
-     * $t->align = array(null, 'right');
-     * or
-     * $t->align[1] = 'right';
-     */
-    public $align;
-
-    /**
-     * @var array The value is used as CSS 'size' property.
-     *
-     * Examples of usage:
-     * $t->size = array('50%', '50%');
-     * or
-     * $t->size[1] = '120px';
-     */
-    public $size;
-
-    /**
-     * @var array An array of wrapping information.
-     * The only possible value is 'nowrap' that sets the
-     * CSS property 'white-space' to the value 'nowrap' in the given column.
-     *
-     * Example of usage:
-     * $t->wrap = array(null, 'nowrap');
-     */
-    public $wrap;
-
-    /**
-     * @var array Array of arrays or html_table_row objects containing the data. Alternatively, if you have
-     * $head specified, the string 'hr' (for horizontal ruler) can be used
-     * instead of an array of cells data resulting in a divider rendered.
-     *
-     * Example of usage with array of arrays:
-     * $row1 = array('Harry Potter', '76 %');
-     * $row2 = array('Hermione Granger', '100 %');
-     * $t->data = array($row1, $row2);
-     *
-     * Example with array of html_table_row objects: (used for more fine-grained control)
-     * $cell1 = new html_table_cell();
-     * $cell1->text = 'Harry Potter';
-     * $cell1->colspan = 2;
-     * $row1 = new html_table_row();
-     * $row1->cells[] = $cell1;
-     * $cell2 = new html_table_cell();
-     * $cell2->text = 'Hermione Granger';
-     * $cell3 = new html_table_cell();
-     * $cell3->text = '100 %';
-     * $row2 = new html_table_row();
-     * $row2->cells = array($cell2, $cell3);
-     * $t->data = array($row1, $row2);
-     */
-    public $data = [];
-
-    /**
-     * @deprecated since Moodle 2.0. Styling should be in the CSS.
-     * @var string Width of the table, percentage of the page preferred.
-     */
-    public $width = null;
-
-    /**
-     * @deprecated since Moodle 2.0. Styling should be in the CSS.
-     * @var string Alignment for the whole table. Can be 'right', 'left' or 'center' (default).
-     */
-    public $tablealign = null;
-
-    /**
-     * @deprecated since Moodle 2.0. Styling should be in the CSS.
-     * @var int Padding on each cell, in pixels
-     */
-    public $cellpadding = null;
-
-    /**
-     * @var int Spacing between cells, in pixels
-     * @deprecated since Moodle 2.0. Styling should be in the CSS.
-     */
-    public $cellspacing = null;
-
-    /**
-     * @var array Array of classes to add to particular rows, space-separated string.
-     * Class 'lastrow' is added automatically for the last row in the table.
-     *
-     * Example of usage:
-     * $t->rowclasses[9] = 'tenth'
-     */
-    public $rowclasses;
-
-    /**
-     * @var array An array of classes to add to every cell in a particular column,
-     * space-separated string. Class 'cell' is added automatically by the renderer.
-     * Classes 'c0' or 'c1' are added automatically for every odd or even column,
-     * respectively. Class 'lastcol' is added automatically for all last cells
-     * in a row.
-     *
-     * Example of usage:
-     * $t->colclasses = array(null, 'grade');
-     */
-    public $colclasses;
-
-    /**
-     * @var string Description of the contents for screen readers.
-     *
-     * The "summary" attribute on the "table" element is not supported in HTML5.
-     * Consider describing the structure of the table in a "caption" element or in a "figure" element containing the table;
-     * or, simplify the structure of the table so that no description is needed.
-     *
-     * @deprecated since Moodle 3.9.
-     */
-    public $summary;
-
-    /**
-     * @var string Caption for the table, typically a title.
-     *
-     * Example of usage:
-     * $t->caption = "TV Guide";
-     */
-    public $caption;
-
-    /**
-     * @var bool Whether to hide the table's caption from sighted users.
-     *
-     * Example of usage:
-     * $t->caption = "TV Guide";
-     * $t->captionhide = true;
-     */
-    public $captionhide = false;
-
-    /** @var bool Whether to make the table to be scrolled horizontally with ease. Make table responsive across all viewports. */
-    public $responsive = true;
-
-    /** @var string class name to add to this html table. */
-    public $class;
-
-    /**
-     * Constructor
-     */
-    public function __construct() {
-        $this->attributes['class'] = '';
-    }
-}
-
-/**
- * Component representing a table row.
- *
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class html_table_row {
-
-    /**
-     * @var string Value to use for the id attribute of the row.
-     */
-    public $id = null;
-
-    /**
-     * @var array Array of html_table_cell objects
-     */
-    public $cells = array();
-
-    /**
-     * @var string Value to use for the style attribute of the table row
-     */
-    public $style = null;
-
-    /**
-     * @var array Attributes of additional HTML attributes for the <tr> element
-     */
-    public $attributes = array();
-
-    /**
-     * Constructor
-     * @param array $cells
-     */
-    public function __construct(array $cells=null) {
-        $this->attributes['class'] = '';
-        $cells = (array)$cells;
-        foreach ($cells as $cell) {
-            if ($cell instanceof html_table_cell) {
-                $this->cells[] = $cell;
-            } else {
-                $this->cells[] = new html_table_cell($cell);
-            }
-        }
-    }
-}
-
-/**
- * Component representing a table cell.
- *
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class html_table_cell {
-
-    /**
-     * @var string Value to use for the id attribute of the cell.
-     */
-    public $id = null;
-
-    /**
-     * @var string The contents of the cell.
-     */
-    public $text;
-
-    /**
-     * @var string Abbreviated version of the contents of the cell.
-     */
-    public $abbr = null;
-
-    /**
-     * @var int Number of columns this cell should span.
-     */
-    public $colspan = null;
-
-    /**
-     * @var int Number of rows this cell should span.
-     */
-    public $rowspan = null;
-
-    /**
-     * @var string Defines a way to associate header cells and data cells in a table.
-     */
-    public $scope = null;
-
-    /**
-     * @var bool Whether or not this cell is a header cell.
-     */
-    public $header = null;
-
-    /**
-     * @var string Value to use for the style attribute of the table cell
-     */
-    public $style = null;
-
-    /**
-     * @var array Attributes of additional HTML attributes for the <td> element
-     */
-    public $attributes = array();
-
-    /**
-     * Constructs a table cell
-     *
-     * @param string $text
-     */
-    public function __construct($text = null) {
-        $this->text = $text;
-        $this->attributes['class'] = '';
-    }
-}
-
-/**
- * Component representing a paging bar.
- *
- * @copyright 2009 Nicolas Connault
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class paging_bar implements renderable, templatable {
-
-    /**
-     * @var int The maximum number of pagelinks to display.
-     */
-    public $maxdisplay = 18;
-
-    /**
-     * @var int The total number of entries to be pages through..
-     */
-    public $totalcount;
-
-    /**
-     * @var int The page you are currently viewing.
-     */
-    public $page;
-
-    /**
-     * @var int The number of entries that should be shown per page.
-     */
-    public $perpage;
-
-    /**
-     * @var string|moodle_url If this  is a string then it is the url which will be appended with $pagevar,
-     * an equals sign and the page number.
-     * If this is a moodle_url object then the pagevar param will be replaced by
-     * the page no, for each page.
-     */
-    public $baseurl;
-
-    /**
-     * @var string This is the variable name that you use for the pagenumber in your
-     * code (ie. 'tablepage', 'blogpage', etc)
-     */
-    public $pagevar;
-
-    /**
-     * @var string A HTML link representing the "previous" page.
-     */
-    public $previouslink = null;
-
-    /**
-     * @var string A HTML link representing the "next" page.
-     */
-    public $nextlink = null;
-
-    /**
-     * @var string A HTML link representing the first page.
-     */
-    public $firstlink = null;
-
-    /**
-     * @var string A HTML link representing the last page.
-     */
-    public $lastlink = null;
-
-    /**
-     * @var array An array of strings. One of them is just a string: the current page
-     */
-    public $pagelinks = array();
-
-    /**
-     * Constructor paging_bar with only the required params.
-     *
-     * @param int $totalcount The total number of entries available to be paged through
-     * @param int $page The page you are currently viewing
-     * @param int $perpage The number of entries that should be shown per page
-     * @param string|moodle_url $baseurl url of the current page, the $pagevar parameter is added
-     * @param string $pagevar name of page parameter that holds the page number
-     */
-    public function __construct($totalcount, $page, $perpage, $baseurl, $pagevar = 'page') {
-        $this->totalcount = $totalcount;
-        $this->page       = $page;
-        $this->perpage    = $perpage;
-        $this->baseurl    = $baseurl;
-        $this->pagevar    = $pagevar;
-    }
-
-    /**
-     * Prepares the paging bar for output.
-     *
-     * This method validates the arguments set up for the paging bar and then
-     * produces fragments of HTML to assist display later on.
-     *
-     * @param renderer_base $output
-     * @param moodle_page $page
-     * @param string $target
-     * @throws coding_exception
-     */
-    public function prepare(renderer_base $output, moodle_page $page, $target) {
-        if (!isset($this->totalcount) || is_null($this->totalcount)) {
-            throw new coding_exception('paging_bar requires a totalcount value.');
-        }
-        if (!isset($this->page) || is_null($this->page)) {
-            throw new coding_exception('paging_bar requires a page value.');
-        }
-        if (empty($this->perpage)) {
-            throw new coding_exception('paging_bar requires a perpage value.');
-        }
-        if (empty($this->baseurl)) {
-            throw new coding_exception('paging_bar requires a baseurl value.');
-        }
-
-        if ($this->totalcount > $this->perpage) {
-            $pagenum = $this->page - 1;
-
-            if ($this->page > 0) {
-                $this->previouslink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$pagenum)), get_string('previous'), array('class'=>'previous'));
-            }
-
-            if ($this->perpage > 0) {
-                $lastpage = ceil($this->totalcount / $this->perpage);
-            } else {
-                $lastpage = 1;
-            }
-
-            if ($this->page > round(($this->maxdisplay/3)*2)) {
-                $currpage = $this->page - round($this->maxdisplay/3);
-
-                $this->firstlink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>0)), '1', array('class'=>'first'));
-            } else {
-                $currpage = 0;
-            }
-
-            $displaycount = $displaypage = 0;
-
-            while ($displaycount < $this->maxdisplay and $currpage < $lastpage) {
-                $displaypage = $currpage + 1;
-
-                if ($this->page == $currpage) {
-                    $this->pagelinks[] = html_writer::span($displaypage, 'current-page');
-                } else {
-                    $pagelink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$currpage)), $displaypage);
-                    $this->pagelinks[] = $pagelink;
-                }
-
-                $displaycount++;
-                $currpage++;
-            }
-
-            if ($currpage < $lastpage) {
-                $lastpageactual = $lastpage - 1;
-                $this->lastlink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$lastpageactual)), $lastpage, array('class'=>'last'));
-            }
-
-            $pagenum = $this->page + 1;
-
-            if ($pagenum != $lastpage) {
-                $this->nextlink = html_writer::link(new moodle_url($this->baseurl, array($this->pagevar=>$pagenum)), get_string('next'), array('class'=>'next'));
-            }
-        }
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output The renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $data = new stdClass();
-        $data->previous = null;
-        $data->next = null;
-        $data->first = null;
-        $data->last = null;
-        $data->label = get_string('page');
-        $data->pages = [];
-        $data->haspages = $this->totalcount > $this->perpage;
-        $data->pagesize = $this->perpage;
-
-        if (!$data->haspages) {
-            return $data;
-        }
-
-        if ($this->page > 0) {
-            $data->previous = [
-                'page' => $this->page,
-                'url' => (new moodle_url($this->baseurl, [$this->pagevar => $this->page - 1]))->out(false)
-            ];
-        }
-
-        $currpage = 0;
-        if ($this->page > round(($this->maxdisplay / 3) * 2)) {
-            $currpage = $this->page - round($this->maxdisplay / 3);
-            $data->first = [
-                'page' => 1,
-                'url' => (new moodle_url($this->baseurl, [$this->pagevar => 0]))->out(false)
-            ];
-        }
-
-        $lastpage = 1;
-        if ($this->perpage > 0) {
-            $lastpage = ceil($this->totalcount / $this->perpage);
-        }
-
-        $displaycount = 0;
-        $displaypage = 0;
-        while ($displaycount < $this->maxdisplay and $currpage < $lastpage) {
-            $displaypage = $currpage + 1;
-
-            $iscurrent = $this->page == $currpage;
-            $link = new moodle_url($this->baseurl, [$this->pagevar => $currpage]);
-
-            $data->pages[] = [
-                'page' => $displaypage,
-                'active' => $iscurrent,
-                'url' => $iscurrent ? null : $link->out(false)
-            ];
-
-            $displaycount++;
-            $currpage++;
-        }
-
-        if ($currpage < $lastpage) {
-            $data->last = [
-                'page' => $lastpage,
-                'url' => (new moodle_url($this->baseurl, [$this->pagevar => $lastpage - 1]))->out(false)
-            ];
-        }
-
-        if ($this->page + 1 != $lastpage) {
-            $data->next = [
-                'page' => $this->page + 2,
-                'url' => (new moodle_url($this->baseurl, [$this->pagevar => $this->page + 1]))->out(false)
-            ];
-        }
-
-        return $data;
-    }
-}
-
-/**
- * Component representing initials bar.
- *
- * @copyright 2017 Ilya Tregubov
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 3.3
- * @package core
- * @category output
- */
-class initials_bar implements renderable, templatable {
-
-    /**
-     * @var string Currently selected letter.
-     */
-    public $current;
-
-    /**
-     * @var string Class name to add to this initial bar.
-     */
-    public $class;
-
-    /**
-     * @var string The name to put in front of this initial bar.
-     */
-    public $title;
-
-    /**
-     * @var string URL parameter name for this initial.
-     */
-    public $urlvar;
-
-    /**
-     * @var moodle_url URL object.
-     */
-    public $url;
-
-    /**
-     * @var array An array of letters in the alphabet.
-     */
-    public $alpha;
-
-    /**
-     * @var bool Omit links if we are doing a mini render.
-     */
-    public $minirender;
-
-    /**
-     * Constructor initials_bar with only the required params.
-     *
-     * @param string $current the currently selected letter.
-     * @param string $class class name to add to this initial bar.
-     * @param string $title the name to put in front of this initial bar.
-     * @param string $urlvar URL parameter name for this initial.
-     * @param string $url URL object.
-     * @param array $alpha of letters in the alphabet.
-     * @param bool $minirender Return a trimmed down view of the initials bar.
-     */
-    public function __construct($current, $class, $title, $urlvar, $url, $alpha = null, bool $minirender = false) {
-        $this->current       = $current;
-        $this->class    = $class;
-        $this->title    = $title;
-        $this->urlvar    = $urlvar;
-        $this->url    = $url;
-        $this->alpha    = $alpha;
-        $this->minirender = $minirender;
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output The renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $data = new stdClass();
-
-        if ($this->alpha == null) {
-            $this->alpha = explode(',', get_string('alphabet', 'langconfig'));
-        }
-
-        if ($this->current == 'all') {
-            $this->current = '';
-        }
-
-        // We want to find a letter grouping size which suits the language so
-        // find the largest group size which is less than 15 chars.
-        // The choice of 15 chars is the largest number of chars that reasonably
-        // fits on the smallest supported screen size. By always using a max number
-        // of groups which is a factor of 2, we always get nice wrapping, and the
-        // last row is always the shortest.
-        $groupsize = count($this->alpha);
-        $groups = 1;
-        while ($groupsize > 15) {
-            $groups *= 2;
-            $groupsize = ceil(count($this->alpha) / $groups);
-        }
-
-        $groupsizelimit = 0;
-        $groupnumber = 0;
-        foreach ($this->alpha as $letter) {
-            if ($groupsizelimit++ > 0 && $groupsizelimit % $groupsize == 1) {
-                $groupnumber++;
-            }
-            $groupletter = new stdClass();
-            $groupletter->name = $letter;
-            if (!$this->minirender) {
-                $groupletter->url = $this->url->out(false, array($this->urlvar => $letter));
-            } else {
-                $groupletter->input = $letter;
-            }
-            if ($letter == $this->current) {
-                $groupletter->selected = $this->current;
-            }
-            if (!isset($data->group[$groupnumber])) {
-                $data->group[$groupnumber] = new stdClass();
-            }
-            $data->group[$groupnumber]->letter[] = $groupletter;
-        }
-
-        $data->class = $this->class;
-        $data->title = $this->title;
-        if (!$this->minirender) {
-            $data->url = $this->url->out(false, array($this->urlvar => ''));
-        } else {
-            $data->input = 'ALL';
-        }
-        $data->current = $this->current;
-        $data->all = get_string('all');
-
-        return $data;
-    }
-}
-
-/**
- * This class represents how a block appears on a page.
- *
- * During output, each block instance is asked to return a block_contents object,
- * those are then passed to the $OUTPUT->block function for display.
- *
- * contents should probably be generated using a moodle_block_..._renderer.
- *
- * Other block-like things that need to appear on the page, for example the
- * add new block UI, are also represented as block_contents objects.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class block_contents {
-
-    /** Used when the block cannot be collapsed **/
-    const NOT_HIDEABLE = 0;
-
-    /** Used when the block can be collapsed but currently is not **/
-    const VISIBLE = 1;
-
-    /** Used when the block has been collapsed **/
-    const HIDDEN = 2;
-
-    /**
-     * @var int Used to set $skipid.
-     */
-    protected static $idcounter = 1;
-
-    /**
-     * @var int All the blocks (or things that look like blocks) printed on
-     * a page are given a unique number that can be used to construct id="" attributes.
-     * This is set automatically be the {@link prepare()} method.
-     * Do not try to set it manually.
-     */
-    public $skipid;
-
-    /**
-     * @var int If this is the contents of a real block, this should be set
-     * to the block_instance.id. Otherwise this should be set to 0.
-     */
-    public $blockinstanceid = 0;
-
-    /**
-     * @var int If this is a real block instance, and there is a corresponding
-     * block_position.id for the block on this page, this should be set to that id.
-     * Otherwise it should be 0.
-     */
-    public $blockpositionid = 0;
-
-    /**
-     * @var array An array of attribute => value pairs that are put on the outer div of this
-     * block. {@link $id} and {@link $classes} attributes should be set separately.
-     */
-    public $attributes;
-
-    /**
-     * @var string The title of this block. If this came from user input, it should already
-     * have had format_string() processing done on it. This will be output inside
-     * <h2> tags. Please do not cause invalid XHTML.
-     */
-    public $title = '';
-
-    /**
-     * @var string The label to use when the block does not, or will not have a visible title.
-     * You should never set this as well as title... it will just be ignored.
-     */
-    public $arialabel = '';
-
-    /**
-     * @var string HTML for the content
-     */
-    public $content = '';
-
-    /**
-     * @var array An alternative to $content, it you want a list of things with optional icons.
-     */
-    public $footer = '';
-
-    /**
-     * @var string Any small print that should appear under the block to explain
-     * to the teacher about the block, for example 'This is a sticky block that was
-     * added in the system context.'
-     */
-    public $annotation = '';
-
-    /**
-     * @var int One of the constants NOT_HIDEABLE, VISIBLE, HIDDEN. Whether
-     * the user can toggle whether this block is visible.
-     */
-    public $collapsible = self::NOT_HIDEABLE;
-
-    /**
-     * Set this to true if the block is dockable.
-     * @var bool
-     */
-    public $dockable = false;
-
-    /**
-     * @var array A (possibly empty) array of editing controls. Each element of
-     * this array should be an array('url' => $url, 'icon' => $icon, 'caption' => $caption).
-     * $icon is the icon name. Fed to $OUTPUT->image_url.
-     */
-    public $controls = array();
-
-
-    /**
-     * Create new instance of block content
-     * @param array $attributes
-     */
-    public function __construct(array $attributes = null) {
-        $this->skipid = self::$idcounter;
-        self::$idcounter += 1;
-
-        if ($attributes) {
-            // standard block
-            $this->attributes = $attributes;
-        } else {
-            // simple "fake" blocks used in some modules and "Add new block" block
-            $this->attributes = array('class'=>'block');
-        }
-    }
-
-    /**
-     * Add html class to block
-     *
-     * @param string $class
-     */
-    public function add_class($class) {
-        $this->attributes['class'] .= ' '.$class;
-    }
-
-    /**
-     * Check if the block is a fake block.
-     *
-     * @return boolean
-     */
-    public function is_fake() {
-        return isset($this->attributes['data-block']) && $this->attributes['data-block'] == '_fake';
-    }
-}
-
-
-/**
- * This class represents a target for where a block can go when it is being moved.
- *
- * This needs to be rendered as a form with the given hidden from fields, and
- * clicking anywhere in the form should submit it. The form action should be
- * $PAGE->url.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class block_move_target {
-
-    /**
-     * @var moodle_url Move url
-     */
-    public $url;
-
-    /**
-     * Constructor
-     * @param moodle_url $url
-     */
-    public function __construct(moodle_url $url) {
-        $this->url  = $url;
-    }
-}
-
-/**
- * Custom menu item
- *
- * This class is used to represent one item within a custom menu that may or may
- * not have children.
- *
- * @copyright 2010 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class custom_menu_item implements renderable, templatable {
-
-    /**
-     * @var string The text to show for the item
-     */
-    protected $text;
-
-    /**
-     * @var moodle_url The link to give the icon if it has no children
-     */
-    protected $url;
-
-    /**
-     * @var string A title to apply to the item. By default the text
-     */
-    protected $title;
-
-    /**
-     * @var int A sort order for the item, not necessary if you order things in
-     * the CFG var.
-     */
-    protected $sort;
-
-    /**
-     * @var custom_menu_item A reference to the parent for this item or NULL if
-     * it is a top level item
-     */
-    protected $parent;
-
-    /**
-     * @var array A array in which to store children this item has.
-     */
-    protected $children = array();
-
-    /**
-     * @var int A reference to the sort var of the last child that was added
-     */
-    protected $lastsort = 0;
-
-    /** @var array Array of other HTML attributes for the custom menu item. */
-    protected $attributes = [];
-
-    /**
-     * Constructs the new custom menu item
-     *
-     * @param string $text
-     * @param moodle_url $url A moodle url to apply as the link for this item [Optional]
-     * @param string $title A title to apply to this item [Optional]
-     * @param int $sort A sort or to use if we need to sort differently [Optional]
-     * @param custom_menu_item $parent A reference to the parent custom_menu_item this child
-     *        belongs to, only if the child has a parent. [Optional]
-     * @param array $attributes Array of other HTML attributes for the custom menu item.
-     */
-    public function __construct($text, moodle_url $url = null, $title = null, $sort = null, custom_menu_item $parent = null,
-        array $attributes = []) {
-
-        // Use class setter method for text to ensure it's always a string type.
-        $this->set_text($text);
-
-        $this->url = $url;
-        $this->title = $title;
-        $this->sort = (int)$sort;
-        $this->parent = $parent;
-        $this->attributes = $attributes;
-    }
-
-    /**
-     * Adds a custom menu item as a child of this node given its properties.
-     *
-     * @param string $text
-     * @param moodle_url $url
-     * @param string $title
-     * @param int $sort
-     * @param array $attributes Array of other HTML attributes for the custom menu item.
-     * @return custom_menu_item
-     */
-    public function add($text, moodle_url $url = null, $title = null, $sort = null, $attributes = []) {
-        $key = count($this->children);
-        if (empty($sort)) {
-            $sort = $this->lastsort + 1;
-        }
-        $this->children[$key] = new custom_menu_item($text, $url, $title, $sort, $this, $attributes);
-        $this->lastsort = (int)$sort;
-        return $this->children[$key];
-    }
-
-    /**
-     * Removes a custom menu item that is a child or descendant to the current menu.
-     *
-     * Returns true if child was found and removed.
-     *
-     * @param custom_menu_item $menuitem
-     * @return bool
-     */
-    public function remove_child(custom_menu_item $menuitem) {
-        $removed = false;
-        if (($key = array_search($menuitem, $this->children)) !== false) {
-            unset($this->children[$key]);
-            $this->children = array_values($this->children);
-            $removed = true;
-        } else {
-            foreach ($this->children as $child) {
-                if ($removed = $child->remove_child($menuitem)) {
-                    break;
-                }
-            }
-        }
-        return $removed;
-    }
-
-    /**
-     * Returns the text for this item
-     * @return string
-     */
-    public function get_text() {
-        return $this->text;
-    }
-
-    /**
-     * Returns the url for this item
-     * @return moodle_url
-     */
-    public function get_url() {
-        return $this->url;
-    }
-
-    /**
-     * Returns the title for this item
-     * @return string
-     */
-    public function get_title() {
-        return $this->title;
-    }
-
-    /**
-     * Sorts and returns the children for this item
-     * @return array
-     */
-    public function get_children() {
-        $this->sort();
-        return $this->children;
-    }
-
-    /**
-     * Gets the sort order for this child
-     * @return int
-     */
-    public function get_sort_order() {
-        return $this->sort;
-    }
-
-    /**
-     * Gets the parent this child belong to
-     * @return custom_menu_item
-     */
-    public function get_parent() {
-        return $this->parent;
-    }
-
-    /**
-     * Sorts the children this item has
-     */
-    public function sort() {
-        usort($this->children, array('custom_menu','sort_custom_menu_items'));
-    }
-
-    /**
-     * Returns true if this item has any children
-     * @return bool
-     */
-    public function has_children() {
-        return (count($this->children) > 0);
-    }
-
-    /**
-     * Sets the text for the node
-     * @param string $text
-     */
-    public function set_text($text) {
-        $this->text = (string)$text;
-    }
-
-    /**
-     * Sets the title for the node
-     * @param string $title
-     */
-    public function set_title($title) {
-        $this->title = (string)$title;
-    }
-
-    /**
-     * Sets the url for the node
-     * @param moodle_url $url
-     */
-    public function set_url(moodle_url $url) {
-        $this->url = $url;
-    }
-
-    /**
-     * Export this data so it can be used as the context for a mustache template.
-     *
-     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $syscontext = context_system::instance();
-
-        $context = new stdClass();
-        $context->moremenuid = uniqid();
-        $context->text = \core_external\util::format_string($this->text, $syscontext->id);
-        $context->url = $this->url ? $this->url->out() : null;
-        // No need for the title if it's the same with text.
-        if ($this->text !== $this->title) {
-            // Show the title attribute only if it's different from the text.
-            $context->title = \core_external\util::format_string($this->title, $syscontext->id);
-        }
-        $context->sort = $this->sort;
-        if (!empty($this->attributes)) {
-            $context->attributes = $this->attributes;
-        }
-        $context->children = array();
-        if (preg_match("/^#+$/", $this->text)) {
-            $context->divider = true;
-        }
-        $context->haschildren = !empty($this->children) && (count($this->children) > 0);
-        foreach ($this->children as $child) {
-            $child = $child->export_for_template($output);
-            array_push($context->children, $child);
-        }
-
-        return $context;
-    }
-}
-
-/**
- * Custom menu class
- *
- * This class is used to operate a custom menu that can be rendered for the page.
- * The custom menu is built using $CFG->custommenuitems and is a structured collection
- * of custom_menu_item nodes that can be rendered by the core renderer.
- *
- * To configure the custom menu:
- *     Settings: Administration > Appearance > Advanced theme settings
- *
- * @copyright 2010 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class custom_menu extends custom_menu_item {
-
-    /**
-     * @var string The language we should render for, null disables multilang support.
-     */
-    protected $currentlanguage = null;
-
-    /**
-     * Creates the custom menu
-     *
-     * @param string $definition the menu items definition in syntax required by {@link convert_text_to_menu_nodes()}
-     * @param string $currentlanguage the current language code, null disables multilang support
-     */
-    public function __construct($definition = '', $currentlanguage = null) {
-        $this->currentlanguage = $currentlanguage;
-        parent::__construct('root'); // create virtual root element of the menu
-        if (!empty($definition)) {
-            $this->override_children(self::convert_text_to_menu_nodes($definition, $currentlanguage));
-        }
-    }
-
-    /**
-     * Overrides the children of this custom menu. Useful when getting children
-     * from $CFG->custommenuitems
-     *
-     * @param array $children
-     */
-    public function override_children(array $children) {
-        $this->children = array();
-        foreach ($children as $child) {
-            if ($child instanceof custom_menu_item) {
-                $this->children[] = $child;
-            }
-        }
-    }
-
-    /**
-     * Converts a string into a structured array of custom_menu_items which can
-     * then be added to a custom menu.
-     *
-     * Structure:
-     *     text|url|title|langs
-     * The number of hyphens at the start determines the depth of the item. The
-     * languages are optional, comma separated list of languages the line is for.
-     *
-     * Example structure:
-     *     First level first item|http://www.moodle.com/
-     *     -Second level first item|http://www.moodle.com/partners/
-     *     -Second level second item|http://www.moodle.com/hq/
-     *     --Third level first item|http://www.moodle.com/jobs/
-     *     -Second level third item|http://www.moodle.com/development/
-     *     First level second item|http://www.moodle.com/feedback/
-     *     First level third item
-     *     English only|http://moodle.com|English only item|en
-     *     German only|http://moodle.de|Deutsch|de,de_du,de_kids
-     *
-     *
-     * @static
-     * @param string $text the menu items definition
-     * @param string $language the language code, null disables multilang support
-     * @return array
-     */
-    public static function convert_text_to_menu_nodes($text, $language = null) {
-        $root = new custom_menu();
-        $lastitem = $root;
-        $lastdepth = 0;
-        $hiddenitems = array();
-        $lines = explode("\n", $text);
-        foreach ($lines as $linenumber => $line) {
-            $line = trim($line);
-            if (strlen($line) == 0) {
-                continue;
-            }
-            // Parse item settings.
-            $itemtext = null;
-            $itemurl = null;
-            $itemtitle = null;
-            $itemvisible = true;
-            $settings = explode('|', $line);
-            foreach ($settings as $i => $setting) {
-                $setting = trim($setting);
-                if ($setting !== '') {
-                    switch ($i) {
-                        case 0: // Menu text.
-                            $itemtext = ltrim($setting, '-');
-                            break;
-                        case 1: // URL.
-                            try {
-                                $itemurl = new moodle_url($setting);
-                            } catch (moodle_exception $exception) {
-                                // We're not actually worried about this, we don't want to mess up the display
-                                // just for a wrongly entered URL.
-                                $itemurl = null;
-                            }
-                            break;
-                        case 2: // Title attribute.
-                            $itemtitle = $setting;
-                            break;
-                        case 3: // Language.
-                            if (!empty($language)) {
-                                $itemlanguages = array_map('trim', explode(',', $setting));
-                                $itemvisible &= in_array($language, $itemlanguages);
-                            }
-                            break;
-                    }
-                }
-            }
-            // Get depth of new item.
-            preg_match('/^(\-*)/', $line, $match);
-            $itemdepth = strlen($match[1]) + 1;
-            // Find parent item for new item.
-            while (($lastdepth - $itemdepth) >= 0) {
-                $lastitem = $lastitem->get_parent();
-                $lastdepth--;
-            }
-            $lastitem = $lastitem->add($itemtext, $itemurl, $itemtitle, $linenumber + 1);
-            $lastdepth++;
-            if (!$itemvisible) {
-                $hiddenitems[] = $lastitem;
-            }
-        }
-        foreach ($hiddenitems as $item) {
-            $item->parent->remove_child($item);
-        }
-        return $root->get_children();
-    }
-
-    /**
-     * Sorts two custom menu items
-     *
-     * This function is designed to be used with the usort method
-     *     usort($this->children, array('custom_menu','sort_custom_menu_items'));
-     *
-     * @static
-     * @param custom_menu_item $itema
-     * @param custom_menu_item $itemb
-     * @return int
-     */
-    public static function sort_custom_menu_items(custom_menu_item $itema, custom_menu_item $itemb) {
-        $itema = $itema->get_sort_order();
-        $itemb = $itemb->get_sort_order();
-        if ($itema == $itemb) {
-            return 0;
-        }
-        return ($itema > $itemb) ? +1 : -1;
-    }
-}
-
-/**
- * Stores one tab
- *
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- */
-class tabobject implements renderable, templatable {
-    /** @var string unique id of the tab in this tree, it is used to find selected and/or inactive tabs */
-    var $id;
-    /** @var moodle_url|string link */
-    var $link;
-    /** @var string text on the tab */
-    var $text;
-    /** @var string title under the link, by defaul equals to text */
-    var $title;
-    /** @var bool whether to display a link under the tab name when it's selected */
-    var $linkedwhenselected = false;
-    /** @var bool whether the tab is inactive */
-    var $inactive = false;
-    /** @var bool indicates that this tab's child is selected */
-    var $activated = false;
-    /** @var bool indicates that this tab is selected */
-    var $selected = false;
-    /** @var array stores children tabobjects */
-    var $subtree = array();
-    /** @var int level of tab in the tree, 0 for root (instance of tabtree), 1 for the first row of tabs */
-    var $level = 1;
-
-    /**
-     * Constructor
-     *
-     * @param string $id unique id of the tab in this tree, it is used to find selected and/or inactive tabs
-     * @param string|moodle_url $link
-     * @param string $text text on the tab
-     * @param string $title title under the link, by defaul equals to text
-     * @param bool $linkedwhenselected whether to display a link under the tab name when it's selected
-     */
-    public function __construct($id, $link = null, $text = '', $title = '', $linkedwhenselected = false) {
-        $this->id = $id;
-        $this->link = $link;
-        $this->text = $text;
-        $this->title = $title ? $title : $text;
-        $this->linkedwhenselected = $linkedwhenselected;
-    }
-
-    /**
-     * Travels through tree and finds the tab to mark as selected, all parents are automatically marked as activated
-     *
-     * @param string $selected the id of the selected tab (whatever row it's on),
-     *    if null marks all tabs as unselected
-     * @return bool whether this tab is selected or contains selected tab in its subtree
-     */
-    protected function set_selected($selected) {
-        if ((string)$selected === (string)$this->id) {
-            $this->selected = true;
-            // This tab is selected. No need to travel through subtree.
-            return true;
-        }
-        foreach ($this->subtree as $subitem) {
-            if ($subitem->set_selected($selected)) {
-                // This tab has child that is selected. Mark it as activated. No need to check other children.
-                $this->activated = true;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Travels through tree and finds a tab with specified id
-     *
-     * @param string $id
-     * @return tabtree|null
-     */
-    public function find($id) {
-        if ((string)$this->id === (string)$id) {
-            return $this;
-        }
-        foreach ($this->subtree as $tab) {
-            if ($obj = $tab->find($id)) {
-                return $obj;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Allows to mark each tab's level in the tree before rendering.
-     *
-     * @param int $level
-     */
-    protected function set_level($level) {
-        $this->level = $level;
-        foreach ($this->subtree as $tab) {
-            $tab->set_level($level + 1);
-        }
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output Renderer.
-     * @return object
-     */
-    public function export_for_template(renderer_base $output) {
-        if ($this->inactive || ($this->selected && !$this->linkedwhenselected) || $this->activated) {
-            $link = null;
-        } else {
-            $link = $this->link;
-        }
-        $active = $this->activated || $this->selected;
-
-        return (object) [
-            'id' => $this->id,
-            'link' => is_object($link) ? $link->out(false) : $link,
-            'text' => $this->text,
-            'title' => $this->title,
-            'inactive' => !$active && $this->inactive,
-            'active' => $active,
-            'level' => $this->level,
-        ];
-    }
-
-}
-
-/**
- * Renderable for the main page header.
- *
- * @package core
- * @category output
- * @since 2.9
- * @copyright 2015 Adrian Greeve <adrian@moodle.com>
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class context_header implements renderable, templatable {
-
-    /**
-     * @var string $heading Main heading.
-     */
-    public $heading;
-    /**
-     * @var int $headinglevel Main heading 'h' tag level.
-     */
-    public $headinglevel;
-    /**
-     * @var string|null $imagedata HTML code for the picture in the page header.
-     */
-    public $imagedata;
-    /**
-     * @var array $additionalbuttons Additional buttons for the header e.g. Messaging button for the user header.
-     *      array elements - title => alternate text for the image, or if no image is available the button text.
-     *                       url => Link for the button to head to. Should be a moodle_url.
-     *                       image => location to the image, or name of the image in /pix/t/{image name}.
-     *                       linkattributes => additional attributes for the <a href> element.
-     *                       page => page object. Don't include if the image is an external image.
-     */
-    public $additionalbuttons;
-    /**
-     * @var string $prefix A string that is before the title.
-     */
-    public $prefix;
-
-    /**
-     * Constructor.
-     *
-     * @param string $heading Main heading data.
-     * @param int $headinglevel Main heading 'h' tag level.
-     * @param string|null $imagedata HTML code for the picture in the page header.
-     * @param string $additionalbuttons Buttons for the header e.g. Messaging button for the user header.
-     * @param string $prefix Text that precedes the heading.
-     */
-    public function __construct($heading = null, $headinglevel = 1, $imagedata = null, $additionalbuttons = null, $prefix = null) {
-
-        $this->heading = $heading;
-        $this->headinglevel = $headinglevel;
-        $this->imagedata = $imagedata;
-        $this->additionalbuttons = $additionalbuttons;
-        // If we have buttons then format them.
-        if (isset($this->additionalbuttons)) {
-            $this->format_button_images();
-        }
-        $this->prefix = $prefix;
-    }
-
-    /**
-     * Adds an array element for a formatted image.
-     */
-    protected function format_button_images() {
-
-        foreach ($this->additionalbuttons as $buttontype => $button) {
-            $page = $button['page'];
-            // If no image is provided then just use the title.
-            if (!isset($button['image'])) {
-                $this->additionalbuttons[$buttontype]['formattedimage'] = $button['title'];
-            } else {
-                // Check to see if this is an internal Moodle icon.
-                $internalimage = $page->theme->resolve_image_location('t/' . $button['image'], 'moodle');
-                if ($internalimage) {
-                    $this->additionalbuttons[$buttontype]['formattedimage'] = 't/' . $button['image'];
-                } else {
-                    // Treat as an external image.
-                    $this->additionalbuttons[$buttontype]['formattedimage'] = $button['image'];
-                }
-            }
-
-            if (isset($button['linkattributes']['class'])) {
-                $class = $button['linkattributes']['class'] . ' btn';
-            } else {
-                $class = 'btn';
-            }
-            // Add the bootstrap 'btn' class for formatting.
-            $this->additionalbuttons[$buttontype]['linkattributes'] = array_merge($button['linkattributes'],
-                array('class' => $class));
-        }
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output Renderer.
-     * @return array
-     */
-    public function export_for_template(renderer_base $output): array {
-        // Heading.
-        $headingtext = isset($this->heading) ? $this->heading : $output->get_page()->heading;
-        $heading = $output->heading($headingtext, $this->headinglevel, "h2 mb-0");
-
-        // Buttons.
-        if (isset($this->additionalbuttons)) {
-            $additionalbuttons = [];
-            foreach ($this->additionalbuttons as $button) {
-                if (!isset($button->page)) {
-                    // Include js for messaging.
-                    if ($button['buttontype'] === 'togglecontact') {
-                        \core_message\helper::togglecontact_requirejs();
-                    }
-                    if ($button['buttontype'] === 'message') {
-                        \core_message\helper::messageuser_requirejs();
-                    }
-                }
-                foreach ($button['linkattributes'] as $key => $value) {
-                    $button['attributes'][] = ['name' => $key, 'value' => $value];
-                }
-                $additionalbuttons[] = $button;
-            }
-        }
-
-        return [
-            'heading' => $heading,
-            'headinglevel' => $this->headinglevel,
-            'imagedata' => $this->imagedata,
-            'prefix' => $this->prefix,
-            'hasadditionalbuttons' => !empty($additionalbuttons),
-            'additionalbuttons' => $additionalbuttons ?? [],
-        ];
-    }
-}
-
-/**
- * Stores tabs list
- *
- * Example how to print a single line tabs:
- * $rows = array(
- *    new tabobject(...),
- *    new tabobject(...)
- * );
- * echo $OUTPUT->tabtree($rows, $selectedid);
- *
- * Multiple row tabs may not look good on some devices but if you want to use them
- * you can specify ->subtree for the active tabobject.
- *
- * @copyright 2013 Marina Glancy
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.5
- * @package core
- * @category output
- */
-class tabtree extends tabobject {
-    /**
-     * Constuctor
-     *
-     * It is highly recommended to call constructor when list of tabs is already
-     * populated, this way you ensure that selected and inactive tabs are located
-     * and attribute level is set correctly.
-     *
-     * @param array $tabs array of tabs, each of them may have it's own ->subtree
-     * @param string|null $selected which tab to mark as selected, all parent tabs will
-     *     automatically be marked as activated
-     * @param array|string|null $inactive list of ids of inactive tabs, regardless of
-     *     their level. Note that you can as weel specify tabobject::$inactive for separate instances
-     */
-    public function __construct($tabs, $selected = null, $inactive = null) {
-        $this->subtree = $tabs;
-        if ($selected !== null) {
-            $this->set_selected($selected);
-        }
-        if ($inactive !== null) {
-            if (is_array($inactive)) {
-                foreach ($inactive as $id) {
-                    if ($tab = $this->find($id)) {
-                        $tab->inactive = true;
-                    }
-                }
-            } else if ($tab = $this->find($inactive)) {
-                $tab->inactive = true;
-            }
-        }
-        $this->set_level(0);
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output Renderer.
-     * @return object
-     */
-    public function export_for_template(renderer_base $output) {
-        $tabs = [];
-        $secondrow = false;
-
-        foreach ($this->subtree as $tab) {
-            $tabs[] = $tab->export_for_template($output);
-            if (!empty($tab->subtree) && ($tab->level == 0 || $tab->selected || $tab->activated)) {
-                $secondrow = new tabtree($tab->subtree);
-            }
-        }
-
-        return (object) [
-            'tabs' => $tabs,
-            'secondrow' => $secondrow ? $secondrow->export_for_template($output) : false
-        ];
-    }
-}
-
-/**
- * An action menu.
- *
- * This action menu component takes a series of primary and secondary actions.
- * The primary actions are displayed permanently and the secondary attributes are displayed within a drop
- * down menu.
- *
- * @package core
- * @category output
- * @copyright 2013 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class action_menu implements renderable, templatable {
-
-    /**
-     * Top right alignment.
-     */
-    const TL = 1;
-
-    /**
-     * Top right alignment.
-     */
-    const TR = 2;
-
-    /**
-     * Top right alignment.
-     */
-    const BL = 3;
-
-    /**
-     * Top right alignment.
-     */
-    const BR = 4;
-
-    /**
-     * The instance number. This is unique to this instance of the action menu.
-     * @var int
-     */
-    protected $instance = 0;
-
-    /**
-     * An array of primary actions. Please use {@link action_menu::add_primary_action()} to add actions.
-     * @var array
-     */
-    protected $primaryactions = array();
-
-    /**
-     * An array of secondary actions. Please use {@link action_menu::add_secondary_action()} to add actions.
-     * @var array
-     */
-    protected $secondaryactions = array();
-
-    /**
-     * An array of attributes added to the container of the action menu.
-     * Initialised with defaults during construction.
-     * @var array
-     */
-    public $attributes = array();
-    /**
-     * An array of attributes added to the container of the primary actions.
-     * Initialised with defaults during construction.
-     * @var array
-     */
-    public $attributesprimary = array();
-    /**
-     * An array of attributes added to the container of the secondary actions.
-     * Initialised with defaults during construction.
-     * @var array
-     */
-    public $attributessecondary = array();
-
-    /**
-     * The string to use next to the icon for the action icon relating to the secondary (dropdown) menu.
-     * @var array
-     */
-    public $actiontext = null;
-
-    /**
-     * The string to use for the accessible label for the menu.
-     * @var array
-     */
-    public $actionlabel = null;
-
-    /**
-     * An icon to use for the toggling the secondary menu (dropdown).
-     * @var pix_icon
-     */
-    public $actionicon;
-
-    /**
-     * Any text to use for the toggling the secondary menu (dropdown).
-     * @var string
-     */
-    public $menutrigger = '';
-
-    /**
-     * An array of attributes added to the trigger element of the secondary menu.
-     * @var array
-     */
-    public $triggerattributes = [];
-
-    /**
-     * Any extra classes for toggling to the secondary menu.
-     * @var string
-     */
-    public $triggerextraclasses = '';
-
-    /**
-     * Place the action menu before all other actions.
-     * @var bool
-     */
-    public $prioritise = false;
-
-    /**
-     * Dropdown menu alignment class.
-     * @var string
-     */
-    public $dropdownalignment = '';
-
-    /**
-     * Constructs the action menu with the given items.
-     *
-     * @param array $actions An array of actions (action_menu_link|pix_icon|string).
-     */
-    public function __construct(array $actions = array()) {
-        static $initialised = 0;
-        $this->instance = $initialised;
-        $initialised++;
-
-        $this->attributes = array(
-            'id' => 'action-menu-'.$this->instance,
-            'class' => 'moodle-actionmenu',
-            'data-enhance' => 'moodle-core-actionmenu'
-        );
-        $this->attributesprimary = array(
-            'id' => 'action-menu-'.$this->instance.'-menubar',
-            'class' => 'menubar',
-        );
-        $this->attributessecondary = array(
-            'id' => 'action-menu-'.$this->instance.'-menu',
-            'class' => 'menu',
-            'data-rel' => 'menu-content',
-            'aria-labelledby' => 'action-menu-toggle-'.$this->instance,
-            'role' => 'menu'
-        );
-        $this->dropdownalignment = 'dropdown-menu-right';
-        foreach ($actions as $action) {
-            $this->add($action);
-        }
-    }
-
-    /**
-     * Sets the label for the menu trigger.
-     *
-     * @param string $label The text
-     */
-    public function set_action_label($label) {
-        $this->actionlabel = $label;
-    }
-
-    /**
-     * Sets the menu trigger text.
-     *
-     * @param string $trigger The text
-     * @param string $extraclasses Extra classes to style the secondary menu toggle.
-     */
-    public function set_menu_trigger($trigger, $extraclasses = '') {
-        $this->menutrigger = $trigger;
-        $this->triggerextraclasses = $extraclasses;
-    }
-
-    /**
-     * Classes for the trigger menu
-     */
-    const DEFAULT_KEBAB_TRIGGER_CLASSES = 'btn btn-icon d-flex align-items-center justify-content-center no-caret';
-
-    /**
-     * Setup trigger as in the kebab menu.
-     *
-     * @param string|null $triggername
-     * @param core_renderer|null $output
-     * @param string|null $extraclasses extra classes for the trigger {@see self::set_menu_trigger()}
-     * @throws coding_exception
-     */
-    public function set_kebab_trigger(?string $triggername = null, ?core_renderer $output = null,
-        ?string $extraclasses = '') {
-        global $OUTPUT;
-        if (empty($output)) {
-            $output = $OUTPUT;
-        }
-        $label = $triggername ?? get_string('actions');
-        $triggerclasses = self::DEFAULT_KEBAB_TRIGGER_CLASSES . ' ' . $extraclasses;
-        $icon = $output->pix_icon('i/menu', $label);
-        $this->set_menu_trigger($icon, $triggerclasses);
-    }
-
-    /**
-     * Return true if there is at least one visible link in the menu.
-     *
-     * @return bool
-     */
-    public function is_empty() {
-        return !count($this->primaryactions) && !count($this->secondaryactions);
-    }
-
-    /**
-     * Initialises JS required fore the action menu.
-     * The JS is only required once as it manages all action menu's on the page.
-     *
-     * @param moodle_page $page
-     */
-    public function initialise_js(moodle_page $page) {
-        static $initialised = false;
-        if (!$initialised) {
-            $page->requires->yui_module('moodle-core-actionmenu', 'M.core.actionmenu.init');
-            $initialised = true;
-        }
-    }
-
-    /**
-     * Adds an action to this action menu.
-     *
-     * @param action_link|pix_icon|subpanel|string $action
-     */
-    public function add($action) {
-
-        if ($action instanceof subpanel) {
-            $this->add_secondary_subpanel($action);
-        } else if ($action instanceof action_link) {
-            if ($action->primary) {
-                $this->add_primary_action($action);
-            } else {
-                $this->add_secondary_action($action);
-            }
-        } else if ($action instanceof pix_icon) {
-            $this->add_primary_action($action);
-        } else {
-            $this->add_secondary_action($action);
-        }
-    }
-
-    /**
-     * Adds a secondary subpanel.
-     * @param subpanel $subpanel
-     */
-    public function add_secondary_subpanel(subpanel $subpanel) {
-        $this->secondaryactions[] = $subpanel;
-    }
-
-    /**
-     * Adds a primary action to the action menu.
-     *
-     * @param action_menu_link|action_link|pix_icon|string $action
-     */
-    public function add_primary_action($action) {
-        if ($action instanceof action_link || $action instanceof pix_icon) {
-            $action->attributes['role'] = 'menuitem';
-            $action->attributes['tabindex'] = '-1';
-            if ($action instanceof action_menu_link) {
-                $action->actionmenu = $this;
-            }
-        }
-        $this->primaryactions[] = $action;
-    }
-
-    /**
-     * Adds a secondary action to the action menu.
-     *
-     * @param action_link|pix_icon|string $action
-     */
-    public function add_secondary_action($action) {
-        if ($action instanceof action_link || $action instanceof pix_icon) {
-            $action->attributes['role'] = 'menuitem';
-            $action->attributes['tabindex'] = '-1';
-            if ($action instanceof action_menu_link) {
-                $action->actionmenu = $this;
-            }
-        }
-        $this->secondaryactions[] = $action;
-    }
-
-    /**
-     * Returns the primary actions ready to be rendered.
-     *
-     * @param core_renderer $output The renderer to use for getting icons.
-     * @return array
-     */
-    public function get_primary_actions(core_renderer $output = null) {
-        global $OUTPUT;
-        if ($output === null) {
-            $output = $OUTPUT;
-        }
-        $pixicon = $this->actionicon;
-        $linkclasses = array('toggle-display');
-
-        $title = '';
-        if (!empty($this->menutrigger)) {
-            $pixicon = '<b class="caret"></b>';
-            $linkclasses[] = 'textmenu';
-        } else {
-            $title = new lang_string('actionsmenu', 'moodle');
-            $this->actionicon = new pix_icon(
-                't/edit_menu',
-                '',
-                'moodle',
-                array('class' => 'iconsmall actionmenu', 'title' => '')
-            );
-            $pixicon = $this->actionicon;
-        }
-        if ($pixicon instanceof renderable) {
-            $pixicon = $output->render($pixicon);
-            if ($pixicon instanceof pix_icon && isset($pixicon->attributes['alt'])) {
-                $title = $pixicon->attributes['alt'];
-            }
-        }
-        $string = '';
-        if ($this->actiontext) {
-            $string = $this->actiontext;
-        }
-        $label = '';
-        if ($this->actionlabel) {
-            $label = $this->actionlabel;
-        } else {
-            $label = $title;
-        }
-        $actions = $this->primaryactions;
-        $attributes = array(
-            'class' => implode(' ', $linkclasses),
-            'title' => $title,
-            'aria-label' => $label,
-            'id' => 'action-menu-toggle-'.$this->instance,
-            'role' => 'menuitem',
-            'tabindex' => '-1',
-        );
-        $link = html_writer::link('#', $string . $this->menutrigger . $pixicon, $attributes);
-        if ($this->prioritise) {
-            array_unshift($actions, $link);
-        } else {
-            $actions[] = $link;
-        }
-        return $actions;
-    }
-
-    /**
-     * Returns the secondary actions ready to be rendered.
-     * @return array
-     */
-    public function get_secondary_actions() {
-        return $this->secondaryactions;
-    }
-
-    /**
-     * Sets the selector that should be used to find the owning node of this menu.
-     * @param string $selector A CSS/YUI selector to identify the owner of the menu.
-     */
-    public function set_owner_selector($selector) {
-        $this->attributes['data-owner'] = $selector;
-    }
-
-    /**
-     * Sets the alignment of the dialogue in relation to button used to toggle it.
-     *
-     * @deprecated since Moodle 4.0
-     *
-     * @param int $dialogue One of action_menu::TL, action_menu::TR, action_menu::BL, action_menu::BR.
-     * @param int $button One of action_menu::TL, action_menu::TR, action_menu::BL, action_menu::BR.
-     */
-    public function set_alignment($dialogue, $button) {
-        debugging('The method action_menu::set_alignment() is deprecated, use action_menu::set_menu_left()', DEBUG_DEVELOPER);
-        if (isset($this->attributessecondary['data-align'])) {
-            // We've already got one set, lets remove the old class so as to avoid troubles.
-            $class = $this->attributessecondary['class'];
-            $search = 'align-'.$this->attributessecondary['data-align'];
-            $this->attributessecondary['class'] = str_replace($search, '', $class);
-        }
-        $align = $this->get_align_string($dialogue) . '-' . $this->get_align_string($button);
-        $this->attributessecondary['data-align'] = $align;
-        $this->attributessecondary['class'] .= ' align-'.$align;
-    }
-
-    /**
-     * Returns a string to describe the alignment.
-     *
-     * @param int $align One of action_menu::TL, action_menu::TR, action_menu::BL, action_menu::BR.
-     * @return string
-     */
-    protected function get_align_string($align) {
-        switch ($align) {
-            case self::TL :
-                return 'tl';
-            case self::TR :
-                return 'tr';
-            case self::BL :
-                return 'bl';
-            case self::BR :
-                return 'br';
-            default :
-                return 'tl';
-        }
-    }
-
-    /**
-     * Aligns the left corner of the dropdown.
-     *
-     */
-    public function set_menu_left() {
-        $this->dropdownalignment = 'dropdown-menu-left';
-    }
-
-    /**
-     * Sets a constraint for the dialogue.
-     *
-     * The constraint is applied when the dialogue is shown and limits the display of the dialogue to within the
-     * element the constraint identifies.
-     *
-     * This is required whenever the action menu is displayed inside any CSS element with the .no-overflow class
-     * (flexible_table and any of it's child classes are a likely candidate).
-     *
-     * @deprecated since Moodle 4.3
-     * @param string $ancestorselector A snippet of CSS used to identify the ancestor to contrain the dialogue to.
-     */
-    public function set_constraint($ancestorselector) {
-        debugging('The method set_constraint() is deprecated. Please use the set_boundary() method instead.', DEBUG_DEVELOPER);
-        $this->set_boundary('window');
-    }
-
-    /**
-     * Set the overflow constraint boundary of the dropdown menu.
-     * @see https://getbootstrap.com/docs/4.6/components/dropdowns/#options The 'boundary' option in the Bootstrap documentation
-     *
-     * @param string $boundary Accepts the values of 'viewport', 'window', or 'scrollParent'.
-     * @throws coding_exception
-     */
-    public function set_boundary(string $boundary) {
-        if (!in_array($boundary, ['viewport', 'window', 'scrollParent'])) {
-            throw new coding_exception("HTMLElement reference boundaries are not supported." .
-                "Accepted boundaries are 'viewport', 'window', or 'scrollParent'.", DEBUG_DEVELOPER);
-        }
-
-        $this->triggerattributes['data-boundary'] = $boundary;
-    }
-
-    /**
-     * If you call this method the action menu will be displayed but will not be enhanced.
-     *
-     * By not displaying the menu enhanced all items will be displayed in a single row.
-     *
-     * @deprecated since Moodle 3.2
-     */
-    public function do_not_enhance() {
-        debugging('The method action_menu::do_not_enhance() is deprecated, use a list of action_icon instead.', DEBUG_DEVELOPER);
-    }
-
-    /**
-     * Returns true if this action menu will be enhanced.
-     *
-     * @return bool
-     */
-    public function will_be_enhanced() {
-        return isset($this->attributes['data-enhance']);
-    }
-
-    /**
-     * Sets nowrap on items. If true menu items should not wrap lines if they are longer than the available space.
-     *
-     * This property can be useful when the action menu is displayed within a parent element that is either floated
-     * or relatively positioned.
-     * In that situation the width of the menu is determined by the width of the parent element which may not be large
-     * enough for the menu items without them wrapping.
-     * This disables the wrapping so that the menu takes on the width of the longest item.
-     *
-     * @param bool $value If true nowrap gets set, if false it gets removed. Defaults to true.
-     */
-    public function set_nowrap_on_items($value = true) {
-        $class = 'nowrap-items';
-        if (!empty($this->attributes['class'])) {
-            $pos = strpos($this->attributes['class'], $class);
-            if ($value === true && $pos === false) {
-                // The value is true and the class has not been set yet. Add it.
-                $this->attributes['class'] .= ' '.$class;
-            } else if ($value === false && $pos !== false) {
-                // The value is false and the class has been set. Remove it.
-                $this->attributes['class'] = substr($this->attributes['class'], $pos, strlen($class));
-            }
-        } else if ($value) {
-            // The value is true and the class has not been set yet. Add it.
-            $this->attributes['class'] = $class;
-        }
-    }
-
-    /**
-     * Add classes to the action menu for an easier styling.
-     *
-     * @param string $class The class to add to attributes.
-     */
-    public function set_additional_classes(string $class = '') {
-        if (!empty($this->attributes['class'])) {
-            $this->attributes['class'] .= " ".$class;
-        } else {
-            $this->attributes['class'] = $class;
-        }
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output The renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $data = new stdClass();
-        // Assign a role of menubar to this action menu when:
-        // - it contains 2 or more primary actions; or
-        // - if it contains a primary action and secondary actions.
-        if (count($this->primaryactions) > 1 || (!empty($this->primaryactions) && !empty($this->secondaryactions))) {
-            $this->attributes['role'] = 'menubar';
-        }
-        $attributes = $this->attributes;
-
-        $data->instance = $this->instance;
-
-        $data->classes = isset($attributes['class']) ? $attributes['class'] : '';
-        unset($attributes['class']);
-
-        $data->attributes = array_map(function($key, $value) {
-            return [ 'name' => $key, 'value' => $value ];
-        }, array_keys($attributes), $attributes);
-
-        $data->primary = $this->export_primary_actions_for_template($output);
-        $data->secondary = $this->export_secondary_actions_for_template($output);
-        $data->dropdownalignment = $this->dropdownalignment;
-
-        return $data;
-    }
-
-    /**
-     * Export the primary actions for the template.
-     * @param renderer_base $output
-     * @return stdClass
-     */
-    protected function export_primary_actions_for_template(renderer_base $output): stdClass {
-        $attributes = $this->attributes;
-        $attributesprimary = $this->attributesprimary;
-
-        $primary = new stdClass();
-        $primary->title = '';
-        $primary->prioritise = $this->prioritise;
-
-        $primary->classes = isset($attributesprimary['class']) ? $attributesprimary['class'] : '';
-        unset($attributesprimary['class']);
-
-        $primary->attributes = array_map(function ($key, $value) {
-            return ['name' => $key, 'value' => $value];
-        }, array_keys($attributesprimary), $attributesprimary);
-        $primary->triggerattributes = array_map(function ($key, $value) {
-            return ['name' => $key, 'value' => $value];
-        }, array_keys($this->triggerattributes), $this->triggerattributes);
-
-        $actionicon = $this->actionicon;
-        if (!empty($this->menutrigger)) {
-            $primary->menutrigger = $this->menutrigger;
-            $primary->triggerextraclasses = $this->triggerextraclasses;
-            if ($this->actionlabel) {
-                $primary->title = $this->actionlabel;
-            } else if ($this->actiontext) {
-                $primary->title = $this->actiontext;
-            } else {
-                $primary->title = strip_tags($this->menutrigger);
-            }
-        } else {
-            $primary->title = get_string('actionsmenu');
-            $iconattributes = ['class' => 'iconsmall actionmenu', 'title' => $primary->title];
-            $actionicon = new pix_icon('t/edit_menu', '', 'moodle', $iconattributes);
-        }
-
-        // If the menu trigger is within the menubar, assign a role of menuitem. Otherwise, assign as a button.
-        $primary->triggerrole = 'button';
-        if (isset($attributes['role']) && $attributes['role'] === 'menubar') {
-            $primary->triggerrole = 'menuitem';
-        }
-
-        if ($actionicon instanceof pix_icon) {
-            $primary->icon = $actionicon->export_for_pix();
-            if (!empty($actionicon->attributes['alt'])) {
-                $primary->title = $actionicon->attributes['alt'];
-            }
-        } else {
-            $primary->iconraw = $actionicon ? $output->render($actionicon) : '';
-        }
-
-        $primary->actiontext = $this->actiontext ? (string) $this->actiontext : '';
-        $primary->items = array_map(function ($item) use ($output) {
-            $data = (object) [];
-            if ($item instanceof action_menu_link) {
-                $data->actionmenulink = $item->export_for_template($output);
-            } else if ($item instanceof action_menu_filler) {
-                $data->actionmenufiller = $item->export_for_template($output);
-            } else if ($item instanceof action_link) {
-                $data->actionlink = $item->export_for_template($output);
-            } else if ($item instanceof pix_icon) {
-                $data->pixicon = $item->export_for_template($output);
-            } else {
-                $data->rawhtml = ($item instanceof renderable) ? $output->render($item) : $item;
-            }
-            return $data;
-        }, $this->primaryactions);
-        return $primary;
-    }
-
-    /**
-     * Export the secondary actions for the template.
-     * @param renderer_base $output
-     * @return stdClass
-     */
-    protected function export_secondary_actions_for_template(renderer_base $output): stdClass {
-        $attributessecondary = $this->attributessecondary;
-        $secondary = new stdClass();
-        $secondary->classes = isset($attributessecondary['class']) ? $attributessecondary['class'] : '';
-        unset($attributessecondary['class']);
-
-        $secondary->attributes = array_map(function ($key, $value) {
-            return ['name' => $key, 'value' => $value];
-        }, array_keys($attributessecondary), $attributessecondary);
-        $secondary->items = array_map(function ($item) use ($output) {
-            $data = (object) [
-                'simpleitem' => true,
-            ];
-            if ($item instanceof action_menu_link) {
-                $data->actionmenulink = $item->export_for_template($output);
-                $data->simpleitem = false;
-            } else if ($item instanceof action_menu_filler) {
-                $data->actionmenufiller = $item->export_for_template($output);
-                $data->simpleitem = false;
-            } else if ($item instanceof subpanel) {
-                $data->subpanel = $item->export_for_template($output);
-                $data->simpleitem = false;
-            } else if ($item instanceof action_link) {
-                $data->actionlink = $item->export_for_template($output);
-            } else if ($item instanceof pix_icon) {
-                $data->pixicon = $item->export_for_template($output);
-            } else {
-                $data->rawhtml = ($item instanceof renderable) ? $output->render($item) : $item;
-            }
-            return $data;
-        }, $this->secondaryactions);
-        return $secondary;
-    }
-}
-
-/**
- * An action menu filler
- *
- * @package core
- * @category output
- * @copyright 2013 Andrew Nicols
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class action_menu_filler extends action_link implements renderable {
-
-    /**
-     * True if this is a primary action. False if not.
-     * @var bool
-     */
-    public $primary = true;
-
-    /**
-     * Constructs the object.
-     */
-    public function __construct() {
-        $this->attributes['id'] = html_writer::random_id('action_link');
-    }
-}
-
-/**
- * An action menu action
- *
- * @package core
- * @category output
- * @copyright 2013 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class action_menu_link extends action_link implements renderable {
-
-    /**
-     * True if this is a primary action. False if not.
-     * @var bool
-     */
-    public $primary = true;
-
-    /**
-     * The action menu this link has been added to.
-     * @var action_menu
-     */
-    public $actionmenu = null;
-
-    /**
-     * The number of instances of this action menu link (and its subclasses).
-     *
-     * @deprecated since Moodle 4.4.
-     * @var int
-     */
-    protected static $instance = 1;
-
-    /**
-     * Constructs the object.
-     *
-     * @param moodle_url $url The URL for the action.
-     * @param pix_icon|null $icon The icon to represent the action.
-     * @param string $text The text to represent the action.
-     * @param bool $primary Whether this is a primary action or not.
-     * @param array $attributes Any attribtues associated with the action.
-     */
-    public function __construct(moodle_url $url, ?pix_icon $icon, $text, $primary = true, array $attributes = array()) {
-        parent::__construct($url, $text, null, $attributes, $icon);
-        $this->primary = (bool)$primary;
-        $this->add_class('menu-action');
-        $this->attributes['role'] = 'menuitem';
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param renderer_base $output The renderer.
-     * @return stdClass
-     */
-    public function export_for_template(renderer_base $output) {
-        $data = parent::export_for_template($output);
-
-        // Ignore what the parent did with the attributes, except for ID and class.
-        $data->attributes = [];
-        $attributes = $this->attributes;
-        unset($attributes['id']);
-        unset($attributes['class']);
-
-        // Handle text being a renderable.
-        if ($this->text instanceof renderable) {
-            $data->text = $this->render($this->text);
-        }
-
-        $data->showtext = (!$this->icon || $this->primary === false);
-
-        $data->icon = null;
-        if ($this->icon) {
-            $icon = $this->icon;
-            if ($this->primary || !$this->actionmenu->will_be_enhanced()) {
-                $attributes['title'] = $data->text;
-            }
-            $data->icon = $icon ? $icon->export_for_pix() : null;
-        }
-
-        $data->disabled = !empty($attributes['disabled']);
-        unset($attributes['disabled']);
-
-        $data->attributes = array_map(function($key, $value) {
-            return [
-                'name' => $key,
-                'value' => $value
-            ];
-        }, array_keys($attributes), $attributes);
-
-        return $data;
-    }
-}
-
-/**
- * A primary action menu action
- *
- * @package core
- * @category output
- * @copyright 2013 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class action_menu_link_primary extends action_menu_link {
-    /**
-     * Constructs the object.
-     *
-     * @param moodle_url $url
-     * @param pix_icon|null $icon
-     * @param string $text
-     * @param array $attributes
-     */
-    public function __construct(moodle_url $url, ?pix_icon $icon, $text, array $attributes = array()) {
-        parent::__construct($url, $icon, $text, true, $attributes);
-    }
-}
-
-/**
- * A secondary action menu action
- *
- * @package core
- * @category output
- * @copyright 2013 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class action_menu_link_secondary extends action_menu_link {
-    /**
-     * Constructs the object.
-     *
-     * @param moodle_url $url
-     * @param pix_icon|null $icon
-     * @param string $text
-     * @param array $attributes
-     */
-    public function __construct(moodle_url $url, ?pix_icon $icon, $text, array $attributes = array()) {
-        parent::__construct($url, $icon, $text, false, $attributes);
-    }
-}
-
-/**
- * Represents a set of preferences groups.
- *
- * @package core
- * @category output
- * @copyright 2015 Frédéric Massart - FMCorz.net
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class preferences_groups implements renderable {
-
-    /**
-     * Array of preferences_group.
-     * @var array
-     */
-    public $groups;
-
-    /**
-     * Constructor.
-     * @param array $groups of preferences_group
-     */
-    public function __construct($groups) {
-        $this->groups = $groups;
-    }
-
-}
-
-/**
- * Represents a group of preferences page link.
- *
- * @package core
- * @category output
- * @copyright 2015 Frédéric Massart - FMCorz.net
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class preferences_group implements renderable {
-
-    /**
-     * Title of the group.
-     * @var string
-     */
-    public $title;
-
-    /**
-     * Array of navigation_node.
-     * @var array
-     */
-    public $nodes;
-
-    /**
-     * Constructor.
-     * @param string $title The title.
-     * @param array $nodes of navigation_node.
-     */
-    public function __construct($title, $nodes) {
-        $this->title = $title;
-        $this->nodes = $nodes;
-    }
-}
-
-/**
- * Progress bar class.
- *
- * Manages the display of a progress bar.
- *
- * To use this class.
- * - construct
- * - call create (or use the 3rd param to the constructor)
- * - call update or update_full() or update() repeatedly
- *
- * @copyright 2008 jamiesensei
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- * @category output
- */
-class progress_bar implements renderable, templatable {
-    /** @var string html id */
-    private $html_id;
-    /** @var int total width */
-    private $width;
-    /** @var int last percentage printed */
-    private $percent = 0;
-    /** @var int time when last printed */
-    private $lastupdate = 0;
-    /** @var int when did we start printing this */
-    private $time_start = 0;
-
-    /**
-     * Constructor
-     *
-     * Prints JS code if $autostart true.
-     *
-     * @param string $htmlid The container ID.
-     * @param int $width The suggested width.
-     * @param bool $autostart Whether to start the progress bar right away.
-     */
-    public function __construct($htmlid = '', $width = 500, $autostart = false) {
-        if (!CLI_SCRIPT && !NO_OUTPUT_BUFFERING) {
-            debugging('progress_bar used in a non-CLI script without setting NO_OUTPUT_BUFFERING.', DEBUG_DEVELOPER);
-        }
-
-        if (!empty($htmlid)) {
-            $this->html_id  = $htmlid;
-        } else {
-            $this->html_id  = 'pbar_'.uniqid();
-        }
-
-        $this->width = $width;
-
-        if ($autostart) {
-            $this->create();
-        }
-    }
-
-    /**
-     * Getter for ID
-     * @return string id
-     */
-    public function get_id(): string {
-        return $this->html_id;
-    }
-
-    /**
-     * Create a new progress bar, this function will output html.
-     *
-     * @return void Echo's output
-     */
-    public function create() {
-        global $OUTPUT;
-
-        $this->time_start = microtime(true);
-
-        flush();
-        echo $OUTPUT->render($this);
-        flush();
-    }
-
-    /**
-     * Update the progress bar.
-     *
-     * @param int $percent From 1-100.
-     * @param string $msg The message.
-     * @return void Echo's output
-     * @throws coding_exception
-     */
-    private function _update($percent, $msg) {
-        global $OUTPUT;
-
-        if (empty($this->time_start)) {
-            throw new coding_exception('You must call create() (or use the $autostart ' .
-                'argument to the constructor) before you try updating the progress bar.');
-        }
-
-        $estimate = $this->estimate($percent);
-
-        if ($estimate === null) {
-            // Always do the first and last updates.
-        } else if ($estimate == 0) {
-            // Always do the last updates.
-        } else if ($this->lastupdate + 20 < time()) {
-            // We must update otherwise browser would time out.
-        } else if (round($this->percent, 2) === round($percent, 2)) {
-            // No significant change, no need to update anything.
-            return;
-        }
-
-        $estimatemsg = '';
-        if ($estimate != 0 && is_numeric($estimate)) {
-            // Err on the conservative side and also avoid showing 'now' as the estimate.
-            $estimatemsg = format_time(ceil($estimate));
-        }
-
-        $this->percent = $percent;
-        $this->lastupdate = microtime(true);
-
-        echo $OUTPUT->render_progress_bar_update($this->html_id, $this->percent, $msg, $estimatemsg);
-        flush();
-    }
-
-    /**
-     * Estimate how much time it is going to take.
-     *
-     * @param int $pt From 1-100.
-     * @return mixed Null (unknown), or int.
-     */
-    private function estimate($pt) {
-        if ($this->lastupdate == 0) {
-            return null;
-        }
-        if ($pt < 0.00001) {
-            return null; // We do not know yet how long it will take.
-        }
-        if ($pt > 99.99999) {
-            return 0; // Nearly done, right?
-        }
-        $consumed = microtime(true) - $this->time_start;
-        if ($consumed < 0.001) {
-            return null;
-        }
-
-        return (100 - $pt) * ($consumed / $pt);
-    }
-
-    /**
-     * Update progress bar according percent.
-     *
-     * @param int $percent From 1-100.
-     * @param string $msg The message needed to be shown.
-     */
-    public function update_full($percent, $msg) {
-        $percent = max(min($percent, 100), 0);
-        $this->_update($percent, $msg);
-    }
-
-    /**
-     * Update progress bar according the number of tasks.
-     *
-     * @param int $cur Current task number.
-     * @param int $total Total task number.
-     * @param string $msg The message needed to be shown.
-     */
-    public function update($cur, $total, $msg) {
-        $percent = ($cur / $total) * 100;
-        $this->update_full($percent, $msg);
-    }
-
-    /**
-     * Restart the progress bar.
-     */
-    public function restart() {
-        $this->percent    = 0;
-        $this->lastupdate = 0;
-        $this->time_start = 0;
-    }
-
-    /**
-     * Export for template.
-     *
-     * @param  renderer_base $output The renderer.
-     * @return array
-     */
-    public function export_for_template(renderer_base $output) {
-        return [
-            'id' => $this->html_id,
-            'width' => $this->width,
-        ];
-    }
-}
+// This file is deprecated, but it should never have been manually included by anything outside of lib/outputlib.php.
+// Throwing an exception here should be fine because removing the manual inclusion should have no impact.
+throw new \core\exception\coding_exception(
+    'This file should not be manually included by any component.',
+);
diff --git a/lib/outputfactories.php b/lib/outputfactories.php
index aa28a9e6901..0fdca282e68 100644
--- a/lib/outputfactories.php
+++ b/lib/outputfactories.php
@@ -14,436 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Interface and classes for creating appropriate renderers for various parts of Moodle.
- *
- * Please see http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML
- * for an overview.
- *
- * @copyright 2009 Tim Hunt
- * @license  http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- * @category output
- */
-
-defined('MOODLE_INTERNAL') || die();
-
-/** General rendering target, usually normal browser page */
-define('RENDERER_TARGET_GENERAL', 'general');
-
-/** General rendering target, usually normal browser page, but with limited capacity to avoid API use */
-define('RENDERER_TARGET_MAINTENANCE', 'maintenance');
-
-/** Plain text rendering for CLI scripts and cron */
-define('RENDERER_TARGET_CLI', 'cli');
-
-/** Plain text rendering for Ajax scripts*/
-define('RENDERER_TARGET_AJAX', 'ajax');
-
-/** Plain text rendering intended for sending via email */
-define('RENDERER_TARGET_TEXTEMAIL', 'textemail');
-
-/** Rich text html rendering intended for sending via email */
-define('RENDERER_TARGET_HTMLEMAIL', 'htmlemail');
-
-// note: maybe we could define portfolio export target too
-
-
-/**
- * A renderer factory is just responsible for creating an appropriate renderer
- * for any given part of Moodle.
- *
- * Which renderer factory to use is chose by the current theme, and an instance
- * if created automatically when the theme is set up.
- *
- * A renderer factory must also have a constructor that takes a theme_config object.
- * (See {@link renderer_factory_base::__construct} for an example.)
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-interface renderer_factory {
-
-    /**
-     * Return the renderer for a particular part of Moodle.
-     *
-     * The renderer interfaces are defined by classes called {plugin}_renderer
-     * where {plugin} is the name of the component. The renderers for core Moodle are
-     * defined in lib/renderer.php. For plugins, they will be defined in a file
-     * called renderer.php inside the plugin.
-     *
-     * Renderers will normally want to subclass the renderer_base class.
-     * (However, if you really know what you are doing, you don't have to do that.)
-     *
-     * There is no separate interface definition for renderers. The default
-     * {plugin}_renderer implementation also serves to define the API for
-     * other implementations of the interface, whether or not they subclass it.
-     *
-     * A particular plugin can define multiple renderers if it wishes, using the
-     * $subtype parameter. For example workshop_renderer,
-     * workshop_allocation_manual_renderer etc.
-     *
-     * @param moodle_page $page the page the renderer is outputting content for.
-     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
-     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
-     * @param string $target one of rendering target constants
-     * @return renderer_base an object implementing the requested renderer interface.
-     */
-    public function get_renderer(moodle_page $page, $component, $subtype=null, $target=null);
-}
-
-
-/**
- * This is a base class to help you implement the renderer_factory interface.
- *
- * It keeps a cache of renderers that have been constructed, so you only need
- * to construct each one once in you subclass.
- *
- * It also has a method to get the name of, and include the renderer.php with
- * the definition of, the standard renderer class for a given module.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-abstract class renderer_factory_base implements renderer_factory {
-    /**
-     * @var theme_config The theme we belong to.
-     */
-    protected $theme;
-
-    /**
-     * Constructor.
-     *
-     * @param theme_config $theme the theme we belong to.
-     */
-    public function __construct(theme_config $theme) {
-        $this->theme = $theme;
-    }
-
-    /**
-     * Returns suffix of renderer class expected for given target.
-     *
-     * @param string $target one of the renderer target constants, target is guessed if null used
-     * @return array two element array, first element is target, second the target suffix string
-     */
-    protected function get_target_suffix($target) {
-        if (empty($target) || $target === RENDERER_TARGET_MAINTENANCE) {
-            // If the target hasn't been specified we need to guess the defaults.
-            // We also override the target with the default if the maintenance target has been provided.
-            // This ensures we don't use the maintenance renderer if we are processing a special target.
-            if (defined('PREFERRED_RENDERER_TARGET')) {
-                $target = PREFERRED_RENDERER_TARGET;
-            } else if (CLI_SCRIPT) {
-                $target = RENDERER_TARGET_CLI;
-            } else if (AJAX_SCRIPT) {
-                $target = RENDERER_TARGET_AJAX;
-            }
-        }
-
-        switch ($target) {
-            case RENDERER_TARGET_CLI: $suffix = '_cli'; break;
-            case RENDERER_TARGET_AJAX: $suffix = '_ajax'; break;
-            case RENDERER_TARGET_TEXTEMAIL: $suffix = '_textemail'; break;
-            case RENDERER_TARGET_HTMLEMAIL: $suffix = '_htmlemail'; break;
-            case RENDERER_TARGET_MAINTENANCE: $suffix = '_maintenance'; break;
-            default: $target = RENDERER_TARGET_GENERAL; $suffix = '';
-        }
-
-        return array($target, $suffix);
-    }
-
-    /**
-     * For a given module name, return the possible class names
-     * that defines the renderer interface for that module.
-     *
-     * Newer auto-loaded class names are returned as well as the old style _renderable classnames.
-     *
-     * Also, if it exists, include the renderer.php file for that module, so
-     * the class definition of the default renderer has been loaded.
-     *
-     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
-     * @param string $subtype optional subtype such as 'news' resulting to:
-     *              '\mod_forum\output\news_renderer'
-     *              or '\mod_forum\output\news\renderer'
-     *              or non-autoloaded 'mod_forum_news'
-     * @return array[] Each element of the array is an array with keys:
-     *                 classname - The class name to search
-     *                 autoloaded - Does this classname assume autoloading?
-     *                 validwithprefix - Is this class name valid when a prefix is added to it?
-     *                 validwithoutprefix - Is this class name valid when no prefix is added to it?
-     * @throws coding_exception
-     */
-    protected function standard_renderer_classnames($component, $subtype = null) {
-        global $CFG; // Needed in included files.
-        $classnames = array();
-
-        // Standardize component name ala frankenstyle.
-        list($plugin, $type) = core_component::normalize_component($component);
-        if ($type === null) {
-            $component = $plugin;
-        } else {
-            $component = $plugin.'_'.$type;
-        }
-
-        if ($component !== 'core') {
-            // Renderers are stored in renderer.php files.
-            if (!$compdirectory = core_component::get_component_directory($component)) {
-                throw new coding_exception('Invalid component specified in renderer request', $component);
-            }
-            $rendererfile = $compdirectory . '/renderer.php';
-            if (file_exists($rendererfile)) {
-                include_once($rendererfile);
-            }
-
-        } else if (!empty($subtype)) {
-            $coresubsystems = core_component::get_core_subsystems();
-            if (!array_key_exists($subtype, $coresubsystems)) { // There may be nulls.
-                throw new coding_exception('Invalid core subtype "' . $subtype . '" in renderer request', $subtype);
-            }
-            if ($coresubsystems[$subtype]) {
-                $rendererfile = $coresubsystems[$subtype] . '/renderer.php';
-                if (file_exists($rendererfile)) {
-                    include_once($rendererfile);
-                }
-            }
-        }
-
-        if (empty($subtype)) {
-            // Theme specific auto-loaded name (only valid when prefixed with the theme name).
-            $classnames[] = array(
-                'validwithprefix' => true,
-                'validwithoutprefix' => false,
-                'autoloaded' => true,
-                'classname' => '\\output\\' . $component . '_renderer'
-            );
-
-            // Standard autoloaded plugin name (not valid with a prefix).
-            $classnames[] = array(
-                'validwithprefix' => false,
-                'validwithoutprefix' => true,
-                'autoloaded' => true,
-                'classname' => '\\' . $component . '\\output\\renderer'
-            );
-            // Legacy class name - (valid with or without a prefix).
-            $classnames[] = array(
-                'validwithprefix' => true,
-                'validwithoutprefix' => true,
-                'autoloaded' => false,
-                'classname' => $component . '_renderer'
-            );
-        } else {
-            // Theme specific auto-loaded name (only valid when prefixed with the theme name).
-            $classnames[] = array(
-                'validwithprefix' => true,
-                'validwithoutprefix' => false,
-                'autoloaded' => true,
-                'classname' => '\\output\\' . $component . '\\' . $subtype . '_renderer'
-            );
-            // Version of the above with subtype being a namespace level on it's own.
-            $classnames[] = array(
-                'validwithprefix' => true,
-                'validwithoutprefix' => false,
-                'autoloaded' => true,
-                'classname' => '\\output\\' . $component . '\\' . $subtype . '\\renderer'
-            );
-            // Standard autoloaded plugin name (not valid with a prefix).
-            $classnames[] = array(
-                'validwithprefix' => false,
-                'validwithoutprefix' => true,
-                'autoloaded' => true,
-                'classname' => '\\' . $component . '\\output\\' . $subtype . '_renderer'
-            );
-            // Version of the above with subtype being a namespace level on it's own.
-            $classnames[] = array(
-                'validwithprefix' => false,
-                'validwithoutprefix' => true,
-                'autoloaded' => true,
-                'classname' => '\\' . $component . '\\output\\' . $subtype . '\\renderer'
-            );
-            // Legacy class name - (valid with or without a prefix).
-            $classnames[] = array(
-                'validwithprefix' => true,
-                'validwithoutprefix' => true,
-                'autoloaded' => false,
-                'classname' => $component . '_' . $subtype . '_renderer'
-            );
-        }
-        return $classnames;
-    }
-}
-
-/**
- * This is the default renderer factory for Moodle.
- *
- * It simply returns an instance of the appropriate standard renderer class.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class standard_renderer_factory extends renderer_factory_base {
-
-    /**
-     * Implement the subclass method
-     *
-     * @param moodle_page $page the page the renderer is outputting content for.
-     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
-     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
-     * @param string $target one of rendering target constants
-     * @return renderer_base an object implementing the requested renderer interface.
-     */
-    public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) {
-        $classnames = $this->standard_renderer_classnames($component, $subtype);
-        $classname = '';
-
-        list($target, $suffix) = $this->get_target_suffix($target);
-        // First look for a version with a suffix.
-        foreach ($classnames as $classnamedetails) {
-            if ($classnamedetails['validwithoutprefix']) {
-                $newclassname = $classnamedetails['classname'] . $suffix;
-                if (class_exists($newclassname)) {
-                    $classname = $newclassname;
-                    break;
-                } else {
-                    $newclassname = $classnamedetails['classname'];
-                    if (class_exists($newclassname)) {
-                        $classname = $newclassname;
-                        break;
-                    }
-                }
-            }
-        }
-        // Now look for a non-suffixed version.
-        if (empty($classname)) {
-            foreach ($classnames as $classnamedetails) {
-                if ($classnamedetails['validwithoutprefix']) {
-                    $newclassname = $classnamedetails['classname'];
-                    if (class_exists($newclassname)) {
-                        $classname = $newclassname;
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (empty($classname)) {
-            // Standard renderer must always exist.
-            throw new coding_exception('Request for an unknown renderer class. Searched for: ' . var_export($classnames, true));
-        }
-
-        return new $classname($page, $target);
-    }
-}
-
-
-/**
- * This is renderer factory allows themes to override the standard renderers using php code.
- *
- * It will load any code from theme/mytheme/renderers.php and
- * theme/parenttheme/renderers.php, if then exist. Then whenever you ask for
- * a renderer for 'component', it will create a mytheme_component_renderer or a
- * parenttheme_component_renderer, instead of a component_renderer,
- * if either of those classes exist.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class theme_overridden_renderer_factory extends renderer_factory_base {
-
-    /**
-     * @var array An array of renderer prefixes
-     */
-    protected $prefixes = array();
-
-    /**
-     * Constructor.
-     * @param theme_config $theme the theme we are rendering for.
-     */
-    public function __construct(theme_config $theme) {
-        parent::__construct($theme);
-        // Initialise $this->prefixes.
-        $this->prefixes = $theme->renderer_prefixes();
-    }
-
-    /**
-     * Implement the subclass method
-     *
-     * @param moodle_page $page the page the renderer is outputting content for.
-     * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
-     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
-     * @param string $target one of rendering target constants
-     * @return renderer_base an object implementing the requested renderer interface.
-     */
-    public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) {
-        $classnames = $this->standard_renderer_classnames($component, $subtype);
-
-        list($target, $suffix) = $this->get_target_suffix($target);
-
-        // Theme lib.php and renderers.php files are loaded automatically
-        // when loading the theme configs.
-
-        // First try the renderers with correct suffix.
-        foreach ($this->prefixes as $prefix) {
-            foreach ($classnames as $classnamedetails) {
-                if ($classnamedetails['validwithprefix']) {
-                    if ($classnamedetails['autoloaded']) {
-                        $newclassname = $prefix . $classnamedetails['classname'] . $suffix;
-                    } else {
-                        $newclassname = $prefix . '_' . $classnamedetails['classname'] . $suffix;
-                    }
-                    if (class_exists($newclassname)) {
-                        return new $newclassname($page, $target);
-                    }
-                }
-            }
-        }
-        foreach ($classnames as $classnamedetails) {
-            if ($classnamedetails['validwithoutprefix']) {
-                $newclassname = $classnamedetails['classname'] . $suffix;
-                if (class_exists($newclassname)) {
-                    // Use the specialised renderer for given target, default renderer might also decide
-                    // to implement support for more targets.
-                    return new $newclassname($page, $target);
-                }
-            }
-        }
-
-        // Then try general renderer.
-        foreach ($this->prefixes as $prefix) {
-            foreach ($classnames as $classnamedetails) {
-                if ($classnamedetails['validwithprefix']) {
-                    if ($classnamedetails['autoloaded']) {
-                        $newclassname = $prefix . $classnamedetails['classname'];
-                    } else {
-                        $newclassname = $prefix . '_' . $classnamedetails['classname'];
-                    }
-                    if (class_exists($newclassname)) {
-                        return new $newclassname($page, $target);
-                    }
-                }
-            }
-        }
-
-        // Final attempt - no prefix or suffix.
-        foreach ($classnames as $classnamedetails) {
-            if ($classnamedetails['validwithoutprefix']) {
-                $newclassname = $classnamedetails['classname'];
-                if (class_exists($newclassname)) {
-                    return new $newclassname($page, $target);
-                }
-            }
-        }
-        throw new coding_exception('Request for an unknown renderer ' . $component . ', ' . $subtype . ', ' . $target);
-    }
-}
+// This file is deprecated, but it should never have been manually included by anything outside of lib/outputlib.php.
+// Throwing an exception here should be fine because removing the manual inclusion should have no impact.
+throw new \core\exception\coding_exception(
+    'This file should not be manually included by any component.',
+);
diff --git a/lib/outputfragmentrequirementslib.php b/lib/outputfragmentrequirementslib.php
index da753ef3332..2b6fa039198 100644
--- a/lib/outputfragmentrequirementslib.php
+++ b/lib/outputfragmentrequirementslib.php
@@ -14,116 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Library functions to facilitate the use of JavaScript in Moodle.
- *
- * @copyright 2016 Adrian Greeve <adrian@moodle.com>
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- * @category output
- */
-
-defined('MOODLE_INTERNAL') || die();
-
-/**
- * This requirements manager captures the appropriate html for creating a fragment to
- * be inserted elsewhere.
- *
- * @copyright 2016 Adrian Greeve <adrian@moodle.com>
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 3.1
- * @package core
- * @category output
- */
-class fragment_requirements_manager extends page_requirements_manager {
-
-    /**
-     * Page fragment constructor.
-     */
-    public function __construct() {
-        parent::__construct();
-        // As this is a fragment the header should already be done.
-        $this->headdone = true;
-    }
-
-    /**
-     * Returns js code to load amd module loader, then insert inline script tags
-     * that contain require() calls using RequireJS.
-     *
-     * @return string
-     */
-    protected function get_amd_footercode() {
-        global $CFG;
-        $output = '';
-
-        // First include must be to a module with no dependencies, this prevents multiple requests.
-        $prefix = 'M.util.js_pending("core/first");';
-        $prefix .= "require(['core/first'], function() {\n";
-        $suffix = "\n});";
-        $suffix .= 'M.util.js_complete("core/first");';
-        $output .= html_writer::script($prefix . implode(";\n", $this->amdjscode) . $suffix);
-        return $output;
-    }
-
-
-    /**
-     * Generate any HTML that needs to go at the end of the page.
-     *
-     * @return string the HTML code to to at the end of the page.
-     */
-    public function get_end_code() {
-        global $CFG;
-
-        $output = '';
-
-        // Call amd init functions.
-        $output .= $this->get_amd_footercode();
-
-        // Add other requested modules.
-        $output .= $this->get_extra_modules_code();
-
-        // All the other linked scripts - there should be as few as possible.
-        if ($this->jsincludes['footer']) {
-            foreach ($this->jsincludes['footer'] as $url) {
-                $output .= html_writer::script('', $url);
-            }
-        }
-
-        if (!empty($this->stringsforjs)) {
-            // Add all needed strings.
-            $strings = array();
-            foreach ($this->stringsforjs as $component => $v) {
-                foreach ($v as $indentifier => $langstring) {
-                    $strings[$component][$indentifier] = $langstring->out();
-                }
-            }
-            // Append don't overwrite.
-            $output .= html_writer::script('require(["jquery"], function($) {
-                M.str = $.extend(true, M.str, ' . json_encode($strings) . ');
-            });');
-        }
-
-        // Add variables.
-        if ($this->jsinitvariables['footer']) {
-            $js = '';
-            foreach ($this->jsinitvariables['footer'] as $data) {
-                list($var, $value) = $data;
-                $js .= js_writer::set_variable($var, $value, true);
-            }
-            $output .= html_writer::script($js);
-        }
-
-        $inyuijs = $this->get_javascript_code(false);
-        $ondomreadyjs = $this->get_javascript_code(true);
-        // See if this is still needed when we get to the ajax page.
-        $jsinit = $this->get_javascript_init_code();
-        $handlersjs = $this->get_event_handler_code();
-
-        // There is a global Y, make sure it is available in your scope.
-        $js = "(function() {{$inyuijs}{$ondomreadyjs}{$jsinit}{$handlersjs}})();";
-
-        $output .= html_writer::script($js);
-
-        return $output;
-    }
-}
+// This file is deprecated, but it should never have been manually included by anything outside of lib/pagelib.php.
+// Throwing an exception here should be fine because removing the manual inclusion should have no impact.
+throw new \core\exception\coding_exception(
+    'This file should not be manually included by any component.',
+);
diff --git a/lib/outputlib.php b/lib/outputlib.php
index 2925074bbcc..4dbf86e0b3b 100644
--- a/lib/outputlib.php
+++ b/lib/outputlib.php
@@ -26,13 +26,23 @@
  * @category output
  */
 
-defined('MOODLE_INTERNAL') || die();
+/** General rendering target, usually normal browser page */
+define('RENDERER_TARGET_GENERAL', 'general');
 
-require_once($CFG->libdir.'/outputcomponents.php');
-require_once($CFG->libdir.'/outputactions.php');
-require_once($CFG->libdir.'/outputfactories.php');
-require_once($CFG->libdir.'/outputrenderers.php');
-require_once($CFG->libdir.'/outputrequirementslib.php');
+/** General rendering target, usually normal browser page, but with limited capacity to avoid API use */
+define('RENDERER_TARGET_MAINTENANCE', 'maintenance');
+
+/** Plain text rendering for CLI scripts and cron */
+define('RENDERER_TARGET_CLI', 'cli');
+
+/** Plain text rendering for Ajax scripts*/
+define('RENDERER_TARGET_AJAX', 'ajax');
+
+/** Plain text rendering intended for sending via email */
+define('RENDERER_TARGET_TEXTEMAIL', 'textemail');
+
+/** Rich text html rendering intended for sending via email */
+define('RENDERER_TARGET_HTMLEMAIL', 'htmlemail');
 
 /**
  * Returns current theme revision number.
@@ -328,2438 +338,35 @@ function theme_delete_used_in_context_cache(string $newtheme, string $oldtheme):
 }
 
 /**
- * This class represents the configuration variables of a Moodle theme.
- *
- * All the variables with access: public below (with a few exceptions that are marked)
- * are the properties you can set in your themes config.php file.
- *
- * There are also some methods and protected variables that are part of the inner
- * workings of Moodle's themes system. If you are just editing a themes config.php
- * file, you can just ignore those, and the following information for developers.
- *
- * Normally, to create an instance of this class, you should use the
- * {@link theme_config::load()} factory method to load a themes config.php file.
- * However, normally you don't need to bother, because moodle_page (that is, $PAGE)
- * will create one for you, accessible as $PAGE->theme.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
+ * Invalidate all server and client side template caches.
  */
-class theme_config {
+function template_reset_all_caches() {
+    global $CFG;
 
-    /**
-     * @var string Default theme, used when requested theme not found.
-     */
-    const DEFAULT_THEME = 'boost';
-
-    /** The key under which the SCSS file is stored amongst the CSS files. */
-    const SCSS_KEY = '__SCSS__';
-
-    /**
-     * @var array You can base your theme on other themes by linking to the other theme as
-     * parents. This lets you use the CSS and layouts from the other themes
-     * (see {@link theme_config::$layouts}).
-     * That makes it easy to create a new theme that is similar to another one
-     * but with a few changes. In this themes CSS you only need to override
-     * those rules you want to change.
-     */
-    public $parents;
-
-    /**
-     * @var array The names of all the stylesheets from this theme that you would
-     * like included, in order. Give the names of the files without .css.
-     */
-    public $sheets = array();
-
-    /**
-     * @var array The names of all the stylesheets from parents that should be excluded.
-     * true value may be used to specify all parents or all themes from one parent.
-     * If no value specified value from parent theme used.
-     */
-    public $parents_exclude_sheets = null;
-
-    /**
-     * @var array List of plugin sheets to be excluded.
-     * If no value specified value from parent theme used.
-     */
-    public $plugins_exclude_sheets = null;
-
-    /**
-     * @var array List of style sheets that are included in the text editor bodies.
-     * Sheets from parent themes are used automatically and can not be excluded.
-     */
-    public $editor_sheets = array();
-
-    /**
-     * @var bool Whether a fallback version of the stylesheet will be used
-     * whilst the final version is generated.
-     */
-    public $usefallback = false;
-
-    /**
-     * @var array The names of all the javascript files this theme that you would
-     * like included from head, in order. Give the names of the files without .js.
-     */
-    public $javascripts = array();
-
-    /**
-     * @var array The names of all the javascript files this theme that you would
-     * like included from footer, in order. Give the names of the files without .js.
-     */
-    public $javascripts_footer = array();
-
-    /**
-     * @var array The names of all the javascript files from parents that should
-     * be excluded. true value may be used to specify all parents or all themes
-     * from one parent.
-     * If no value specified value from parent theme used.
-     */
-    public $parents_exclude_javascripts = null;
-
-    /**
-     * @var array Which file to use for each page layout.
-     *
-     * This is an array of arrays. The keys of the outer array are the different layouts.
-     * Pages in Moodle are using several different layouts like 'normal', 'course', 'home',
-     * 'popup', 'form', .... The most reliable way to get a complete list is to look at
-     * {@link http://cvs.moodle.org/moodle/theme/base/config.php?view=markup the base theme config.php file}.
-     * That file also has a good example of how to set this setting.
-     *
-     * For each layout, the value in the outer array is an array that describes
-     * how you want that type of page to look. For example
-     * <pre>
-     *   $THEME->layouts = array(
-     *       // Most pages - if we encounter an unknown or a missing page type, this one is used.
-     *       'standard' => array(
-     *           'theme' = 'mytheme',
-     *           'file' => 'normal.php',
-     *           'regions' => array('side-pre', 'side-post'),
-     *           'defaultregion' => 'side-post'
-     *       ),
-     *       // The site home page.
-     *       'home' => array(
-     *           'theme' = 'mytheme',
-     *           'file' => 'home.php',
-     *           'regions' => array('side-pre', 'side-post'),
-     *           'defaultregion' => 'side-post'
-     *       ),
-     *       // ...
-     *   );
-     * </pre>
-     *
-     * 'theme' name of the theme where is the layout located
-     * 'file' is the layout file to use for this type of page.
-     * layout files are stored in layout subfolder
-     * 'regions' This lists the regions on the page where blocks may appear. For
-     * each region you list here, your layout file must include a call to
-     * <pre>
-     *   echo $OUTPUT->blocks_for_region($regionname);
-     * </pre>
-     * or equivalent so that the blocks are actually visible.
-     *
-     * 'defaultregion' If the list of regions is non-empty, then you must pick
-     * one of the one of them as 'default'. This has two meanings. First, this is
-     * where new blocks are added. Second, if there are any blocks associated with
-     * the page, but in non-existent regions, they appear here. (Imaging, for example,
-     * that someone added blocks using a different theme that used different region
-     * names, and then switched to this theme.)
-     */
-    public $layouts = array();
-
-    /**
-     * @var string Name of the renderer factory class to use. Must implement the
-     * {@link renderer_factory} interface.
-     *
-     * This is an advanced feature. Moodle output is generated by 'renderers',
-     * you can customise the HTML that is output by writing custom renderers,
-     * and then you need to specify 'renderer factory' so that Moodle can find
-     * your renderers.
-     *
-     * There are some renderer factories supplied with Moodle. Please follow these
-     * links to see what they do.
-     * <ul>
-     * <li>{@link standard_renderer_factory} - the default.</li>
-     * <li>{@link theme_overridden_renderer_factory} - use this if you want to write
-     *      your own custom renderers in a lib.php file in this theme (or the parent theme).</li>
-     * </ul>
-     */
-    public $rendererfactory = 'standard_renderer_factory';
-
-    /**
-     * @var string Function to do custom CSS post-processing.
-     *
-     * This is an advanced feature. If you want to do custom post-processing on the
-     * CSS before it is output (for example, to replace certain variable names
-     * with particular values) you can give the name of a function here.
-     */
-    public $csspostprocess = null;
-
-    /**
-     * @var string Function to do custom CSS post-processing on a parsed CSS tree.
-     *
-     * This is an advanced feature. If you want to do custom post-processing on the
-     * CSS before it is output, you can provide the name of the function here. The
-     * function will receive a CSS tree document as first parameter, and the theme_config
-     * object as second parameter. A return value is not required, the tree can
-     * be edited in place.
-     */
-    public $csstreepostprocessor = null;
-
-    /**
-     * @var string Accessibility: Right arrow-like character is
-     * used in the breadcrumb trail, course navigation menu
-     * (previous/next activity), calendar, and search forum block.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically. Please DO NOT
-     * use &lt; &gt; &raquo; - these are confusing for blind users.
-     */
-    public $rarrow = null;
-
-    /**
-     * @var string Accessibility: Left arrow-like character is
-     * used in the breadcrumb trail, course navigation menu
-     * (previous/next activity), calendar, and search forum block.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically. Please DO NOT
-     * use &lt; &gt; &raquo; - these are confusing for blind users.
-     */
-    public $larrow = null;
-
-    /**
-     * @var string Accessibility: Up arrow-like character is used in
-     * the book heirarchical navigation.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically. Please DO NOT
-     * use ^ - this is confusing for blind users.
-     */
-    public $uarrow = null;
-
-    /**
-     * @var string Accessibility: Down arrow-like character.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically.
-     */
-    public $darrow = null;
-
-    /**
-     * @var bool Some themes may want to disable ajax course editing.
-     */
-    public $enablecourseajax = true;
-
-    /**
-     * @var string Determines served document types
-     *  - 'html5' the only officially supported doctype in Moodle
-     *  - 'xhtml5' may be used in development for validation (not intended for production servers!)
-     *  - 'xhtml' XHTML 1.0 Strict for legacy themes only
-     */
-    public $doctype = 'html5';
-
-    /**
-     * @var string|false requiredblocks If set to a string, will list the block types that cannot be deleted. Defaults to
-     *                                   navigation and settings.
-     */
-    public $requiredblocks = false;
-
-    //==Following properties are not configurable from theme config.php==
-
-    /**
-     * @var string The name of this theme. Set automatically when this theme is
-     * loaded. This can not be set in theme config.php
-     */
-    public $name;
-
-    /**
-     * @var string The folder where this themes files are stored. This is set
-     * automatically. This can not be set in theme config.php
-     */
-    public $dir;
-
-    /**
-     * @var stdClass Theme settings stored in config_plugins table.
-     * This can not be set in theme config.php
-     */
-    public $settings = null;
-
-    /**
-     * @var bool If set to true and the theme enables the dock then  blocks will be able
-     * to be moved to the special dock
-     */
-    public $enable_dock = false;
-
-    /**
-     * @var bool If set to true then this theme will not be shown in the theme selector unless
-     * theme designer mode is turned on.
-     */
-    public $hidefromselector = false;
-
-    /**
-     * @var array list of YUI CSS modules to be included on each page. This may be used
-     * to remove cssreset and use cssnormalise module instead.
-     */
-    public $yuicssmodules = array('cssreset', 'cssfonts', 'cssgrids', 'cssbase');
-
-    /**
-     * An associative array of block manipulations that should be made if the user is using an rtl language.
-     * The key is the original block region, and the value is the block region to change to.
-     * This is used when displaying blocks for regions only.
-     * @var array
-     */
-    public $blockrtlmanipulations = array();
-
-    /**
-     * @var renderer_factory Instance of the renderer_factory implementation
-     * we are using. Implementation detail.
-     */
-    protected $rf = null;
-
-    /**
-     * @var array List of parent config objects.
-     **/
-    protected $parent_configs = array();
-
-    /**
-     * Used to determine whether we can serve SVG images or not.
-     * @var bool
-     */
-    private $usesvg = null;
-
-    /**
-     * Whether in RTL mode or not.
-     * @var bool
-     */
-    protected $rtlmode = false;
-
-    /**
-     * The SCSS file to compile (without .scss), located in the scss/ folder of the theme.
-     * Or a Closure, which receives the theme_config as argument and must
-     * return the SCSS content.
-     * @var string|Closure
-     */
-    public $scss = false;
-
-    /**
-     * Local cache of the SCSS property.
-     * @var false|array
-     */
-    protected $scsscache = null;
-
-    /**
-     * The name of the function to call to get the SCSS code to inject.
-     * @var string
-     */
-    public $extrascsscallback = null;
-
-    /**
-     * The name of the function to call to get SCSS to prepend.
-     * @var string
-     */
-    public $prescsscallback = null;
-
-    /**
-     * Sets the render method that should be used for rendering custom block regions by scripts such as my/index.php
-     * Defaults to {@link core_renderer::blocks_for_region()}
-     * @var string
-     */
-    public $blockrendermethod = null;
-
-    /**
-     * Remember the results of icon remapping for the current page.
-     * @var array
-     */
-    public $remapiconcache = [];
-
-    /**
-     * The name of the function to call to get precompiled CSS.
-     * @var string
-     */
-    public $precompiledcsscallback = null;
-
-    /**
-     * Whether the theme uses course index.
-     * @var bool
-     */
-    public $usescourseindex = false;
-
-    /**
-     * Configuration for the page activity header
-     * @var array
-     */
-    public $activityheaderconfig = [];
-
-    /**
-     * For backward compatibility with old themes.
-     * BLOCK_ADDBLOCK_POSITION_DEFAULT, BLOCK_ADDBLOCK_POSITION_FLATNAV.
-     * @var int
-     */
-    public $addblockposition;
-
-    /**
-     * editor_scss file(s) provided by this theme.
-     * @var array
-     */
-    public $editor_scss;
-
-    /**
-     * Name of the class extending \core\output\icon_system.
-     * @var string
-     */
-    public $iconsystem;
-
-    /**
-     * Theme defines its own editing mode switch.
-     * @var bool
-     */
-    public $haseditswitch = false;
-
-    /**
-     * Allows a theme to customise primary navigation by specifying the list of items to remove.
-     * @var array
-     */
-    public $removedprimarynavitems = [];
-
-    /**
-     * Load the config.php file for a particular theme, and return an instance
-     * of this class. (That is, this is a factory method.)
-     *
-     * @param string $themename the name of the theme.
-     * @return theme_config an instance of this class.
-     */
-    public static function load($themename) {
-        global $CFG;
-
-        // load theme settings from db
-        try {
-            $settings = get_config('theme_'.$themename);
-        } catch (dml_exception $e) {
-            // most probably moodle tables not created yet
-            $settings = new stdClass();
-        }
-
-        if ($config = theme_config::find_theme_config($themename, $settings)) {
-            return new theme_config($config);
-
-        } else if ($themename == theme_config::DEFAULT_THEME) {
-            throw new coding_exception('Default theme '.theme_config::DEFAULT_THEME.' not available or broken!');
-
-        } else if ($config = theme_config::find_theme_config($CFG->theme, $settings)) {
-            debugging('This page should be using theme ' . $themename .
-                    ' which cannot be initialised. Falling back to the site theme ' . $CFG->theme, DEBUG_NORMAL);
-            return new theme_config($config);
-
-        } else {
-            // bad luck, the requested theme has some problems - admin see details in theme config
-            debugging('This page should be using theme ' . $themename .
-                    ' which cannot be initialised. Nor can the site theme ' . $CFG->theme .
-                    '. Falling back to ' . theme_config::DEFAULT_THEME, DEBUG_NORMAL);
-            return new theme_config(theme_config::find_theme_config(theme_config::DEFAULT_THEME, $settings));
-        }
-    }
-
-    /**
-     * Theme diagnostic code. It is very problematic to send debug output
-     * to the actual CSS file, instead this functions is supposed to
-     * diagnose given theme and highlights all potential problems.
-     * This information should be available from the theme selection page
-     * or some other debug page for theme designers.
-     *
-     * @param string $themename
-     * @return array description of problems
-     */
-    public static function diagnose($themename) {
-        //TODO: MDL-21108
-        return array();
-    }
-
-    /**
-     * Private constructor, can be called only from the factory method.
-     * @param stdClass $config
-     */
-    private function __construct($config) {
-        global $CFG; //needed for included lib.php files
-
-        $this->settings = $config->settings;
-        $this->name     = $config->name;
-        $this->dir      = $config->dir;
-
-        if ($this->name != self::DEFAULT_THEME) {
-            $baseconfig = self::find_theme_config(self::DEFAULT_THEME, $this->settings);
-        } else {
-            $baseconfig = $config;
-        }
-
-        // Ensure that each of the configurable properties defined below are also defined at the class level.
-        $configurable = [
-            'parents', 'sheets', 'parents_exclude_sheets', 'plugins_exclude_sheets', 'usefallback',
-            'javascripts', 'javascripts_footer', 'parents_exclude_javascripts',
-            'layouts', 'enablecourseajax', 'requiredblocks',
-            'rendererfactory', 'csspostprocess', 'editor_sheets', 'editor_scss', 'rarrow', 'larrow', 'uarrow', 'darrow',
-            'hidefromselector', 'doctype', 'yuicssmodules', 'blockrtlmanipulations', 'blockrendermethod',
-            'scss', 'extrascsscallback', 'prescsscallback', 'csstreepostprocessor', 'addblockposition',
-            'iconsystem', 'precompiledcsscallback', 'haseditswitch', 'usescourseindex', 'activityheaderconfig',
-            'removedprimarynavitems',
-        ];
-
-        foreach ($config as $key=>$value) {
-            if (in_array($key, $configurable)) {
-                $this->$key = $value;
-            }
-        }
-
-        // verify all parents and load configs and renderers
-        foreach ($this->parents as $parent) {
-            if (!$parent_config = theme_config::find_theme_config($parent, $this->settings)) {
-                // this is not good - better exclude faulty parents
-                continue;
-            }
-            $libfile = $parent_config->dir.'/lib.php';
-            if (is_readable($libfile)) {
-                // theme may store various function here
-                include_once($libfile);
-            }
-            $renderersfile = $parent_config->dir.'/renderers.php';
-            if (is_readable($renderersfile)) {
-                // may contain core and plugin renderers and renderer factory
-                include_once($renderersfile);
-            }
-            $this->parent_configs[$parent] = $parent_config;
-        }
-        $libfile = $this->dir.'/lib.php';
-        if (is_readable($libfile)) {
-            // theme may store various function here
-            include_once($libfile);
-        }
-        $rendererfile = $this->dir.'/renderers.php';
-        if (is_readable($rendererfile)) {
-            // may contain core and plugin renderers and renderer factory
-            include_once($rendererfile);
-        } else {
-            // check if renderers.php file is missnamed renderer.php
-            if (is_readable($this->dir.'/renderer.php')) {
-                debugging('Developer hint: '.$this->dir.'/renderer.php should be renamed to ' . $this->dir."/renderers.php.
-                    See: http://docs.moodle.org/dev/Output_renderers#Theme_renderers.", DEBUG_DEVELOPER);
-            }
-        }
-
-        // cascade all layouts properly
-        foreach ($baseconfig->layouts as $layout=>$value) {
-            if (!isset($this->layouts[$layout])) {
-                foreach ($this->parent_configs as $parent_config) {
-                    if (isset($parent_config->layouts[$layout])) {
-                        $this->layouts[$layout] = $parent_config->layouts[$layout];
-                        continue 2;
-                    }
-                }
-                $this->layouts[$layout] = $value;
-            }
-        }
-
-        //fix arrows if needed
-        $this->check_theme_arrows();
-    }
-
-    /**
-     * Let the theme initialise the page object (usually $PAGE).
-     *
-     * This may be used for example to request jQuery in add-ons.
-     *
-     * @param moodle_page $page
-     */
-    public function init_page(moodle_page $page) {
-        $themeinitfunction = 'theme_'.$this->name.'_page_init';
-        if (function_exists($themeinitfunction)) {
-            $themeinitfunction($page);
-        }
-    }
-
-    /**
-     * Checks if arrows $THEME->rarrow, $THEME->larrow, $THEME->uarrow, $THEME->darrow have been set (theme/-/config.php).
-     * If not it applies sensible defaults.
-     *
-     * Accessibility: right and left arrow Unicode characters for breadcrumb, calendar,
-     * search forum block, etc. Important: these are 'silent' in a screen-reader
-     * (unlike &gt; &raquo;), and must be accompanied by text.
-     */
-    private function check_theme_arrows() {
-        if (!isset($this->rarrow) and !isset($this->larrow)) {
-            // Default, looks good in Win XP/IE 6, Win/Firefox 1.5, Win/Netscape 8...
-            // Also OK in Win 9x/2K/IE 5.x
-            $this->rarrow = '&#x25BA;';
-            $this->larrow = '&#x25C4;';
-            $this->uarrow = '&#x25B2;';
-            $this->darrow = '&#x25BC;';
-            if (empty($_SERVER['HTTP_USER_AGENT'])) {
-                $uagent = '';
-            } else {
-                $uagent = $_SERVER['HTTP_USER_AGENT'];
-            }
-            if (false !== strpos($uagent, 'Opera')
-                || false !== strpos($uagent, 'Mac')) {
-                // Looks good in Win XP/Mac/Opera 8/9, Mac/Firefox 2, Camino, Safari.
-                // Not broken in Mac/IE 5, Mac/Netscape 7 (?).
-                $this->rarrow = '&#x25B6;&#xFE0E;';
-                $this->larrow = '&#x25C0;&#xFE0E;';
-            }
-            elseif ((false !== strpos($uagent, 'Konqueror'))
-                || (false !== strpos($uagent, 'Android')))  {
-                // The fonts on Android don't include the characters required for this to work as expected.
-                // So we use the same ones Konqueror uses.
-                $this->rarrow = '&rarr;';
-                $this->larrow = '&larr;';
-                $this->uarrow = '&uarr;';
-                $this->darrow = '&darr;';
-            }
-            elseif (isset($_SERVER['HTTP_ACCEPT_CHARSET'])
-                && false === stripos($_SERVER['HTTP_ACCEPT_CHARSET'], 'utf-8')) {
-                // (Win/IE 5 doesn't set ACCEPT_CHARSET, but handles Unicode.)
-                // To be safe, non-Unicode browsers!
-                $this->rarrow = '&gt;';
-                $this->larrow = '&lt;';
-                $this->uarrow = '^';
-                $this->darrow = 'v';
-            }
-
-            // RTL support - in RTL languages, swap r and l arrows
-            if (right_to_left()) {
-                $t = $this->rarrow;
-                $this->rarrow = $this->larrow;
-                $this->larrow = $t;
-            }
-        }
-    }
-
-    /**
-     * Returns output renderer prefixes, these are used when looking
-     * for the overridden renderers in themes.
-     *
-     * @return array
-     */
-    public function renderer_prefixes() {
-        global $CFG; // just in case the included files need it
-
-        $prefixes = array('theme_'.$this->name);
-
-        foreach ($this->parent_configs as $parent) {
-            $prefixes[] = 'theme_'.$parent->name;
-        }
-
-        return $prefixes;
-    }
-
-    /**
-     * Returns the stylesheet URL of this editor content
-     *
-     * @param bool $encoded false means use & and true use &amp; in URLs
-     * @return moodle_url
-     */
-    public function editor_css_url($encoded=true) {
-        global $CFG;
-        $rev = theme_get_revision();
-        $type = 'editor';
-        if (right_to_left()) {
-            $type .= '-rtl';
-        }
-
-        if ($rev > -1) {
-            $themesubrevision = theme_get_sub_revision_for_theme($this->name);
-
-            // Provide the sub revision to allow us to invalidate cached theme CSS
-            // on a per theme basis, rather than globally.
-            if ($themesubrevision && $themesubrevision > 0) {
-                $rev .= "_{$themesubrevision}";
-            }
-
-            $url = new moodle_url("/theme/styles.php");
-            if (!empty($CFG->slasharguments)) {
-                $url->set_slashargument("/{$this->name}/{$rev}/{$type}", 'noparam', true);
-            } else {
-                $url->params([
-                    'theme' => $this->name,
-                    'rev' => $rev,
-                    'type' => $type,
-                ]);
-            }
-        } else {
-            $url = new moodle_url('/theme/styles_debug.php', [
-                'theme' => $this->name,
-                'type' => $type,
-            ]);
-        }
-        return $url;
-    }
-
-    /**
-     * Returns the content of the CSS to be used in editor content
-     *
-     * @return array
-     */
-    public function editor_css_files() {
-        $files = array();
-
-        // First editor plugins.
-        $plugins = core_component::get_plugin_list('editor');
-        foreach ($plugins as $plugin => $fulldir) {
-            $sheetfile = "$fulldir/editor_styles.css";
-            if (is_readable($sheetfile)) {
-                $files['plugin_'.$plugin] = $sheetfile;
-            }
-
-            $subplugintypes = core_component::get_subplugins("editor_{$plugin}") ?? [];
-            // Fetch sheets for any editor subplugins.
-            foreach ($subplugintypes as $plugintype => $subplugins) {
-                foreach ($subplugins as $subplugin) {
-                    $plugindir = core_component::get_plugin_directory($plugintype, $subplugin);
-                    $sheetfile = "{$plugindir}/editor_styles.css";
-                    if (is_readable($sheetfile)) {
-                        $files["{$plugintype}_{$subplugin}"] = $sheetfile;
-                    }
-                }
-            }
-        }
-
-        // Then parent themes - base first, the immediate parent last.
-        foreach (array_reverse($this->parent_configs) as $parent_config) {
-            if (empty($parent_config->editor_sheets)) {
-                continue;
-            }
-            foreach ($parent_config->editor_sheets as $sheet) {
-                $sheetfile = "$parent_config->dir/style/$sheet.css";
-                if (is_readable($sheetfile)) {
-                    $files['parent_'.$parent_config->name.'_'.$sheet] = $sheetfile;
-                }
-            }
-        }
-        // Finally this theme.
-        if (!empty($this->editor_sheets)) {
-            foreach ($this->editor_sheets as $sheet) {
-                $sheetfile = "$this->dir/style/$sheet.css";
-                if (is_readable($sheetfile)) {
-                    $files['theme_'.$sheet] = $sheetfile;
-                }
-            }
-        }
-
-        return $files;
-    }
-
-    /**
-     * Compiles and returns the content of the SCSS to be used in editor content
-     *
-     * @return string Compiled CSS from the editor SCSS
-     */
-    public function editor_scss_to_css() {
-        $css = '';
-        $dir = $this->dir;
-        $filenames = [];
-
-        // Use editor_scss file(s) provided by this theme if set.
-        if (!empty($this->editor_scss)) {
-            $filenames = $this->editor_scss;
-        } else {
-            // If no editor_scss set, move up theme hierarchy until one is found (if at all).
-            // This is so child themes only need to set editor_scss if an override is required.
-            foreach (array_reverse($this->parent_configs) as $parentconfig) {
-                if (!empty($parentconfig->editor_scss)) {
-                    $dir = $parentconfig->dir;
-                    $filenames = $parentconfig->editor_scss;
-
-                    // Config found, stop looking.
-                    break;
-                }
-            }
-        }
-
-        if (!empty($filenames)) {
-            $compiler = new core_scss();
-
-            foreach ($filenames as $filename) {
-                $compiler->set_file("{$dir}/scss/{$filename}.scss");
-
-                try {
-                    $css .= $compiler->to_css();
-                } catch (\Exception $e) {
-                    debugging('Error while compiling editor SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER);
-                }
-            }
-        }
-
-        return $css;
-    }
-
-    /**
-     * Get the stylesheet URL of this theme.
-     *
-     * @param moodle_page $page Not used... deprecated?
-     * @return moodle_url[]
-     */
-    public function css_urls(moodle_page $page) {
-        global $CFG;
-
-        $rev = theme_get_revision();
-
-        $urls = array();
-
-        $svg = $this->use_svg_icons();
-        $separate = (core_useragent::is_ie() && !core_useragent::check_ie_version('10'));
-
-        if ($rev > -1) {
-            $filename = right_to_left() ? 'all-rtl' : 'all';
-            $url = new moodle_url("/theme/styles.php");
-            $themesubrevision = theme_get_sub_revision_for_theme($this->name);
-
-            // Provide the sub revision to allow us to invalidate cached theme CSS
-            // on a per theme basis, rather than globally.
-            if ($themesubrevision && $themesubrevision > 0) {
-                $rev .= "_{$themesubrevision}";
-            }
-
-            if (!empty($CFG->slasharguments)) {
-                $slashargs = '';
-                if (!$svg) {
-                    // We add a simple /_s to the start of the path.
-                    // The underscore is used to ensure that it isn't a valid theme name.
-                    $slashargs .= '/_s'.$slashargs;
-                }
-                $slashargs .= '/'.$this->name.'/'.$rev.'/'.$filename;
-                if ($separate) {
-                    $slashargs .= '/chunk0';
-                }
-                $url->set_slashargument($slashargs, 'noparam', true);
-            } else {
-                $params = array('theme' => $this->name, 'rev' => $rev, 'type' => $filename);
-                if (!$svg) {
-                    // We add an SVG param so that we know not to serve SVG images.
-                    // We do this because all modern browsers support SVG and this param will one day be removed.
-                    $params['svg'] = '0';
-                }
-                if ($separate) {
-                    $params['chunk'] = '0';
-                }
-                $url->params($params);
-            }
-            $urls[] = $url;
-
-        } else {
-            $baseurl = new moodle_url('/theme/styles_debug.php');
-
-            $css = $this->get_css_files(true);
-            if (!$svg) {
-                // We add an SVG param so that we know not to serve SVG images.
-                // We do this because all modern browsers support SVG and this param will one day be removed.
-                $baseurl->param('svg', '0');
-            }
-            if (right_to_left()) {
-                $baseurl->param('rtl', 1);
-            }
-            if ($separate) {
-                // We might need to chunk long files.
-                $baseurl->param('chunk', '0');
-            }
-            if (core_useragent::is_ie()) {
-                // Lalala, IE does not allow more than 31 linked CSS files from main document.
-                $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'plugins'));
-                foreach ($css['parents'] as $parent=>$sheets) {
-                    // We need to serve parents individually otherwise we may easily exceed the style limit IE imposes (4096).
-                    $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'ie', 'subtype'=>'parents', 'sheet'=>$parent));
-                }
-                if ($this->get_scss_property()) {
-                    // No need to define the type as IE here.
-                    $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss'));
-                }
-                $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'theme'));
-
-            } else {
-                foreach ($css['plugins'] as $plugin=>$unused) {
-                    $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'plugin', 'subtype'=>$plugin));
-                }
-                foreach ($css['parents'] as $parent=>$sheets) {
-                    foreach ($sheets as $sheet=>$unused2) {
-                        $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'parent', 'subtype'=>$parent, 'sheet'=>$sheet));
-                    }
-                }
-                foreach ($css['theme'] as $sheet => $filename) {
-                    if ($sheet === self::SCSS_KEY) {
-                        // This is the theme SCSS file.
-                        $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss'));
-                    } else {
-                        // Sheet first in order to make long urls easier to read.
-                        $urls[] = new moodle_url($baseurl, array('sheet'=>$sheet, 'theme'=>$this->name, 'type'=>'theme'));
-                    }
-                }
-            }
-        }
-
-        // Allow themes to change the css url to something like theme/mytheme/mycss.php.
-        component_callback('theme_' . $this->name, 'alter_css_urls', [&$urls]);
-        return $urls;
-    }
-
-    /**
-     * Get the whole css stylesheet for production mode.
-     *
-     * NOTE: this method is not expected to be used from any addons.
-     *
-     * @return string CSS markup compressed
-     */
-    public function get_css_content() {
-
-        $csscontent = '';
-        foreach ($this->get_css_files(false) as $type => $value) {
-            foreach ($value as $identifier => $val) {
-                if (is_array($val)) {
-                    foreach ($val as $v) {
-                        $csscontent .= file_get_contents($v) . "\n";
-                    }
-                } else {
-                    if ($type === 'theme' && $identifier === self::SCSS_KEY) {
-                        // We need the content from SCSS because this is the SCSS file from the theme.
-                        if ($compiled = $this->get_css_content_from_scss(false)) {
-                            $csscontent .= $compiled;
-                        } else {
-                            // The compiler failed so default back to any precompiled css that might
-                            // exist.
-                            $csscontent .= $this->get_precompiled_css_content();
-                        }
-                    } else {
-                        $csscontent .= file_get_contents($val) . "\n";
-                    }
-                }
-            }
-        }
-        $csscontent = $this->post_process($csscontent);
-        $csscontent = core_minify::css($csscontent);
-
-        return $csscontent;
-    }
-    /**
-     * Set post processed CSS content cache.
-     *
-     * @param string $csscontent The post processed CSS content.
-     * @return bool True if the content was successfully cached.
-     */
-    public function set_css_content_cache($csscontent) {
-
-        $cache = cache::make('core', 'postprocessedcss');
-        $key = $this->get_css_cache_key();
-
-        return $cache->set($key, $csscontent);
-    }
-
-    /**
-     * Return whether the post processed CSS content has been cached.
-     *
-     * @return bool Whether the post-processed CSS is available in the cache.
-     */
-    public function has_css_cached_content() {
-
-        $key = $this->get_css_cache_key();
-        $cache = cache::make('core', 'postprocessedcss');
-
-        return $cache->has($key);
-    }
-
-    /**
-     * Return cached post processed CSS content.
-     *
-     * @return bool|string The cached css content or false if not found.
-     */
-    public function get_css_cached_content() {
-
-        $key = $this->get_css_cache_key();
-        $cache = cache::make('core', 'postprocessedcss');
-
-        return $cache->get($key);
-    }
-
-    /**
-     * Generate the css content cache key.
-     *
-     * @return string The post processed css cache key.
-     */
-    public function get_css_cache_key() {
-        $nosvg = (!$this->use_svg_icons()) ? 'nosvg_' : '';
-        $rtlmode = ($this->rtlmode == true) ? 'rtl' : 'ltr';
-
-        return $nosvg . $this->name . '_' . $rtlmode;
-    }
-
-    /**
-     * Get the theme designer css markup,
-     * the parameters are coming from css_urls().
-     *
-     * NOTE: this method is not expected to be used from any addons.
-     *
-     * @param string $type
-     * @param string $subtype
-     * @param string $sheet
-     * @return string CSS markup
-     */
-    public function get_css_content_debug($type, $subtype, $sheet) {
-        if ($type === 'scss') {
-            // The SCSS file of the theme is requested.
-            $csscontent = $this->get_css_content_from_scss(true);
-            if ($csscontent !== false) {
-                return $this->post_process($csscontent);
-            }
-            return '';
-        }
-
-        $cssfiles = array();
-        $css = $this->get_css_files(true);
-
-        if ($type === 'ie') {
-            // IE is a sloppy browser with weird limits, sorry.
-            if ($subtype === 'plugins') {
-                $cssfiles = $css['plugins'];
-
-            } else if ($subtype === 'parents') {
-                if (empty($sheet)) {
-                    // Do not bother with the empty parent here.
-                } else {
-                    // Build up the CSS for that parent so we can serve it as one file.
-                    foreach ($css[$subtype][$sheet] as $parent => $css) {
-                        $cssfiles[] = $css;
-                    }
-                }
-            } else if ($subtype === 'theme') {
-                $cssfiles = $css['theme'];
-                foreach ($cssfiles as $key => $value) {
-                    if (in_array($key, [self::SCSS_KEY])) {
-                        // Remove the SCSS file from the theme CSS files.
-                        // The SCSS files use the type 'scss', not 'ie'.
-                        unset($cssfiles[$key]);
-                    }
-                }
-            }
-
-        } else if ($type === 'plugin') {
-            if (isset($css['plugins'][$subtype])) {
-                $cssfiles[] = $css['plugins'][$subtype];
-            }
-
-        } else if ($type === 'parent') {
-            if (isset($css['parents'][$subtype][$sheet])) {
-                $cssfiles[] = $css['parents'][$subtype][$sheet];
-            }
-
-        } else if ($type === 'theme') {
-            if (isset($css['theme'][$sheet])) {
-                $cssfiles[] = $css['theme'][$sheet];
-            }
-        }
-
-        $csscontent = '';
-        foreach ($cssfiles as $file) {
-            $contents = file_get_contents($file);
-            $contents = $this->post_process($contents);
-            $comment = "/** Path: $type $subtype $sheet.' **/\n";
-            $stats = '';
-            $csscontent .= $comment.$stats.$contents."\n\n";
-        }
-
-        return $csscontent;
-    }
-
-    /**
-     * Get the whole css stylesheet for editor iframe.
-     *
-     * NOTE: this method is not expected to be used from any addons.
-     *
-     * @return string CSS markup
-     */
-    public function get_css_content_editor() {
-        $css = '';
-        $cssfiles = $this->editor_css_files();
-
-        // If editor has static CSS, include it.
-        foreach ($cssfiles as $file) {
-            $css .= file_get_contents($file)."\n";
-        }
-
-        // If editor has SCSS, compile and include it.
-        if (($convertedscss = $this->editor_scss_to_css())) {
-            $css .= $convertedscss;
-        }
-
-        $output = $this->post_process($css);
-
-        return $output;
-    }
-
-    /**
-     * Returns an array of organised CSS files required for this output.
-     *
-     * @param bool $themedesigner
-     * @return array nested array of file paths
-     */
-    protected function get_css_files($themedesigner) {
-        global $CFG;
-
-        $cache = null;
-        $cachekey = 'cssfiles';
-        if ($themedesigner) {
-            require_once($CFG->dirroot.'/lib/csslib.php');
-            // We need some kind of caching here because otherwise the page navigation becomes
-            // way too slow in theme designer mode. Feel free to create full cache definition later...
-            $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'core', 'themedesigner', array('theme' => $this->name));
-            if ($files = $cache->get($cachekey)) {
-                if ($files['created'] > time() - THEME_DESIGNER_CACHE_LIFETIME) {
-                    unset($files['created']);
-                    return $files;
-                }
-            }
-        }
-
-        $cssfiles = array('plugins'=>array(), 'parents'=>array(), 'theme'=>array());
-
-        // Get all plugin sheets.
-        $excludes = $this->resolve_excludes('plugins_exclude_sheets');
-        if ($excludes !== true) {
-            foreach (core_component::get_plugin_types() as $type=>$unused) {
-                if ($type === 'theme' || (!empty($excludes[$type]) and $excludes[$type] === true)) {
-                    continue;
-                }
-                $plugins = core_component::get_plugin_list($type);
-                foreach ($plugins as $plugin=>$fulldir) {
-                    if (!empty($excludes[$type]) and is_array($excludes[$type])
-                            and in_array($plugin, $excludes[$type])) {
-                        continue;
-                    }
-
-                    // Get the CSS from the plugin.
-                    $sheetfile = "$fulldir/styles.css";
-                    if (is_readable($sheetfile)) {
-                        $cssfiles['plugins'][$type.'_'.$plugin] = $sheetfile;
-                    }
-
-                    // Create a list of candidate sheets from parents (direct parent last) and current theme.
-                    $candidates = array();
-                    foreach (array_reverse($this->parent_configs) as $parent_config) {
-                        $candidates[] = $parent_config->name;
-                    }
-                    $candidates[] = $this->name;
-
-                    // Add the sheets found.
-                    foreach ($candidates as $candidate) {
-                        $sheetthemefile = "$fulldir/styles_{$candidate}.css";
-                        if (is_readable($sheetthemefile)) {
-                            $cssfiles['plugins'][$type.'_'.$plugin.'_'.$candidate] = $sheetthemefile;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Find out wanted parent sheets.
-        $excludes = $this->resolve_excludes('parents_exclude_sheets');
-        if ($excludes !== true) {
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
-                $parent = $parent_config->name;
-                if (empty($parent_config->sheets) || (!empty($excludes[$parent]) and $excludes[$parent] === true)) {
-                    continue;
-                }
-                foreach ($parent_config->sheets as $sheet) {
-                    if (!empty($excludes[$parent]) && is_array($excludes[$parent])
-                            && in_array($sheet, $excludes[$parent])) {
-                        continue;
-                    }
-
-                    // We never refer to the parent LESS files.
-                    $sheetfile = "$parent_config->dir/style/$sheet.css";
-                    if (is_readable($sheetfile)) {
-                        $cssfiles['parents'][$parent][$sheet] = $sheetfile;
-                    }
-                }
-            }
-        }
-
-
-        // Current theme sheets.
-        // We first add the SCSS file because we want the CSS ones to
-        // be included after the SCSS code.
-        if ($this->get_scss_property()) {
-            $cssfiles['theme'][self::SCSS_KEY] = true;
-        }
-        if (is_array($this->sheets)) {
-            foreach ($this->sheets as $sheet) {
-                $sheetfile = "$this->dir/style/$sheet.css";
-                if (is_readable($sheetfile) && !isset($cssfiles['theme'][$sheet])) {
-                    $cssfiles['theme'][$sheet] = $sheetfile;
-                }
-            }
-        }
-
-        if ($cache) {
-            $files = $cssfiles;
-            $files['created'] = time();
-            $cache->set($cachekey, $files);
-        }
-        return $cssfiles;
-    }
-
-    /**
-     * Return the CSS content generated from the SCSS file.
-     *
-     * @param bool $themedesigner True if theme designer is enabled.
-     * @return bool|string Return false when the compilation failed. Else the compiled string.
-     */
-    protected function get_css_content_from_scss($themedesigner) {
-        global $CFG;
-
-        list($paths, $scss) = $this->get_scss_property();
-        if (!$scss) {
-            throw new coding_exception('The theme did not define a SCSS file, or it is not readable.');
-        }
-
-        // We might need more memory/time to do this, so let's play safe.
-        raise_memory_limit(MEMORY_EXTRA);
-        core_php_time_limit::raise(300);
-
-        // TODO: MDL-62757 When changing anything in this method please do not forget to check
-        // if the validate() method in class admin_setting_configthemepreset needs updating too.
-
-        $cachedir = make_localcache_directory('scsscache-' . $this->name, false);
-        $cacheoptions = [];
-        if ($themedesigner) {
-            $cacheoptions = array(
-                  'cacheDir' => $cachedir,
-                  'prefix' => 'scssphp_',
-                  'forceRefresh' => false,
-            );
-        } else {
-            if (file_exists($cachedir)) {
-                remove_dir($cachedir);
-            }
-        }
-
-        // Set-up the compiler.
-        $compiler = new core_scss($cacheoptions);
-
-        if ($this->supports_source_maps($themedesigner)) {
-            // Enable source maps.
-            $compiler->setSourceMapOptions([
-                'sourceMapBasepath' => str_replace('\\', '/', $CFG->dirroot),
-                'sourceMapRootpath' => $CFG->wwwroot . '/'
-            ]);
-            $compiler->setSourceMap($compiler::SOURCE_MAP_INLINE);
-        }
-
-        $compiler->prepend_raw_scss($this->get_pre_scss_code());
-        if (is_string($scss)) {
-            $compiler->set_file($scss);
-        } else {
-            $compiler->append_raw_scss($scss($this));
-            $compiler->setImportPaths($paths);
-        }
-        $compiler->append_raw_scss($this->get_extra_scss_code());
-
-        try {
-            // Compile!
-            $compiled = $compiler->to_css();
-
-        } catch (\Exception $e) {
-            $compiled = false;
-            debugging('Error while compiling SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER);
-        }
-
-        // Try to save memory.
-        $compiler = null;
-        unset($compiler);
-
-        return $compiled;
-    }
-
-    /**
-     * Return the precompiled CSS if the precompiledcsscallback exists.
-     *
-     * @return string Return compiled css.
-     */
-    public function get_precompiled_css_content() {
-        $configs = array_reverse($this->parent_configs) + [$this];
-        $css = '';
-
-        foreach ($configs as $config) {
-            if (isset($config->precompiledcsscallback)) {
-                $function = $config->precompiledcsscallback;
-                if (function_exists($function)) {
-                    $css .= $function($this);
-                }
-            }
-        }
-        return $css;
-    }
-
-    /**
-     * Get the icon system to use.
-     *
-     * @return string
-     */
-    public function get_icon_system() {
-
-        // Getting all the candidate functions.
-        $system = false;
-        if (isset($this->iconsystem) && \core\output\icon_system::is_valid_system($this->iconsystem)) {
-            return $this->iconsystem;
-        }
-        foreach ($this->parent_configs as $parent_config) {
-            if (isset($parent_config->iconsystem) && \core\output\icon_system::is_valid_system($parent_config->iconsystem)) {
-                return $parent_config->iconsystem;
-            }
-        }
-        return \core\output\icon_system::STANDARD;
-    }
-
-    /**
-     * Return extra SCSS code to add when compiling.
-     *
-     * This is intended to be used by themes to inject some SCSS code
-     * before it gets compiled. If you want to inject variables you
-     * should use {@link self::get_scss_variables()}.
-     *
-     * @return string The SCSS code to inject.
-     */
-    public function get_extra_scss_code() {
-        $content = '';
-
-        // Getting all the candidate functions.
-        $candidates = array();
-        foreach (array_reverse($this->parent_configs) as $parent_config) {
-            if (!isset($parent_config->extrascsscallback)) {
-                continue;
-            }
-            $candidates[] = $parent_config->extrascsscallback;
-        }
-
-        if (isset($this->extrascsscallback)) {
-            $candidates[] = $this->extrascsscallback;
-        }
-
-        // Calling the functions.
-        foreach ($candidates as $function) {
-            if (function_exists($function)) {
-                $content .= "\n/** Extra SCSS from $function **/\n" . $function($this) . "\n";
-            }
-        }
-
-        return $content;
-    }
-
-    /**
-     * SCSS code to prepend when compiling.
-     *
-     * This is intended to be used by themes to inject SCSS code before it gets compiled.
-     *
-     * @return string The SCSS code to inject.
-     */
-    public function get_pre_scss_code() {
-        $content = '';
-
-        // Getting all the candidate functions.
-        $candidates = array();
-        foreach (array_reverse($this->parent_configs) as $parent_config) {
-            if (!isset($parent_config->prescsscallback)) {
-                continue;
-            }
-            $candidates[] = $parent_config->prescsscallback;
-        }
-
-        if (isset($this->prescsscallback)) {
-            $candidates[] = $this->prescsscallback;
-        }
-
-        // Calling the functions.
-        foreach ($candidates as $function) {
-            if (function_exists($function)) {
-                $content .= "\n/** Pre-SCSS from $function **/\n" . $function($this) . "\n";
-            }
-        }
-
-        return $content;
-    }
-
-    /**
-     * Get the SCSS property.
-     *
-     * This resolves whether a SCSS file (or content) has to be used when generating
-     * the stylesheet for the theme. It will look at parents themes and check the
-     * SCSS properties there.
-     *
-     * @return array|false False when SCSS is not used.
-     *         An array with the import paths, and the path to the SCSS file or Closure as second.
-     */
-    public function get_scss_property() {
-        if ($this->scsscache === null) {
-            $configs = [$this] + $this->parent_configs;
-            $scss = null;
-
-            foreach ($configs as $config) {
-                $path = "{$config->dir}/scss";
-
-                // We collect the SCSS property until we've found one.
-                if (empty($scss) && !empty($config->scss)) {
-                    $candidate = is_string($config->scss) ? "{$path}/{$config->scss}.scss" : $config->scss;
-                    if ($candidate instanceof Closure) {
-                        $scss = $candidate;
-                    } else if (is_string($candidate) && is_readable($candidate)) {
-                        $scss = $candidate;
-                    }
-                }
-
-                // We collect the import paths once we've found a SCSS property.
-                if ($scss && is_dir($path)) {
-                    $paths[] = $path;
-                }
-
-            }
-
-            $this->scsscache = $scss !== null ? [$paths, $scss] : false;
-        }
-
-        return $this->scsscache;
-    }
-
-    /**
-     * Generate a URL to the file that serves theme JavaScript files.
-     *
-     * If we determine that the theme has no relevant files, then we return
-     * early with a null value.
-     *
-     * @param bool $inhead true means head url, false means footer
-     * @return moodle_url|null
-     */
-    public function javascript_url($inhead) {
-        global $CFG;
-
-        $rev = theme_get_revision();
-        $params = array('theme'=>$this->name,'rev'=>$rev);
-        $params['type'] = $inhead ? 'head' : 'footer';
-
-        // Return early if there are no files to serve
-        if (count($this->javascript_files($params['type'])) === 0) {
-            return null;
-        }
-
-        if (!empty($CFG->slasharguments) and $rev > 0) {
-            $url = new moodle_url("/theme/javascript.php");
-            $url->set_slashargument('/'.$this->name.'/'.$rev.'/'.$params['type'], 'noparam', true);
-            return $url;
-        } else {
-            return new moodle_url('/theme/javascript.php', $params);
-        }
-    }
-
-    /**
-     * Get the URL's for the JavaScript files used by this theme.
-     * They won't be served directly, instead they'll be mediated through
-     * theme/javascript.php.
-     *
-     * @param string $type Either javascripts_footer, or javascripts
-     * @return array
-     */
-    public function javascript_files($type) {
-        if ($type === 'footer') {
-            $type = 'javascripts_footer';
-        } else {
-            $type = 'javascripts';
-        }
-
-        $js = array();
-        // find out wanted parent javascripts
-        $excludes = $this->resolve_excludes('parents_exclude_javascripts');
-        if ($excludes !== true) {
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last
-                $parent = $parent_config->name;
-                if (empty($parent_config->$type)) {
-                    continue;
-                }
-                if (!empty($excludes[$parent]) and $excludes[$parent] === true) {
-                    continue;
-                }
-                foreach ($parent_config->$type as $javascript) {
-                    if (!empty($excludes[$parent]) and is_array($excludes[$parent])
-                        and in_array($javascript, $excludes[$parent])) {
-                        continue;
-                    }
-                    $javascriptfile = "$parent_config->dir/javascript/$javascript.js";
-                    if (is_readable($javascriptfile)) {
-                        $js[] = $javascriptfile;
-                    }
-                }
-            }
-        }
-
-        // current theme javascripts
-        if (is_array($this->$type)) {
-            foreach ($this->$type as $javascript) {
-                $javascriptfile = "$this->dir/javascript/$javascript.js";
-                if (is_readable($javascriptfile)) {
-                    $js[] = $javascriptfile;
-                }
-            }
-        }
-        return $js;
-    }
-
-    /**
-     * Resolves an exclude setting to the themes setting is applicable or the
-     * setting of its closest parent.
-     *
-     * @param string $variable The name of the setting the exclude setting to resolve
-     * @param string $default
-     * @return mixed
-     */
-    protected function resolve_excludes($variable, $default = null) {
-        $setting = $default;
-        if (is_array($this->{$variable}) or $this->{$variable} === true) {
-            $setting = $this->{$variable};
-        } else {
-            foreach ($this->parent_configs as $parent_config) { // the immediate parent first, base last
-                if (!isset($parent_config->{$variable})) {
-                    continue;
-                }
-                if (is_array($parent_config->{$variable}) or $parent_config->{$variable} === true) {
-                    $setting = $parent_config->{$variable};
-                    break;
-                }
-            }
-        }
-        return $setting;
-    }
-
-    /**
-     * Returns the content of the one huge javascript file merged from all theme javascript files.
-     *
-     * @param bool $type
-     * @return string
-     */
-    public function javascript_content($type) {
-        $jsfiles = $this->javascript_files($type);
-        $js = '';
-        foreach ($jsfiles as $jsfile) {
-            $js .= file_get_contents($jsfile)."\n";
-        }
-        return $js;
-    }
-
-    /**
-     * Post processes CSS.
-     *
-     * This method post processes all of the CSS before it is served for this theme.
-     * This is done so that things such as image URL's can be swapped in and to
-     * run any specific CSS post process method the theme has requested.
-     * This allows themes to use CSS settings.
-     *
-     * @param string $css The CSS to process.
-     * @return string The processed CSS.
-     */
-    public function post_process($css) {
-        // now resolve all image locations
-        if (preg_match_all('/\[\[pix:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) {
-            $replaced = array();
-            foreach ($matches as $match) {
-                if (isset($replaced[$match[0]])) {
-                    continue;
-                }
-                $replaced[$match[0]] = true;
-                $imagename = $match[2];
-                $component = rtrim($match[1], '|');
-                $imageurl = $this->image_url($imagename, $component)->out(false);
-                 // we do not need full url because the image.php is always in the same dir
-                $imageurl = preg_replace('|^http.?://[^/]+|', '', $imageurl);
-                $css = str_replace($match[0], $imageurl, $css);
-            }
-        }
-
-        // Now resolve all font locations.
-        if (preg_match_all('/\[\[font:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) {
-            $replaced = array();
-            foreach ($matches as $match) {
-                if (isset($replaced[$match[0]])) {
-                    continue;
-                }
-                $replaced[$match[0]] = true;
-                $fontname = $match[2];
-                $component = rtrim($match[1], '|');
-                $fonturl = $this->font_url($fontname, $component)->out(false);
-                // We do not need full url because the font.php is always in the same dir.
-                $fonturl = preg_replace('|^http.?://[^/]+|', '', $fonturl);
-                $css = str_replace($match[0], $fonturl, $css);
-            }
-        }
-
-        // Now resolve all theme settings or do any other postprocessing.
-        // This needs to be done before calling core parser, since the parser strips [[settings]] tags.
-        $csspostprocess = $this->csspostprocess;
-        if ($csspostprocess && function_exists($csspostprocess)) {
-            $css = $csspostprocess($css, $this);
-        }
-
-        // Post processing using an object representation of CSS.
-        $treeprocessor = $this->get_css_tree_post_processor();
-        $needsparsing = !empty($treeprocessor) || !empty($this->rtlmode);
-        if ($needsparsing) {
-
-            // We might need more memory/time to do this, so let's play safe.
-            raise_memory_limit(MEMORY_EXTRA);
-            core_php_time_limit::raise(300);
-
-            $parser = new core_cssparser($css);
-            $csstree = $parser->parse();
-            unset($parser);
-
-            if ($this->rtlmode) {
-                $this->rtlize($csstree);
-            }
-
-            if ($treeprocessor) {
-                $treeprocessor($csstree, $this);
-            }
-
-            $css = $csstree->render();
-            unset($csstree);
-        }
-
-        return $css;
-    }
-
-    /**
-     * Flip a stylesheet to RTL.
-     *
-     * @param mixed $csstree The parsed CSS tree structure to flip.
-     * @return void
-     */
-    protected function rtlize($csstree) {
-        $rtlcss = new core_rtlcss($csstree);
-        $rtlcss->flip();
-    }
-
-    /**
-     * Return the direct URL for an image from the pix folder.
-     *
-     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.
-     *
-     * @deprecated since Moodle 3.3
-     * @param string $imagename the name of the icon.
-     * @param string $component specification of one plugin like in get_string()
-     * @return moodle_url
-     */
-    public function pix_url($imagename, $component) {
-        debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER);
-        return $this->image_url($imagename, $component);
-    }
-
-    /**
-     * Return the direct URL for an image from the pix folder.
-     *
-     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.
-     *
-     * @param string $imagename the name of the icon.
-     * @param string $component specification of one plugin like in get_string()
-     * @return moodle_url
-     */
-    public function image_url($imagename, $component) {
-        global $CFG;
-
-        $params = array('theme'=>$this->name);
-        $svg = $this->use_svg_icons();
-
-        if (empty($component) or $component === 'moodle' or $component === 'core') {
-            $params['component'] = 'core';
-        } else {
-            $params['component'] = $component;
-        }
-
-        $rev = theme_get_revision();
-        if ($rev != -1) {
-            $params['rev'] = $rev;
-        }
-
-        $params['image'] = $imagename;
-
-        $url = new moodle_url("/theme/image.php");
-        if (!empty($CFG->slasharguments) and $rev > 0) {
-            $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['image'];
-            if (!$svg) {
-                // We add a simple /_s to the start of the path.
-                // The underscore is used to ensure that it isn't a valid theme name.
-                $path = '/_s'.$path;
-            }
-            $url->set_slashargument($path, 'noparam', true);
-        } else {
-            if (!$svg) {
-                // We add an SVG param so that we know not to serve SVG images.
-                // We do this because all modern browsers support SVG and this param will one day be removed.
-                $params['svg'] = '0';
-            }
-            $url->params($params);
-        }
-
-        return $url;
-    }
-
-    /**
-     * Return the URL for a font
-     *
-     * @param string $font the name of the font (including extension).
-     * @param string $component specification of one plugin like in get_string()
-     * @return moodle_url
-     */
-    public function font_url($font, $component) {
-        global $CFG;
-
-        $params = array('theme'=>$this->name);
-
-        if (empty($component) or $component === 'moodle' or $component === 'core') {
-            $params['component'] = 'core';
-        } else {
-            $params['component'] = $component;
-        }
-
-        $rev = theme_get_revision();
-        if ($rev != -1) {
-            $params['rev'] = $rev;
-        }
-
-        $params['font'] = $font;
-
-        $url = new moodle_url("/theme/font.php");
-        if (!empty($CFG->slasharguments) and $rev > 0) {
-            $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['font'];
-            $url->set_slashargument($path, 'noparam', true);
-        } else {
-            $url->params($params);
-        }
-
-        return $url;
-    }
-
-    /**
-     * Returns URL to the stored file via pluginfile.php.
-     *
-     * Note the theme must also implement pluginfile.php handler,
-     * theme revision is used instead of the itemid.
-     *
-     * @param string $setting
-     * @param string $filearea
-     * @return string protocol relative URL or null if not present
-     */
-    public function setting_file_url($setting, $filearea) {
-        global $CFG;
-
-        if (empty($this->settings->$setting)) {
-            return null;
-        }
-
-        $component = 'theme_'.$this->name;
-        $itemid = theme_get_revision();
-        $filepath = $this->settings->$setting;
-        $syscontext = context_system::instance();
-
-        $url = moodle_url::make_file_url("$CFG->wwwroot/pluginfile.php", "/$syscontext->id/$component/$filearea/$itemid".$filepath);
-
-        // Now this is tricky because the we can not hardcode http or https here, lets use the relative link.
-        // Note: unfortunately moodle_url does not support //urls yet.
-
-        $url = preg_replace('|^https?://|i', '//', $url->out(false));
-
-        return $url;
-    }
-
-    /**
-     * Serve the theme setting file.
-     *
-     * @param string $filearea
-     * @param array $args
-     * @param bool $forcedownload
-     * @param array $options
-     * @return bool may terminate if file not found or donotdie not specified
-     */
-    public function setting_file_serve($filearea, $args, $forcedownload, $options) {
-        global $CFG;
-        require_once("$CFG->libdir/filelib.php");
-
-        $syscontext = context_system::instance();
-        $component = 'theme_'.$this->name;
-
-        $revision = array_shift($args);
-        if ($revision < 0) {
-            $lifetime = 0;
-        } else {
-            $lifetime = 60*60*24*60;
-            // By default, theme files must be cache-able by both browsers and proxies.
-            if (!array_key_exists('cacheability', $options)) {
-                $options['cacheability'] = 'public';
-            }
-        }
-
-        $fs = get_file_storage();
-        $relativepath = implode('/', $args);
-
-        $fullpath = "/{$syscontext->id}/{$component}/{$filearea}/0/{$relativepath}";
-        $fullpath = rtrim($fullpath, '/');
-        if ($file = $fs->get_file_by_hash(sha1($fullpath))) {
-            send_stored_file($file, $lifetime, 0, $forcedownload, $options);
-            return true;
-        } else {
-            send_file_not_found();
-        }
-    }
-
-    /**
-     * Resolves the real image location.
-     *
-     * $svg was introduced as an arg in 2.4. It is important because not all supported browsers support the use of SVG
-     * and we need a way in which to turn it off.
-     * By default SVG won't be used unless asked for. This is done for two reasons:
-     *   1. It ensures that we don't serve svg images unless we really want to. The admin has selected to force them, of the users
-     *      browser supports SVG.
-     *   2. We only serve SVG images from locations we trust. This must NOT include any areas where the image may have been uploaded
-     *      by the user due to security concerns.
-     *
-     * @param string $image name of image, may contain relative path
-     * @param string $component
-     * @param bool|null $svg Should SVG images also be looked for? If null, falls back to auto-detection of browser support
-     * @return string full file path
-     */
-    public function resolve_image_location($image, $component, $svg = false) {
-        global $CFG;
-
-        if (!is_bool($svg)) {
-            // If $svg isn't a bool then we need to decide for ourselves.
-            $svg = $this->use_svg_icons();
-        }
-
-        if ($component === 'moodle' or $component === 'core' or empty($component)) {
-            if ($imagefile = $this->image_exists("$this->dir/pix_core/$image", $svg)) {
-                return $imagefile;
-            }
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last
-                if ($imagefile = $this->image_exists("$parent_config->dir/pix_core/$image", $svg)) {
-                    return $imagefile;
-                }
-            }
-            if ($imagefile = $this->image_exists("$CFG->dataroot/pix/$image", $svg)) {
-                return $imagefile;
-            }
-            if ($imagefile = $this->image_exists("$CFG->dirroot/pix/$image", $svg)) {
-                return $imagefile;
-            }
-            return null;
-
-        } else if ($component === 'theme') { //exception
-            if ($image === 'favicon') {
-                return "$this->dir/pix/favicon.ico";
-            }
-            if ($imagefile = $this->image_exists("$this->dir/pix/$image", $svg)) {
-                return $imagefile;
-            }
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last
-                if ($imagefile = $this->image_exists("$parent_config->dir/pix/$image", $svg)) {
-                    return $imagefile;
-                }
-            }
-            return null;
-
-        } else {
-            if (strpos($component, '_') === false) {
-                $component = "mod_{$component}";
-            }
-            list($type, $plugin) = explode('_', $component, 2);
-
-            // In Moodle 4.0 we introduced a new image format.
-            // Support that image format here.
-            $candidates = [$image];
-
-            if ($type === 'mod') {
-                if ($image === 'icon' || $image === 'monologo') {
-                    $candidates = ['monologo', 'icon'];
-                    if ($image === 'icon') {
-                        debugging(
-                            "The 'icon' image for activity modules has been replaced with a new 'monologo'. " .
-                                "Please update your calling code to fetch the new icon where possible. " .
-                                "Called for component {$component}.",
-                            DEBUG_DEVELOPER
-                        );
-                    }
-                }
-            }
-            foreach ($candidates as $image) {
-                if ($imagefile = $this->image_exists("$this->dir/pix_plugins/$type/$plugin/$image", $svg)) {
-                    return $imagefile;
-                }
-
-                // Base first, the immediate parent last.
-                foreach (array_reverse($this->parent_configs) as $parentconfig) {
-                    if ($imagefile = $this->image_exists("$parentconfig->dir/pix_plugins/$type/$plugin/$image", $svg)) {
-                        return $imagefile;
-                    }
-                }
-                if ($imagefile = $this->image_exists("$CFG->dataroot/pix_plugins/$type/$plugin/$image", $svg)) {
-                    return $imagefile;
-                }
-                $dir = core_component::get_plugin_directory($type, $plugin);
-                if ($imagefile = $this->image_exists("$dir/pix/$image", $svg)) {
-                    return $imagefile;
-                }
-            }
-            return null;
-        }
-    }
-
-    /**
-     * Resolves the real font location.
-     *
-     * @param string $font name of font file
-     * @param string $component
-     * @return string full file path
-     */
-    public function resolve_font_location($font, $component) {
-        global $CFG;
-
-        if ($component === 'moodle' or $component === 'core' or empty($component)) {
-            if (file_exists("$this->dir/fonts_core/$font")) {
-                return "$this->dir/fonts_core/$font";
-            }
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
-                if (file_exists("$parent_config->dir/fonts_core/$font")) {
-                    return "$parent_config->dir/fonts_core/$font";
-                }
-            }
-            if (file_exists("$CFG->dataroot/fonts/$font")) {
-                return "$CFG->dataroot/fonts/$font";
-            }
-            if (file_exists("$CFG->dirroot/lib/fonts/$font")) {
-                return "$CFG->dirroot/lib/fonts/$font";
-            }
-            return null;
-
-        } else if ($component === 'theme') { // Exception.
-            if (file_exists("$this->dir/fonts/$font")) {
-                return "$this->dir/fonts/$font";
-            }
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
-                if (file_exists("$parent_config->dir/fonts/$font")) {
-                    return "$parent_config->dir/fonts/$font";
-                }
-            }
-            return null;
-
-        } else {
-            if (strpos($component, '_') === false) {
-                $component = 'mod_'.$component;
-            }
-            list($type, $plugin) = explode('_', $component, 2);
-
-            if (file_exists("$this->dir/fonts_plugins/$type/$plugin/$font")) {
-                return "$this->dir/fonts_plugins/$type/$plugin/$font";
-            }
-            foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last.
-                if (file_exists("$parent_config->dir/fonts_plugins/$type/$plugin/$font")) {
-                    return "$parent_config->dir/fonts_plugins/$type/$plugin/$font";
-                }
-            }
-            if (file_exists("$CFG->dataroot/fonts_plugins/$type/$plugin/$font")) {
-                return "$CFG->dataroot/fonts_plugins/$type/$plugin/$font";
-            }
-            $dir = core_component::get_plugin_directory($type, $plugin);
-            if (file_exists("$dir/fonts/$font")) {
-                return "$dir/fonts/$font";
-            }
-            return null;
-        }
-    }
-
-    /**
-     * Return true if we should look for SVG images as well.
-     *
-     * @return bool
-     */
-    public function use_svg_icons() {
-        if ($this->usesvg === null) {
-            $this->usesvg = core_useragent::supports_svg();
-        }
-
-        return $this->usesvg;
-    }
-
-    /**
-     * Forces the usesvg setting to either true or false, avoiding any decision making.
-     *
-     * This function should only ever be used when absolutely required, and before any generation of image URL's has occurred.
-     * DO NOT ABUSE THIS FUNCTION... not that you'd want to right ;)
-     *
-     * @param bool $setting True to force the use of svg when available, null otherwise.
-     */
-    public function force_svg_use($setting) {
-        $this->usesvg = (bool)$setting;
-    }
-
-    /**
-     * Set to be in RTL mode.
-     *
-     * This will likely be used when post processing the CSS before serving it.
-     *
-     * @param bool $inrtl True when in RTL mode.
-     */
-    public function set_rtl_mode($inrtl = true) {
-        $this->rtlmode = $inrtl;
-    }
-
-    /**
-     * Checks if source maps are supported
-     *
-     * @param bool $themedesigner True if theme designer is enabled.
-     * @return boolean True if source maps are supported.
-     */
-    public function supports_source_maps($themedesigner): bool {
-        if (empty($this->rtlmode) && $themedesigner) {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Whether the theme is being served in RTL mode.
-     *
-     * @return bool True when in RTL mode.
-     */
-    public function get_rtl_mode() {
-        return $this->rtlmode;
-    }
-
-    /**
-     * Checks if file with any image extension exists.
-     *
-     * The order to these images was adjusted prior to the release of 2.4
-     * At that point the were the following image counts in Moodle core:
-     *
-     *     - png = 667 in pix dirs (1499 total)
-     *     - gif = 385 in pix dirs (606 total)
-     *     - jpg = 62  in pix dirs (74 total)
-     *     - jpeg = 0  in pix dirs (1 total)
-     *
-     * There is work in progress to move towards SVG presently hence that has been prioritiesed.
-     *
-     * @param string $filepath
-     * @param bool $svg If set to true SVG images will also be looked for.
-     * @return string image name with extension
-     */
-    private static function image_exists($filepath, $svg = false) {
-        if ($svg && file_exists("$filepath.svg")) {
-            return "$filepath.svg";
-        } else  if (file_exists("$filepath.png")) {
-            return "$filepath.png";
-        } else if (file_exists("$filepath.gif")) {
-            return "$filepath.gif";
-        } else  if (file_exists("$filepath.jpg")) {
-            return "$filepath.jpg";
-        } else  if (file_exists("$filepath.jpeg")) {
-            return "$filepath.jpeg";
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Loads the theme config from config.php file.
-     *
-     * @param string $themename
-     * @param stdClass $settings from config_plugins table
-     * @param boolean $parentscheck true to also check the parents.    .
-     * @return ?stdClass The theme configuration
-     */
-    private static function find_theme_config($themename, $settings, $parentscheck = true) {
-        // We have to use the variable name $THEME (upper case) because that
-        // is what is used in theme config.php files.
-
-        if (!$dir = theme_config::find_theme_location($themename)) {
-            return null;
-        }
-
-        $THEME = new stdClass();
-        $THEME->name     = $themename;
-        $THEME->dir      = $dir;
-        $THEME->settings = $settings;
-
-        global $CFG; // just in case somebody tries to use $CFG in theme config
-        include("$THEME->dir/config.php");
-
-        // verify the theme configuration is OK
-        if (!is_array($THEME->parents)) {
-            // parents option is mandatory now
-            return null;
-        } else {
-            // We use $parentscheck to only check the direct parents (avoid infinite loop).
-            if ($parentscheck) {
-                // Find all parent theme configs.
-                foreach ($THEME->parents as $parent) {
-                    $parentconfig = theme_config::find_theme_config($parent, $settings, false);
-                    if (empty($parentconfig)) {
-                        return null;
-                    }
-                }
-            }
-        }
-
-        return $THEME;
-    }
-
-    /**
-     * Finds the theme location and verifies the theme has all needed files
-     * and is not obsoleted.
-     *
-     * @param string $themename
-     * @return string full dir path or null if not found
-     */
-    private static function find_theme_location($themename) {
-        global $CFG;
-
-        if (file_exists("$CFG->dirroot/theme/$themename/config.php")) {
-            $dir = "$CFG->dirroot/theme/$themename";
-
-        } else if (!empty($CFG->themedir) and file_exists("$CFG->themedir/$themename/config.php")) {
-            $dir = "$CFG->themedir/$themename";
-
-        } else {
-            return null;
-        }
-
-        if (file_exists("$dir/styles.php")) {
-            //legacy theme - needs to be upgraded - upgrade info is displayed on the admin settings page
-            return null;
-        }
-
-        return $dir;
-    }
-
-    /**
-     * Get the renderer for a part of Moodle for this theme.
-     *
-     * @param moodle_page $page the page we are rendering
-     * @param string $component the name of part of moodle. E.g. 'core', 'quiz', 'qtype_multichoice'.
-     * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
-     * @param string $target one of rendering target constants
-     * @return renderer_base the requested renderer.
-     */
-    public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) {
-        if (is_null($this->rf)) {
-            $classname = $this->rendererfactory;
-            $this->rf = new $classname($this);
-        }
-
-        return $this->rf->get_renderer($page, $component, $subtype, $target);
-    }
-
-    /**
-     * Get the information from {@link $layouts} for this type of page.
-     *
-     * @param string $pagelayout the the page layout name.
-     * @return array the appropriate part of {@link $layouts}.
-     */
-    protected function layout_info_for_page($pagelayout) {
-        if (array_key_exists($pagelayout, $this->layouts)) {
-            return $this->layouts[$pagelayout];
-        } else {
-            debugging('Invalid page layout specified: ' . $pagelayout);
-            return $this->layouts['standard'];
-        }
-    }
-
-    /**
-     * Given the settings of this theme, and the page pagelayout, return the
-     * full path of the page layout file to use.
-     *
-     * Used by {@link core_renderer::header()}.
-     *
-     * @param string $pagelayout the the page layout name.
-     * @return string Full path to the lyout file to use
-     */
-    public function layout_file($pagelayout) {
-        global $CFG;
-
-        $layoutinfo = $this->layout_info_for_page($pagelayout);
-        $layoutfile = $layoutinfo['file'];
-
-        if (array_key_exists('theme', $layoutinfo)) {
-            $themes = array($layoutinfo['theme']);
-        } else {
-            $themes = array_merge(array($this->name),$this->parents);
-        }
-
-        foreach ($themes as $theme) {
-            if ($dir = $this->find_theme_location($theme)) {
-                $path = "$dir/layout/$layoutfile";
-
-                // Check the template exists, return general base theme template if not.
-                if (is_readable($path)) {
-                    return $path;
-                }
-            }
-        }
-
-        throw new coding_exception('Can not find layout file for: ' . $pagelayout . ' (' . $layoutfile . ')');
-    }
-
-    /**
-     * Returns auxiliary page layout options specified in layout configuration array.
-     *
-     * @param string $pagelayout
-     * @return array
-     */
-    public function pagelayout_options($pagelayout) {
-        $info = $this->layout_info_for_page($pagelayout);
-        if (!empty($info['options'])) {
-            return $info['options'];
-        }
-        return array();
-    }
-
-    /**
-     * Inform a block_manager about the block regions this theme wants on this
-     * page layout.
-     *
-     * @param string $pagelayout the general type of the page.
-     * @param block_manager $blockmanager the block_manger to set up.
-     */
-    public function setup_blocks($pagelayout, $blockmanager) {
-        $layoutinfo = $this->layout_info_for_page($pagelayout);
-        if (!empty($layoutinfo['regions'])) {
-            $blockmanager->add_regions($layoutinfo['regions'], false);
-            $blockmanager->set_default_region($layoutinfo['defaultregion']);
-        }
-    }
-
-    /**
-     * Gets the visible name for the requested block region.
-     *
-     * @param string $region The region name to get
-     * @param string $theme The theme the region belongs to (may come from the parent theme)
-     * @return string
-     */
-    protected function get_region_name($region, $theme) {
-
-        $stringman = get_string_manager();
-
-        // Check if the name is defined in the theme.
-        if ($stringman->string_exists('region-' . $region, 'theme_' . $theme)) {
-            return get_string('region-' . $region, 'theme_' . $theme);
-        }
-
-        // Check the theme parents.
-        foreach ($this->parents as $parentthemename) {
-            if ($stringman->string_exists('region-' . $region, 'theme_' . $parentthemename)) {
-                return get_string('region-' . $region, 'theme_' . $parentthemename);
-            }
-        }
-
-        // Last resort, try the boost theme for names.
-        return get_string('region-' . $region, 'theme_boost');
-    }
-
-    /**
-     * Get the list of all block regions known to this theme in all templates.
-     *
-     * @return array internal region name => human readable name.
-     */
-    public function get_all_block_regions() {
-        $regions = array();
-        foreach ($this->layouts as $layoutinfo) {
-            foreach ($layoutinfo['regions'] as $region) {
-                $regions[$region] = $this->get_region_name($region, $this->name);
-            }
-        }
-        return $regions;
-    }
-
-    /**
-     * Returns the human readable name of the theme
-     *
-     * @return string
-     */
-    public function get_theme_name() {
-        return get_string('pluginname', 'theme_'.$this->name);
-    }
-
-    /**
-     * Returns the block render method.
-     *
-     * It is set by the theme via:
-     *     $THEME->blockrendermethod = '...';
-     *
-     * It can be one of two values, blocks or blocks_for_region.
-     * It should be set to the method being used by the theme layouts.
-     *
-     * @return string
-     */
-    public function get_block_render_method() {
-        if ($this->blockrendermethod) {
-            // Return the specified block render method.
-            return $this->blockrendermethod;
-        }
-        // Its not explicitly set, check the parent theme configs.
-        foreach ($this->parent_configs as $config) {
-            if (isset($config->blockrendermethod)) {
-                return $config->blockrendermethod;
-            }
-        }
-        // Default it to blocks.
-        return 'blocks';
-    }
-
-    /**
-     * Get the callable for CSS tree post processing.
-     *
-     * @return string|null
-     */
-    public function get_css_tree_post_processor() {
-        $configs = [$this] + $this->parent_configs;
-        foreach ($configs as $config) {
-            if (!empty($config->csstreepostprocessor) && is_callable($config->csstreepostprocessor)) {
-                return $config->csstreepostprocessor;
-            }
-        }
-        return null;
+    $next = time();
+    if (isset($CFG->templaterev) and $next <= $CFG->templaterev and $CFG->templaterev - $next < 60 * 60) {
+        // This resolves problems when reset is requested repeatedly within 1s,
+        // the < 1h condition prevents accidental switching to future dates
+        // because we might not recover from it.
+        $next = $CFG->templaterev + 1;
     }
 
+    set_config('templaterev', $next);
 }
 
 /**
- * This class keeps track of which HTML tags are currently open.
- *
- * This makes it much easier to always generate well formed XHTML output, even
- * if execution terminates abruptly. Any time you output some opening HTML
- * without the matching closing HTML, you should push the necessary close tags
- * onto the stack.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
+ * Invalidate all server and client side JS caches.
  */
-class xhtml_container_stack {
+function js_reset_all_caches() {
+    global $CFG;
 
-    /**
-     * @var array Stores the list of open containers.
-     */
-    protected $opencontainers = array();
-
-    /**
-     * @var array In developer debug mode, stores a stack trace of all opens and
-     * closes, so we can output helpful error messages when there is a mismatch.
-     */
-    protected $log = array();
-
-    /**
-     * @var boolean Store whether we are developer debug mode. We need this in
-     * several places including in the destructor where we may not have access to $CFG.
-     */
-    protected $isdebugging;
-
-    /**
-     * Constructor
-     */
-    public function __construct() {
-        global $CFG;
-        $this->isdebugging = $CFG->debugdeveloper;
+    $next = time();
+    if (isset($CFG->jsrev) and $next <= $CFG->jsrev and $CFG->jsrev - $next < 60*60) {
+        // This resolves problems when reset is requested repeatedly within 1s,
+        // the < 1h condition prevents accidental switching to future dates
+        // because we might not recover from it.
+        $next = $CFG->jsrev+1;
     }
 
-    /**
-     * Push the close HTML for a recently opened container onto the stack.
-     *
-     * @param string $type The type of container. This is checked when {@link pop()}
-     *      is called and must match, otherwise a developer debug warning is output.
-     * @param string $closehtml The HTML required to close the container.
-     */
-    public function push($type, $closehtml) {
-        $container = new stdClass;
-        $container->type = $type;
-        $container->closehtml = $closehtml;
-        if ($this->isdebugging) {
-            $this->log('Open', $type);
-        }
-        array_push($this->opencontainers, $container);
-    }
-
-    /**
-     * Pop the HTML for the next closing container from the stack. The $type
-     * must match the type passed when the container was opened, otherwise a
-     * warning will be output.
-     *
-     * @param string $type The type of container.
-     * @return ?string the HTML required to close the container.
-     */
-    public function pop($type) {
-        if (empty($this->opencontainers)) {
-            debugging('<p>There are no more open containers. This suggests there is a nesting problem.</p>' .
-                    $this->output_log(), DEBUG_DEVELOPER);
-            return;
-        }
-
-        $container = array_pop($this->opencontainers);
-        if ($container->type != $type) {
-            debugging('<p>The type of container to be closed (' . $container->type .
-                    ') does not match the type of the next open container (' . $type .
-                    '). This suggests there is a nesting problem.</p>' .
-                    $this->output_log(), DEBUG_DEVELOPER);
-        }
-        if ($this->isdebugging) {
-            $this->log('Close', $type);
-        }
-        return $container->closehtml;
-    }
-
-    /**
-     * Close all but the last open container. This is useful in places like error
-     * handling, where you want to close all the open containers (apart from <body>)
-     * before outputting the error message.
-     *
-     * @param bool $shouldbenone assert that the stack should be empty now - causes a
-     *      developer debug warning if it isn't.
-     * @return string the HTML required to close any open containers inside <body>.
-     */
-    public function pop_all_but_last($shouldbenone = false) {
-        if ($shouldbenone && count($this->opencontainers) != 1) {
-            debugging('<p>Some HTML tags were opened in the body of the page but not closed.</p>' .
-                    $this->output_log(), DEBUG_DEVELOPER);
-        }
-        $output = '';
-        while (count($this->opencontainers) > 1) {
-            $container = array_pop($this->opencontainers);
-            $output .= $container->closehtml;
-        }
-        return $output;
-    }
-
-    /**
-     * You can call this function if you want to throw away an instance of this
-     * class without properly emptying the stack (for example, in a unit test).
-     * Calling this method stops the destruct method from outputting a developer
-     * debug warning. After calling this method, the instance can no longer be used.
-     */
-    public function discard() {
-        $this->opencontainers = null;
-    }
-
-    /**
-     * Adds an entry to the log.
-     *
-     * @param string $action The name of the action
-     * @param string $type The type of action
-     */
-    protected function log($action, $type) {
-        $this->log[] = '<li>' . $action . ' ' . $type . ' at:' .
-                format_backtrace(debug_backtrace()) . '</li>';
-    }
-
-    /**
-     * Outputs the log's contents as a HTML list.
-     *
-     * @return string HTML list of the log
-     */
-    protected function output_log() {
-        return '<ul>' . implode("\n", $this->log) . '</ul>';
-    }
+    set_config('jsrev', $next);
 }
diff --git a/lib/outputrenderers.php b/lib/outputrenderers.php
index 918db5ec79d..0fdca282e68 100644
--- a/lib/outputrenderers.php
+++ b/lib/outputrenderers.php
@@ -14,5855 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Classes for rendering HTML output for Moodle.
- *
- * Please see {@link http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML}
- * for an overview.
- *
- * Included in this file are the primary renderer classes:
- *     - renderer_base:         The renderer outline class that all renderers
- *                              should inherit from.
- *     - core_renderer:         The standard HTML renderer.
- *     - core_renderer_cli:     An adaption of the standard renderer for CLI scripts.
- *     - core_renderer_ajax:    An adaption of the standard renderer for AJAX scripts.
- *     - plugin_renderer_base:  A renderer class that should be extended by all
- *                              plugin renderers.
- *
- * @package core
- * @category output
- * @copyright  2009 Tim Hunt
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-
-use core\di;
-use core\hook\manager as hook_manager;
-use core\hook\output\after_standard_main_region_html_generation;
-use core\hook\output\before_footer_html_generation;
-use core\hook\output\before_html_attributes;
-use core\hook\output\before_http_headers;
-use core\hook\output\before_standard_footer_html_generation;
-use core\hook\output\before_standard_top_of_body_html_generation;
-use core\output\named_templatable;
-use core_completion\cm_completion_details;
-use core_course\output\activity_information;
-
-defined('MOODLE_INTERNAL') || die();
-
-/**
- * Simple base class for Moodle renderers.
- *
- * Tracks the xhtml_container_stack to use, which is passed in in the constructor.
- *
- * Also has methods to facilitate generating HTML output.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class renderer_base {
-    /**
-     * @var xhtml_container_stack The xhtml_container_stack to use.
-     */
-    protected $opencontainers;
-
-    /**
-     * @var moodle_page The Moodle page the renderer has been created to assist with.
-     */
-    protected $page;
-
-    /**
-     * @var string The requested rendering target.
-     */
-    protected $target;
-
-    /**
-     * @var Mustache_Engine $mustache The mustache template compiler
-     */
-    private $mustache;
-
-    /**
-     * @var array $templatecache The mustache template cache.
-     */
-    protected $templatecache = [];
-
-    /**
-     * Return an instance of the mustache class.
-     *
-     * @since 2.9
-     * @return Mustache_Engine
-     */
-    protected function get_mustache() {
-        global $CFG;
-
-        if ($this->mustache === null) {
-            require_once("{$CFG->libdir}/filelib.php");
-
-            $themename = $this->page->theme->name;
-            $themerev = theme_get_revision();
-
-            // Create new localcache directory.
-            $cachedir = make_localcache_directory("mustache/$themerev/$themename");
-
-            // Remove old localcache directories.
-            $mustachecachedirs = glob("{$CFG->localcachedir}/mustache/*", GLOB_ONLYDIR);
-            foreach ($mustachecachedirs as $localcachedir) {
-                $cachedrev = [];
-                preg_match("/\/mustache\/([0-9]+)$/", $localcachedir, $cachedrev);
-                $cachedrev = isset($cachedrev[1]) ? intval($cachedrev[1]) : 0;
-                if ($cachedrev > 0 && $cachedrev < $themerev) {
-                    fulldelete($localcachedir);
-                }
-            }
-
-            $loader = new \core\output\mustache_filesystem_loader();
-            $stringhelper = new \core\output\mustache_string_helper();
-            $cleanstringhelper = new \core\output\mustache_clean_string_helper();
-            $quotehelper = new \core\output\mustache_quote_helper();
-            $jshelper = new \core\output\mustache_javascript_helper($this->page);
-            $pixhelper = new \core\output\mustache_pix_helper($this);
-            $shortentexthelper = new \core\output\mustache_shorten_text_helper();
-            $userdatehelper = new \core\output\mustache_user_date_helper();
-
-            // We only expose the variables that are exposed to JS templates.
-            $safeconfig = $this->page->requires->get_config_for_javascript($this->page, $this);
-
-            $helpers = array('config' => $safeconfig,
-                             'str' => array($stringhelper, 'str'),
-                             'cleanstr' => array($cleanstringhelper, 'cleanstr'),
-                             'quote' => array($quotehelper, 'quote'),
-                             'js' => array($jshelper, 'help'),
-                             'pix' => array($pixhelper, 'pix'),
-                             'shortentext' => array($shortentexthelper, 'shorten'),
-                             'userdate' => array($userdatehelper, 'transform'),
-                         );
-
-            $this->mustache = new \core\output\mustache_engine(array(
-                'cache' => $cachedir,
-                'escape' => 's',
-                'loader' => $loader,
-                'helpers' => $helpers,
-                'pragmas' => [Mustache_Engine::PRAGMA_BLOCKS],
-                // Don't allow the JavaScript helper to be executed from within another
-                // helper. If it's allowed it can be used by users to inject malicious
-                // JS into the page.
-                'disallowednestedhelpers' => ['js'],
-                // Disable lambda rendering - content in helpers is already rendered, no need to render it again.
-                'disable_lambda_rendering' => true,
-            ));
-
-        }
-
-        return $this->mustache;
-    }
-
-
-    /**
-     * Constructor
-     *
-     * The constructor takes two arguments. The first is the page that the renderer
-     * has been created to assist with, and the second is the target.
-     * The target is an additional identifier that can be used to load different
-     * renderers for different options.
-     *
-     * @param moodle_page $page the page we are doing output for.
-     * @param string $target one of rendering target constants
-     */
-    public function __construct(moodle_page $page, $target) {
-        $this->opencontainers = $page->opencontainers;
-        $this->page = $page;
-        $this->target = $target;
-    }
-
-    /**
-     * Renders a template by name with the given context.
-     *
-     * The provided data needs to be array/stdClass made up of only simple types.
-     * Simple types are array,stdClass,bool,int,float,string
-     *
-     * @since 2.9
-     * @param array|stdClass $context Context containing data for the template.
-     * @return string|boolean
-     */
-    public function render_from_template($templatename, $context) {
-        $mustache = $this->get_mustache();
-
-        if ($mustache->hasHelper('uniqid')) {
-            // Grab a copy of the existing helper to be restored later.
-            $uniqidhelper = $mustache->getHelper('uniqid');
-        } else {
-            // Helper doesn't exist.
-            $uniqidhelper = null;
-        }
-
-        // Provide 1 random value that will not change within a template
-        // but will be different from template to template. This is useful for
-        // e.g. aria attributes that only work with id attributes and must be
-        // unique in a page.
-        $mustache->addHelper('uniqid', new \core\output\mustache_uniqid_helper());
-        if (isset($this->templatecache[$templatename])) {
-            $template = $this->templatecache[$templatename];
-        } else {
-            try {
-                $template = $mustache->loadTemplate($templatename);
-                $this->templatecache[$templatename] = $template;
-            } catch (Mustache_Exception_UnknownTemplateException $e) {
-                throw new moodle_exception('Unknown template: ' . $templatename);
-            }
-        }
-
-        $renderedtemplate = trim($template->render($context));
-
-        // If we had an existing uniqid helper then we need to restore it to allow
-        // handle nested calls of render_from_template.
-        if ($uniqidhelper) {
-            $mustache->addHelper('uniqid', $uniqidhelper);
-        }
-
-        return $renderedtemplate;
-    }
-
-
-    /**
-     * Returns rendered widget.
-     *
-     * The provided widget needs to be an object that extends the renderable
-     * interface.
-     * If will then be rendered by a method based upon the classname for the widget.
-     * For instance a widget of class `crazywidget` will be rendered by a protected
-     * render_crazywidget method of this renderer.
-     * If no render_crazywidget method exists and crazywidget implements templatable,
-     * look for the 'crazywidget' template in the same component and render that.
-     *
-     * @param renderable $widget instance with renderable interface
-     * @return string
-     */
-    public function render(renderable $widget) {
-        $classparts = explode('\\', get_class($widget));
-        // Strip namespaces.
-        $classname = array_pop($classparts);
-        // Remove _renderable suffixes.
-        $classname = preg_replace('/_renderable$/', '', $classname);
-
-        $rendermethod = "render_{$classname}";
-        if (method_exists($this, $rendermethod)) {
-            // Call the render_[widget_name] function.
-            // Note: This has a higher priority than the named_templatable to allow the theme to override the template.
-            return $this->$rendermethod($widget);
-        }
-
-        if ($widget instanceof named_templatable) {
-            // This is a named templatable.
-            // Fetch the template name from the get_template_name function instead.
-            // Note: This has higher priority than the guessed template name.
-            return $this->render_from_template(
-                $widget->get_template_name($this),
-                $widget->export_for_template($this)
-            );
-        }
-
-        if ($widget instanceof templatable) {
-            // Guess the templat ename based on the class name.
-            // Note: There's no benefit to moving this aboved the named_templatable and this approach is more costly.
-            $component = array_shift($classparts);
-            if (!$component) {
-                $component = 'core';
-            }
-            $template = $component . '/' . $classname;
-            $context = $widget->export_for_template($this);
-            return $this->render_from_template($template, $context);
-        }
-        throw new coding_exception("Can not render widget, renderer method ('{$rendermethod}') not found.");
-    }
-
-    /**
-     * Adds a JS action for the element with the provided id.
-     *
-     * This method adds a JS event for the provided component action to the page
-     * and then returns the id that the event has been attached to.
-     * If no id has been provided then a new ID is generated by {@link html_writer::random_id()}
-     *
-     * @param component_action $action
-     * @param string $id
-     * @return string id of element, either original submitted or random new if not supplied
-     */
-    public function add_action_handler(component_action $action, $id = null) {
-        if (!$id) {
-            $id = html_writer::random_id($action->event);
-        }
-        $this->page->requires->event_handler("#$id", $action->event, $action->jsfunction, $action->jsfunctionargs);
-        return $id;
-    }
-
-    /**
-     * Returns true is output has already started, and false if not.
-     *
-     * @return boolean true if the header has been printed.
-     */
-    public function has_started() {
-        return $this->page->state >= moodle_page::STATE_IN_BODY;
-    }
-
-    /**
-     * Given an array or space-separated list of classes, prepares and returns the HTML class attribute value
-     *
-     * @param mixed $classes Space-separated string or array of classes
-     * @return string HTML class attribute value
-     */
-    public static function prepare_classes($classes) {
-        if (is_array($classes)) {
-            return implode(' ', array_unique($classes));
-        }
-        return $classes;
-    }
-
-    /**
-     * Return the direct URL for an image from the pix folder.
-     *
-     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.
-     *
-     * @deprecated since Moodle 3.3
-     * @param string $imagename the name of the icon.
-     * @param string $component specification of one plugin like in get_string()
-     * @return moodle_url
-     */
-    public function pix_url($imagename, $component = 'moodle') {
-        debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER);
-        return $this->page->theme->image_url($imagename, $component);
-    }
-
-    /**
-     * Return the moodle_url for an image.
-     *
-     * The exact image location and extension is determined
-     * automatically by searching for gif|png|jpg|jpeg, please
-     * note there can not be diferent images with the different
-     * extension. The imagename is for historical reasons
-     * a relative path name, it may be changed later for core
-     * images. It is recommended to not use subdirectories
-     * in plugin and theme pix directories.
-     *
-     * There are three types of images:
-     * 1/ theme images  - stored in theme/mytheme/pix/,
-     *                    use component 'theme'
-     * 2/ core images   - stored in /pix/,
-     *                    overridden via theme/mytheme/pix_core/
-     * 3/ plugin images - stored in mod/mymodule/pix,
-     *                    overridden via theme/mytheme/pix_plugins/mod/mymodule/,
-     *                    example: image_url('comment', 'mod_glossary')
-     *
-     * @param string $imagename the pathname of the image
-     * @param string $component full plugin name (aka component) or 'theme'
-     * @return moodle_url
-     */
-    public function image_url($imagename, $component = 'moodle') {
-        return $this->page->theme->image_url($imagename, $component);
-    }
-
-    /**
-     * Return the site's logo URL, if any.
-     *
-     * @param int $maxwidth The maximum width, or null when the maximum width does not matter.
-     * @param int $maxheight The maximum height, or null when the maximum height does not matter.
-     * @return moodle_url|false
-     */
-    public function get_logo_url($maxwidth = null, $maxheight = 200) {
-        global $CFG;
-        $logo = get_config('core_admin', 'logo');
-        if (empty($logo)) {
-            return false;
-        }
-
-        // 200px high is the default image size which should be displayed at 100px in the page to account for retina displays.
-        // It's not worth the overhead of detecting and serving 2 different images based on the device.
-
-        // Hide the requested size in the file path.
-        $filepath = ((int) $maxwidth . 'x' . (int) $maxheight) . '/';
-
-        // Use $CFG->themerev to prevent browser caching when the file changes.
-        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'logo', $filepath,
-            theme_get_revision(), $logo);
-    }
-
-    /**
-     * Return the site's compact logo URL, if any.
-     *
-     * @param int $maxwidth The maximum width, or null when the maximum width does not matter.
-     * @param int $maxheight The maximum height, or null when the maximum height does not matter.
-     * @return moodle_url|false
-     */
-    public function get_compact_logo_url($maxwidth = 300, $maxheight = 300) {
-        global $CFG;
-        $logo = get_config('core_admin', 'logocompact');
-        if (empty($logo)) {
-            return false;
-        }
-
-        // Hide the requested size in the file path.
-        $filepath = ((int) $maxwidth . 'x' . (int) $maxheight) . '/';
-
-        // Use $CFG->themerev to prevent browser caching when the file changes.
-        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'logocompact', $filepath,
-            theme_get_revision(), $logo);
-    }
-
-    /**
-     * Whether we should display the logo in the navbar.
-     *
-     * We will when there are no main logos, and we have compact logo.
-     *
-     * @return bool
-     */
-    public function should_display_navbar_logo() {
-        $logo = $this->get_compact_logo_url();
-        return !empty($logo);
-    }
-
-    /**
-     * @deprecated since Moodle 4.0
-     */
-    #[\core\attribute\deprecated(null, reason: 'It is no longer used', since: '4.0', final: true)]
-    public function should_display_main_logo() {
-        \core\deprecation::emit_deprecation_if_present([self::class, __FUNCTION__]);
-    }
-
-    /**
-     * Returns the moodle page object.
-     *
-     * @return moodle_page
-     */
-    public function get_page(): moodle_page {
-        return $this->page;
-    }
-}
-
-
-/**
- * Basis for all plugin renderers.
- *
- * @copyright Petr Skoda (skodak)
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class plugin_renderer_base extends renderer_base {
-
-    /**
-     * @var renderer_base|core_renderer A reference to the current renderer.
-     * The renderer provided here will be determined by the page but will in 90%
-     * of cases by the {@link core_renderer}
-     */
-    protected $output;
-
-    /**
-     * Constructor method, calls the parent constructor
-     *
-     * @param moodle_page $page
-     * @param string $target one of rendering target constants
-     */
-    public function __construct(moodle_page $page, $target) {
-        if (empty($target) && $page->pagelayout === 'maintenance') {
-            // If the page is using the maintenance layout then we're going to force the target to maintenance.
-            // This way we'll get a special maintenance renderer that is designed to block access to API's that are likely
-            // unavailable for this page layout.
-            $target = RENDERER_TARGET_MAINTENANCE;
-        }
-        $this->output = $page->get_renderer('core', null, $target);
-        parent::__construct($page, $target);
-    }
-
-    /**
-     * Renders the provided widget and returns the HTML to display it.
-     *
-     * @param renderable $widget instance with renderable interface
-     * @return string
-     */
-    public function render(renderable $widget) {
-        $classname = get_class($widget);
-
-        // Strip namespaces.
-        $classname = preg_replace('/^.*\\\/', '', $classname);
-
-        // Keep a copy at this point, we may need to look for a deprecated method.
-        $deprecatedmethod = "render_{$classname}";
-
-        // Remove _renderable suffixes.
-        $classname = preg_replace('/_renderable$/', '', $classname);
-        $rendermethod = "render_{$classname}";
-
-        if (method_exists($this, $rendermethod)) {
-            // Call the render_[widget_name] function.
-            // Note: This has a higher priority than the named_templatable to allow the theme to override the template.
-            return $this->$rendermethod($widget);
-        }
-
-        if ($widget instanceof named_templatable) {
-            // This is a named templatable.
-            // Fetch the template name from the get_template_name function instead.
-            // Note: This has higher priority than the deprecated method which is not overridable by themes anyway.
-            return $this->render_from_template(
-                $widget->get_template_name($this),
-                $widget->export_for_template($this)
-            );
-        }
-
-        if ($rendermethod !== $deprecatedmethod && method_exists($this, $deprecatedmethod)) {
-            // This is exactly where we don't want to be.
-            // If you have arrived here you have a renderable component within your plugin that has the name
-            // blah_renderable, and you have a render method render_blah_renderable on your plugin.
-            // In 2.8 we revamped output, as part of this change we changed slightly how renderables got rendered
-            // and the _renderable suffix now gets removed when looking for a render method.
-            // You need to change your renderers render_blah_renderable to render_blah.
-            // Until you do this it will not be possible for a theme to override the renderer to override your method.
-            // Please do it ASAP.
-            static $debugged = [];
-            if (!isset($debugged[$deprecatedmethod])) {
-                debugging(sprintf(
-                    'Deprecated call. Please rename your renderables render method from %s to %s.',
-                    $deprecatedmethod,
-                    $rendermethod
-                ), DEBUG_DEVELOPER);
-                $debugged[$deprecatedmethod] = true;
-            }
-            return $this->$deprecatedmethod($widget);
-        }
-
-        // Pass to core renderer if method not found here.
-        // Note: this is not a parent. This is _new_ renderer which respects the requested format, and output type.
-        return $this->output->render($widget);
-    }
-
-    /**
-     * Magic method used to pass calls otherwise meant for the standard renderer
-     * to it to ensure we don't go causing unnecessary grief.
-     *
-     * @param string $method
-     * @param array $arguments
-     * @return mixed
-     */
-    public function __call($method, $arguments) {
-        if (method_exists('renderer_base', $method)) {
-            throw new coding_exception('Protected method called against '.get_class($this).' :: '.$method);
-        }
-        if (method_exists($this->output, $method)) {
-            return call_user_func_array(array($this->output, $method), $arguments);
-        } else {
-            throw new coding_exception('Unknown method called against '.get_class($this).' :: '.$method);
-        }
-    }
-}
-
-
-/**
- * The standard implementation of the core_renderer interface.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class core_renderer extends renderer_base {
-    /**
-     * Do NOT use, please use <?php echo $OUTPUT->main_content() ?>
-     * in layout files instead.
-     * @deprecated
-     * @var string used in {@link core_renderer::header()}.
-     */
-    const MAIN_CONTENT_TOKEN = '[MAIN CONTENT GOES HERE]';
-
-    /**
-     * @var string Used to pass information from {@link core_renderer::doctype()} to
-     * {@link core_renderer::standard_head_html()}.
-     */
-    protected $contenttype;
-
-    /**
-     * @var string Used by {@link core_renderer::redirect_message()} method to communicate
-     * with {@link core_renderer::header()}.
-     */
-    protected $metarefreshtag = '';
-
-    /**
-     * @var string Unique token for the closing HTML
-     */
-    protected $unique_end_html_token;
-
-    /**
-     * @var string Unique token for performance information
-     */
-    protected $unique_performance_info_token;
-
-    /**
-     * @var string Unique token for the main content.
-     */
-    protected $unique_main_content_token;
-
-    /** @var custom_menu_item language The language menu if created */
-    protected $language = null;
-
-    /** @var string The current selector for an element being streamed into */
-    protected $currentselector = '';
-
-    /** @var string The current element tag which is being streamed into */
-    protected $currentelement = '';
-
-    /**
-     * Constructor
-     *
-     * @param moodle_page $page the page we are doing output for.
-     * @param string $target one of rendering target constants
-     */
-    public function __construct(moodle_page $page, $target) {
-        $this->opencontainers = $page->opencontainers;
-        $this->page = $page;
-        $this->target = $target;
-
-        $this->unique_end_html_token = '%%ENDHTML-'.sesskey().'%%';
-        $this->unique_performance_info_token = '%%PERFORMANCEINFO-'.sesskey().'%%';
-        $this->unique_main_content_token = '[MAIN CONTENT GOES HERE - '.sesskey().']';
-    }
-
-    /**
-     * Get the DOCTYPE declaration that should be used with this page. Designed to
-     * be called in theme layout.php files.
-     *
-     * @return string the DOCTYPE declaration that should be used.
-     */
-    public function doctype() {
-        if ($this->page->theme->doctype === 'html5') {
-            $this->contenttype = 'text/html; charset=utf-8';
-            return "<!DOCTYPE html>\n";
-
-        } else if ($this->page->theme->doctype === 'xhtml5') {
-            $this->contenttype = 'application/xhtml+xml; charset=utf-8';
-            return "<!DOCTYPE html>\n";
-
-        } else {
-            // legacy xhtml 1.0
-            $this->contenttype = 'text/html; charset=utf-8';
-            return ('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' . "\n");
-        }
-    }
-
-    /**
-     * The attributes that should be added to the <html> tag. Designed to
-     * be called in theme layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function htmlattributes() {
-        $return = get_html_lang(true);
-
-        $hook = new before_html_attributes($this);
-
-        if ($this->page->theme->doctype !== 'html5') {
-            $hook->add_attribute('xmlns', 'http://www.w3.org/1999/xhtml');
-        }
-
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-
-        foreach ($hook->get_attributes() as $key => $val) {
-            $val = s($val);
-            $return .= " $key=\"$val\"";
-        }
-
-        return $return;
-    }
-
-    /**
-     * The standard tags (meta tags, links to stylesheets and JavaScript, etc.)
-     * that should be included in the <head> tag. Designed to be called in theme
-     * layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function standard_head_html() {
-        global $CFG, $SESSION, $SITE;
-
-        // Before we output any content, we need to ensure that certain
-        // page components are set up.
-
-        // Blocks must be set up early as they may require javascript which
-        // has to be included in the page header before output is created.
-        foreach ($this->page->blocks->get_regions() as $region) {
-            $this->page->blocks->ensure_content_created($region, $this);
-        }
-
-        // Give plugins an opportunity to add any head elements. The callback
-        // must always return a string containing valid html head content.
-
-        $hook = new \core\hook\output\before_standard_head_html_generation($this);
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-
-        // Allow a url_rewrite plugin to setup any dynamic head content.
-        if (isset($CFG->urlrewriteclass) && !isset($CFG->upgraderunning)) {
-            $class = $CFG->urlrewriteclass;
-            $hook->add_html($class::html_head_setup());
-        }
-
-        $hook->add_html('<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' . "\n");
-        $hook->add_html('<meta name="keywords" content="moodle, ' . $this->page->title . '" />' . "\n");
-        // This is only set by the {@link redirect()} method
-        $hook->add_html($this->metarefreshtag);
-
-        // Check if a periodic refresh delay has been set and make sure we arn't
-        // already meta refreshing
-        if ($this->metarefreshtag=='' && $this->page->periodicrefreshdelay!==null) {
-            $hook->add_html(
-                html_writer::empty_tag('meta', [
-                    'http-equiv' => 'refresh',
-                    'content' => $this->page->periodicrefreshdelay . ';url='.$this->page->url->out(),
-                ]),
-            );
-        }
-
-        $output = $hook->get_output();
-
-        // Set up help link popups for all links with the helptooltip class
-        $this->page->requires->js_init_call('M.util.help_popups.setup');
-
-        $focus = $this->page->focuscontrol;
-        if (!empty($focus)) {
-            if (preg_match("#forms\['([a-zA-Z0-9]+)'\].elements\['([a-zA-Z0-9]+)'\]#", $focus, $matches)) {
-                // This is a horrifically bad way to handle focus but it is passed in
-                // through messy formslib::moodleform
-                $this->page->requires->js_function_call('old_onload_focus', array($matches[1], $matches[2]));
-            } else if (strpos($focus, '.')!==false) {
-                // Old style of focus, bad way to do it
-                debugging('This code is using the old style focus event, Please update this code to focus on an element id or the moodleform focus method.', DEBUG_DEVELOPER);
-                $this->page->requires->js_function_call('old_onload_focus', explode('.', $focus, 2));
-            } else {
-                // Focus element with given id
-                $this->page->requires->js_function_call('focuscontrol', array($focus));
-            }
-        }
-
-        // Get the theme stylesheet - this has to be always first CSS, this loads also styles.css from all plugins;
-        // any other custom CSS can not be overridden via themes and is highly discouraged
-        $urls = $this->page->theme->css_urls($this->page);
-        foreach ($urls as $url) {
-            $this->page->requires->css_theme($url);
-        }
-
-        // Get the theme javascript head and footer
-        if ($jsurl = $this->page->theme->javascript_url(true)) {
-            $this->page->requires->js($jsurl, true);
-        }
-        if ($jsurl = $this->page->theme->javascript_url(false)) {
-            $this->page->requires->js($jsurl);
-        }
-
-        // Get any HTML from the page_requirements_manager.
-        $output .= $this->page->requires->get_head_code($this->page, $this);
-
-        // List alternate versions.
-        foreach ($this->page->alternateversions as $type => $alt) {
-            $output .= html_writer::empty_tag('link', array('rel' => 'alternate',
-                    'type' => $type, 'title' => $alt->title, 'href' => $alt->url));
-        }
-
-        // Add noindex tag if relevant page and setting applied.
-        $allowindexing = isset($CFG->allowindexing) ? $CFG->allowindexing : 0;
-        $loginpages = array('login-index', 'login-signup');
-        if ($allowindexing == 2 || ($allowindexing == 0 && in_array($this->page->pagetype, $loginpages))) {
-            if (!isset($CFG->additionalhtmlhead)) {
-                $CFG->additionalhtmlhead = '';
-            }
-            $CFG->additionalhtmlhead .= '<meta name="robots" content="noindex" />';
-        }
-
-        if (!empty($CFG->additionalhtmlhead)) {
-            $output .= "\n".$CFG->additionalhtmlhead;
-        }
-
-        if ($this->page->pagelayout == 'frontpage') {
-            $summary = s(strip_tags(format_text($SITE->summary, FORMAT_HTML)));
-            if (!empty($summary)) {
-                $output .= "<meta name=\"description\" content=\"$summary\" />\n";
-            }
-        }
-
-        return $output;
-    }
-
-    /**
-     * The standard tags (typically skip links) that should be output just inside
-     * the start of the <body> tag. Designed to be called in theme layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function standard_top_of_body_html() {
-        global $CFG;
-        $output = $this->page->requires->get_top_of_body_code($this);
-        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmltopofbody)) {
-            $output .= "\n".$CFG->additionalhtmltopofbody;
-        }
-
-        // Allow components to add content to the top of the body.
-        $hook = new before_standard_top_of_body_html_generation($this, $output);
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-        $output = $hook->get_output();
-
-        $output .= $this->maintenance_warning();
-
-        return $output;
-    }
-
-    /**
-     * Scheduled maintenance warning message.
-     *
-     * Note: This is a nasty hack to display maintenance notice, this should be moved
-     *       to some general notification area once we have it.
-     *
-     * @return string
-     */
-    public function maintenance_warning() {
-        global $CFG;
-
-        $output = '';
-        if (isset($CFG->maintenance_later) and $CFG->maintenance_later > time()) {
-            $timeleft = $CFG->maintenance_later - time();
-            // If timeleft less than 30 sec, set the class on block to error to highlight.
-            $errorclass = ($timeleft < 30) ? 'alert-error alert-danger' : 'alert-warning';
-            $output .= $this->box_start($errorclass . ' moodle-has-zindex maintenancewarning m-3 alert');
-            $a = new stdClass();
-            $a->hour = (int)($timeleft / 3600);
-            $a->min = (int)(floor($timeleft / 60) % 60);
-            $a->sec = (int)($timeleft % 60);
-            if ($a->hour > 0) {
-                $output .= get_string('maintenancemodeisscheduledlong', 'admin', $a);
-            } else {
-                $output .= get_string('maintenancemodeisscheduled', 'admin', $a);
-            }
-
-            $output .= $this->box_end();
-            $this->page->requires->yui_module('moodle-core-maintenancemodetimer', 'M.core.maintenancemodetimer',
-                    array(array('timeleftinsec' => $timeleft)));
-            $this->page->requires->strings_for_js(
-                    array('maintenancemodeisscheduled', 'maintenancemodeisscheduledlong', 'sitemaintenance'),
-                    'admin');
-        }
-        return $output;
-    }
-
-    /**
-     * content that should be output in the footer area
-     * of the page. Designed to be called in theme layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function standard_footer_html() {
-        if (during_initial_install()) {
-            // Debugging info can not work before install is finished,
-            // in any case we do not want any links during installation!
-            return '';
-        }
-
-        $hook = new before_standard_footer_html_generation($this);
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-        $output = $hook->get_output();
-
-        if ($this->page->devicetypeinuse == 'legacy') {
-            // The legacy theme is in use print the notification
-            $output .= html_writer::tag('div', get_string('legacythemeinuse'), array('class'=>'legacythemeinuse'));
-        }
-
-        // Get links to switch device types (only shown for users not on a default device)
-        $output .= $this->theme_switch_links();
-
-        return $output;
-    }
-
-    /**
-     * Performance information and validation links for debugging.
-     *
-     * @return string HTML fragment.
-     */
-    public function debug_footer_html() {
-        global $CFG, $SCRIPT;
-        $output = '';
-
-        if (during_initial_install()) {
-            // Debugging info can not work before install is finished.
-            return $output;
-        }
-
-        // This function is normally called from a layout.php file
-        // but some of the content won't be known until later, so we return a placeholder
-        // for now. This will be replaced with the real content in the footer.
-        $output .= $this->unique_performance_info_token;
-
-        if (!empty($CFG->debugpageinfo)) {
-            $output .= '<div class="performanceinfo pageinfo">' . get_string('pageinfodebugsummary', 'core_admin',
-                $this->page->debug_summary()) . '</div>';
-        }
-        if (debugging(null, DEBUG_DEVELOPER) and has_capability('moodle/site:config', context_system::instance())) {  // Only in developer mode
-
-            // Add link to profiling report if necessary
-            if (function_exists('profiling_is_running') && profiling_is_running()) {
-                $txt = get_string('profiledscript', 'admin');
-                $title = get_string('profiledscriptview', 'admin');
-                $url = $CFG->wwwroot . '/admin/tool/profiling/index.php?script=' . urlencode($SCRIPT);
-                $link= '<a title="' . $title . '" href="' . $url . '">' . $txt . '</a>';
-                $output .= '<div class="profilingfooter">' . $link . '</div>';
-            }
-            $purgeurl = new moodle_url('/admin/purgecaches.php', array('confirm' => 1,
-                'sesskey' => sesskey(), 'returnurl' => $this->page->url->out_as_local_url(false)));
-            $output .= '<div class="purgecaches">' .
-                    html_writer::link($purgeurl, get_string('purgecaches', 'admin')) . '</div>';
-
-            // Reactive module debug panel.
-            $output .= $this->render_from_template('core/local/reactive/debugpanel', []);
-        }
-        if (!empty($CFG->debugvalidators)) {
-            $siteurl = qualified_me();
-            $nuurl = new moodle_url('https://validator.w3.org/nu/', ['doc' => $siteurl, 'showsource' => 'yes']);
-            $waveurl = new moodle_url('https://wave.webaim.org/report#/' . urlencode($siteurl));
-            $validatorlinks = [
-                html_writer::link($nuurl, get_string('validatehtml')),
-                html_writer::link($waveurl, get_string('wcagcheck'))
-            ];
-            $validatorlinkslist = html_writer::alist($validatorlinks, ['class' => 'list-unstyled ml-1']);
-            $output .= html_writer::div($validatorlinkslist, 'validators');
-        }
-        return $output;
-    }
-
-    /**
-     * Returns standard main content placeholder.
-     * Designed to be called in theme layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function main_content() {
-        // This is here because it is the only place we can inject the "main" role over the entire main content area
-        // without requiring all theme's to manually do it, and without creating yet another thing people need to
-        // remember in the theme.
-        // This is an unfortunate hack. DO NO EVER add anything more here.
-        // DO NOT add classes.
-        // DO NOT add an id.
-        return '<div role="main">'.$this->unique_main_content_token.'</div>';
-    }
-
-    /**
-     * Returns information about an activity.
-     *
-     * @deprecated since Moodle 4.3 MDL-78744
-     * @todo MDL-78926 This method will be deleted in Moodle 4.7
-     * @param cm_info $cminfo The course module information.
-     * @param cm_completion_details $completiondetails The completion details for this activity module.
-     * @param array $activitydates The dates for this activity module.
-     * @return string the activity information HTML.
-     * @throws coding_exception
-     */
-    public function activity_information(cm_info $cminfo, cm_completion_details $completiondetails, array $activitydates): string {
-        debugging('activity_information method is deprecated.', DEBUG_DEVELOPER);
-        if (!$completiondetails->has_completion() && empty($activitydates)) {
-            // No need to render the activity information when there's no completion info and activity dates to show.
-            return '';
-        }
-        $activityinfo = new activity_information($cminfo, $completiondetails, $activitydates);
-        $renderer = $this->page->get_renderer('core', 'course');
-        return $renderer->render($activityinfo);
-    }
-
-    /**
-     * Returns standard navigation between activities in a course.
-     *
-     * @return string the navigation HTML.
-     */
-    public function activity_navigation() {
-        // First we should check if we want to add navigation.
-        $context = $this->page->context;
-        if (($this->page->pagelayout !== 'incourse' && $this->page->pagelayout !== 'frametop')
-            || $context->contextlevel != CONTEXT_MODULE) {
-            return '';
-        }
-
-        // If the activity is in stealth mode, show no links.
-        if ($this->page->cm->is_stealth()) {
-            return '';
-        }
-
-        $course = $this->page->cm->get_course();
-        $courseformat = course_get_format($course);
-
-        // If the theme implements course index and the current course format uses course index and the current
-        // page layout is not 'frametop' (this layout does not support course index), show no links.
-        if ($this->page->theme->usescourseindex && $courseformat->uses_course_index() &&
-                $this->page->pagelayout !== 'frametop') {
-            return '';
-        }
-
-        // Get a list of all the activities in the course.
-        $modules = get_fast_modinfo($course->id)->get_cms();
-
-        // Put the modules into an array in order by the position they are shown in the course.
-        $mods = [];
-        $activitylist = [];
-        foreach ($modules as $module) {
-            // Only add activities the user can access, aren't in stealth mode and have a url (eg. mod_label does not).
-            if (!$module->uservisible || $module->is_stealth() || empty($module->url)) {
-                continue;
-            }
-            $mods[$module->id] = $module;
-
-            // No need to add the current module to the list for the activity dropdown menu.
-            if ($module->id == $this->page->cm->id) {
-                continue;
-            }
-            // Module name.
-            $modname = $module->get_formatted_name();
-            // Display the hidden text if necessary.
-            if (!$module->visible) {
-                $modname .= ' ' . get_string('hiddenwithbrackets');
-            }
-            // Module URL.
-            $linkurl = new moodle_url($module->url, array('forceview' => 1));
-            // Add module URL (as key) and name (as value) to the activity list array.
-            $activitylist[$linkurl->out(false)] = $modname;
-        }
-
-        $nummods = count($mods);
-
-        // If there is only one mod then do nothing.
-        if ($nummods == 1) {
-            return '';
-        }
-
-        // Get an array of just the course module ids used to get the cmid value based on their position in the course.
-        $modids = array_keys($mods);
-
-        // Get the position in the array of the course module we are viewing.
-        $position = array_search($this->page->cm->id, $modids);
-
-        $prevmod = null;
-        $nextmod = null;
-
-        // Check if we have a previous mod to show.
-        if ($position > 0) {
-            $prevmod = $mods[$modids[$position - 1]];
-        }
-
-        // Check if we have a next mod to show.
-        if ($position < ($nummods - 1)) {
-            $nextmod = $mods[$modids[$position + 1]];
-        }
-
-        $activitynav = new \core_course\output\activity_navigation($prevmod, $nextmod, $activitylist);
-        $renderer = $this->page->get_renderer('core', 'course');
-        return $renderer->render($activitynav);
-    }
-
-    /**
-     * The standard tags (typically script tags that are not needed earlier) that
-     * should be output after everything else. Designed to be called in theme layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function standard_end_of_body_html() {
-        global $CFG;
-
-        // This function is normally called from a layout.php file in {@link core_renderer::header()}
-        // but some of the content won't be known until later, so we return a placeholder
-        // for now. This will be replaced with the real content in {@link core_renderer::footer()}.
-        $output = '';
-        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmlfooter)) {
-            $output .= "\n".$CFG->additionalhtmlfooter;
-        }
-        $output .= $this->unique_end_html_token;
-        return $output;
-    }
-
-    /**
-     * The standard HTML that should be output just before the <footer> tag.
-     * Designed to be called in theme layout.php files.
-     *
-     * @return string HTML fragment.
-     */
-    public function standard_after_main_region_html() {
-        global $CFG;
-
-        $hook = new after_standard_main_region_html_generation($this);
-
-        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmlbottomofbody)) {
-            $hook->add_html("\n");
-            $hook->add_html($CFG->additionalhtmlbottomofbody);
-        }
-
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-
-        return $hook->get_output();
-    }
-
-    /**
-     * Return the standard string that says whether you are logged in (and switched
-     * roles/logged in as another user).
-     * @param bool $withlinks if false, then don't include any links in the HTML produced.
-     * If not set, the default is the nologinlinks option from the theme config.php file,
-     * and if that is not set, then links are included.
-     * @return string HTML fragment.
-     */
-    public function login_info($withlinks = null) {
-        global $USER, $CFG, $DB, $SESSION;
-
-        if (during_initial_install()) {
-            return '';
-        }
-
-        if (is_null($withlinks)) {
-            $withlinks = empty($this->page->layout_options['nologinlinks']);
-        }
-
-        $course = $this->page->course;
-        if (\core\session\manager::is_loggedinas()) {
-            $realuser = \core\session\manager::get_realuser();
-            $fullname = fullname($realuser);
-            if ($withlinks) {
-                $loginastitle = get_string('loginas');
-                $realuserinfo = " [<a href=\"$CFG->wwwroot/course/loginas.php?id=$course->id&amp;sesskey=".sesskey()."\"";
-                $realuserinfo .= "title =\"".$loginastitle."\">$fullname</a>] ";
-            } else {
-                $realuserinfo = " [$fullname] ";
-            }
-        } else {
-            $realuserinfo = '';
-        }
-
-        $loginpage = $this->is_login_page();
-        $loginurl = get_login_url();
-
-        if (empty($course->id)) {
-            // $course->id is not defined during installation
-            return '';
-        } else if (isloggedin()) {
-            $context = context_course::instance($course->id);
-
-            $fullname = fullname($USER);
-            // Since Moodle 2.0 this link always goes to the public profile page (not the course profile page)
-            if ($withlinks) {
-                $linktitle = get_string('viewprofile');
-                $username = "<a href=\"$CFG->wwwroot/user/profile.php?id=$USER->id\" title=\"$linktitle\">$fullname</a>";
-            } else {
-                $username = $fullname;
-            }
-            if (is_mnet_remote_user($USER) and $idprovider = $DB->get_record('mnet_host', array('id'=>$USER->mnethostid))) {
-                if ($withlinks) {
-                    $username .= " from <a href=\"{$idprovider->wwwroot}\">{$idprovider->name}</a>";
-                } else {
-                    $username .= " from {$idprovider->name}";
-                }
-            }
-            if (isguestuser()) {
-                $loggedinas = $realuserinfo.get_string('loggedinasguest');
-                if (!$loginpage && $withlinks) {
-                    $loggedinas .= " (<a href=\"$loginurl\">".get_string('login').'</a>)';
-                }
-            } else if (is_role_switched($course->id)) { // Has switched roles
-                $rolename = '';
-                if ($role = $DB->get_record('role', array('id'=>$USER->access['rsw'][$context->path]))) {
-                    $rolename = ': '.role_get_name($role, $context);
-                }
-                $loggedinas = get_string('loggedinas', 'moodle', $username).$rolename;
-                if ($withlinks) {
-                    $url = new moodle_url('/course/switchrole.php', array('id'=>$course->id,'sesskey'=>sesskey(), 'switchrole'=>0, 'returnurl'=>$this->page->url->out_as_local_url(false)));
-                    $loggedinas .= ' ('.html_writer::tag('a', get_string('switchrolereturn'), array('href' => $url)).')';
-                }
-            } else {
-                $loggedinas = $realuserinfo.get_string('loggedinas', 'moodle', $username);
-                if ($withlinks) {
-                    $loggedinas .= " (<a href=\"$CFG->wwwroot/login/logout.php?sesskey=".sesskey()."\">".get_string('logout').'</a>)';
-                }
-            }
-        } else {
-            $loggedinas = get_string('loggedinnot', 'moodle');
-            if (!$loginpage && $withlinks) {
-                $loggedinas .= " (<a href=\"$loginurl\">".get_string('login').'</a>)';
-            }
-        }
-
-        $loggedinas = '<div class="logininfo">'.$loggedinas.'</div>';
-
-        if (isset($SESSION->justloggedin)) {
-            unset($SESSION->justloggedin);
-            if (!isguestuser()) {
-                // Include this file only when required.
-                require_once($CFG->dirroot . '/user/lib.php');
-                if (($count = user_count_login_failures($USER)) && !empty($CFG->displayloginfailures)) {
-                    $loggedinas .= '<div class="loginfailures">';
-                    $a = new stdClass();
-                    $a->attempts = $count;
-                    $loggedinas .= get_string('failedloginattempts', '', $a);
-                    if (file_exists("$CFG->dirroot/report/log/index.php") and has_capability('report/log:view', context_system::instance())) {
-                        $loggedinas .= ' ('.html_writer::link(new moodle_url('/report/log/index.php', array('chooselog' => 1,
-                                'id' => 0 , 'modid' => 'site_errors')), get_string('logs')).')';
-                    }
-                    $loggedinas .= '</div>';
-                }
-            }
-        }
-
-        return $loggedinas;
-    }
-
-    /**
-     * Check whether the current page is a login page.
-     *
-     * @since Moodle 2.9
-     * @return bool
-     */
-    protected function is_login_page() {
-        // This is a real bit of a hack, but its a rarety that we need to do something like this.
-        // In fact the login pages should be only these two pages and as exposing this as an option for all pages
-        // could lead to abuse (or at least unneedingly complex code) the hack is the way to go.
-        return in_array(
-            $this->page->url->out_as_local_url(false, array()),
-            array(
-                '/login/index.php',
-                '/login/forgot_password.php',
-            )
-        );
-    }
-
-    /**
-     * Return the 'back' link that normally appears in the footer.
-     *
-     * @return string HTML fragment.
-     */
-    public function home_link() {
-        global $CFG, $SITE;
-
-        if ($this->page->pagetype == 'site-index') {
-            // Special case for site home page - please do not remove
-            return '<div class="sitelink">' .
-                   '<a title="Moodle" class="d-inline-block aalink" href="http://moodle.org/">' .
-                   '<img src="' . $this->image_url('moodlelogo_grayhat') . '" alt="'.get_string('moodlelogo').'" /></a></div>';
-
-        } else if (!empty($CFG->target_release) && $CFG->target_release != $CFG->release) {
-            // Special case for during install/upgrade.
-            return '<div class="sitelink">'.
-                   '<a title="Moodle" href="http://docs.moodle.org/en/Administrator_documentation" onclick="this.target=\'_blank\'">' .
-                   '<img src="' . $this->image_url('moodlelogo_grayhat') . '" alt="'.get_string('moodlelogo').'" /></a></div>';
-
-        } else if ($this->page->course->id == $SITE->id || strpos($this->page->pagetype, 'course-view') === 0) {
-            return '<div class="homelink"><a href="' . $CFG->wwwroot . '/">' .
-                    get_string('home') . '</a></div>';
-
-        } else {
-            return '<div class="homelink"><a href="' . $CFG->wwwroot . '/course/view.php?id=' . $this->page->course->id . '">' .
-                    format_string($this->page->course->shortname, true, array('context' => $this->page->context)) . '</a></div>';
-        }
-    }
-
-    /**
-     * Redirects the user by any means possible given the current state
-     *
-     * This function should not be called directly, it should always be called using
-     * the redirect function in lib/weblib.php
-     *
-     * The redirect function should really only be called before page output has started
-     * however it will allow itself to be called during the state STATE_IN_BODY
-     *
-     * @param string $encodedurl The URL to send to encoded if required
-     * @param string $message The message to display to the user if any
-     * @param int $delay The delay before redirecting a user, if $message has been
-     *         set this is a requirement and defaults to 3, set to 0 no delay
-     * @param boolean $debugdisableredirect this redirect has been disabled for
-     *         debugging purposes. Display a message that explains, and don't
-     *         trigger the redirect.
-     * @param string $messagetype The type of notification to show the message in.
-     *         See constants on \core\output\notification.
-     * @return string The HTML to display to the user before dying, may contain
-     *         meta refresh, javascript refresh, and may have set header redirects
-     */
-    public function redirect_message($encodedurl, $message, $delay, $debugdisableredirect,
-                                     $messagetype = \core\output\notification::NOTIFY_INFO) {
-        global $CFG;
-        $url = str_replace('&amp;', '&', $encodedurl);
-
-        switch ($this->page->state) {
-            case moodle_page::STATE_BEFORE_HEADER :
-                // No output yet it is safe to delivery the full arsenal of redirect methods
-                if (!$debugdisableredirect) {
-                    // Don't use exactly the same time here, it can cause problems when both redirects fire at the same time.
-                    $this->metarefreshtag = '<meta http-equiv="refresh" content="'. $delay .'; url='. $encodedurl .'" />'."\n";
-                    $this->page->requires->js_function_call('document.location.replace', array($url), false, ($delay + 3));
-                }
-                $output = $this->header();
-                break;
-            case moodle_page::STATE_PRINTING_HEADER :
-                // We should hopefully never get here
-                throw new coding_exception('You cannot redirect while printing the page header');
-                break;
-            case moodle_page::STATE_IN_BODY :
-                // We really shouldn't be here but we can deal with this
-                debugging("You should really redirect before you start page output");
-                if (!$debugdisableredirect) {
-                    $this->page->requires->js_function_call('document.location.replace', array($url), false, $delay);
-                }
-                $output = $this->opencontainers->pop_all_but_last();
-                break;
-            case moodle_page::STATE_DONE :
-                // Too late to be calling redirect now
-                throw new coding_exception('You cannot redirect after the entire page has been generated');
-                break;
-        }
-        $output .= $this->notification($message, $messagetype);
-        $output .= '<div class="continuebutton">(<a href="'. $encodedurl .'">'. get_string('continue') .'</a>)</div>';
-        if ($debugdisableredirect) {
-            $output .= '<p><strong>'.get_string('erroroutput', 'error').'</strong></p>';
-        }
-        $output .= $this->footer();
-        return $output;
-    }
-
-    /**
-     * Start output by sending the HTTP headers, and printing the HTML <head>
-     * and the start of the <body>.
-     *
-     * To control what is printed, you should set properties on $PAGE.
-     *
-     * @return string HTML that you must output this, preferably immediately.
-     */
-    public function header() {
-        global $USER, $CFG, $SESSION;
-
-        $hook = new before_http_headers($this);
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-
-        if (\core\session\manager::is_loggedinas()) {
-            $this->page->add_body_class('userloggedinas');
-        }
-
-        if (isset($SESSION->justloggedin) && !empty($CFG->displayloginfailures)) {
-            require_once($CFG->dirroot . '/user/lib.php');
-            // Set second parameter to false as we do not want reset the counter, the same message appears on footer.
-            if ($count = user_count_login_failures($USER, false)) {
-                $this->page->add_body_class('loginfailures');
-            }
-        }
-
-        // If the user is logged in, and we're not in initial install,
-        // check to see if the user is role-switched and add the appropriate
-        // CSS class to the body element.
-        if (!during_initial_install() && isloggedin() && is_role_switched($this->page->course->id)) {
-            $this->page->add_body_class('userswitchedrole');
-        }
-
-        // Give themes a chance to init/alter the page object.
-        $this->page->theme->init_page($this->page);
-
-        $this->page->set_state(moodle_page::STATE_PRINTING_HEADER);
-
-        // Find the appropriate page layout file, based on $this->page->pagelayout.
-        $layoutfile = $this->page->theme->layout_file($this->page->pagelayout);
-        // Render the layout using the layout file.
-        $rendered = $this->render_page_layout($layoutfile);
-
-        // Slice the rendered output into header and footer.
-        $cutpos = strpos($rendered, $this->unique_main_content_token);
-        if ($cutpos === false) {
-            $cutpos = strpos($rendered, self::MAIN_CONTENT_TOKEN);
-            $token = self::MAIN_CONTENT_TOKEN;
-        } else {
-            $token = $this->unique_main_content_token;
-        }
-
-        if ($cutpos === false) {
-            throw new coding_exception('page layout file ' . $layoutfile . ' does not contain the main content placeholder, please include "<?php echo $OUTPUT->main_content() ?>" in theme layout file.');
-        }
-
-        $header = substr($rendered, 0, $cutpos);
-        $footer = substr($rendered, $cutpos + strlen($token));
-
-        if (empty($this->contenttype)) {
-            debugging('The page layout file did not call $OUTPUT->doctype()');
-            $header = $this->doctype() . $header;
-        }
-
-        // If this theme version is below 2.4 release and this is a course view page
-        if ((!isset($this->page->theme->settings->version) || $this->page->theme->settings->version < 2012101500) &&
-                $this->page->pagelayout === 'course' && $this->page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)) {
-            // check if course content header/footer have not been output during render of theme layout
-            $coursecontentheader = $this->course_content_header(true);
-            $coursecontentfooter = $this->course_content_footer(true);
-            if (!empty($coursecontentheader)) {
-                // display debug message and add header and footer right above and below main content
-                // Please note that course header and footer (to be displayed above and below the whole page)
-                // are not displayed in this case at all.
-                // Besides the content header and footer are not displayed on any other course page
-                debugging('The current theme is not optimised for 2.4, the course-specific header and footer defined in course format will not be output', DEBUG_DEVELOPER);
-                $header .= $coursecontentheader;
-                $footer = $coursecontentfooter. $footer;
-            }
-        }
-
-        send_headers($this->contenttype, $this->page->cacheable);
-
-        $this->opencontainers->push('header/footer', $footer);
-        $this->page->set_state(moodle_page::STATE_IN_BODY);
-
-        // If an activity record has been set, activity_header will handle this.
-        if (!$this->page->cm || !empty($this->page->layout_options['noactivityheader'])) {
-            $header .= $this->skip_link_target('maincontent');
-        }
-        return $header;
-    }
-
-    /**
-     * Renders and outputs the page layout file.
-     *
-     * This is done by preparing the normal globals available to a script, and
-     * then including the layout file provided by the current theme for the
-     * requested layout.
-     *
-     * @param string $layoutfile The name of the layout file
-     * @return string HTML code
-     */
-    protected function render_page_layout($layoutfile) {
-        global $CFG, $SITE, $USER;
-        // The next lines are a bit tricky. The point is, here we are in a method
-        // of a renderer class, and this object may, or may not, be the same as
-        // the global $OUTPUT object. When rendering the page layout file, we want to use
-        // this object. However, people writing Moodle code expect the current
-        // renderer to be called $OUTPUT, not $this, so define a variable called
-        // $OUTPUT pointing at $this. The same comment applies to $PAGE and $COURSE.
-        $OUTPUT = $this;
-        $PAGE = $this->page;
-        $COURSE = $this->page->course;
-
-        ob_start();
-        include($layoutfile);
-        $rendered = ob_get_contents();
-        ob_end_clean();
-        return $rendered;
-    }
-
-    /**
-     * Outputs the page's footer
-     *
-     * @return string HTML fragment
-     */
-    public function footer() {
-        global $CFG, $DB, $PERF;
-
-        $hook = new before_footer_html_generation($this);
-        $hook->process_legacy_callbacks();
-        di::get(hook_manager::class)->dispatch($hook);
-        $hook->add_html($this->container_end_all(true));
-        $output = $hook->get_output();
-
-        $footer = $this->opencontainers->pop('header/footer');
-
-        if (debugging() and $DB and $DB->is_transaction_started()) {
-            // TODO: MDL-20625 print warning - transaction will be rolled back
-        }
-
-        // Provide some performance info if required
-        $performanceinfo = '';
-        if (MDL_PERF || (!empty($CFG->perfdebug) && $CFG->perfdebug > 7)) {
-            if (MDL_PERFTOFOOT || debugging() || (!empty($CFG->perfdebug) && $CFG->perfdebug > 7)) {
-                if (NO_OUTPUT_BUFFERING) {
-                    // If the output buffer was off then we render a placeholder and stream the
-                    // performance debugging into it at the very end in the shutdown handler.
-                    $PERF->perfdebugdeferred = true;
-                    $performanceinfo .= html_writer::tag('div',
-                        get_string('perfdebugdeferred', 'admin'),
-                        [
-                            'id' => 'perfdebugfooter',
-                            'style' => 'min-height: 30em',
-                        ]);
-                } else {
-                    $perf = get_performance_info();
-                    $performanceinfo = $perf['html'];
-                }
-            }
-        }
-
-        // We always want performance data when running a performance test, even if the user is redirected to another page.
-        if (MDL_PERF_TEST && strpos($footer, $this->unique_performance_info_token) === false) {
-            $footer = $this->unique_performance_info_token . $footer;
-        }
-        $footer = str_replace($this->unique_performance_info_token, $performanceinfo, $footer);
-
-        // Only show notifications when the current page has a context id.
-        if (!empty($this->page->context->id)) {
-            $this->page->requires->js_call_amd('core/notification', 'init', array(
-                $this->page->context->id,
-                \core\notification::fetch_as_array($this)
-            ));
-        }
-        $footer = str_replace($this->unique_end_html_token, $this->page->requires->get_end_code(), $footer);
-
-        $this->page->set_state(moodle_page::STATE_DONE);
-
-        // Here we remove the closing body and html tags and store them to be added back
-        // in the shutdown handler so we can have valid html with streaming script tags
-        // which are rendered after the visible footer.
-        $tags = '';
-        preg_match('#\<\/body>#i', $footer, $matches);
-        $tags .= $matches[0];
-        $footer = str_replace($matches[0], '', $footer);
-
-        preg_match('#\<\/html>#i', $footer, $matches);
-        $tags .= $matches[0];
-        $footer = str_replace($matches[0], '', $footer);
-
-        $CFG->closingtags = $tags;
-
-        return $output . $footer;
-    }
-
-    /**
-     * Close all but the last open container. This is useful in places like error
-     * handling, where you want to close all the open containers (apart from <body>)
-     * before outputting the error message.
-     *
-     * @param bool $shouldbenone assert that the stack should be empty now - causes a
-     *      developer debug warning if it isn't.
-     * @return string the HTML required to close any open containers inside <body>.
-     */
-    public function container_end_all($shouldbenone = false) {
-        return $this->opencontainers->pop_all_but_last($shouldbenone);
-    }
-
-    /**
-     * Returns course-specific information to be output immediately above content on any course page
-     * (for the current course)
-     *
-     * @param bool $onlyifnotcalledbefore output content only if it has not been output before
-     * @return string
-     */
-    public function course_content_header($onlyifnotcalledbefore = false) {
-        global $CFG;
-        static $functioncalled = false;
-        if ($functioncalled && $onlyifnotcalledbefore) {
-            // we have already output the content header
-            return '';
-        }
-
-        // Output any session notification.
-        $notifications = \core\notification::fetch();
-
-        $bodynotifications = '';
-        foreach ($notifications as $notification) {
-            $bodynotifications .= $this->render_from_template(
-                    $notification->get_template_name(),
-                    $notification->export_for_template($this)
-                );
-        }
-
-        $output = html_writer::span($bodynotifications, 'notifications', array('id' => 'user-notifications'));
-
-        if ($this->page->course->id == SITEID) {
-            // return immediately and do not include /course/lib.php if not necessary
-            return $output;
-        }
-
-        require_once($CFG->dirroot.'/course/lib.php');
-        $functioncalled = true;
-        $courseformat = course_get_format($this->page->course);
-        if (($obj = $courseformat->course_content_header()) !== null) {
-            $output .= html_writer::div($courseformat->get_renderer($this->page)->render($obj), 'course-content-header');
-        }
-        return $output;
-    }
-
-    /**
-     * Returns course-specific information to be output immediately below content on any course page
-     * (for the current course)
-     *
-     * @param bool $onlyifnotcalledbefore output content only if it has not been output before
-     * @return string
-     */
-    public function course_content_footer($onlyifnotcalledbefore = false) {
-        global $CFG;
-        if ($this->page->course->id == SITEID) {
-            // return immediately and do not include /course/lib.php if not necessary
-            return '';
-        }
-        static $functioncalled = false;
-        if ($functioncalled && $onlyifnotcalledbefore) {
-            // we have already output the content footer
-            return '';
-        }
-        $functioncalled = true;
-        require_once($CFG->dirroot.'/course/lib.php');
-        $courseformat = course_get_format($this->page->course);
-        if (($obj = $courseformat->course_content_footer()) !== null) {
-            return html_writer::div($courseformat->get_renderer($this->page)->render($obj), 'course-content-footer');
-        }
-        return '';
-    }
-
-    /**
-     * Returns course-specific information to be output on any course page in the header area
-     * (for the current course)
-     *
-     * @return string
-     */
-    public function course_header() {
-        global $CFG;
-        if ($this->page->course->id == SITEID) {
-            // return immediately and do not include /course/lib.php if not necessary
-            return '';
-        }
-        require_once($CFG->dirroot.'/course/lib.php');
-        $courseformat = course_get_format($this->page->course);
-        if (($obj = $courseformat->course_header()) !== null) {
-            return $courseformat->get_renderer($this->page)->render($obj);
-        }
-        return '';
-    }
-
-    /**
-     * Returns course-specific information to be output on any course page in the footer area
-     * (for the current course)
-     *
-     * @return string
-     */
-    public function course_footer() {
-        global $CFG;
-        if ($this->page->course->id == SITEID) {
-            // return immediately and do not include /course/lib.php if not necessary
-            return '';
-        }
-        require_once($CFG->dirroot.'/course/lib.php');
-        $courseformat = course_get_format($this->page->course);
-        if (($obj = $courseformat->course_footer()) !== null) {
-            return $courseformat->get_renderer($this->page)->render($obj);
-        }
-        return '';
-    }
-
-    /**
-     * Get the course pattern datauri to show on a course card.
-     *
-     * The datauri is an encoded svg that can be passed as a url.
-     * @param int $id Id to use when generating the pattern
-     * @return string datauri
-     */
-    public function get_generated_image_for_id($id) {
-        $color = $this->get_generated_color_for_id($id);
-        $pattern = new \core_geopattern();
-        $pattern->setColor($color);
-        $pattern->patternbyid($id);
-        return $pattern->datauri();
-    }
-
-    /**
-     * Get the course pattern image URL.
-     *
-     * @param context_course $context course context object
-     * @return string URL of the course pattern image in SVG format
-     */
-    public function get_generated_url_for_course(context_course $context): string {
-        return moodle_url::make_pluginfile_url($context->id, 'course', 'generated', null, '/', 'course.svg')->out();
-    }
-
-    /**
-     * Get the course pattern in SVG format to show on a course card.
-     *
-     * @param int $id id to use when generating the pattern
-     * @return string SVG file contents
-     */
-    public function get_generated_svg_for_id(int $id): string {
-        $color = $this->get_generated_color_for_id($id);
-        $pattern = new \core_geopattern();
-        $pattern->setColor($color);
-        $pattern->patternbyid($id);
-        return $pattern->toSVG();
-    }
-
-    /**
-     * Get the course color to show on a course card.
-     *
-     * @param int $id Id to use when generating the color.
-     * @return string hex color code.
-     */
-    public function get_generated_color_for_id($id) {
-        $colornumbers = range(1, 10);
-        $basecolors = [];
-        foreach ($colornumbers as $number) {
-            $basecolors[] = get_config('core_admin', 'coursecolor' . $number);
-        }
-
-        $color = $basecolors[$id % 10];
-        return $color;
-    }
-
-    /**
-     * Returns lang menu or '', this method also checks forcing of languages in courses.
-     *
-     * This function calls {@link core_renderer::render_single_select()} to actually display the language menu.
-     *
-     * @return string The lang menu HTML or empty string
-     */
-    public function lang_menu() {
-        $languagemenu = new \core\output\language_menu($this->page);
-        $data = $languagemenu->export_for_single_select($this);
-        if ($data) {
-            return $this->render_from_template('core/single_select', $data);
-        }
-        return '';
-    }
-
-    /**
-     * Output the row of editing icons for a block, as defined by the controls array.
-     *
-     * @param array $controls an array like {@link block_contents::$controls}.
-     * @param string $blockid The ID given to the block.
-     * @return string HTML fragment.
-     */
-    public function block_controls($actions, $blockid = null) {
-        if (empty($actions)) {
-            return '';
-        }
-        $menu = new action_menu($actions);
-        if ($blockid !== null) {
-            $menu->set_owner_selector('#'.$blockid);
-        }
-        $menu->attributes['class'] .= ' block-control-actions commands';
-        return $this->render($menu);
-    }
-
-    /**
-     * Returns the HTML for a basic textarea field.
-     *
-     * @param string $name Name to use for the textarea element
-     * @param string $id The id to use fort he textarea element
-     * @param string $value Initial content to display in the textarea
-     * @param int $rows Number of rows to display
-     * @param int $cols Number of columns to display
-     * @return string the HTML to display
-     */
-    public function print_textarea($name, $id, $value, $rows, $cols) {
-        editors_head_setup();
-        $editor = editors_get_preferred_editor(FORMAT_HTML);
-        $editor->set_text($value);
-        $editor->use_editor($id, []);
-
-        $context = [
-            'id' => $id,
-            'name' => $name,
-            'value' => $value,
-            'rows' => $rows,
-            'cols' => $cols
-        ];
-
-        return $this->render_from_template('core_form/editor_textarea', $context);
-    }
-
-    /**
-     * Renders an action menu component.
-     *
-     * @param action_menu $menu
-     * @return string HTML
-     */
-    public function render_action_menu(action_menu $menu) {
-
-        // We don't want the class icon there!
-        foreach ($menu->get_secondary_actions() as $action) {
-            if ($action instanceof \action_menu_link && $action->has_class('icon')) {
-                $action->attributes['class'] = preg_replace('/(^|\s+)icon(\s+|$)/i', '', $action->attributes['class']);
-            }
-        }
-
-        if ($menu->is_empty()) {
-            return '';
-        }
-        $context = $menu->export_for_template($this);
-
-        return $this->render_from_template('core/action_menu', $context);
-    }
-
-    /**
-     * Renders a full check API result including summary and details
-     *
-     * @param core\check\check $check the check that was run to get details from
-     * @param core\check\result $result the result of a check
-     * @param bool $includedetails if true, details are included as well
-     * @return string rendered html
-     */
-    protected function render_check_full_result(core\check\check $check, core\check\result $result, bool $includedetails): string {
-        // Initially render just badge itself.
-        $renderedresult = $this->render_from_template($result->get_template_name(), $result->export_for_template($this));
-
-        // Add summary.
-        $renderedresult .= ' ' . $result->get_summary();
-
-        // Wrap in notificaiton.
-        $notificationmap = [
-            \core\check\result::NA => \core\output\notification::NOTIFY_INFO,
-            \core\check\result::OK => \core\output\notification::NOTIFY_SUCCESS,
-            \core\check\result::INFO => \core\output\notification::NOTIFY_INFO,
-            \core\check\result::UNKNOWN => \core\output\notification::NOTIFY_WARNING,
-            \core\check\result::WARNING => \core\output\notification::NOTIFY_WARNING,
-            \core\check\result::ERROR => \core\output\notification::NOTIFY_ERROR,
-            \core\check\result::CRITICAL => \core\output\notification::NOTIFY_ERROR,
-        ];
-
-        // Get type, or default to error.
-        $notificationtype = $notificationmap[$result->get_status()] ?? \core\output\notification::NOTIFY_ERROR;
-        $renderedresult = $this->notification($renderedresult, $notificationtype, false);
-
-        // If adding details, add on new line.
-        if ($includedetails) {
-            $renderedresult .= $result->get_details();
-        }
-
-        // Add the action link.
-        $renderedresult .= $this->render_action_link($check->get_action_link());
-
-        return $renderedresult;
-    }
-
-    /**
-     * Renders a full check API result including summary and details
-     *
-     * @param core\check\check $check the check that was run to get details from
-     * @param core\check\result $result the result of a check
-     * @param bool $includedetails if details should be included
-     * @return string HTML fragment
-     */
-    public function check_full_result(core\check\check $check, core\check\result $result, bool $includedetails = false) {
-        return $this->render_check_full_result($check, $result, $includedetails);
-    }
-
-    /**
-     * Renders a Check API result
-     *
-     * @param core\check\result $result
-     * @return string HTML fragment
-     */
-    protected function render_check_result(core\check\result $result) {
-        return $this->render_from_template($result->get_template_name(), $result->export_for_template($this));
-    }
-
-    /**
-     * Renders a Check API result
-     *
-     * @param core\check\result $result
-     * @return string HTML fragment
-     */
-    public function check_result(core\check\result $result) {
-        return $this->render_check_result($result);
-    }
-
-    /**
-     * Renders an action_menu_link item.
-     *
-     * @param action_menu_link $action
-     * @return string HTML fragment
-     */
-    protected function render_action_menu_link(action_menu_link $action) {
-        return $this->render_from_template('core/action_menu_link', $action->export_for_template($this));
-    }
-
-    /**
-     * Renders a primary action_menu_filler item.
-     *
-     * @param action_menu_filler $action
-     * @return string HTML fragment
-     */
-    protected function render_action_menu_filler(action_menu_filler $action) {
-        return html_writer::span('&nbsp;', 'filler');
-    }
-
-    /**
-     * Renders a primary action_menu_link item.
-     *
-     * @param action_menu_link_primary $action
-     * @return string HTML fragment
-     */
-    protected function render_action_menu_link_primary(action_menu_link_primary $action) {
-        return $this->render_action_menu_link($action);
-    }
-
-    /**
-     * Renders a secondary action_menu_link item.
-     *
-     * @param action_menu_link_secondary $action
-     * @return string HTML fragment
-     */
-    protected function render_action_menu_link_secondary(action_menu_link_secondary $action) {
-        return $this->render_action_menu_link($action);
-    }
-
-    /**
-     * Prints a nice side block with an optional header.
-     *
-     * @param block_contents $bc HTML for the content
-     * @param string $region the region the block is appearing in.
-     * @return string the HTML to be output.
-     */
-    public function block(block_contents $bc, $region) {
-        $bc = clone($bc); // Avoid messing up the object passed in.
-        if (empty($bc->blockinstanceid) || !strip_tags($bc->title)) {
-            $bc->collapsible = block_contents::NOT_HIDEABLE;
-        }
-
-        $id = !empty($bc->attributes['id']) ? $bc->attributes['id'] : uniqid('block-');
-        $context = new stdClass();
-        $context->skipid = $bc->skipid;
-        $context->blockinstanceid = $bc->blockinstanceid ?: uniqid('fakeid-');
-        $context->dockable = $bc->dockable;
-        $context->id = $id;
-        $context->hidden = $bc->collapsible == block_contents::HIDDEN;
-        $context->skiptitle = strip_tags($bc->title);
-        $context->showskiplink = !empty($context->skiptitle);
-        $context->arialabel = $bc->arialabel;
-        $context->ariarole = !empty($bc->attributes['role']) ? $bc->attributes['role'] : 'complementary';
-        $context->class = $bc->attributes['class'];
-        $context->type = $bc->attributes['data-block'];
-        $context->title = $bc->title;
-        $context->content = $bc->content;
-        $context->annotation = $bc->annotation;
-        $context->footer = $bc->footer;
-        $context->hascontrols = !empty($bc->controls);
-        if ($context->hascontrols) {
-            $context->controls = $this->block_controls($bc->controls, $id);
-        }
-
-        return $this->render_from_template('core/block', $context);
-    }
-
-    /**
-     * Render the contents of a block_list.
-     *
-     * @param array $icons the icon for each item.
-     * @param array $items the content of each item.
-     * @return string HTML
-     */
-    public function list_block_contents($icons, $items) {
-        $row = 0;
-        $lis = array();
-        foreach ($items as $key => $string) {
-            $item = html_writer::start_tag('li', array('class' => 'r' . $row));
-            if (!empty($icons[$key])) { //test if the content has an assigned icon
-                $item .= html_writer::tag('div', $icons[$key], array('class' => 'icon column c0'));
-            }
-            $item .= html_writer::tag('div', $string, array('class' => 'column c1'));
-            $item .= html_writer::end_tag('li');
-            $lis[] = $item;
-            $row = 1 - $row; // Flip even/odd.
-        }
-        return html_writer::tag('ul', implode("\n", $lis), array('class' => 'unlist'));
-    }
-
-    /**
-     * Output all the blocks in a particular region.
-     *
-     * @param string $region the name of a region on this page.
-     * @param boolean $fakeblocksonly Output fake block only.
-     * @return string the HTML to be output.
-     */
-    public function blocks_for_region($region, $fakeblocksonly = false) {
-        $blockcontents = $this->page->blocks->get_content_for_region($region, $this);
-        $lastblock = null;
-        $zones = array();
-        foreach ($blockcontents as $bc) {
-            if ($bc instanceof block_contents) {
-                $zones[] = $bc->title;
-            }
-        }
-        $output = '';
-
-        foreach ($blockcontents as $bc) {
-            if ($bc instanceof block_contents) {
-                if ($fakeblocksonly && !$bc->is_fake()) {
-                    // Skip rendering real blocks if we only want to show fake blocks.
-                    continue;
-                }
-                $output .= $this->block($bc, $region);
-                $lastblock = $bc->title;
-            } else if ($bc instanceof block_move_target) {
-                if (!$fakeblocksonly) {
-                    $output .= $this->block_move_target($bc, $zones, $lastblock, $region);
-                }
-            } else {
-                throw new coding_exception('Unexpected type of thing (' . get_class($bc) . ') found in list of block contents.');
-            }
-        }
-        return $output;
-    }
-
-    /**
-     * Output a place where the block that is currently being moved can be dropped.
-     *
-     * @param block_move_target $target with the necessary details.
-     * @param array $zones array of areas where the block can be moved to
-     * @param string $previous the block located before the area currently being rendered.
-     * @param string $region the name of the region
-     * @return string the HTML to be output.
-     */
-    public function block_move_target($target, $zones, $previous, $region) {
-        if ($previous == null) {
-            if (empty($zones)) {
-                // There are no zones, probably because there are no blocks.
-                $regions = $this->page->theme->get_all_block_regions();
-                $position = get_string('moveblockinregion', 'block', $regions[$region]);
-            } else {
-                $position = get_string('moveblockbefore', 'block', $zones[0]);
-            }
-        } else {
-            $position = get_string('moveblockafter', 'block', $previous);
-        }
-        return html_writer::tag('a', html_writer::tag('span', $position, array('class' => 'accesshide')), array('href' => $target->url, 'class' => 'blockmovetarget'));
-    }
-
-    /**
-     * Renders a special html link with attached action
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_action_link()} instead.
-     *
-     * @param string|moodle_url $url
-     * @param string $text HTML fragment
-     * @param component_action $action
-     * @param array $attributes associative array of html link attributes + disabled
-     * @param pix_icon optional pix icon to render with the link
-     * @return string HTML fragment
-     */
-    public function action_link($url, $text, component_action $action = null, array $attributes = null, $icon = null) {
-        if (!($url instanceof moodle_url)) {
-            $url = new moodle_url($url);
-        }
-        $link = new action_link($url, $text, $action, $attributes, $icon);
-
-        return $this->render($link);
-    }
-
-    /**
-     * Renders an action_link object.
-     *
-     * The provided link is renderer and the HTML returned. At the same time the
-     * associated actions are setup in JS by {@link core_renderer::add_action_handler()}
-     *
-     * @param action_link $link
-     * @return string HTML fragment
-     */
-    protected function render_action_link(action_link $link) {
-        return $this->render_from_template('core/action_link', $link->export_for_template($this));
-    }
-
-    /**
-     * Renders an action_icon.
-     *
-     * This function uses the {@link core_renderer::action_link()} method for the
-     * most part. What it does different is prepare the icon as HTML and use it
-     * as the link text.
-     *
-     * Theme developers: If you want to change how action links and/or icons are rendered,
-     * consider overriding function {@link core_renderer::render_action_link()} and
-     * {@link core_renderer::render_pix_icon()}.
-     *
-     * @param string|moodle_url $url A string URL or moodel_url
-     * @param pix_icon $pixicon
-     * @param component_action $action
-     * @param array $attributes associative array of html link attributes + disabled
-     * @param bool $linktext show title next to image in link
-     * @return string HTML fragment
-     */
-    public function action_icon($url, pix_icon $pixicon, component_action $action = null, array $attributes = null, $linktext=false) {
-        if (!($url instanceof moodle_url)) {
-            $url = new moodle_url($url);
-        }
-        $attributes = (array)$attributes;
-
-        if (empty($attributes['class'])) {
-            // let ppl override the class via $options
-            $attributes['class'] = 'action-icon';
-        }
-
-        if ($linktext) {
-            $text = $pixicon->attributes['alt'];
-            // Set the icon as a decorative image if we're displaying the action text.
-            // Otherwise, the action name will be read twice by assistive technologies.
-            $pixicon->attributes['alt'] = '';
-            $pixicon->attributes['title'] = '';
-            $pixicon->attributes['aria-hidden'] = 'true';
-        } else {
-            $text = '';
-        }
-
-        $icon = $this->render($pixicon);
-
-        return $this->action_link($url, $text.$icon, $action, $attributes);
-    }
-
-   /**
-    * Print a message along with button choices for Continue/Cancel
-    *
-    * If a string or moodle_url is given instead of a single_button, method defaults to post.
-    *
-    * @param string $message The question to ask the user
-    * @param single_button|moodle_url|string $continue The single_button component representing the Continue answer. Can also be a moodle_url or string URL
-    * @param single_button|moodle_url|string $cancel The single_button component representing the Cancel answer. Can also be a moodle_url or string URL
-    * @param array $displayoptions optional extra display options
-    * @return string HTML fragment
-    */
-    public function confirm($message, $continue, $cancel, array $displayoptions = []) {
-
-        // Check existing displayoptions.
-        $displayoptions['confirmtitle'] = $displayoptions['confirmtitle'] ?? get_string('confirm');
-        $displayoptions['continuestr'] = $displayoptions['continuestr'] ?? get_string('continue');
-        $displayoptions['cancelstr'] = $displayoptions['cancelstr'] ?? get_string('cancel');
-
-        if ($continue instanceof single_button) {
-            // Continue button should be primary if set to secondary type as it is the fefault.
-            if ($continue->type === single_button::BUTTON_SECONDARY) {
-                $continue->type = single_button::BUTTON_PRIMARY;
-            }
-        } else if (is_string($continue)) {
-            $continue = new single_button(new moodle_url($continue), $displayoptions['continuestr'], 'post',
-                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
-        } else if ($continue instanceof moodle_url) {
-            $continue = new single_button($continue, $displayoptions['continuestr'], 'post',
-                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
-        } else {
-            throw new coding_exception('The continue param to $OUTPUT->confirm() must be either a URL (string/moodle_url) or a single_button instance.');
-        }
-
-        if ($cancel instanceof single_button) {
-            // ok
-        } else if (is_string($cancel)) {
-            $cancel = new single_button(new moodle_url($cancel), $displayoptions['cancelstr'], 'get');
-        } else if ($cancel instanceof moodle_url) {
-            $cancel = new single_button($cancel, $displayoptions['cancelstr'], 'get');
-        } else {
-            throw new coding_exception('The cancel param to $OUTPUT->confirm() must be either a URL (string/moodle_url) or a single_button instance.');
-        }
-
-        $attributes = [
-            'role'=>'alertdialog',
-            'aria-labelledby'=>'modal-header',
-            'aria-describedby'=>'modal-body',
-            'aria-modal'=>'true'
-        ];
-
-        $output = $this->box_start('generalbox modal modal-dialog modal-in-page show', 'notice', $attributes);
-        $output .= $this->box_start('modal-content', 'modal-content');
-        $output .= $this->box_start('modal-header px-3', 'modal-header');
-        $output .= html_writer::tag('h4', $displayoptions['confirmtitle']);
-        $output .= $this->box_end();
-        $attributes = [
-            'role'=>'alert',
-            'data-aria-autofocus'=>'true'
-        ];
-        $output .= $this->box_start('modal-body', 'modal-body', $attributes);
-        $output .= html_writer::tag('p', $message);
-        $output .= $this->box_end();
-        $output .= $this->box_start('modal-footer', 'modal-footer');
-        $output .= html_writer::tag('div', $this->render($cancel) . $this->render($continue), ['class' => 'buttons']);
-        $output .= $this->box_end();
-        $output .= $this->box_end();
-        $output .= $this->box_end();
-        return $output;
-    }
-
-    /**
-     * Returns a form with a single button.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_single_button()} instead.
-     *
-     * @param string|moodle_url $url
-     * @param string $label button text
-     * @param string $method get or post submit method
-     * @param array $options associative array {disabled, title, etc.}
-     * @return string HTML fragment
-     */
-    public function single_button($url, $label, $method='post', array $options=null) {
-        if (!($url instanceof moodle_url)) {
-            $url = new moodle_url($url);
-        }
-        $button = new single_button($url, $label, $method);
-
-        foreach ((array)$options as $key=>$value) {
-            if (property_exists($button, $key)) {
-                $button->$key = $value;
-            } else {
-                $button->set_attribute($key, $value);
-            }
-        }
-
-        return $this->render($button);
-    }
-
-    /**
-     * Renders a single button widget.
-     *
-     * This will return HTML to display a form containing a single button.
-     *
-     * @param single_button $button
-     * @return string HTML fragment
-     */
-    protected function render_single_button(single_button $button) {
-        return $this->render_from_template('core/single_button', $button->export_for_template($this));
-    }
-
-    /**
-     * Returns a form with a single select widget.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_single_select()} instead.
-     *
-     * @param moodle_url $url form action target, includes hidden fields
-     * @param string $name name of selection field - the changing parameter in url
-     * @param array $options list of options
-     * @param string $selected selected element
-     * @param array $nothing
-     * @param string $formid
-     * @param array $attributes other attributes for the single select
-     * @return string HTML fragment
-     */
-    public function single_select($url, $name, array $options, $selected = '',
-                                $nothing = array('' => 'choosedots'), $formid = null, $attributes = array()) {
-        if (!($url instanceof moodle_url)) {
-            $url = new moodle_url($url);
-        }
-        $select = new single_select($url, $name, $options, $selected, $nothing, $formid);
-
-        if (array_key_exists('label', $attributes)) {
-            $select->set_label($attributes['label']);
-            unset($attributes['label']);
-        }
-        $select->attributes = $attributes;
-
-        return $this->render($select);
-    }
-
-    /**
-     * Returns a dataformat selection and download form
-     *
-     * @param string $label A text label
-     * @param moodle_url|string $base The download page url
-     * @param string $name The query param which will hold the type of the download
-     * @param array $params Extra params sent to the download page
-     * @return string HTML fragment
-     */
-    public function download_dataformat_selector($label, $base, $name = 'dataformat', $params = array()) {
-
-        $formats = core_plugin_manager::instance()->get_plugins_of_type('dataformat');
-        $options = array();
-        foreach ($formats as $format) {
-            if ($format->is_enabled()) {
-                $options[] = array(
-                    'value' => $format->name,
-                    'label' => get_string('dataformat', $format->component),
-                );
-            }
-        }
-        $hiddenparams = array();
-        foreach ($params as $key => $value) {
-            $hiddenparams[] = array(
-                'name' => $key,
-                'value' => $value,
-            );
-        }
-        $data = array(
-            'label' => $label,
-            'base' => $base,
-            'name' => $name,
-            'params' => $hiddenparams,
-            'options' => $options,
-            'sesskey' => sesskey(),
-            'submit' => get_string('download'),
-        );
-
-        return $this->render_from_template('core/dataformat_selector', $data);
-    }
-
-
-    /**
-     * Internal implementation of single_select rendering
-     *
-     * @param single_select $select
-     * @return string HTML fragment
-     */
-    protected function render_single_select(single_select $select) {
-        return $this->render_from_template('core/single_select', $select->export_for_template($this));
-    }
-
-    /**
-     * Returns a form with a url select widget.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_url_select()} instead.
-     *
-     * @param array $urls list of urls - array('/course/view.php?id=1'=>'Frontpage', ....)
-     * @param string $selected selected element
-     * @param array $nothing
-     * @param string $formid
-     * @return string HTML fragment
-     */
-    public function url_select(array $urls, $selected, $nothing = array('' => 'choosedots'), $formid = null) {
-        $select = new url_select($urls, $selected, $nothing, $formid);
-        return $this->render($select);
-    }
-
-    /**
-     * Internal implementation of url_select rendering
-     *
-     * @param url_select $select
-     * @return string HTML fragment
-     */
-    protected function render_url_select(url_select $select) {
-        return $this->render_from_template('core/url_select', $select->export_for_template($this));
-    }
-
-    /**
-     * Returns a string containing a link to the user documentation.
-     * Also contains an icon by default. Shown to teachers and admin only.
-     *
-     * @param string $path The page link after doc root and language, no leading slash.
-     * @param string $text The text to be displayed for the link
-     * @param boolean $forcepopup Whether to force a popup regardless of the value of $CFG->doctonewwindow
-     * @param array $attributes htm attributes
-     * @return string
-     */
-    public function doc_link($path, $text = '', $forcepopup = false, array $attributes = []) {
-        global $CFG;
-
-        $icon = $this->pix_icon('book', '', 'moodle', array('class' => 'iconhelp icon-pre'));
-
-        $attributes['href'] = new moodle_url(get_docs_url($path));
-        $newwindowicon = '';
-        if (!empty($CFG->doctonewwindow) || $forcepopup) {
-            $attributes['target'] = '_blank';
-            $newwindowicon = $this->pix_icon('i/externallink', get_string('opensinnewwindow'), 'moodle',
-            ['class' => 'fa fa-externallink fa-fw']);
-        }
-
-        return html_writer::tag('a', $icon . $text . $newwindowicon, $attributes);
-    }
-
-    /**
-     * Return HTML for an image_icon.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_image_icon()} instead.
-     *
-     * @param string $pix short pix name
-     * @param string $alt mandatory alt attribute
-     * @param string $component standard compoennt name like 'moodle', 'mod_forum', etc.
-     * @param array $attributes htm attributes
-     * @return string HTML fragment
-     */
-    public function image_icon($pix, $alt, $component='moodle', array $attributes = null) {
-        $icon = new image_icon($pix, $alt, $component, $attributes);
-        return $this->render($icon);
-    }
-
-    /**
-     * Renders a pix_icon widget and returns the HTML to display it.
-     *
-     * @param image_icon $icon
-     * @return string HTML fragment
-     */
-    protected function render_image_icon(image_icon $icon) {
-        $system = \core\output\icon_system::instance(\core\output\icon_system::STANDARD);
-        return $system->render_pix_icon($this, $icon);
-    }
-
-    /**
-     * Return HTML for a pix_icon.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_pix_icon()} instead.
-     *
-     * @param string $pix short pix name
-     * @param string $alt mandatory alt attribute
-     * @param string $component standard compoennt name like 'moodle', 'mod_forum', etc.
-     * @param array $attributes htm lattributes
-     * @return string HTML fragment
-     */
-    public function pix_icon($pix, $alt, $component='moodle', array $attributes = null) {
-        $icon = new pix_icon($pix, $alt, $component, $attributes);
-        return $this->render($icon);
-    }
-
-    /**
-     * Renders a pix_icon widget and returns the HTML to display it.
-     *
-     * @param pix_icon $icon
-     * @return string HTML fragment
-     */
-    protected function render_pix_icon(pix_icon $icon) {
-        $system = \core\output\icon_system::instance();
-        return $system->render_pix_icon($this, $icon);
-    }
-
-    /**
-     * Return HTML to display an emoticon icon.
-     *
-     * @param pix_emoticon $emoticon
-     * @return string HTML fragment
-     */
-    protected function render_pix_emoticon(pix_emoticon $emoticon) {
-        $system = \core\output\icon_system::instance(\core\output\icon_system::STANDARD);
-        return $system->render_pix_icon($this, $emoticon);
-    }
-
-    /**
-     * Produces the html that represents this rating in the UI
-     *
-     * @param rating $rating the page object on which this rating will appear
-     * @return string
-     */
-    function render_rating(rating $rating) {
-        global $CFG, $USER;
-
-        if ($rating->settings->aggregationmethod == RATING_AGGREGATE_NONE) {
-            return null;//ratings are turned off
-        }
-
-        $ratingmanager = new rating_manager();
-        // Initialise the JavaScript so ratings can be done by AJAX.
-        $ratingmanager->initialise_rating_javascript($this->page);
-
-        $strrate = get_string("rate", "rating");
-        $ratinghtml = ''; //the string we'll return
-
-        // permissions check - can they view the aggregate?
-        if ($rating->user_can_view_aggregate()) {
-
-            $aggregatelabel = $ratingmanager->get_aggregate_label($rating->settings->aggregationmethod);
-            $aggregatelabel = html_writer::tag('span', $aggregatelabel, array('class'=>'rating-aggregate-label'));
-            $aggregatestr   = $rating->get_aggregate_string();
-
-            $aggregatehtml  = html_writer::tag('span', $aggregatestr, array('id' => 'ratingaggregate'.$rating->itemid, 'class' => 'ratingaggregate')).' ';
-            if ($rating->count > 0) {
-                $countstr = "({$rating->count})";
-            } else {
-                $countstr = '-';
-            }
-            $aggregatehtml .= html_writer::tag('span', $countstr, array('id'=>"ratingcount{$rating->itemid}", 'class' => 'ratingcount')).' ';
-
-            if ($rating->settings->permissions->viewall && $rating->settings->pluginpermissions->viewall) {
-
-                $nonpopuplink = $rating->get_view_ratings_url();
-                $popuplink = $rating->get_view_ratings_url(true);
-
-                $action = new popup_action('click', $popuplink, 'ratings', array('height' => 400, 'width' => 600));
-                $aggregatehtml = $this->action_link($nonpopuplink, $aggregatehtml, $action);
-            }
-
-            $ratinghtml .= html_writer::tag('span', $aggregatelabel . $aggregatehtml, array('class' => 'rating-aggregate-container'));
-        }
-
-        $formstart = null;
-        // if the item doesn't belong to the current user, the user has permission to rate
-        // and we're within the assessable period
-        if ($rating->user_can_rate()) {
-
-            $rateurl = $rating->get_rate_url();
-            $inputs = $rateurl->params();
-
-            //start the rating form
-            $formattrs = array(
-                'id'     => "postrating{$rating->itemid}",
-                'class'  => 'postratingform',
-                'method' => 'post',
-                'action' => $rateurl->out_omit_querystring()
-            );
-            $formstart  = html_writer::start_tag('form', $formattrs);
-            $formstart .= html_writer::start_tag('div', array('class' => 'ratingform'));
-
-            // add the hidden inputs
-            foreach ($inputs as $name => $value) {
-                $attributes = array('type' => 'hidden', 'class' => 'ratinginput', 'name' => $name, 'value' => $value);
-                $formstart .= html_writer::empty_tag('input', $attributes);
-            }
-
-            if (empty($ratinghtml)) {
-                $ratinghtml .= $strrate.': ';
-            }
-            $ratinghtml = $formstart.$ratinghtml;
-
-            $scalearray = array(RATING_UNSET_RATING => $strrate.'...') + $rating->settings->scale->scaleitems;
-            $scaleattrs = array('class'=>'postratingmenu ratinginput','id'=>'menurating'.$rating->itemid);
-            $ratinghtml .= html_writer::label($rating->rating, 'menurating'.$rating->itemid, false, array('class' => 'accesshide'));
-            $ratinghtml .= html_writer::select($scalearray, 'rating', $rating->rating, false, $scaleattrs);
-
-            //output submit button
-            $ratinghtml .= html_writer::start_tag('span', array('class'=>"ratingsubmit"));
-
-            $attributes = array('type' => 'submit', 'class' => 'postratingmenusubmit', 'id' => 'postratingsubmit'.$rating->itemid, 'value' => s(get_string('rate', 'rating')));
-            $ratinghtml .= html_writer::empty_tag('input', $attributes);
-
-            if (!$rating->settings->scale->isnumeric) {
-                // If a global scale, try to find current course ID from the context
-                if (empty($rating->settings->scale->courseid) and $coursecontext = $rating->context->get_course_context(false)) {
-                    $courseid = $coursecontext->instanceid;
-                } else {
-                    $courseid = $rating->settings->scale->courseid;
-                }
-                $ratinghtml .= $this->help_icon_scale($courseid, $rating->settings->scale);
-            }
-            $ratinghtml .= html_writer::end_tag('span');
-            $ratinghtml .= html_writer::end_tag('div');
-            $ratinghtml .= html_writer::end_tag('form');
-        }
-
-        return $ratinghtml;
-    }
-
-    /**
-     * Centered heading with attached help button (same title text)
-     * and optional icon attached.
-     *
-     * @param string $text A heading text
-     * @param string $helpidentifier The keyword that defines a help page
-     * @param string $component component name
-     * @param string|moodle_url $icon
-     * @param string $iconalt icon alt text
-     * @param int $level The level of importance of the heading. Defaulting to 2
-     * @param string $classnames A space-separated list of CSS classes. Defaulting to null
-     * @return string HTML fragment
-     */
-    public function heading_with_help($text, $helpidentifier, $component = 'moodle', $icon = '', $iconalt = '', $level = 2, $classnames = null) {
-        $image = '';
-        if ($icon) {
-            $image = $this->pix_icon($icon, $iconalt, $component, array('class'=>'icon iconlarge'));
-        }
-
-        $help = '';
-        if ($helpidentifier) {
-            $help = $this->help_icon($helpidentifier, $component);
-        }
-
-        return $this->heading($image.$text.$help, $level, $classnames);
-    }
-
-    /**
-     * Returns HTML to display a help icon.
-     *
-     * @deprecated since Moodle 2.0
-     */
-    public function old_help_icon($helpidentifier, $title, $component = 'moodle', $linktext = '') {
-        throw new coding_exception('old_help_icon() can not be used any more, please see help_icon().');
-    }
-
-    /**
-     * Returns HTML to display a help icon.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_help_icon()} instead.
-     *
-     * @param string $identifier The keyword that defines a help page
-     * @param string $component component name
-     * @param string|bool $linktext true means use $title as link text, string means link text value
-     * @param string|object|array|int $a An object, string or number that can be used
-     *      within translation strings
-     * @return string HTML fragment
-     */
-    public function help_icon($identifier, $component = 'moodle', $linktext = '', $a = null) {
-        $icon = new help_icon($identifier, $component, $a);
-        $icon->diag_strings();
-        if ($linktext === true) {
-            $icon->linktext = get_string($icon->identifier, $icon->component, $a);
-        } else if (!empty($linktext)) {
-            $icon->linktext = $linktext;
-        }
-        return $this->render($icon);
-    }
-
-    /**
-     * Implementation of user image rendering.
-     *
-     * @param help_icon $helpicon A help icon instance
-     * @return string HTML fragment
-     */
-    protected function render_help_icon(help_icon $helpicon) {
-        $context = $helpicon->export_for_template($this);
-        return $this->render_from_template('core/help_icon', $context);
-    }
-
-    /**
-     * Returns HTML to display a scale help icon.
-     *
-     * @param int $courseid
-     * @param stdClass $scale instance
-     * @return string HTML fragment
-     */
-    public function help_icon_scale($courseid, stdClass $scale) {
-        global $CFG;
-
-        $title = get_string('helpprefix2', '', $scale->name) .' ('.get_string('newwindow').')';
-
-        $icon = $this->pix_icon('help', get_string('scales'), 'moodle', array('class'=>'iconhelp'));
-
-        $scaleid = abs($scale->id);
-
-        $link = new moodle_url('/course/scales.php', array('id' => $courseid, 'list' => true, 'scaleid' => $scaleid));
-        $action = new popup_action('click', $link, 'ratingscale');
-
-        return html_writer::tag('span', $this->action_link($link, $icon, $action), array('class' => 'helplink'));
-    }
-
-    /**
-     * Creates and returns a spacer image with optional line break.
-     *
-     * @param array $attributes Any HTML attributes to add to the spaced.
-     * @param bool $br Include a BR after the spacer.... DON'T USE THIS. Don't be
-     *     laxy do it with CSS which is a much better solution.
-     * @return string HTML fragment
-     */
-    public function spacer(array $attributes = null, $br = false) {
-        $attributes = (array)$attributes;
-        if (empty($attributes['width'])) {
-            $attributes['width'] = 1;
-        }
-        if (empty($attributes['height'])) {
-            $attributes['height'] = 1;
-        }
-        $attributes['class'] = 'spacer';
-
-        $output = $this->pix_icon('spacer', '', 'moodle', $attributes);
-
-        if (!empty($br)) {
-            $output .= '<br />';
-        }
-
-        return $output;
-    }
-
-    /**
-     * Returns HTML to display the specified user's avatar.
-     *
-     * User avatar may be obtained in two ways:
-     * <pre>
-     * // Option 1: (shortcut for simple cases, preferred way)
-     * // $user has come from the DB and has fields id, picture, imagealt, firstname and lastname
-     * $OUTPUT->user_picture($user, array('popup'=>true));
-     *
-     * // Option 2:
-     * $userpic = new user_picture($user);
-     * // Set properties of $userpic
-     * $userpic->popup = true;
-     * $OUTPUT->render($userpic);
-     * </pre>
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_user_picture()} instead.
-     *
-     * @param stdClass $user Object with at least fields id, picture, imagealt, firstname, lastname
-     *     If any of these are missing, the database is queried. Avoid this
-     *     if at all possible, particularly for reports. It is very bad for performance.
-     * @param array $options associative array with user picture options, used only if not a user_picture object,
-     *     options are:
-     *     - courseid=$this->page->course->id (course id of user profile in link)
-     *     - size=35 (size of image)
-     *     - link=true (make image clickable - the link leads to user profile)
-     *     - popup=false (open in popup)
-     *     - alttext=true (add image alt attribute)
-     *     - class = image class attribute (default 'userpicture')
-     *     - visibletoscreenreaders=true (whether to be visible to screen readers)
-     *     - includefullname=false (whether to include the user's full name together with the user picture)
-     *     - includetoken = false (whether to use a token for authentication. True for current user, int value for other user id)
-     * @return string HTML fragment
-     */
-    public function user_picture(stdClass $user, array $options = null) {
-        $userpicture = new user_picture($user);
-        foreach ((array)$options as $key=>$value) {
-            if (property_exists($userpicture, $key)) {
-                $userpicture->$key = $value;
-            }
-        }
-        return $this->render($userpicture);
-    }
-
-    /**
-     * Internal implementation of user image rendering.
-     *
-     * @param user_picture $userpicture
-     * @return string
-     */
-    protected function render_user_picture(user_picture $userpicture) {
-        global $CFG;
-
-        $user = $userpicture->user;
-        $canviewfullnames = has_capability('moodle/site:viewfullnames', $this->page->context);
-
-        $alt = '';
-        if ($userpicture->alttext) {
-            if (!empty($user->imagealt)) {
-                $alt = trim($user->imagealt);
-            }
-        }
-
-        // If the user picture is being rendered as a link but without the full name, an empty alt text for the user picture
-        // would mean that the link displayed will not have any discernible text. This becomes an accessibility issue,
-        // especially to screen reader users. Use the user's full name by default for the user picture's alt-text if this is
-        // the case.
-        if ($userpicture->link && !$userpicture->includefullname && empty($alt)) {
-            $alt = fullname($user);
-        }
-
-        if (empty($userpicture->size)) {
-            $size = 35;
-        } else if ($userpicture->size === true or $userpicture->size == 1) {
-            $size = 100;
-        } else {
-            $size = $userpicture->size;
-        }
-
-        $class = $userpicture->class;
-
-        if ($user->picture == 0) {
-            $class .= ' defaultuserpic';
-        }
-
-        $src = $userpicture->get_url($this->page, $this);
-
-        $attributes = array('src' => $src, 'class' => $class, 'width' => $size, 'height' => $size);
-        if (!$userpicture->visibletoscreenreaders) {
-            $alt = '';
-        }
-        $attributes['alt'] = $alt;
-
-        if (!empty($alt)) {
-            $attributes['title'] = $alt;
-        }
-
-        // Get the image html output first, auto generated based on initials if one isn't already set.
-        if ($user->picture == 0 && empty($CFG->enablegravatar) && !defined('BEHAT_SITE_RUNNING')) {
-            $initials = \core_user::get_initials($user);
-            $fullname = fullname($userpicture->user, $canviewfullnames);
-            // Don't modify in corner cases where neither the firstname nor the lastname appears.
-            $output = html_writer::tag(
-                'span', $initials,
-                [
-                    'class' => 'userinitials size-' . $size,
-                    'title' => $fullname,
-                    'aria-label' => $fullname,
-                    'role' => 'img',
-                ]
-            );
-        } else {
-            $output = html_writer::empty_tag('img', $attributes);
-        }
-
-        // Show fullname together with the picture when desired.
-        if ($userpicture->includefullname) {
-            $output .= fullname($userpicture->user, $canviewfullnames);
-        }
-
-        if (empty($userpicture->courseid)) {
-            $courseid = $this->page->course->id;
-        } else {
-            $courseid = $userpicture->courseid;
-        }
-        if ($courseid == SITEID) {
-            $url = new moodle_url('/user/profile.php', array('id' => $user->id));
-        } else {
-            $url = new moodle_url('/user/view.php', array('id' => $user->id, 'course' => $courseid));
-        }
-
-        // Then wrap it in link if needed. Also we don't wrap it in link if the link redirects to itself.
-        if (!$userpicture->link ||
-                ($this->page->has_set_url() && $this->page->url == $url)) { // Protect against unset page->url.
-            return $output;
-        }
-
-        $attributes = array('href' => $url, 'class' => 'd-inline-block aabtn');
-        if (!$userpicture->visibletoscreenreaders) {
-            $attributes['tabindex'] = '-1';
-            $attributes['aria-hidden'] = 'true';
-        }
-
-        if ($userpicture->popup) {
-            $id = html_writer::random_id('userpicture');
-            $attributes['id'] = $id;
-            $this->add_action_handler(new popup_action('click', $url), $id);
-        }
-
-        return html_writer::tag('a', $output, $attributes);
-    }
-
-    /**
-     * @deprecated since Moodle 4.3
-     */
-    public function htmllize_file_tree() {
-        throw new coding_exception('This function is deprecated and no longer relevant.');
-    }
-
-    /**
-     * Returns HTML to display the file picker
-     *
-     * <pre>
-     * $OUTPUT->file_picker($options);
-     * </pre>
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_file_picker()} instead.
-     *
-     * @param stdClass $options file manager options
-     *   options are:
-     *       maxbytes=>-1,
-     *       itemid=>0,
-     *       client_id=>uniqid(),
-     *       acepted_types=>'*',
-     *       return_types=>FILE_INTERNAL,
-     *       context=>current page context
-     * @return string HTML fragment
-     */
-    public function file_picker($options) {
-        $fp = new file_picker($options);
-        return $this->render($fp);
-    }
-
-    /**
-     * Internal implementation of file picker rendering.
-     *
-     * @param file_picker $fp
-     * @return string
-     */
-    public function render_file_picker(file_picker $fp) {
-        $options = $fp->options;
-        $client_id = $options->client_id;
-        $strsaved = get_string('filesaved', 'repository');
-        $straddfile = get_string('openpicker', 'repository');
-        $strloading  = get_string('loading', 'repository');
-        $strdndenabled = get_string('dndenabled_inbox', 'moodle');
-        $strdroptoupload = get_string('droptoupload', 'moodle');
-        $iconprogress = $this->pix_icon('i/loading_small', $strloading).'';
-
-        $currentfile = $options->currentfile;
-        if (empty($currentfile)) {
-            $currentfile = '';
-        } else {
-            $currentfile .= ' - ';
-        }
-        if ($options->maxbytes) {
-            $size = $options->maxbytes;
-        } else {
-            $size = get_max_upload_file_size();
-        }
-        if ($size == -1) {
-            $maxsize = '';
-        } else {
-            $maxsize = get_string('maxfilesize', 'moodle', display_size($size, 0));
-        }
-        if ($options->buttonname) {
-            $buttonname = ' name="' . $options->buttonname . '"';
-        } else {
-            $buttonname = '';
-        }
-        $html = <<<EOD
-<div class="filemanager-loading mdl-align" id='filepicker-loading-{$client_id}'>
-$iconprogress
-</div>
-<div id="filepicker-wrapper-{$client_id}" class="mdl-left w-100" style="display:none">
-    <div>
-        <input type="button" class="btn btn-secondary fp-btn-choose" id="filepicker-button-{$client_id}" value="{$straddfile}"{$buttonname}/>
-        <span> $maxsize </span>
-    </div>
-EOD;
-        if ($options->env != 'url') {
-            $html .= <<<EOD
-    <div id="file_info_{$client_id}" class="mdl-left filepicker-filelist" style="position: relative">
-    <div class="filepicker-filename">
-        <div class="filepicker-container">$currentfile
-            <div class="dndupload-message">$strdndenabled <br/>
-                <div class="dndupload-arrow d-flex"><i class="fa fa-arrow-circle-o-down fa-3x m-auto"></i></div>
-            </div>
-        </div>
-        <div class="dndupload-progressbars"></div>
-    </div>
-    <div>
-        <div class="dndupload-target">{$strdroptoupload}<br/>
-            <div class="dndupload-arrow d-flex"><i class="fa fa-arrow-circle-o-down fa-3x m-auto"></i></div>
-        </div>
-    </div>
-    </div>
-EOD;
-        }
-        $html .= '</div>';
-        return $html;
-    }
-
-    /**
-     * @deprecated since Moodle 3.2
-     */
-    public function update_module_button() {
-        throw new coding_exception('core_renderer::update_module_button() can not be used anymore. Activity ' .
-            'modules should not add the edit module button, the link is already available in the Administration block. ' .
-            'Themes can choose to display the link in the buttons row consistently for all module types.');
-    }
-
-    /**
-     * Returns HTML to display a "Turn editing on/off" button in a form.
-     *
-     * @param moodle_url $url The URL + params to send through when clicking the button
-     * @param string $method
-     * @return ?string HTML the button
-     */
-    public function edit_button(moodle_url $url, string $method = 'post') {
-
-        if ($this->page->theme->haseditswitch == true) {
-            return;
-        }
-        $url->param('sesskey', sesskey());
-        if ($this->page->user_is_editing()) {
-            $url->param('edit', 'off');
-            $editstring = get_string('turneditingoff');
-        } else {
-            $url->param('edit', 'on');
-            $editstring = get_string('turneditingon');
-        }
-
-        return $this->single_button($url, $editstring, $method);
-    }
-
-    /**
-     * Create a navbar switch for toggling editing mode.
-     *
-     * @return ?string Html containing the edit switch
-     */
-    public function edit_switch() {
-        if ($this->page->user_allowed_editing()) {
-
-            $temp = (object) [
-                'legacyseturl' => (new moodle_url('/editmode.php'))->out(false),
-                'pagecontextid' => $this->page->context->id,
-                'pageurl' => $this->page->url,
-                'sesskey' => sesskey(),
-            ];
-            if ($this->page->user_is_editing()) {
-                $temp->checked = true;
-            }
-            return $this->render_from_template('core/editswitch', $temp);
-        }
-    }
-
-    /**
-     * Returns HTML to display a simple button to close a window
-     *
-     * @param string $text The lang string for the button's label (already output from get_string())
-     * @return string html fragment
-     */
-    public function close_window_button($text='') {
-        if (empty($text)) {
-            $text = get_string('closewindow');
-        }
-        $button = new single_button(new moodle_url('#'), $text, 'get');
-        $button->add_action(new component_action('click', 'close_window'));
-
-        return $this->container($this->render($button), 'closewindow');
-    }
-
-    /**
-     * Output an error message. By default wraps the error message in <span class="error">.
-     * If the error message is blank, nothing is output.
-     *
-     * @param string $message the error message.
-     * @return string the HTML to output.
-     */
-    public function error_text($message) {
-        if (empty($message)) {
-            return '';
-        }
-        $message = $this->pix_icon('i/warning', get_string('error'), '', array('class' => 'icon icon-pre', 'title'=>'')) . $message;
-        return html_writer::tag('span', $message, array('class' => 'error'));
-    }
-
-    /**
-     * Do not call this function directly.
-     *
-     * To terminate the current script with a fatal error, throw an exception.
-     * Doing this will then call this function to display the error, before terminating the execution.
-     *
-     * @param string $message The message to output
-     * @param string $moreinfourl URL where more info can be found about the error
-     * @param string $link Link for the Continue button
-     * @param array $backtrace The execution backtrace
-     * @param string $debuginfo Debugging information
-     * @return string the HTML to output.
-     */
-    public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null, $errorcode = "") {
-        global $CFG;
-
-        $output = '';
-        $obbuffer = '';
-
-        if ($this->has_started()) {
-            // we can not always recover properly here, we have problems with output buffering,
-            // html tables, etc.
-            $output .= $this->opencontainers->pop_all_but_last();
-
-        } else {
-            // It is really bad if library code throws exception when output buffering is on,
-            // because the buffered text would be printed before our start of page.
-            // NOTE: this hack might be behave unexpectedly in case output buffering is enabled in PHP.ini
-            error_reporting(0); // disable notices from gzip compression, etc.
-            while (ob_get_level() > 0) {
-                $buff = ob_get_clean();
-                if ($buff === false) {
-                    break;
-                }
-                $obbuffer .= $buff;
-            }
-            error_reporting($CFG->debug);
-
-            // Output not yet started.
-            $protocol = (isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0');
-            if (empty($_SERVER['HTTP_RANGE'])) {
-                @header($protocol . ' 404 Not Found');
-            } else if (core_useragent::check_safari_ios_version(602) && !empty($_SERVER['HTTP_X_PLAYBACK_SESSION_ID'])) {
-                // Coax iOS 10 into sending the session cookie.
-                @header($protocol . ' 403 Forbidden');
-            } else {
-                // Must stop byteserving attempts somehow,
-                // this is weird but Chrome PDF viewer can be stopped only with 407!
-                @header($protocol . ' 407 Proxy Authentication Required');
-            }
-
-            $this->page->set_context(null); // ugly hack - make sure page context is set to something, we do not want bogus warnings here
-            $this->page->set_url('/'); // no url
-            //$this->page->set_pagelayout('base'); //TODO: MDL-20676 blocks on error pages are weird, unfortunately it somehow detect the pagelayout from URL :-(
-            $this->page->set_title(get_string('error'));
-            $this->page->set_heading($this->page->course->fullname);
-            // No need to display the activity header when encountering an error.
-            $this->page->activityheader->disable();
-            $output .= $this->header();
-        }
-
-        $message = '<p class="errormessage">' . s($message) . '</p>'.
-                '<p class="errorcode"><a href="' . s($moreinfourl) . '">' .
-                get_string('moreinformation') . '</a></p>';
-        if (empty($CFG->rolesactive)) {
-            $message .= '<p class="errormessage">' . get_string('installproblem', 'error') . '</p>';
-            //It is usually not possible to recover from errors triggered during installation, you may need to create a new database or use a different database prefix for new installation.
-        }
-        $output .= $this->box($message, 'errorbox alert alert-danger', null, array('data-rel' => 'fatalerror'));
-
-        if ($CFG->debugdeveloper) {
-            $labelsep = get_string('labelsep', 'langconfig');
-            if (!empty($debuginfo)) {
-                $debuginfo = s($debuginfo); // removes all nasty JS
-                $debuginfo = str_replace("\n", '<br />', $debuginfo); // keep newlines
-                $label = get_string('debuginfo', 'debug') . $labelsep;
-                $output .= $this->notification("<strong>$label</strong> " . $debuginfo, 'notifytiny');
-            }
-            if (!empty($backtrace)) {
-                $label = get_string('stacktrace', 'debug') . $labelsep;
-                $output .= $this->notification("<strong>$label</strong> " . format_backtrace($backtrace), 'notifytiny');
-            }
-            if ($obbuffer !== '' ) {
-                $label = get_string('outputbuffer', 'debug') . $labelsep;
-                $output .= $this->notification("<strong>$label</strong> " . s($obbuffer), 'notifytiny');
-            }
-        }
-
-        if (empty($CFG->rolesactive)) {
-            // continue does not make much sense if moodle is not installed yet because error is most probably not recoverable
-        } else if (!empty($link)) {
-            $output .= $this->continue_button($link);
-        }
-
-        $output .= $this->footer();
-
-        // Padding to encourage IE to display our error page, rather than its own.
-        $output .= str_repeat(' ', 512);
-
-        return $output;
-    }
-
-    /**
-     * Output a notification (that is, a status message about something that has just happened).
-     *
-     * Note: \core\notification::add() may be more suitable for your usage.
-     *
-     * @param string $message The message to print out.
-     * @param ?string $type   The type of notification. See constants on \core\output\notification.
-     * @param bool $closebutton Whether to show a close icon to remove the notification (default true).
-     * @return string the HTML to output.
-     */
-    public function notification($message, $type = null, $closebutton = true) {
-        $typemappings = [
-            // Valid types.
-            'success'           => \core\output\notification::NOTIFY_SUCCESS,
-            'info'              => \core\output\notification::NOTIFY_INFO,
-            'warning'           => \core\output\notification::NOTIFY_WARNING,
-            'error'             => \core\output\notification::NOTIFY_ERROR,
-
-            // Legacy types mapped to current types.
-            'notifyproblem'     => \core\output\notification::NOTIFY_ERROR,
-            'notifytiny'        => \core\output\notification::NOTIFY_ERROR,
-            'notifyerror'       => \core\output\notification::NOTIFY_ERROR,
-            'notifysuccess'     => \core\output\notification::NOTIFY_SUCCESS,
-            'notifymessage'     => \core\output\notification::NOTIFY_INFO,
-            'notifyredirect'    => \core\output\notification::NOTIFY_INFO,
-            'redirectmessage'   => \core\output\notification::NOTIFY_INFO,
-        ];
-
-        $extraclasses = [];
-
-        if ($type) {
-            if (strpos($type, ' ') === false) {
-                // No spaces in the list of classes, therefore no need to loop over and determine the class.
-                if (isset($typemappings[$type])) {
-                    $type = $typemappings[$type];
-                } else {
-                    // The value provided did not match a known type. It must be an extra class.
-                    $extraclasses = [$type];
-                }
-            } else {
-                // Identify what type of notification this is.
-                $classarray = explode(' ', self::prepare_classes($type));
-
-                // Separate out the type of notification from the extra classes.
-                foreach ($classarray as $class) {
-                    if (isset($typemappings[$class])) {
-                        $type = $typemappings[$class];
-                    } else {
-                        $extraclasses[] = $class;
-                    }
-                }
-            }
-        }
-
-        $notification = new \core\output\notification($message, $type, $closebutton);
-        if (count($extraclasses)) {
-            $notification->set_extra_classes($extraclasses);
-        }
-
-        // Return the rendered template.
-        return $this->render_from_template($notification->get_template_name(), $notification->export_for_template($this));
-    }
-
-    /**
-     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
-     */
-    public function notify_problem() {
-        throw new coding_exception('core_renderer::notify_problem() can not be used any more, '.
-            'please use \core\notification::add(), or \core\output\notification as required.');
-    }
-
-    /**
-     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
-     */
-    public function notify_success() {
-        throw new coding_exception('core_renderer::notify_success() can not be used any more, '.
-            'please use \core\notification::add(), or \core\output\notification as required.');
-    }
-
-    /**
-     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
-     */
-    public function notify_message() {
-        throw new coding_exception('core_renderer::notify_message() can not be used any more, '.
-            'please use \core\notification::add(), or \core\output\notification as required.');
-    }
-
-    /**
-     * @deprecated since Moodle 3.1 MDL-30811 - please do not use this function any more.
-     */
-    public function notify_redirect() {
-        throw new coding_exception('core_renderer::notify_redirect() can not be used any more, '.
-            'please use \core\notification::add(), or \core\output\notification as required.');
-    }
-
-    /**
-     * Render a notification (that is, a status message about something that has
-     * just happened).
-     *
-     * @param \core\output\notification $notification the notification to print out
-     * @return string the HTML to output.
-     */
-    protected function render_notification(\core\output\notification $notification) {
-        return $this->render_from_template($notification->get_template_name(), $notification->export_for_template($this));
-    }
-
-    /**
-     * Returns HTML to display a continue button that goes to a particular URL.
-     *
-     * @param string|moodle_url $url The url the button goes to.
-     * @return string the HTML to output.
-     */
-    public function continue_button($url) {
-        if (!($url instanceof moodle_url)) {
-            $url = new moodle_url($url);
-        }
-        $button = new single_button($url, get_string('continue'), 'get', single_button::BUTTON_PRIMARY);
-        $button->class = 'continuebutton';
-
-        return $this->render($button);
-    }
-
-    /**
-     * Returns HTML to display a single paging bar to provide access to other pages  (usually in a search)
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_paging_bar()} instead.
-     *
-     * @param int $totalcount The total number of entries available to be paged through
-     * @param int $page The page you are currently viewing
-     * @param int $perpage The number of entries that should be shown per page
-     * @param string|moodle_url $baseurl url of the current page, the $pagevar parameter is added
-     * @param string $pagevar name of page parameter that holds the page number
-     * @return string the HTML to output.
-     */
-    public function paging_bar($totalcount, $page, $perpage, $baseurl, $pagevar = 'page') {
-        $pb = new paging_bar($totalcount, $page, $perpage, $baseurl, $pagevar);
-        return $this->render($pb);
-    }
-
-    /**
-     * Returns HTML to display the paging bar.
-     *
-     * @param paging_bar $pagingbar
-     * @return string the HTML to output.
-     */
-    protected function render_paging_bar(paging_bar $pagingbar) {
-        // Any more than 10 is not usable and causes weird wrapping of the pagination.
-        $pagingbar->maxdisplay = 10;
-        return $this->render_from_template('core/paging_bar', $pagingbar->export_for_template($this));
-    }
-
-    /**
-     * Returns HTML to display initials bar to provide access to other pages  (usually in a search)
-     *
-     * @param string $current the currently selected letter.
-     * @param string $class class name to add to this initial bar.
-     * @param string $title the name to put in front of this initial bar.
-     * @param string $urlvar URL parameter name for this initial.
-     * @param string $url URL object.
-     * @param array $alpha of letters in the alphabet.
-     * @param bool $minirender Return a trimmed down view of the initials bar.
-     * @return string the HTML to output.
-     */
-    public function initials_bar($current, $class, $title, $urlvar, $url, $alpha = null, bool $minirender = false) {
-        $ib = new initials_bar($current, $class, $title, $urlvar, $url, $alpha, $minirender);
-        return $this->render($ib);
-    }
-
-    /**
-     * Internal implementation of initials bar rendering.
-     *
-     * @param initials_bar $initialsbar
-     * @return string
-     */
-    protected function render_initials_bar(initials_bar $initialsbar) {
-        return $this->render_from_template('core/initials_bar', $initialsbar->export_for_template($this));
-    }
-
-    /**
-     * Output the place a skip link goes to.
-     *
-     * @param string $id The target name from the corresponding $PAGE->requires->skip_link_to($target) call.
-     * @return string the HTML to output.
-     */
-    public function skip_link_target($id = null) {
-        return html_writer::span('', '', array('id' => $id));
-    }
-
-    /**
-     * Outputs a heading
-     *
-     * @param string $text The text of the heading
-     * @param int $level The level of importance of the heading. Defaulting to 2
-     * @param string $classes A space-separated list of CSS classes. Defaulting to null
-     * @param string $id An optional ID
-     * @return string the HTML to output.
-     */
-    public function heading($text, $level = 2, $classes = null, $id = null) {
-        $level = (integer) $level;
-        if ($level < 1 or $level > 6) {
-            throw new coding_exception('Heading level must be an integer between 1 and 6.');
-        }
-        return html_writer::tag('h' . $level, $text, array('id' => $id, 'class' => renderer_base::prepare_classes($classes)));
-    }
-
-    /**
-     * Outputs a box.
-     *
-     * @param string $contents The contents of the box
-     * @param string $classes A space-separated list of CSS classes
-     * @param string $id An optional ID
-     * @param array $attributes An array of other attributes to give the box.
-     * @return string the HTML to output.
-     */
-    public function box($contents, $classes = 'generalbox', $id = null, $attributes = array()) {
-        return $this->box_start($classes, $id, $attributes) . $contents . $this->box_end();
-    }
-
-    /**
-     * Outputs the opening section of a box.
-     *
-     * @param string $classes A space-separated list of CSS classes
-     * @param string $id An optional ID
-     * @param array $attributes An array of other attributes to give the box.
-     * @return string the HTML to output.
-     */
-    public function box_start($classes = 'generalbox', $id = null, $attributes = array()) {
-        $this->opencontainers->push('box', html_writer::end_tag('div'));
-        $attributes['id'] = $id;
-        $attributes['class'] = 'box py-3 ' . renderer_base::prepare_classes($classes);
-        return html_writer::start_tag('div', $attributes);
-    }
-
-    /**
-     * Outputs the closing section of a box.
-     *
-     * @return string the HTML to output.
-     */
-    public function box_end() {
-        return $this->opencontainers->pop('box');
-    }
-
-    /**
-     * Outputs a paragraph.
-     *
-     * @param string $contents The contents of the paragraph
-     * @param string|null $classes A space-separated list of CSS classes
-     * @param string|null $id An optional ID
-     * @return string the HTML to output.
-     */
-    public function paragraph(string $contents, ?string $classes = null, ?string $id = null): string {
-        return html_writer::tag(
-            'p',
-            $contents,
-            ['id' => $id, 'class' => renderer_base::prepare_classes($classes)]
-        );
-    }
-
-    /**
-     * Outputs a screen reader only inline text.
-     *
-     * @param string $contents The contents of the paragraph
-     * @return string the HTML to output.
-     */
-    public function sr_text(string $contents): string {
-        return html_writer::tag(
-            'span',
-            $contents,
-            ['class' => 'sr-only']
-        ) . ' ';
-    }
-
-    /**
-     * Outputs a container.
-     *
-     * @param string $contents The contents of the box
-     * @param string $classes A space-separated list of CSS classes
-     * @param string $id An optional ID
-     * @param array $attributes Optional other attributes as array
-     * @return string the HTML to output.
-     */
-    public function container($contents, $classes = null, $id = null, $attributes = []) {
-        return $this->container_start($classes, $id, $attributes) . $contents . $this->container_end();
-    }
-
-    /**
-     * Outputs the opening section of a container.
-     *
-     * @param string $classes A space-separated list of CSS classes
-     * @param string $id An optional ID
-     * @param array $attributes Optional other attributes as array
-     * @return string the HTML to output.
-     */
-    public function container_start($classes = null, $id = null, $attributes = []) {
-        $this->opencontainers->push('container', html_writer::end_tag('div'));
-        $attributes = array_merge(['id' => $id, 'class' => renderer_base::prepare_classes($classes)], $attributes);
-        return html_writer::start_tag('div', $attributes);
-    }
-
-    /**
-     * Outputs the closing section of a container.
-     *
-     * @return string the HTML to output.
-     */
-    public function container_end() {
-        return $this->opencontainers->pop('container');
-    }
-
-    /**
-     * Make nested HTML lists out of the items
-     *
-     * The resulting list will look something like this:
-     *
-     * <pre>
-     * <<ul>>
-     * <<li>><div class='tree_item parent'>(item contents)</div>
-     *      <<ul>
-     *      <<li>><div class='tree_item'>(item contents)</div><</li>>
-     *      <</ul>>
-     * <</li>>
-     * <</ul>>
-     * </pre>
-     *
-     * @param array $items
-     * @param array $attrs html attributes passed to the top ofs the list
-     * @return string HTML
-     */
-    public function tree_block_contents($items, $attrs = array()) {
-        // exit if empty, we don't want an empty ul element
-        if (empty($items)) {
-            return '';
-        }
-        // array of nested li elements
-        $lis = array();
-        foreach ($items as $item) {
-            // this applies to the li item which contains all child lists too
-            $content = $item->content($this);
-            $liclasses = array($item->get_css_type());
-            if (!$item->forceopen || (!$item->forceopen && $item->collapse) || ($item->children->count()==0  && $item->nodetype==navigation_node::NODETYPE_BRANCH)) {
-                $liclasses[] = 'collapsed';
-            }
-            if ($item->isactive === true) {
-                $liclasses[] = 'current_branch';
-            }
-            $liattr = array('class'=>join(' ',$liclasses));
-            // class attribute on the div item which only contains the item content
-            $divclasses = array('tree_item');
-            if ($item->children->count()>0  || $item->nodetype==navigation_node::NODETYPE_BRANCH) {
-                $divclasses[] = 'branch';
-            } else {
-                $divclasses[] = 'leaf';
-            }
-            if (!empty($item->classes) && count($item->classes)>0) {
-                $divclasses[] = join(' ', $item->classes);
-            }
-            $divattr = array('class'=>join(' ', $divclasses));
-            if (!empty($item->id)) {
-                $divattr['id'] = $item->id;
-            }
-            $content = html_writer::tag('p', $content, $divattr) . $this->tree_block_contents($item->children);
-            if (!empty($item->preceedwithhr) && $item->preceedwithhr===true) {
-                $content = html_writer::empty_tag('hr') . $content;
-            }
-            $content = html_writer::tag('li', $content, $liattr);
-            $lis[] = $content;
-        }
-        return html_writer::tag('ul', implode("\n", $lis), $attrs);
-    }
-
-    /**
-     * Returns a search box.
-     *
-     * @param  string $id     The search box wrapper div id, defaults to an autogenerated one.
-     * @return string         HTML with the search form hidden by default.
-     */
-    public function search_box($id = false) {
-        global $CFG;
-
-        // Accessing $CFG directly as using \core_search::is_global_search_enabled would
-        // result in an extra included file for each site, even the ones where global search
-        // is disabled.
-        if (empty($CFG->enableglobalsearch) || !has_capability('moodle/search:query', context_system::instance())) {
-            return '';
-        }
-
-        $data = [
-            'action' => new moodle_url('/search/index.php'),
-            'hiddenfields' => (object) ['name' => 'context', 'value' => $this->page->context->id],
-            'inputname' => 'q',
-            'searchstring' => get_string('search'),
-            ];
-        return $this->render_from_template('core/search_input_navbar', $data);
-    }
-
-    /**
-     * Allow plugins to provide some content to be rendered in the navbar.
-     * The plugin must define a PLUGIN_render_navbar_output function that returns
-     * the HTML they wish to add to the navbar.
-     *
-     * @return string HTML for the navbar
-     */
-    public function navbar_plugin_output() {
-        $output = '';
-
-        // Give subsystems an opportunity to inject extra html content. The callback
-        // must always return a string containing valid html.
-        foreach (\core_component::get_core_subsystems() as $name => $path) {
-            if ($path) {
-                $output .= component_callback($name, 'render_navbar_output', [$this], '');
-            }
-        }
-
-        if ($pluginsfunction = get_plugins_with_function('render_navbar_output')) {
-            foreach ($pluginsfunction as $plugintype => $plugins) {
-                foreach ($plugins as $pluginfunction) {
-                    $output .= $pluginfunction($this);
-                }
-            }
-        }
-
-        return $output;
-    }
-
-    /**
-     * Construct a user menu, returning HTML that can be echoed out by a
-     * layout file.
-     *
-     * @param stdClass $user A user object, usually $USER.
-     * @param bool $withlinks true if a dropdown should be built.
-     * @return string HTML fragment.
-     */
-    public function user_menu($user = null, $withlinks = null) {
-        global $USER, $CFG;
-        require_once($CFG->dirroot . '/user/lib.php');
-
-        if (is_null($user)) {
-            $user = $USER;
-        }
-
-        // Note: this behaviour is intended to match that of core_renderer::login_info,
-        // but should not be considered to be good practice; layout options are
-        // intended to be theme-specific. Please don't copy this snippet anywhere else.
-        if (is_null($withlinks)) {
-            $withlinks = empty($this->page->layout_options['nologinlinks']);
-        }
-
-        // Add a class for when $withlinks is false.
-        $usermenuclasses = 'usermenu';
-        if (!$withlinks) {
-            $usermenuclasses .= ' withoutlinks';
-        }
-
-        $returnstr = "";
-
-        // If during initial install, return the empty return string.
-        if (during_initial_install()) {
-            return $returnstr;
-        }
-
-        $loginpage = $this->is_login_page();
-        $loginurl = get_login_url();
-
-        // Get some navigation opts.
-        $opts = user_get_user_navigation_info($user, $this->page);
-
-        if (!empty($opts->unauthenticateduser)) {
-            $returnstr = get_string($opts->unauthenticateduser['content'], 'moodle');
-            // If not logged in, show the typical not-logged-in string.
-            if (!$loginpage && (!$opts->unauthenticateduser['guest'] || $withlinks)) {
-                $returnstr .= " (<a href=\"$loginurl\">" . get_string('login') . '</a>)';
-            }
-
-            return html_writer::div(
-                html_writer::span(
-                    $returnstr,
-                    'login nav-link'
-                ),
-                $usermenuclasses
-            );
-        }
-
-        $avatarclasses = "avatars";
-        $avatarcontents = html_writer::span($opts->metadata['useravatar'], 'avatar current');
-        $usertextcontents = $opts->metadata['userfullname'];
-
-        // Other user.
-        if (!empty($opts->metadata['asotheruser'])) {
-            $avatarcontents .= html_writer::span(
-                $opts->metadata['realuseravatar'],
-                'avatar realuser'
-            );
-            $usertextcontents = $opts->metadata['realuserfullname'];
-            $usertextcontents .= html_writer::tag(
-                'span',
-                get_string(
-                    'loggedinas',
-                    'moodle',
-                    html_writer::span(
-                        $opts->metadata['userfullname'],
-                        'value'
-                    )
-                ),
-                array('class' => 'meta viewingas')
-            );
-        }
-
-        // Role.
-        if (!empty($opts->metadata['asotherrole'])) {
-            $role = core_text::strtolower(preg_replace('#[ ]+#', '-', trim($opts->metadata['rolename'])));
-            $usertextcontents .= html_writer::span(
-                $opts->metadata['rolename'],
-                'meta role role-' . $role
-            );
-        }
-
-        // User login failures.
-        if (!empty($opts->metadata['userloginfail'])) {
-            $usertextcontents .= html_writer::span(
-                $opts->metadata['userloginfail'],
-                'meta loginfailures'
-            );
-        }
-
-        // MNet.
-        if (!empty($opts->metadata['asmnetuser'])) {
-            $mnet = strtolower(preg_replace('#[ ]+#', '-', trim($opts->metadata['mnetidprovidername'])));
-            $usertextcontents .= html_writer::span(
-                $opts->metadata['mnetidprovidername'],
-                'meta mnet mnet-' . $mnet
-            );
-        }
-
-        $returnstr .= html_writer::span(
-            html_writer::span($usertextcontents, 'usertext mr-1') .
-            html_writer::span($avatarcontents, $avatarclasses),
-            'userbutton'
-        );
-
-        // Create a divider (well, a filler).
-        $divider = new action_menu_filler();
-        $divider->primary = false;
-
-        $am = new action_menu();
-        $am->set_menu_trigger(
-            $returnstr,
-            'nav-link'
-        );
-        $am->set_action_label(get_string('usermenu'));
-        $am->set_nowrap_on_items();
-        if ($withlinks) {
-            $navitemcount = count($opts->navitems);
-            $idx = 0;
-            foreach ($opts->navitems as $key => $value) {
-
-                switch ($value->itemtype) {
-                    case 'divider':
-                        // If the nav item is a divider, add one and skip link processing.
-                        $am->add($divider);
-                        break;
-
-                    case 'invalid':
-                        // Silently skip invalid entries (should we post a notification?).
-                        break;
-
-                    case 'link':
-                        // Process this as a link item.
-                        $pix = null;
-                        if (isset($value->pix) && !empty($value->pix)) {
-                            $pix = new pix_icon($value->pix, '', null, array('class' => 'iconsmall'));
-                        } else if (isset($value->imgsrc) && !empty($value->imgsrc)) {
-                            $value->title = html_writer::img(
-                                $value->imgsrc,
-                                $value->title,
-                                array('class' => 'iconsmall')
-                            ) . $value->title;
-                        }
-
-                        $al = new action_menu_link_secondary(
-                            $value->url,
-                            $pix,
-                            $value->title,
-                            array('class' => 'icon')
-                        );
-                        if (!empty($value->titleidentifier)) {
-                            $al->attributes['data-title'] = $value->titleidentifier;
-                        }
-                        $am->add($al);
-                        break;
-                }
-
-                $idx++;
-
-                // Add dividers after the first item and before the last item.
-                if ($idx == 1 || $idx == $navitemcount - 1) {
-                    $am->add($divider);
-                }
-            }
-        }
-
-        return html_writer::div(
-            $this->render($am),
-            $usermenuclasses
-        );
-    }
-
-    /**
-     * Secure layout login info.
-     *
-     * @return string
-     */
-    public function secure_layout_login_info() {
-        if (get_config('core', 'logininfoinsecurelayout')) {
-            return $this->login_info(false);
-        } else {
-            return '';
-        }
-    }
-
-    /**
-     * Returns the language menu in the secure layout.
-     *
-     * No custom menu items are passed though, such that it will render only the language selection.
-     *
-     * @return string
-     */
-    public function secure_layout_language_menu() {
-        if (get_config('core', 'langmenuinsecurelayout')) {
-            $custommenu = new custom_menu('', current_language());
-            return $this->render_custom_menu($custommenu);
-        } else {
-            return '';
-        }
-    }
-
-    /**
-     * This renders the navbar.
-     * Uses bootstrap compatible html.
-     */
-    public function navbar() {
-        return $this->render_from_template('core/navbar', $this->page->navbar);
-    }
-
-    /**
-     * Renders a breadcrumb navigation node object.
-     *
-     * @param breadcrumb_navigation_node $item The navigation node to render.
-     * @return string HTML fragment
-     */
-    protected function render_breadcrumb_navigation_node(breadcrumb_navigation_node $item) {
-
-        if ($item->action instanceof moodle_url) {
-            $content = $item->get_content();
-            $title = $item->get_title();
-            $attributes = array();
-            $attributes['itemprop'] = 'url';
-            if ($title !== '') {
-                $attributes['title'] = $title;
-            }
-            if ($item->hidden) {
-                $attributes['class'] = 'dimmed_text';
-            }
-            if ($item->is_last()) {
-                $attributes['aria-current'] = 'page';
-            }
-            $content = html_writer::tag('span', $content, array('itemprop' => 'title'));
-            $content = html_writer::link($item->action, $content, $attributes);
-
-            $attributes = array();
-            $attributes['itemscope'] = '';
-            $attributes['itemtype'] = 'http://data-vocabulary.org/Breadcrumb';
-            $content = html_writer::tag('span', $content, $attributes);
-
-        } else {
-            $content = $this->render_navigation_node($item);
-        }
-        return $content;
-    }
-
-    /**
-     * Renders a navigation node object.
-     *
-     * @param navigation_node $item The navigation node to render.
-     * @return string HTML fragment
-     */
-    protected function render_navigation_node(navigation_node $item) {
-        $content = $item->get_content();
-        $title = $item->get_title();
-        if ($item->icon instanceof renderable && !$item->hideicon) {
-            $icon = $this->render($item->icon);
-            $content = $icon.$content; // use CSS for spacing of icons
-        }
-        if ($item->helpbutton !== null) {
-            $content = trim($item->helpbutton).html_writer::tag('span', $content, array('class'=>'clearhelpbutton', 'tabindex'=>'0'));
-        }
-        if ($content === '') {
-            return '';
-        }
-        if ($item->action instanceof action_link) {
-            $link = $item->action;
-            if ($item->hidden) {
-                $link->add_class('dimmed');
-            }
-            if (!empty($content)) {
-                // Providing there is content we will use that for the link content.
-                $link->text = $content;
-            }
-            $content = $this->render($link);
-        } else if ($item->action instanceof moodle_url) {
-            $attributes = array();
-            if ($title !== '') {
-                $attributes['title'] = $title;
-            }
-            if ($item->hidden) {
-                $attributes['class'] = 'dimmed_text';
-            }
-            $content = html_writer::link($item->action, $content, $attributes);
-
-        } else if (is_string($item->action) || empty($item->action)) {
-            $attributes = array('tabindex'=>'0'); //add tab support to span but still maintain character stream sequence.
-            if ($title !== '') {
-                $attributes['title'] = $title;
-            }
-            if ($item->hidden) {
-                $attributes['class'] = 'dimmed_text';
-            }
-            $content = html_writer::tag('span', $content, $attributes);
-        }
-        return $content;
-    }
-
-    /**
-     * Accessibility: Right arrow-like character is
-     * used in the breadcrumb trail, course navigation menu
-     * (previous/next activity), calendar, and search forum block.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically. Please DO NOT
-     * use &lt; &gt; &raquo; - these are confusing for blind users.
-     *
-     * @return string
-     */
-    public function rarrow() {
-        return $this->page->theme->rarrow;
-    }
-
-    /**
-     * Accessibility: Left arrow-like character is
-     * used in the breadcrumb trail, course navigation menu
-     * (previous/next activity), calendar, and search forum block.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically. Please DO NOT
-     * use &lt; &gt; &raquo; - these are confusing for blind users.
-     *
-     * @return string
-     */
-    public function larrow() {
-        return $this->page->theme->larrow;
-    }
-
-    /**
-     * Accessibility: Up arrow-like character is used in
-     * the book heirarchical navigation.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically. Please DO NOT
-     * use ^ - this is confusing for blind users.
-     *
-     * @return string
-     */
-    public function uarrow() {
-        return $this->page->theme->uarrow;
-    }
-
-    /**
-     * Accessibility: Down arrow-like character.
-     * If the theme does not set characters, appropriate defaults
-     * are set automatically.
-     *
-     * @return string
-     */
-    public function darrow() {
-        return $this->page->theme->darrow;
-    }
-
-    /**
-     * Returns the custom menu if one has been set
-     *
-     * A custom menu can be configured by browsing to a theme's settings page
-     * and then configuring the custommenu config setting as described.
-     *
-     * Theme developers: DO NOT OVERRIDE! Please override function
-     * {@link core_renderer::render_custom_menu()} instead.
-     *
-     * @param string $custommenuitems - custom menuitems set by theme instead of global theme settings
-     * @return string
-     */
-    public function custom_menu($custommenuitems = '') {
-        global $CFG;
-
-        if (empty($custommenuitems) && !empty($CFG->custommenuitems)) {
-            $custommenuitems = $CFG->custommenuitems;
-        }
-        $custommenu = new custom_menu($custommenuitems, current_language());
-        return $this->render_custom_menu($custommenu);
-    }
-
-    /**
-     * We want to show the custom menus as a list of links in the footer on small screens.
-     * Just return the menu object exported so we can render it differently.
-     */
-    public function custom_menu_flat() {
-        global $CFG;
-        $custommenuitems = '';
-
-        if (empty($custommenuitems) && !empty($CFG->custommenuitems)) {
-            $custommenuitems = $CFG->custommenuitems;
-        }
-        $custommenu = new custom_menu($custommenuitems, current_language());
-        $langs = get_string_manager()->get_list_of_translations();
-        $haslangmenu = $this->lang_menu() != '';
-
-        if ($haslangmenu) {
-            $strlang = get_string('language');
-            $currentlang = current_language();
-            if (isset($langs[$currentlang])) {
-                $currentlang = $langs[$currentlang];
-            } else {
-                $currentlang = $strlang;
-            }
-            $this->language = $custommenu->add($currentlang, new moodle_url('#'), $strlang, 10000);
-            foreach ($langs as $langtype => $langname) {
-                $this->language->add($langname, new moodle_url($this->page->url, array('lang' => $langtype)), $langname);
-            }
-        }
-
-        return $custommenu->export_for_template($this);
-    }
-
-    /**
-     * Renders a custom menu object (located in outputcomponents.php)
-     *
-     * The custom menu this method produces makes use of the YUI3 menunav widget
-     * and requires very specific html elements and classes.
-     *
-     * @staticvar int $menucount
-     * @param custom_menu $menu
-     * @return string
-     */
-    protected function render_custom_menu(custom_menu $menu) {
-        global $CFG;
-
-        $langs = get_string_manager()->get_list_of_translations();
-        $haslangmenu = $this->lang_menu() != '';
-
-        if (!$menu->has_children() && !$haslangmenu) {
-            return '';
-        }
-
-        if ($haslangmenu) {
-            $strlang = get_string('language');
-            $currentlang = current_language();
-            if (isset($langs[$currentlang])) {
-                $currentlangstr = $langs[$currentlang];
-            } else {
-                $currentlangstr = $strlang;
-            }
-            $this->language = $menu->add($currentlangstr, new moodle_url('#'), $strlang, 10000);
-            foreach ($langs as $langtype => $langname) {
-                $attributes = [];
-                // Set the lang attribute for languages different from the page's current language.
-                if ($langtype !== $currentlang) {
-                    $attributes[] = [
-                        'key' => 'lang',
-                        'value' => get_html_lang_attribute_value($langtype),
-                    ];
-                }
-                $this->language->add($langname, new moodle_url($this->page->url, ['lang' => $langtype]), null, null, $attributes);
-            }
-        }
-
-        $content = '';
-        foreach ($menu->get_children() as $item) {
-            $context = $item->export_for_template($this);
-            $content .= $this->render_from_template('core/custom_menu_item', $context);
-        }
-
-        return $content;
-    }
-
-    /**
-     * Renders a custom menu node as part of a submenu
-     *
-     * The custom menu this method produces makes use of the YUI3 menunav widget
-     * and requires very specific html elements and classes.
-     *
-     * @see core:renderer::render_custom_menu()
-     *
-     * @staticvar int $submenucount
-     * @param custom_menu_item $menunode
-     * @return string
-     */
-    protected function render_custom_menu_item(custom_menu_item $menunode) {
-        // Required to ensure we get unique trackable id's
-        static $submenucount = 0;
-        if ($menunode->has_children()) {
-            // If the child has menus render it as a sub menu
-            $submenucount++;
-            $content = html_writer::start_tag('li');
-            if ($menunode->get_url() !== null) {
-                $url = $menunode->get_url();
-            } else {
-                $url = '#cm_submenu_'.$submenucount;
-            }
-            $content .= html_writer::link($url, $menunode->get_text(), array('class'=>'yui3-menu-label', 'title'=>$menunode->get_title()));
-            $content .= html_writer::start_tag('div', array('id'=>'cm_submenu_'.$submenucount, 'class'=>'yui3-menu custom_menu_submenu'));
-            $content .= html_writer::start_tag('div', array('class'=>'yui3-menu-content'));
-            $content .= html_writer::start_tag('ul');
-            foreach ($menunode->get_children() as $menunode) {
-                $content .= $this->render_custom_menu_item($menunode);
-            }
-            $content .= html_writer::end_tag('ul');
-            $content .= html_writer::end_tag('div');
-            $content .= html_writer::end_tag('div');
-            $content .= html_writer::end_tag('li');
-        } else {
-            // The node doesn't have children so produce a final menuitem.
-            // Also, if the node's text matches '####', add a class so we can treat it as a divider.
-            $content = '';
-            if (preg_match("/^#+$/", $menunode->get_text())) {
-
-                // This is a divider.
-                $content = html_writer::start_tag('li', array('class' => 'yui3-menuitem divider'));
-            } else {
-                $content = html_writer::start_tag(
-                    'li',
-                    array(
-                        'class' => 'yui3-menuitem'
-                    )
-                );
-                if ($menunode->get_url() !== null) {
-                    $url = $menunode->get_url();
-                } else {
-                    $url = '#';
-                }
-                $content .= html_writer::link(
-                    $url,
-                    $menunode->get_text(),
-                    array('class' => 'yui3-menuitem-content', 'title' => $menunode->get_title())
-                );
-            }
-            $content .= html_writer::end_tag('li');
-        }
-        // Return the sub menu
-        return $content;
-    }
-
-    /**
-     * Renders theme links for switching between default and other themes.
-     *
-     * @return string
-     */
-    protected function theme_switch_links() {
-
-        $actualdevice = core_useragent::get_device_type();
-        $currentdevice = $this->page->devicetypeinuse;
-        $switched = ($actualdevice != $currentdevice);
-
-        if (!$switched && $currentdevice == 'default' && $actualdevice == 'default') {
-            // The user is using the a default device and hasn't switched so don't shown the switch
-            // device links.
-            return '';
-        }
-
-        if ($switched) {
-            $linktext = get_string('switchdevicerecommended');
-            $devicetype = $actualdevice;
-        } else {
-            $linktext = get_string('switchdevicedefault');
-            $devicetype = 'default';
-        }
-        $linkurl = new moodle_url('/theme/switchdevice.php', array('url' => $this->page->url, 'device' => $devicetype, 'sesskey' => sesskey()));
-
-        $content  = html_writer::start_tag('div', array('id' => 'theme_switch_link'));
-        $content .= html_writer::link($linkurl, $linktext, array('rel' => 'nofollow'));
-        $content .= html_writer::end_tag('div');
-
-        return $content;
-    }
-
-    /**
-     * Renders tabs
-     *
-     * This function replaces print_tabs() used before Moodle 2.5 but with slightly different arguments
-     *
-     * Theme developers: In order to change how tabs are displayed please override functions
-     * {@link core_renderer::render_tabtree()} and/or {@link core_renderer::render_tabobject()}
-     *
-     * @param array $tabs array of tabs, each of them may have it's own ->subtree
-     * @param string|null $selected which tab to mark as selected, all parent tabs will
-     *     automatically be marked as activated
-     * @param array|string|null $inactive list of ids of inactive tabs, regardless of
-     *     their level. Note that you can as weel specify tabobject::$inactive for separate instances
-     * @return string
-     */
-    final public function tabtree($tabs, $selected = null, $inactive = null) {
-        return $this->render(new tabtree($tabs, $selected, $inactive));
-    }
-
-    /**
-     * Renders tabtree
-     *
-     * @param tabtree $tabtree
-     * @return string
-     */
-    protected function render_tabtree(tabtree $tabtree) {
-        if (empty($tabtree->subtree)) {
-            return '';
-        }
-        $data = $tabtree->export_for_template($this);
-        return $this->render_from_template('core/tabtree', $data);
-    }
-
-    /**
-     * Renders tabobject (part of tabtree)
-     *
-     * This function is called from {@link core_renderer::render_tabtree()}
-     * and also it calls itself when printing the $tabobject subtree recursively.
-     *
-     * Property $tabobject->level indicates the number of row of tabs.
-     *
-     * @param tabobject $tabobject
-     * @return string HTML fragment
-     */
-    protected function render_tabobject(tabobject $tabobject) {
-        $str = '';
-
-        // Print name of the current tab.
-        if ($tabobject instanceof tabtree) {
-            // No name for tabtree root.
-        } else if ($tabobject->inactive || $tabobject->activated || ($tabobject->selected && !$tabobject->linkedwhenselected)) {
-            // Tab name without a link. The <a> tag is used for styling.
-            $str .= html_writer::tag('a', html_writer::span($tabobject->text), array('class' => 'nolink moodle-has-zindex'));
-        } else {
-            // Tab name with a link.
-            if (!($tabobject->link instanceof moodle_url)) {
-                // backward compartibility when link was passed as quoted string
-                $str .= "<a href=\"$tabobject->link\" title=\"$tabobject->title\"><span>$tabobject->text</span></a>";
-            } else {
-                $str .= html_writer::link($tabobject->link, html_writer::span($tabobject->text), array('title' => $tabobject->title));
-            }
-        }
-
-        if (empty($tabobject->subtree)) {
-            if ($tabobject->selected) {
-                $str .= html_writer::tag('div', '&nbsp;', array('class' => 'tabrow'. ($tabobject->level + 1). ' empty'));
-            }
-            return $str;
-        }
-
-        // Print subtree.
-        if ($tabobject->level == 0 || $tabobject->selected || $tabobject->activated) {
-            $str .= html_writer::start_tag('ul', array('class' => 'tabrow'. $tabobject->level));
-            $cnt = 0;
-            foreach ($tabobject->subtree as $tab) {
-                $liclass = '';
-                if (!$cnt) {
-                    $liclass .= ' first';
-                }
-                if ($cnt == count($tabobject->subtree) - 1) {
-                    $liclass .= ' last';
-                }
-                if ((empty($tab->subtree)) && (!empty($tab->selected))) {
-                    $liclass .= ' onerow';
-                }
-
-                if ($tab->selected) {
-                    $liclass .= ' here selected';
-                } else if ($tab->activated) {
-                    $liclass .= ' here active';
-                }
-
-                // This will recursively call function render_tabobject() for each item in subtree.
-                $str .= html_writer::tag('li', $this->render($tab), array('class' => trim($liclass)));
-                $cnt++;
-            }
-            $str .= html_writer::end_tag('ul');
-        }
-
-        return $str;
-    }
-
-    /**
-     * Get the HTML for blocks in the given region.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @param string $region The region to get HTML for.
-     * @param array $classes Wrapping tag classes.
-     * @param string $tag Wrapping tag.
-     * @param boolean $fakeblocksonly Include fake blocks only.
-     * @return string HTML.
-     */
-    public function blocks($region, $classes = array(), $tag = 'aside', $fakeblocksonly = false) {
-        $displayregion = $this->page->apply_theme_region_manipulations($region);
-        $classes = (array)$classes;
-        $classes[] = 'block-region';
-        $attributes = array(
-            'id' => 'block-region-'.preg_replace('#[^a-zA-Z0-9_\-]+#', '-', $displayregion),
-            'class' => join(' ', $classes),
-            'data-blockregion' => $displayregion,
-            'data-droptarget' => '1'
-        );
-        if ($this->page->blocks->region_has_content($displayregion, $this)) {
-            $content = html_writer::tag('h2', get_string('blocks'), ['class' => 'sr-only']) .
-                $this->blocks_for_region($displayregion, $fakeblocksonly);
-        } else {
-            $content = html_writer::tag('h2', get_string('blocks'), ['class' => 'sr-only']);
-        }
-        return html_writer::tag($tag, $content, $attributes);
-    }
-
-    /**
-     * Renders a custom block region.
-     *
-     * Use this method if you want to add an additional block region to the content of the page.
-     * Please note this should only be used in special situations.
-     * We want to leave the theme is control where ever possible!
-     *
-     * This method must use the same method that the theme uses within its layout file.
-     * As such it asks the theme what method it is using.
-     * It can be one of two values, blocks or blocks_for_region (deprecated).
-     *
-     * @param string $regionname The name of the custom region to add.
-     * @return string HTML for the block region.
-     */
-    public function custom_block_region($regionname) {
-        if ($this->page->theme->get_block_render_method() === 'blocks') {
-            return $this->blocks($regionname);
-        } else {
-            return $this->blocks_for_region($regionname);
-        }
-    }
-
-    /**
-     * Returns the CSS classes to apply to the body tag.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @param array $additionalclasses Any additional classes to apply.
-     * @return string
-     */
-    public function body_css_classes(array $additionalclasses = array()) {
-        return $this->page->bodyclasses . ' ' . implode(' ', $additionalclasses);
-    }
-
-    /**
-     * The ID attribute to apply to the body tag.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @return string
-     */
-    public function body_id() {
-        return $this->page->bodyid;
-    }
-
-    /**
-     * Returns HTML attributes to use within the body tag. This includes an ID and classes.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @param string|array $additionalclasses Any additional classes to give the body tag,
-     * @return string
-     */
-    public function body_attributes($additionalclasses = array()) {
-        if (!is_array($additionalclasses)) {
-            $additionalclasses = explode(' ', $additionalclasses);
-        }
-        return ' id="'. $this->body_id().'" class="'.$this->body_css_classes($additionalclasses).'"';
-    }
-
-    /**
-     * Gets HTML for the page heading.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @param string $tag The tag to encase the heading in. h1 by default.
-     * @return string HTML.
-     */
-    public function page_heading($tag = 'h1') {
-        return html_writer::tag($tag, $this->page->heading);
-    }
-
-    /**
-     * Gets the HTML for the page heading button.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @return string HTML.
-     */
-    public function page_heading_button() {
-        return $this->page->button;
-    }
-
-    /**
-     * Returns the Moodle docs link to use for this page.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @param string $text
-     * @return string
-     */
-    public function page_doc_link($text = null) {
-        if ($text === null) {
-            $text = get_string('moodledocslink');
-        }
-        $path = page_get_doc_link_path($this->page);
-        if (!$path) {
-            return '';
-        }
-        return $this->doc_link($path, $text);
-    }
-
-    /**
-     * Returns the HTML for the site support email link
-     *
-     * @param array $customattribs Array of custom attributes for the support email anchor tag.
-     * @param bool $embed Set to true if you want to embed the link in other inline content.
-     * @return string The html code for the support email link.
-     */
-    public function supportemail(array $customattribs = [], bool $embed = false): string {
-        global $CFG;
-
-        // Do not provide a link to contact site support if it is unavailable to this user. This would be where the site has
-        // disabled support, or limited it to authenticated users and the current user is a guest or not logged in.
-        if (!isset($CFG->supportavailability) ||
-                $CFG->supportavailability == CONTACT_SUPPORT_DISABLED ||
-                ($CFG->supportavailability == CONTACT_SUPPORT_AUTHENTICATED && (!isloggedin() || isguestuser()))) {
-            return '';
-        }
-
-        $label = get_string('contactsitesupport', 'admin');
-        $icon = $this->pix_icon('t/email', '');
-
-        if (!$embed) {
-            $content = $icon . $label;
-        } else {
-            $content = $label;
-        }
-
-        if (!empty($CFG->supportpage)) {
-            $attributes = ['href' => $CFG->supportpage, 'target' => 'blank'];
-            $content .= $this->pix_icon('i/externallink', '', 'moodle', ['class' => 'ml-1']);
-        } else {
-            $attributes = ['href' => $CFG->wwwroot . '/user/contactsitesupport.php'];
-        }
-
-        $attributes += $customattribs;
-
-        return html_writer::tag('a', $content, $attributes);
-    }
-
-    /**
-     * Returns the services and support link for the help pop-up.
-     *
-     * @return string
-     */
-    public function services_support_link(): string {
-        global $CFG;
-
-        if (during_initial_install() ||
-            (isset($CFG->showservicesandsupportcontent) && $CFG->showservicesandsupportcontent == false) ||
-            !is_siteadmin()) {
-            return '';
-        }
-
-        $liferingicon = $this->pix_icon('t/life-ring', '', 'moodle', ['class' => 'fa fa-life-ring']);
-        $newwindowicon = $this->pix_icon('i/externallink', get_string('opensinnewwindow'), 'moodle', ['class' => 'ml-1']);
-        $link = !empty($CFG->servicespage)
-            ? $CFG->servicespage
-            : 'https://moodle.com/help/?utm_source=CTA-banner&utm_medium=platform&utm_campaign=name~Moodle4+cat~lms+mp~no';
-        $content = $liferingicon . get_string('moodleservicesandsupport') . $newwindowicon;
-
-        return html_writer::tag('a', $content, ['target' => '_blank', 'href' => $link]);
-    }
-
-    /**
-     * Helper function to decide whether to show the help popover header or not.
-     *
-     * @return bool
-     */
-    public function has_popover_links(): bool {
-        return !empty($this->services_support_link()) || !empty($this->page_doc_link()) || !empty($this->supportemail());
-    }
-
-    /**
-     * Helper function to decide whether to show the communication link or not.
-     *
-     * @return bool
-     */
-    public function has_communication_links(): bool {
-        if (during_initial_install() || !core_communication\api::is_available()) {
-            return false;
-        }
-        return !empty($this->communication_link());
-    }
-
-    /**
-     * Returns the communication link, complete with html.
-     *
-     * @return string
-     */
-    public function communication_link(): string {
-        $link = $this->communication_url() ?? '';
-        $commicon = $this->pix_icon('t/messages-o', '', 'moodle', ['class' => 'fa fa-comments']);
-        $newwindowicon = $this->pix_icon('i/externallink', get_string('opensinnewwindow'), 'moodle', ['class' => 'ml-1']);
-        $content = $commicon . get_string('communicationroomlink', 'course') . $newwindowicon;
-        $html = html_writer::tag('a', $content, ['target' => '_blank', 'href' => $link]);
-
-        return !empty($link) ? $html : '';
-    }
-
-    /**
-     * Returns the communication url for a given instance if it exists.
-     *
-     * @return string
-     */
-    public function communication_url(): string {
-        global $COURSE;
-        return \core_communication\helper::get_course_communication_url($COURSE);
-    }
-
-    /**
-     * Returns the page heading menu.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @return string HTML.
-     */
-    public function page_heading_menu() {
-        return $this->page->headingmenu;
-    }
-
-    /**
-     * Returns the title to use on the page.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @return string
-     */
-    public function page_title() {
-        return $this->page->title;
-    }
-
-    /**
-     * Returns the moodle_url for the favicon.
-     *
-     * @since Moodle 2.5.1 2.6
-     * @return moodle_url The moodle_url for the favicon
-     */
-    public function favicon() {
-        $logo = null;
-        if (!during_initial_install()) {
-            $logo = get_config('core_admin', 'favicon');
-        }
-        if (empty($logo)) {
-            return $this->image_url('favicon', 'theme');
-        }
-
-        // Use $CFG->themerev to prevent browser caching when the file changes.
-        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'favicon', '64x64/',
-            theme_get_revision(), $logo);
-    }
-
-    /**
-     * Renders preferences groups.
-     *
-     * @param  preferences_groups $renderable The renderable
-     * @return string The output.
-     */
-    public function render_preferences_groups(preferences_groups $renderable) {
-        return $this->render_from_template('core/preferences_groups', $renderable);
-    }
-
-    /**
-     * Renders preferences group.
-     *
-     * @param  preferences_group $renderable The renderable
-     * @return string The output.
-     */
-    public function render_preferences_group(preferences_group $renderable) {
-        $html = '';
-        $html .= html_writer::start_tag('div', array('class' => 'col-sm-4 preferences-group'));
-        $html .= $this->heading($renderable->title, 3);
-        $html .= html_writer::start_tag('ul');
-        foreach ($renderable->nodes as $node) {
-            if ($node->has_children()) {
-                debugging('Preferences nodes do not support children', DEBUG_DEVELOPER);
-            }
-            $html .= html_writer::tag('li', $this->render($node));
-        }
-        $html .= html_writer::end_tag('ul');
-        $html .= html_writer::end_tag('div');
-        return $html;
-    }
-
-    public function context_header($headerinfo = null, $headinglevel = 1) {
-        global $DB, $USER, $CFG, $SITE;
-        require_once($CFG->dirroot . '/user/lib.php');
-        $context = $this->page->context;
-        $heading = null;
-        $imagedata = null;
-        $subheader = null;
-        $userbuttons = null;
-
-        // Make sure to use the heading if it has been set.
-        if (isset($headerinfo['heading'])) {
-            $heading = $headerinfo['heading'];
-        } else {
-            $heading = $this->page->heading;
-        }
-
-        // The user context currently has images and buttons. Other contexts may follow.
-        if ((isset($headerinfo['user']) || $context->contextlevel == CONTEXT_USER) && $this->page->pagetype !== 'my-index') {
-            if (isset($headerinfo['user'])) {
-                $user = $headerinfo['user'];
-            } else {
-                // Look up the user information if it is not supplied.
-                $user = $DB->get_record('user', array('id' => $context->instanceid));
-            }
-
-            // If the user context is set, then use that for capability checks.
-            if (isset($headerinfo['usercontext'])) {
-                $context = $headerinfo['usercontext'];
-            }
-
-            // Only provide user information if the user is the current user, or a user which the current user can view.
-            // When checking user_can_view_profile(), either:
-            // If the page context is course, check the course context (from the page object) or;
-            // If page context is NOT course, then check across all courses.
-            $course = ($this->page->context->contextlevel == CONTEXT_COURSE) ? $this->page->course : null;
-
-            if (user_can_view_profile($user, $course)) {
-                // Use the user's full name if the heading isn't set.
-                if (empty($heading)) {
-                    $heading = fullname($user);
-                }
-
-                $imagedata = $this->user_picture($user, array('size' => 100));
-
-                // Check to see if we should be displaying a message button.
-                if (!empty($CFG->messaging) && has_capability('moodle/site:sendmessage', $context)) {
-                    $userbuttons = array(
-                        'messages' => array(
-                            'buttontype' => 'message',
-                            'title' => get_string('message', 'message'),
-                            'url' => new moodle_url('/message/index.php', array('id' => $user->id)),
-                            'image' => 'message',
-                            'linkattributes' => \core_message\helper::messageuser_link_params($user->id),
-                            'page' => $this->page
-                        )
-                    );
-
-                    if ($USER->id != $user->id) {
-                        $iscontact = \core_message\api::is_contact($USER->id, $user->id);
-                        $isrequested = \core_message\api::get_contact_requests_between_users($USER->id, $user->id);
-                        $contacturlaction = '';
-                        $linkattributes = \core_message\helper::togglecontact_link_params(
-                            $user,
-                            $iscontact,
-                            true,
-                            !empty($isrequested),
-                        );
-                        // If the user is not a contact.
-                        if (!$iscontact) {
-                            if ($isrequested) {
-                                // We just need the first request.
-                                $requests = array_shift($isrequested);
-                                if ($requests->userid == $USER->id) {
-                                    // If the user has requested to be a contact.
-                                    $contacttitle = 'contactrequestsent';
-                                } else {
-                                    // If the user has been requested to be a contact.
-                                    $contacttitle = 'waitingforcontactaccept';
-                                }
-                                $linkattributes = array_merge($linkattributes, [
-                                    'class' => 'disabled',
-                                    'tabindex' => '-1',
-                                ]);
-                            } else {
-                                // If the user is not a contact and has not requested to be a contact.
-                                $contacttitle = 'addtoyourcontacts';
-                                $contacturlaction = 'addcontact';
-                            }
-                            $contactimage = 'addcontact';
-                        } else {
-                            // If the user is a contact.
-                            $contacttitle = 'removefromyourcontacts';
-                            $contacturlaction = 'removecontact';
-                            $contactimage = 'removecontact';
-                        }
-                        $userbuttons['togglecontact'] = array(
-                                'buttontype' => 'togglecontact',
-                                'title' => get_string($contacttitle, 'message'),
-                                'url' => new moodle_url('/message/index.php', array(
-                                        'user1' => $USER->id,
-                                        'user2' => $user->id,
-                                        $contacturlaction => $user->id,
-                                        'sesskey' => sesskey())
-                                ),
-                                'image' => $contactimage,
-                                'linkattributes' => $linkattributes,
-                                'page' => $this->page
-                            );
-                    }
-                }
-            } else {
-                $heading = null;
-            }
-        }
-
-        // Return the heading wrapped in an sr-only element so it is only visible to screen-readers for nocontextheader layouts.
-        if (!empty($this->page->layout_options['nocontextheader'])) {
-            return html_writer::div($heading, 'sr-only');
-        }
-
-        $contextheader = new context_header($heading, $headinglevel, $imagedata, $userbuttons);
-        return $this->render($contextheader);
-    }
-
-    /**
-     * Renders the skip links for the page.
-     *
-     * @param array $links List of skip links.
-     * @return string HTML for the skip links.
-     */
-    public function render_skip_links($links) {
-        $context = [ 'links' => []];
-
-        foreach ($links as $url => $text) {
-            $context['links'][] = [ 'url' => $url, 'text' => $text];
-        }
-
-        return $this->render_from_template('core/skip_links', $context);
-    }
-
-    /**
-     * Wrapper for header elements.
-     *
-     * @return string HTML to display the main header.
-     */
-    public function full_header() {
-        $pagetype = $this->page->pagetype;
-        $homepage = get_home_page();
-        $homepagetype = null;
-        // Add a special case since /my/courses is a part of the /my subsystem.
-        if ($homepage == HOMEPAGE_MY || $homepage == HOMEPAGE_MYCOURSES) {
-            $homepagetype = 'my-index';
-        } else if ($homepage == HOMEPAGE_SITE) {
-            $homepagetype = 'site-index';
-        }
-        if ($this->page->include_region_main_settings_in_header_actions() &&
-                !$this->page->blocks->is_block_present('settings')) {
-            // Only include the region main settings if the page has requested it and it doesn't already have
-            // the settings block on it. The region main settings are included in the settings block and
-            // duplicating the content causes behat failures.
-            $this->page->add_header_action(html_writer::div(
-                $this->region_main_settings_menu(),
-                'd-print-none',
-                ['id' => 'region-main-settings-menu']
-            ));
-        }
-
-        $header = new stdClass();
-        $header->settingsmenu = $this->context_header_settings_menu();
-        $header->contextheader = $this->context_header();
-        $header->hasnavbar = empty($this->page->layout_options['nonavbar']);
-        $header->navbar = $this->navbar();
-        $header->pageheadingbutton = $this->page_heading_button();
-        $header->courseheader = $this->course_header();
-        $header->headeractions = $this->page->get_header_actions();
-        if (!empty($pagetype) && !empty($homepagetype) && $pagetype == $homepagetype) {
-            $header->welcomemessage = \core_user::welcome_message();
-        }
-        return $this->render_from_template('core/full_header', $header);
-    }
-
-    /**
-     * This is an optional menu that can be added to a layout by a theme. It contains the
-     * menu for the course administration, only on the course main page.
-     *
-     * @return string
-     */
-    public function context_header_settings_menu() {
-        $context = $this->page->context;
-        $menu = new action_menu();
-
-        $items = $this->page->navbar->get_items();
-        $currentnode = end($items);
-
-        $showcoursemenu = false;
-        $showfrontpagemenu = false;
-        $showusermenu = false;
-
-        // We are on the course home page.
-        if (($context->contextlevel == CONTEXT_COURSE) &&
-                !empty($currentnode) &&
-                ($currentnode->type == navigation_node::TYPE_COURSE || $currentnode->type == navigation_node::TYPE_SECTION)) {
-            $showcoursemenu = true;
-        }
-
-        $courseformat = course_get_format($this->page->course);
-        // This is a single activity course format, always show the course menu on the activity main page.
-        if ($context->contextlevel == CONTEXT_MODULE &&
-                !$courseformat->has_view_page()) {
-
-            $this->page->navigation->initialise();
-            $activenode = $this->page->navigation->find_active_node();
-            // If the settings menu has been forced then show the menu.
-            if ($this->page->is_settings_menu_forced()) {
-                $showcoursemenu = true;
-            } else if (!empty($activenode) && ($activenode->type == navigation_node::TYPE_ACTIVITY ||
-                            $activenode->type == navigation_node::TYPE_RESOURCE)) {
-
-                // We only want to show the menu on the first page of the activity. This means
-                // the breadcrumb has no additional nodes.
-                if ($currentnode && ($currentnode->key == $activenode->key && $currentnode->type == $activenode->type)) {
-                    $showcoursemenu = true;
-                }
-            }
-        }
-
-        // This is the site front page.
-        if ($context->contextlevel == CONTEXT_COURSE &&
-                !empty($currentnode) &&
-                $currentnode->key === 'home') {
-            $showfrontpagemenu = true;
-        }
-
-        // This is the user profile page.
-        if ($context->contextlevel == CONTEXT_USER &&
-                !empty($currentnode) &&
-                ($currentnode->key === 'myprofile')) {
-            $showusermenu = true;
-        }
-
-        if ($showfrontpagemenu) {
-            $settingsnode = $this->page->settingsnav->find('frontpage', navigation_node::TYPE_SETTING);
-            if ($settingsnode) {
-                // Build an action menu based on the visible nodes from this navigation tree.
-                $skipped = $this->build_action_menu_from_navigation($menu, $settingsnode, false, true);
-
-                // We only add a list to the full settings menu if we didn't include every node in the short menu.
-                if ($skipped) {
-                    $text = get_string('morenavigationlinks');
-                    $url = new moodle_url('/course/admin.php', array('courseid' => $this->page->course->id));
-                    $link = new action_link($url, $text, null, null, new pix_icon('t/edit', $text));
-                    $menu->add_secondary_action($link);
-                }
-            }
-        } else if ($showcoursemenu) {
-            $settingsnode = $this->page->settingsnav->find('courseadmin', navigation_node::TYPE_COURSE);
-            if ($settingsnode) {
-                // Build an action menu based on the visible nodes from this navigation tree.
-                $skipped = $this->build_action_menu_from_navigation($menu, $settingsnode, false, true);
-
-                // We only add a list to the full settings menu if we didn't include every node in the short menu.
-                if ($skipped) {
-                    $text = get_string('morenavigationlinks');
-                    $url = new moodle_url('/course/admin.php', array('courseid' => $this->page->course->id));
-                    $link = new action_link($url, $text, null, null, new pix_icon('t/edit', $text));
-                    $menu->add_secondary_action($link);
-                }
-            }
-        } else if ($showusermenu) {
-            // Get the course admin node from the settings navigation.
-            $settingsnode = $this->page->settingsnav->find('useraccount', navigation_node::TYPE_CONTAINER);
-            if ($settingsnode) {
-                // Build an action menu based on the visible nodes from this navigation tree.
-                $this->build_action_menu_from_navigation($menu, $settingsnode);
-            }
-        }
-
-        return $this->render($menu);
-    }
-
-    /**
-     * Take a node in the nav tree and make an action menu out of it.
-     * The links are injected in the action menu.
-     *
-     * @param action_menu $menu
-     * @param navigation_node $node
-     * @param boolean $indent
-     * @param boolean $onlytopleafnodes
-     * @return boolean nodesskipped - True if nodes were skipped in building the menu
-     */
-    protected function build_action_menu_from_navigation(action_menu $menu,
-            navigation_node $node,
-            $indent = false,
-            $onlytopleafnodes = false) {
-        $skipped = false;
-        // Build an action menu based on the visible nodes from this navigation tree.
-        foreach ($node->children as $menuitem) {
-            if ($menuitem->display) {
-                if ($onlytopleafnodes && $menuitem->children->count()) {
-                    $skipped = true;
-                    continue;
-                }
-                if ($menuitem->action) {
-                    if ($menuitem->action instanceof action_link) {
-                        $link = $menuitem->action;
-                        // Give preference to setting icon over action icon.
-                        if (!empty($menuitem->icon)) {
-                            $link->icon = $menuitem->icon;
-                        }
-                    } else {
-                        $link = new action_link($menuitem->action, $menuitem->text, null, null, $menuitem->icon);
-                    }
-                } else {
-                    if ($onlytopleafnodes) {
-                        $skipped = true;
-                        continue;
-                    }
-                    $link = new action_link(new moodle_url('#'), $menuitem->text, null, ['disabled' => true], $menuitem->icon);
-                }
-                if ($indent) {
-                    $link->add_class('ml-4');
-                }
-                if (!empty($menuitem->classes)) {
-                    $link->add_class(implode(" ", $menuitem->classes));
-                }
-
-                $menu->add_secondary_action($link);
-                $skipped = $skipped || $this->build_action_menu_from_navigation($menu, $menuitem, true);
-            }
-        }
-        return $skipped;
-    }
-
-    /**
-     * This is an optional menu that can be added to a layout by a theme. It contains the
-     * menu for the most specific thing from the settings block. E.g. Module administration.
-     *
-     * @return string
-     */
-    public function region_main_settings_menu() {
-        $context = $this->page->context;
-        $menu = new action_menu();
-
-        if ($context->contextlevel == CONTEXT_MODULE) {
-
-            $this->page->navigation->initialise();
-            $node = $this->page->navigation->find_active_node();
-            $buildmenu = false;
-            // If the settings menu has been forced then show the menu.
-            if ($this->page->is_settings_menu_forced()) {
-                $buildmenu = true;
-            } else if (!empty($node) && ($node->type == navigation_node::TYPE_ACTIVITY ||
-                            $node->type == navigation_node::TYPE_RESOURCE)) {
-
-                $items = $this->page->navbar->get_items();
-                $navbarnode = end($items);
-                // We only want to show the menu on the first page of the activity. This means
-                // the breadcrumb has no additional nodes.
-                if ($navbarnode && ($navbarnode->key === $node->key && $navbarnode->type == $node->type)) {
-                    $buildmenu = true;
-                }
-            }
-            if ($buildmenu) {
-                // Get the course admin node from the settings navigation.
-                $node = $this->page->settingsnav->find('modulesettings', navigation_node::TYPE_SETTING);
-                if ($node) {
-                    // Build an action menu based on the visible nodes from this navigation tree.
-                    $this->build_action_menu_from_navigation($menu, $node);
-                }
-            }
-
-        } else if ($context->contextlevel == CONTEXT_COURSECAT) {
-            // For course category context, show category settings menu, if we're on the course category page.
-            if ($this->page->pagetype === 'course-index-category') {
-                $node = $this->page->settingsnav->find('categorysettings', navigation_node::TYPE_CONTAINER);
-                if ($node) {
-                    // Build an action menu based on the visible nodes from this navigation tree.
-                    $this->build_action_menu_from_navigation($menu, $node);
-                }
-            }
-
-        } else {
-            $items = $this->page->navbar->get_items();
-            $navbarnode = end($items);
-
-            if ($navbarnode && ($navbarnode->key === 'participants')) {
-                $node = $this->page->settingsnav->find('users', navigation_node::TYPE_CONTAINER);
-                if ($node) {
-                    // Build an action menu based on the visible nodes from this navigation tree.
-                    $this->build_action_menu_from_navigation($menu, $node);
-                }
-
-            }
-        }
-        return $this->render($menu);
-    }
-
-    /**
-     * Displays the list of tags associated with an entry
-     *
-     * @param array $tags list of instances of core_tag or stdClass
-     * @param string $label label to display in front, by default 'Tags' (get_string('tags')), set to null
-     *               to use default, set to '' (empty string) to omit the label completely
-     * @param string $classes additional classes for the enclosing div element
-     * @param int $limit limit the number of tags to display, if size of $tags is more than this limit the "more" link
-     *               will be appended to the end, JS will toggle the rest of the tags
-     * @param context $pagecontext specify if needed to overwrite the current page context for the view tag link
-     * @param bool $accesshidelabel if true, the label should have class="accesshide" added.
-     * @return string
-     */
-    public function tag_list($tags, $label = null, $classes = '', $limit = 10,
-            $pagecontext = null, $accesshidelabel = false) {
-        $list = new \core_tag\output\taglist($tags, $label, $classes, $limit, $pagecontext, $accesshidelabel);
-        return $this->render_from_template('core_tag/taglist', $list->export_for_template($this));
-    }
-
-    /**
-     * Renders element for inline editing of any value
-     *
-     * @param \core\output\inplace_editable $element
-     * @return string
-     */
-    public function render_inplace_editable(\core\output\inplace_editable $element) {
-        return $this->render_from_template('core/inplace_editable', $element->export_for_template($this));
-    }
-
-    /**
-     * Renders a bar chart.
-     *
-     * @param \core\chart_bar $chart The chart.
-     * @return string
-     */
-    public function render_chart_bar(\core\chart_bar $chart) {
-        return $this->render_chart($chart);
-    }
-
-    /**
-     * Renders a line chart.
-     *
-     * @param \core\chart_line $chart The chart.
-     * @return string
-     */
-    public function render_chart_line(\core\chart_line $chart) {
-        return $this->render_chart($chart);
-    }
-
-    /**
-     * Renders a pie chart.
-     *
-     * @param \core\chart_pie $chart The chart.
-     * @return string
-     */
-    public function render_chart_pie(\core\chart_pie $chart) {
-        return $this->render_chart($chart);
-    }
-
-    /**
-     * Renders a chart.
-     *
-     * @param \core\chart_base $chart The chart.
-     * @param bool $withtable Whether to include a data table with the chart.
-     * @return string
-     */
-    public function render_chart(\core\chart_base $chart, $withtable = true) {
-        $chartdata = json_encode($chart);
-        return $this->render_from_template('core/chart', (object) [
-            'chartdata' => $chartdata,
-            'withtable' => $withtable
-        ]);
-    }
-
-    /**
-     * Renders the login form.
-     *
-     * @param \core_auth\output\login $form The renderable.
-     * @return string
-     */
-    public function render_login(\core_auth\output\login $form) {
-        global $CFG, $SITE;
-
-        $context = $form->export_for_template($this);
-
-        $context->errorformatted = $this->error_text($context->error);
-        $url = $this->get_logo_url();
-        if ($url) {
-            $url = $url->out(false);
-        }
-        $context->logourl = $url;
-        $context->sitename = format_string($SITE->fullname, true,
-                ['context' => context_course::instance(SITEID), "escape" => false]);
-
-        return $this->render_from_template('core/loginform', $context);
-    }
-
-    /**
-     * Renders an mform element from a template.
-     *
-     * @param HTML_QuickForm_element $element element
-     * @param bool $required if input is required field
-     * @param bool $advanced if input is an advanced field
-     * @param string $error error message to display
-     * @param bool $ingroup True if this element is rendered as part of a group
-     * @return mixed string|bool
-     */
-    public function mform_element($element, $required, $advanced, $error, $ingroup) {
-        $templatename = 'core_form/element-' . $element->getType();
-        if ($ingroup) {
-            $templatename .= "-inline";
-        }
-        try {
-            // We call this to generate a file not found exception if there is no template.
-            // We don't want to call export_for_template if there is no template.
-            core\output\mustache_template_finder::get_template_filepath($templatename);
-
-            if ($element instanceof templatable) {
-                $elementcontext = $element->export_for_template($this);
-
-                $helpbutton = '';
-                if (method_exists($element, 'getHelpButton')) {
-                    $helpbutton = $element->getHelpButton();
-                }
-                $label = $element->getLabel();
-                $text = '';
-                if (method_exists($element, 'getText')) {
-                    // There currently exists code that adds a form element with an empty label.
-                    // If this is the case then set the label to the description.
-                    if (empty($label)) {
-                        $label = $element->getText();
-                    } else {
-                        $text = $element->getText();
-                    }
-                }
-
-                // Generate the form element wrapper ids and names to pass to the template.
-                // This differs between group and non-group elements.
-                if ($element->getType() === 'group') {
-                    // Group element.
-                    // The id will be something like 'fgroup_id_NAME'. E.g. fgroup_id_mygroup.
-                    $elementcontext['wrapperid'] = $elementcontext['id'];
-
-                    // Ensure group elements pass through the group name as the element name.
-                    $elementcontext['name'] = $elementcontext['groupname'];
-                } else {
-                    // Non grouped element.
-                    // Creates an id like 'fitem_id_NAME'. E.g. fitem_id_mytextelement.
-                    $elementcontext['wrapperid'] = 'fitem_' . $elementcontext['id'];
-                }
-
-                $context = array(
-                    'element' => $elementcontext,
-                    'label' => $label,
-                    'text' => $text,
-                    'required' => $required,
-                    'advanced' => $advanced,
-                    'helpbutton' => $helpbutton,
-                    'error' => $error
-                );
-                return $this->render_from_template($templatename, $context);
-            }
-        } catch (Exception $e) {
-            // No template for this element.
-            return false;
-        }
-    }
-
-    /**
-     * Render the login signup form into a nice template for the theme.
-     *
-     * @param moodleform $form
-     * @return string
-     */
-    public function render_login_signup_form($form) {
-        global $SITE;
-
-        $context = $form->export_for_template($this);
-        $url = $this->get_logo_url();
-        if ($url) {
-            $url = $url->out(false);
-        }
-        $context['logourl'] = $url;
-        $context['sitename'] = format_string($SITE->fullname, true,
-                ['context' => context_course::instance(SITEID), "escape" => false]);
-
-        return $this->render_from_template('core/signup_form_layout', $context);
-    }
-
-    /**
-     * Render the verify age and location page into a nice template for the theme.
-     *
-     * @param \core_auth\output\verify_age_location_page $page The renderable
-     * @return string
-     */
-    protected function render_verify_age_location_page($page) {
-        $context = $page->export_for_template($this);
-
-        return $this->render_from_template('core/auth_verify_age_location_page', $context);
-    }
-
-    /**
-     * Render the digital minor contact information page into a nice template for the theme.
-     *
-     * @param \core_auth\output\digital_minor_page $page The renderable
-     * @return string
-     */
-    protected function render_digital_minor_page($page) {
-        $context = $page->export_for_template($this);
-
-        return $this->render_from_template('core/auth_digital_minor_page', $context);
-    }
-
-    /**
-     * Renders a progress bar.
-     *
-     * Do not use $OUTPUT->render($bar), instead use progress_bar::create().
-     *
-     * @param  progress_bar $bar The bar.
-     * @return string HTML fragment
-     */
-    public function render_progress_bar(progress_bar $bar) {
-        $data = $bar->export_for_template($this);
-        return $this->render_from_template('core/progress_bar', $data);
-    }
-
-    /**
-     * Renders an update to a progress bar.
-     *
-     * Note: This does not cleanly map to a renderable class and should
-     * never be used directly.
-     *
-     * @param  string $id
-     * @param  float $percent
-     * @param  string $msg Message
-     * @param  string $estimate time remaining message
-     * @return string ascii fragment
-     */
-    public function render_progress_bar_update(string $id, float $percent, string $msg, string $estimate): string {
-        return html_writer::script(js_writer::function_call('updateProgressBar', [
-            $id,
-            round($percent, 1),
-            $msg,
-            $estimate,
-        ]));
-    }
-
-    /**
-     * Renders element for a toggle-all checkbox.
-     *
-     * @param \core\output\checkbox_toggleall $element
-     * @return string
-     */
-    public function render_checkbox_toggleall(\core\output\checkbox_toggleall $element) {
-        return $this->render_from_template($element->get_template(), $element->export_for_template($this));
-    }
-
-    /**
-     * Renders the tertiary nav for the participants page
-     *
-     * @param object $course The course we are operating within
-     * @param string|null $renderedbuttons Any additional buttons/content to be displayed in line with the nav
-     * @return string
-     */
-    public function render_participants_tertiary_nav(object $course, ?string $renderedbuttons = null) {
-        $actionbar = new \core\output\participants_action_bar($course, $this->page, $renderedbuttons);
-        $content = $this->render_from_template('core_course/participants_actionbar', $actionbar->export_for_template($this));
-        return $content ?: "";
-    }
-
-    /**
-     * Renders release information in the footer popup
-     * @return ?string Moodle release info.
-     */
-    public function moodle_release() {
-        global $CFG;
-        if (!during_initial_install() && is_siteadmin()) {
-            return $CFG->release;
-        }
-    }
-
-    /**
-     * Generate the add block button when editing mode is turned on and the user can edit blocks.
-     *
-     * @param string $region where new blocks should be added.
-     * @return string html for the add block button.
-     */
-    public function addblockbutton($region = ''): string {
-        $addblockbutton = '';
-        $regions = $this->page->blocks->get_regions();
-        if (count($regions) == 0) {
-            return '';
-        }
-        if (isset($this->page->theme->addblockposition) &&
-                $this->page->user_is_editing() &&
-                $this->page->user_can_edit_blocks() &&
-                $this->page->pagelayout !== 'mycourses'
-        ) {
-            $params = ['bui_addblock' => '', 'sesskey' => sesskey()];
-            if (!empty($region)) {
-                $params['bui_blockregion'] = $region;
-            }
-            $url = new moodle_url($this->page->url, $params);
-            $addblockbutton = $this->render_from_template('core/add_block_button',
-                [
-                    'link' => $url->out(false),
-                    'escapedlink' => "?{$url->get_query_string(false)}",
-                    'pagehash' => $this->page->get_edited_page_hash(),
-                    'blockregion' => $region,
-                    // The following parameters are not used since Moodle 4.2 but are
-                    // still passed for backward-compatibility.
-                    'pageType' => $this->page->pagetype,
-                    'pageLayout' => $this->page->pagelayout,
-                    'subPage' => $this->page->subpage,
-                ]
-            );
-        }
-        return $addblockbutton;
-    }
-
-    /**
-     * Prepares an element for streaming output
-     *
-     * This must be used with NO_OUTPUT_BUFFERING set to true. After using this method
-     * any subsequent prints or echos to STDOUT result in the outputted content magically
-     * being appended inside that element rather than where the current html would be
-     * normally. This enables pages which take some time to render incremental content to
-     * first output a fully formed html page, including the footer, and to then stream
-     * into an element such as the main content div. This fixes a class of page layout
-     * bugs and reduces layout shift issues and was inspired by Facebook BigPipe.
-     *
-     * Some use cases such as a simple page which loads content via ajax could be swapped
-     * to this method wich saves another http request and its network latency resulting
-     * in both lower server load and better front end performance.
-     *
-     * You should consider giving the element you stream into a minimum height to further
-     * reduce layout shift as the content initally streams into the element.
-     *
-     * You can safely finish the output without closing the streamed element. You can also
-     * call this method again to swap the target of the streaming to a new element as
-     * often as you want.
-
-     * https://www.youtube.com/watch?v=LLRig4s1_yA&t=1022s
-     * Watch this video segment to explain how and why this 'One Weird Trick' works.
-     *
-     * @param string $selector where new content should be appended
-     * @param string $element which contains the streamed content
-     * @return string html to be written
-     */
-    public function select_element_for_append(string $selector = '#region-main [role=main]', string $element = 'div') {
-
-        if (!CLI_SCRIPT && !NO_OUTPUT_BUFFERING) {
-            throw new coding_exception('select_element_for_append used in a non-CLI script without setting NO_OUTPUT_BUFFERING.',
-                DEBUG_DEVELOPER);
-        }
-
-        // We are already streaming into this element so don't change anything.
-        if ($this->currentselector === $selector && $this->currentelement === $element) {
-            return;
-        }
-
-        // If we have a streaming element close it before starting a new one.
-        $html = $this->close_element_for_append();
-
-        $this->currentselector = $selector;
-        $this->currentelement = $element;
-
-        // Create an unclosed element for the streamed content to append into.
-        $id = uniqid();
-        $html .= html_writer::start_tag($element, ['id' => $id]);
-        $html .= html_writer::tag('script', "document.querySelector('$selector').append(document.getElementById('$id'))");
-        $html .= "\n";
-        return $html;
-    }
-
-    /**
-     * This closes any opened stream elements
-     *
-     * @return string html to be written
-     */
-    public function close_element_for_append() {
-        $html = '';
-        if ($this->currentselector !== '') {
-            $html .= html_writer::end_tag($this->currentelement);
-            $html .= "\n";
-            $this->currentelement = '';
-        }
-        return $html;
-    }
-
-    /**
-     * A companion method to select_element_for_append
-     *
-     * This must be used with NO_OUTPUT_BUFFERING set to true.
-     *
-     * This is similar but instead of appending into the element it replaces
-     * the content in the element. Depending on the 3rd argument it can replace
-     * the innerHTML or the outerHTML which can be useful to completely remove
-     * the element if needed.
-     *
-     * @param string $selector where new content should be replaced
-     * @param string $html A chunk of well formed html
-     * @param bool $outer Wether it replaces the innerHTML or the outerHTML
-     * @return string html to be written
-     */
-    public function select_element_for_replace(string $selector, string $html, bool $outer = false) {
-
-        if (!CLI_SCRIPT && !NO_OUTPUT_BUFFERING) {
-            throw new coding_exception('select_element_for_replace used in a non-CLI script without setting NO_OUTPUT_BUFFERING.',
-                DEBUG_DEVELOPER);
-        }
-
-        // Escape html for use inside a javascript string.
-        $html = addslashes_js($html);
-        $property = $outer ? 'outerHTML' : 'innerHTML';
-        $output = html_writer::tag('script', "document.querySelector('$selector').$property = '$html';");
-        $output .= "\n";
-        return $output;
-    }
-}
-
-/**
- * A renderer that generates output for command-line scripts.
- *
- * The implementation of this renderer is probably incomplete.
- *
- * @copyright 2009 Tim Hunt
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class core_renderer_cli extends core_renderer {
-
-    /**
-     * @var array $progressmaximums stores the largest percentage for a progress bar.
-     * @return string ascii fragment
-     */
-    private $progressmaximums = [];
-
-    /**
-     * Returns the page header.
-     *
-     * @return string HTML fragment
-     */
-    public function header() {
-        return $this->page->heading . "\n";
-    }
-
-    /**
-     * Renders a Check API result
-     *
-     * To aid in CLI consistency this status is NOT translated and the visual
-     * width is always exactly 10 chars.
-     *
-     * @param core\check\result $result
-     * @return string HTML fragment
-     */
-    protected function render_check_result(core\check\result $result) {
-        $status = $result->get_status();
-
-        $labels = [
-            core\check\result::NA        => '      ' . cli_ansi_format('<colour:darkGray>' ) . ' NA ',
-            core\check\result::OK        => '      ' . cli_ansi_format('<colour:green>') . ' OK ',
-            core\check\result::INFO      => '    '   . cli_ansi_format('<colour:blue>' ) . ' INFO ',
-            core\check\result::UNKNOWN   => ' '      . cli_ansi_format('<colour:darkGray>' ) . ' UNKNOWN ',
-            core\check\result::WARNING   => ' '      . cli_ansi_format('<colour:black><bgcolour:yellow>') . ' WARNING ',
-            core\check\result::ERROR     => '   '    . cli_ansi_format('<bgcolour:red>') . ' ERROR ',
-            core\check\result::CRITICAL  => ''       . cli_ansi_format('<bgcolour:red>') . ' CRITICAL ',
-        ];
-        $string = $labels[$status] . cli_ansi_format('<colour:normal>');
-        return $string;
-    }
-
-    /**
-     * Renders a Check API result
-     *
-     * @param core\check\result $result
-     * @return string fragment
-     */
-    public function check_result(core\check\result $result) {
-        return $this->render_check_result($result);
-    }
-
-    /**
-     * Renders a progress bar.
-     *
-     * Do not use $OUTPUT->render($bar), instead use progress_bar::create().
-     *
-     * @param  progress_bar $bar The bar.
-     * @return string ascii fragment
-     */
-    public function render_progress_bar(progress_bar $bar) {
-        global $CFG;
-
-        $size = 55; // The width of the progress bar in chars.
-        $ascii = "\n";
-
-        if (stream_isatty(STDOUT)) {
-            require_once($CFG->libdir.'/clilib.php');
-
-            $ascii .= "[" . str_repeat(' ', $size) . "] 0% \n";
-            return cli_ansi_format($ascii);
-        }
-
-        $this->progressmaximums[$bar->get_id()] = 0;
-        $ascii .= '[';
-        return $ascii;
-    }
-
-    /**
-     * Renders an update to a progress bar.
-     *
-     * Note: This does not cleanly map to a renderable class and should
-     * never be used directly.
-     *
-     * @param  string $id
-     * @param  float $percent
-     * @param  string $msg Message
-     * @param  string $estimate time remaining message
-     * @return string ascii fragment
-     */
-    public function render_progress_bar_update(string $id, float $percent, string $msg, string $estimate): string {
-        $size = 55; // The width of the progress bar in chars.
-        $ascii = '';
-
-        // If we are rendering to a terminal then we can safely use ansii codes
-        // to move the cursor and redraw the complete progress bar each time
-        // it is updated.
-        if (stream_isatty(STDOUT)) {
-            $colour = $percent == 100 ? 'green' : 'blue';
-
-            $done = $percent * $size * 0.01;
-            $whole = floor($done);
-            $bar = "<colour:$colour>";
-            $bar .= str_repeat('█', $whole);
-
-            if ($whole < $size) {
-                // By using unicode chars for partial blocks we can have higher
-                // precision progress bar.
-                $fraction = floor(($done - $whole) * 8);
-                $bar .= core_text::substr(' ▏▎▍▌▋▊▉', $fraction, 1);
-
-                // Fill the rest of the empty bar.
-                $bar .= str_repeat(' ', $size - $whole - 1);
-            }
-
-            $bar .= '<colour:normal>';
-
-            if ($estimate) {
-                $estimate = "- $estimate";
-            }
-
-            $ascii .= '<cursor:up>';
-            $ascii .= '<cursor:up>';
-            $ascii .= sprintf("[$bar] %3.1f%% %-22s\n", $percent, $estimate);
-            $ascii .= sprintf("%-80s\n", $msg);
-            return cli_ansi_format($ascii);
-        }
-
-        // If we are not rendering to a tty, ie when piped to another command
-        // or on windows we need to progressively render the progress bar
-        // which can only ever go forwards.
-        $done = round($percent * $size * 0.01);
-        $delta = max(0, $done - $this->progressmaximums[$id]);
-
-        $ascii .= str_repeat('#', $delta);
-        if ($percent >= 100 && $delta > 0) {
-            $ascii .= sprintf("] %3.1f%%", $percent) . "\n$msg\n";
-        }
-        $this->progressmaximums[$id] += $delta;
-        return $ascii;
-    }
-
-    /**
-     * Returns a template fragment representing a Heading.
-     *
-     * @param string $text The text of the heading
-     * @param int $level The level of importance of the heading
-     * @param string $classes A space-separated list of CSS classes
-     * @param string $id An optional ID
-     * @return string A template fragment for a heading
-     */
-    public function heading($text, $level = 2, $classes = 'main', $id = null) {
-        $text .= "\n";
-        switch ($level) {
-            case 1:
-                return '=>' . $text;
-            case 2:
-                return '-->' . $text;
-            default:
-                return $text;
-        }
-    }
-
-    /**
-     * Returns a template fragment representing a fatal error.
-     *
-     * @param string $message The message to output
-     * @param string $moreinfourl URL where more info can be found about the error
-     * @param string $link Link for the Continue button
-     * @param array $backtrace The execution backtrace
-     * @param string $debuginfo Debugging information
-     * @return string A template fragment for a fatal error
-     */
-    public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null, $errorcode = "") {
-        global $CFG;
-
-        $output = "!!! $message !!!\n";
-
-        if ($CFG->debugdeveloper) {
-            if (!empty($debuginfo)) {
-                $output .= $this->notification($debuginfo, 'notifytiny');
-            }
-            if (!empty($backtrace)) {
-                $output .= $this->notification('Stack trace: ' . format_backtrace($backtrace, true), 'notifytiny');
-            }
-        }
-
-        return $output;
-    }
-
-    /**
-     * Returns a template fragment representing a notification.
-     *
-     * @param string $message The message to print out.
-     * @param string $type    The type of notification. See constants on \core\output\notification.
-     * @param bool $closebutton Whether to show a close icon to remove the notification (default true).
-     * @return string A template fragment for a notification
-     */
-    public function notification($message, $type = null, $closebutton = true) {
-        $message = clean_text($message);
-        if ($type === 'notifysuccess' || $type === 'success') {
-            return "++ $message ++\n";
-        }
-        return "!! $message !!\n";
-    }
-
-    /**
-     * There is no footer for a cli request, however we must override the
-     * footer method to prevent the default footer.
-     */
-    public function footer() {}
-
-    /**
-     * Render a notification (that is, a status message about something that has
-     * just happened).
-     *
-     * @param \core\output\notification $notification the notification to print out
-     * @return string plain text output
-     */
-    public function render_notification(\core\output\notification $notification) {
-        return $this->notification($notification->get_message(), $notification->get_message_type());
-    }
-}
-
-
-/**
- * A renderer that generates output for ajax scripts.
- *
- * This renderer prevents accidental sends back only json
- * encoded error messages, all other output is ignored.
- *
- * @copyright 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class core_renderer_ajax extends core_renderer {
-
-    /**
-     * Returns a template fragment representing a fatal error.
-     *
-     * @param string $message The message to output
-     * @param string $moreinfourl URL where more info can be found about the error
-     * @param string $link Link for the Continue button
-     * @param array $backtrace The execution backtrace
-     * @param string $debuginfo Debugging information
-     * @return string A template fragment for a fatal error
-     */
-    public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null, $errorcode = "") {
-        global $CFG;
-
-        $this->page->set_context(null); // ugly hack - make sure page context is set to something, we do not want bogus warnings here
-
-        $e = new stdClass();
-        $e->error      = $message;
-        $e->errorcode  = $errorcode;
-        $e->stacktrace = NULL;
-        $e->debuginfo  = NULL;
-        $e->reproductionlink = NULL;
-        if (!empty($CFG->debug) and $CFG->debug >= DEBUG_DEVELOPER) {
-            $link = (string) $link;
-            if ($link) {
-                $e->reproductionlink = $link;
-            }
-            if (!empty($debuginfo)) {
-                $e->debuginfo = $debuginfo;
-            }
-            if (!empty($backtrace)) {
-                $e->stacktrace = format_backtrace($backtrace, true);
-            }
-        }
-        $this->header();
-        return json_encode($e);
-    }
-
-    /**
-     * Used to display a notification.
-     * For the AJAX notifications are discarded.
-     *
-     * @param string $message The message to print out.
-     * @param string $type    The type of notification. See constants on \core\output\notification.
-     * @param bool $closebutton Whether to show a close icon to remove the notification (default true).
-     */
-    public function notification($message, $type = null, $closebutton = true) {
-    }
-
-    /**
-     * Used to display a redirection message.
-     * AJAX redirections should not occur and as such redirection messages
-     * are discarded.
-     *
-     * @param moodle_url|string $encodedurl
-     * @param string $message
-     * @param int $delay
-     * @param bool $debugdisableredirect
-     * @param string $messagetype The type of notification to show the message in.
-     *         See constants on \core\output\notification.
-     */
-    public function redirect_message($encodedurl, $message, $delay, $debugdisableredirect,
-                                     $messagetype = \core\output\notification::NOTIFY_INFO) {}
-
-    /**
-     * Prepares the start of an AJAX output.
-     */
-    public function header() {
-        // unfortunately YUI iframe upload does not support application/json
-        if (!empty($_FILES)) {
-            @header('Content-type: text/plain; charset=utf-8');
-            if (!core_useragent::supports_json_contenttype()) {
-                @header('X-Content-Type-Options: nosniff');
-            }
-        } else if (!core_useragent::supports_json_contenttype()) {
-            @header('Content-type: text/plain; charset=utf-8');
-            @header('X-Content-Type-Options: nosniff');
-        } else {
-            @header('Content-type: application/json; charset=utf-8');
-        }
-
-        // Headers to make it not cacheable and json
-        @header('Cache-Control: no-store, no-cache, must-revalidate');
-        @header('Cache-Control: post-check=0, pre-check=0', false);
-        @header('Pragma: no-cache');
-        @header('Expires: Mon, 20 Aug 1969 09:23:00 GMT');
-        @header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
-        @header('Accept-Ranges: none');
-    }
-
-    /**
-     * There is no footer for an AJAX request, however we must override the
-     * footer method to prevent the default footer.
-     */
-    public function footer() {}
-
-    /**
-     * No need for headers in an AJAX request... this should never happen.
-     * @param string $text
-     * @param int $level
-     * @param string $classes
-     * @param string $id
-     */
-    public function heading($text, $level = 2, $classes = 'main', $id = null) {}
-}
-
-
-
-/**
- * The maintenance renderer.
- *
- * The purpose of this renderer is to block out the core renderer methods that are not usable when the site
- * is running a maintenance related task.
- * It must always extend the core_renderer as we switch from the core_renderer to this renderer in a couple of places.
- *
- * @since Moodle 2.6
- * @package core
- * @category output
- * @copyright 2013 Sam Hemelryk
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-class core_renderer_maintenance extends core_renderer {
-
-    /**
-     * Initialises the renderer instance.
-     *
-     * @param moodle_page $page
-     * @param string $target
-     * @throws coding_exception
-     */
-    public function __construct(moodle_page $page, $target) {
-        if ($target !== RENDERER_TARGET_MAINTENANCE || $page->pagelayout !== 'maintenance') {
-            throw new coding_exception('Invalid request for the maintenance renderer.');
-        }
-        parent::__construct($page, $target);
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce blocks.
-     *
-     * @param block_contents $bc
-     * @param string $region
-     * @return string
-     */
-    public function block(block_contents $bc, $region) {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce blocks.
-     *
-     * @param string $region
-     * @param array $classes
-     * @param string $tag
-     * @param boolean $fakeblocksonly
-     * @return string
-     */
-    public function blocks($region, $classes = array(), $tag = 'aside', $fakeblocksonly = false) {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce blocks.
-     *
-     * @param string $region
-     * @param boolean $fakeblocksonly Output fake block only.
-     * @return string
-     */
-    public function blocks_for_region($region, $fakeblocksonly = false) {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce a course content header.
-     *
-     * @param bool $onlyifnotcalledbefore
-     * @return string
-     */
-    public function course_content_header($onlyifnotcalledbefore = false) {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce a course content footer.
-     *
-     * @param bool $onlyifnotcalledbefore
-     * @return string
-     */
-    public function course_content_footer($onlyifnotcalledbefore = false) {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce a course header.
-     *
-     * @return string
-     */
-    public function course_header() {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce a course footer.
-     *
-     * @return string
-     */
-    public function course_footer() {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce a custom menu.
-     *
-     * @param string $custommenuitems
-     * @return string
-     */
-    public function custom_menu($custommenuitems = '') {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce a file picker.
-     *
-     * @param array $options
-     * @return string
-     */
-    public function file_picker($options) {
-        return '';
-    }
-
-    /**
-     * Overridden confirm message for upgrades.
-     *
-     * @param string $message The question to ask the user
-     * @param single_button|moodle_url|string $continue The single_button component representing the Continue answer.
-     * @param single_button|moodle_url|string $cancel The single_button component representing the Cancel answer.
-     * @param array $displayoptions optional extra display options
-     * @return string HTML fragment
-     */
-    public function confirm($message, $continue, $cancel, array $displayoptions = []) {
-        // We need plain styling of confirm boxes on upgrade because we don't know which stylesheet we have (it could be
-        // from any previous version of Moodle).
-        if ($continue instanceof single_button) {
-            $continue->type = single_button::BUTTON_PRIMARY;
-        } else if (is_string($continue)) {
-            $continue = new single_button(new moodle_url($continue), get_string('continue'), 'post',
-                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
-        } else if ($continue instanceof moodle_url) {
-            $continue = new single_button($continue, get_string('continue'), 'post',
-                $displayoptions['type'] ?? single_button::BUTTON_PRIMARY);
-        } else {
-            throw new coding_exception('The continue param to $OUTPUT->confirm() must be either a URL' .
-                                       ' (string/moodle_url) or a single_button instance.');
-        }
-
-        if ($cancel instanceof single_button) {
-            $output = '';
-        } else if (is_string($cancel)) {
-            $cancel = new single_button(new moodle_url($cancel), get_string('cancel'), 'get');
-        } else if ($cancel instanceof moodle_url) {
-            $cancel = new single_button($cancel, get_string('cancel'), 'get');
-        } else {
-            throw new coding_exception('The cancel param to $OUTPUT->confirm() must be either a URL' .
-                                       ' (string/moodle_url) or a single_button instance.');
-        }
-
-        $output = $this->box_start('generalbox', 'notice');
-        $output .= html_writer::tag('h4', get_string('confirm'));
-        $output .= html_writer::tag('p', $message);
-        $output .= html_writer::tag('div', $this->render($cancel) . $this->render($continue), ['class' => 'buttons']);
-        $output .= $this->box_end();
-        return $output;
-    }
-
-    /**
-     * Does nothing. The maintenance renderer does not support JS.
-     *
-     * @param block_contents $bc
-     */
-    public function init_block_hider_js(block_contents $bc) {
-        // Does nothing.
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce language menus.
-     *
-     * @return string
-     */
-    public function lang_menu() {
-        return '';
-    }
-
-    /**
-     * Does nothing. The maintenance renderer has no need for login information.
-     *
-     * @param mixed $withlinks
-     * @return string
-     */
-    public function login_info($withlinks = null) {
-        return '';
-    }
-
-    /**
-     * Secure login info.
-     *
-     * @return string
-     */
-    public function secure_login_info() {
-        return $this->login_info(false);
-    }
-
-    /**
-     * Does nothing. The maintenance renderer cannot produce user pictures.
-     *
-     * @param stdClass $user
-     * @param array $options
-     * @return string
-     */
-    public function user_picture(stdClass $user, array $options = null) {
-        return '';
-    }
-}
+// This file is deprecated, but it should never have been manually included by anything outside of lib/outputlib.php.
+// Throwing an exception here should be fine because removing the manual inclusion should have no impact.
+throw new \core\exception\coding_exception(
+    'This file should not be manually included by any component.',
+);
diff --git a/lib/outputrequirementslib.php b/lib/outputrequirementslib.php
index 6ca4c759613..0fdca282e68 100644
--- a/lib/outputrequirementslib.php
+++ b/lib/outputrequirementslib.php
@@ -14,2184 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Library functions to facilitate the use of JavaScript in Moodle.
- *
- * Note: you can find history of this file in lib/ajax/ajaxlib.php
- *
- * @copyright 2009 Tim Hunt, 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @package core
- * @category output
- */
-
-defined('MOODLE_INTERNAL') || die();
-
-/**
- * This class tracks all the things that are needed by the current page.
- *
- * Normally, the only instance of this  class you will need to work with is the
- * one accessible via $PAGE->requires.
- *
- * Typical usage would be
- * <pre>
- *     $PAGE->requires->js_call_amd('mod_forum/view', 'init');
- * </pre>
- *
- * It also supports obsoleted coding style with/without YUI3 modules.
- * <pre>
- *     $PAGE->requires->js_init_call('M.mod_forum.init_view');
- *     $PAGE->requires->css('/mod/mymod/userstyles.php?id='.$id); // not overridable via themes!
- *     $PAGE->requires->js('/mod/mymod/script.js');
- *     $PAGE->requires->js('/mod/mymod/small_but_urgent.js', true);
- *     $PAGE->requires->js_function_call('init_mymod', array($data), true);
- * </pre>
- *
- * There are some natural restrictions on some methods. For example, {@link css()}
- * can only be called before the <head> tag is output. See the comments on the
- * individual methods for details.
- *
- * @copyright 2009 Tim Hunt, 2010 Petr Skoda
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.0
- * @package core
- * @category output
- */
-class page_requirements_manager {
-
-    /**
-     * @var array List of string available from JS
-     */
-    protected $stringsforjs = array();
-
-    /**
-     * @var array List of get_string $a parameters - used for validation only.
-     */
-    protected $stringsforjs_as = array();
-
-    /**
-     * @var array List of JS variables to be initialised
-     */
-    protected $jsinitvariables = array('head'=>array(), 'footer'=>array());
-
-    /**
-     * @var array Included JS scripts
-     */
-    protected $jsincludes = array('head'=>array(), 'footer'=>array());
-
-    /**
-     * @var array Inline scripts using RequireJS module loading.
-     */
-    protected $amdjscode = array('');
-
-    /**
-     * @var array List of needed function calls
-     */
-    protected $jscalls = array('normal'=>array(), 'ondomready'=>array());
-
-    /**
-     * @var array List of skip links, those are needed for accessibility reasons
-     */
-    protected $skiplinks = array();
-
-    /**
-     * @var array Javascript code used for initialisation of page, it should
-     * be relatively small
-     */
-    protected $jsinitcode = array();
-
-    /**
-     * @var array of moodle_url Theme sheets, initialised only from core_renderer
-     */
-    protected $cssthemeurls = array();
-
-    /**
-     * @var array of moodle_url List of custom theme sheets, these are strongly discouraged!
-     * Useful mostly only for CSS submitted by teachers that is not part of the theme.
-     */
-    protected $cssurls = array();
-
-    /**
-     * @var array List of requested event handlers
-     */
-    protected $eventhandlers = array();
-
-    /**
-     * @var array Extra modules
-     */
-    protected $extramodules = array();
-
-    /**
-     * @var array trackes the names of bits of HTML that are only required once
-     * per page. See {@link has_one_time_item_been_created()},
-     * {@link set_one_time_item_created()} and {@link should_create_one_time_item_now()}.
-     */
-    protected $onetimeitemsoutput = array();
-
-    /**
-     * @var bool Flag indicated head stuff already printed
-     */
-    protected $headdone = false;
-
-    /**
-     * @var bool Flag indicating top of body already printed
-     */
-    protected $topofbodydone = false;
-
-    /**
-     * @var stdClass YUI PHPLoader instance responsible for YUI3 loading from PHP only
-     */
-    protected $yui3loader;
-
-    /**
-     * @var YUI_config default YUI loader configuration
-     */
-    protected $YUI_config;
-
-    /**
-     * @var array $yuicssmodules
-     */
-    protected $yuicssmodules = array();
-
-    /**
-     * @var array Some config vars exposed in JS, please no secret stuff there
-     */
-    protected $M_cfg;
-
-    /**
-     * @var array list of requested jQuery plugins
-     */
-    protected $jqueryplugins = array();
-
-    /**
-     * @var array list of jQuery plugin overrides
-     */
-    protected $jquerypluginoverrides = array();
-
-    /**
-     * Page requirements constructor.
-     */
-    public function __construct() {
-        global $CFG;
-
-        // You may need to set up URL rewrite rule because oversized URLs might not be allowed by web server.
-        $sep = empty($CFG->yuislasharguments) ? '?' : '/';
-
-        $this->yui3loader = new stdClass();
-        $this->YUI_config = new YUI_config();
-
-        // Set up some loader options.
-        $this->yui3loader->local_base = $CFG->wwwroot . '/lib/yuilib/'. $CFG->yui3version . '/';
-        $this->yui3loader->local_comboBase = $CFG->wwwroot . '/theme/yui_combo.php'.$sep;
-
-        $this->yui3loader->base = $this->yui3loader->local_base;
-        $this->yui3loader->comboBase = $this->yui3loader->local_comboBase;
-
-        // Enable combo loader? This significantly helps with caching and performance!
-        $this->yui3loader->combine = !empty($CFG->yuicomboloading);
-
-        $jsrev = $this->get_jsrev();
-
-        // Set up JS YUI loader helper object.
-        $this->YUI_config->base         = $this->yui3loader->base;
-        $this->YUI_config->comboBase    = $this->yui3loader->comboBase;
-        $this->YUI_config->combine      = $this->yui3loader->combine;
-
-        // If we've had to patch any YUI modules between releases, we must override the YUI configuration to include them.
-        if (!empty($CFG->yuipatchedmodules) && !empty($CFG->yuipatchlevel)) {
-            $this->YUI_config->define_patched_core_modules($this->yui3loader->local_comboBase,
-                    $CFG->yui3version,
-                    $CFG->yuipatchlevel,
-                    $CFG->yuipatchedmodules);
-        }
-
-        $configname = $this->YUI_config->set_config_source('lib/yui/config/yui2.js');
-        $this->YUI_config->add_group('yui2', array(
-            // Loader configuration for our 2in3.
-            'base' => $CFG->wwwroot . '/lib/yuilib/2in3/' . $CFG->yui2version . '/build/',
-            'comboBase' => $CFG->wwwroot . '/theme/yui_combo.php'.$sep,
-            'combine' => $this->yui3loader->combine,
-            'ext' => false,
-            'root' => '2in3/' . $CFG->yui2version .'/build/',
-            'patterns' => array(
-                'yui2-' => array(
-                    'group' => 'yui2',
-                    'configFn' => $configname,
-                )
-            )
-        ));
-        $configname = $this->YUI_config->set_config_source('lib/yui/config/moodle.js');
-        $this->YUI_config->add_group('moodle', array(
-            'name' => 'moodle',
-            'base' => $CFG->wwwroot . '/theme/yui_combo.php' . $sep . 'm/' . $jsrev . '/',
-            'combine' => $this->yui3loader->combine,
-            'comboBase' => $CFG->wwwroot . '/theme/yui_combo.php'.$sep,
-            'ext' => false,
-            'root' => 'm/'.$jsrev.'/', // Add the rev to the root path so that we can control caching.
-            'patterns' => array(
-                'moodle-' => array(
-                    'group' => 'moodle',
-                    'configFn' => $configname,
-                )
-            )
-        ));
-
-        $this->YUI_config->add_group('gallery', array(
-            'name' => 'gallery',
-            'base' => $CFG->wwwroot . '/lib/yuilib/gallery/',
-            'combine' => $this->yui3loader->combine,
-            'comboBase' => $CFG->wwwroot . '/theme/yui_combo.php' . $sep,
-            'ext' => false,
-            'root' => 'gallery/' . $jsrev . '/',
-            'patterns' => array(
-                'gallery-' => array(
-                    'group' => 'gallery',
-                )
-            )
-        ));
-
-        // Set some more loader options applying to groups too.
-        if ($CFG->debugdeveloper) {
-            // When debugging is enabled, we want to load the non-minified (RAW) versions of YUI library modules rather
-            // than the DEBUG versions as these generally generate too much logging for our purposes.
-            // However we do want the DEBUG versions of our Moodle-specific modules.
-            // To debug a YUI-specific issue, change the yui3loader->filter value to DEBUG.
-            $this->YUI_config->filter = 'RAW';
-            $this->YUI_config->groups['moodle']['filter'] = 'DEBUG';
-
-            // We use the yui3loader->filter setting when writing the YUI3 seed scripts into the header.
-            $this->yui3loader->filter = $this->YUI_config->filter;
-            $this->YUI_config->debug = true;
-        } else {
-            $this->yui3loader->filter = null;
-            $this->YUI_config->groups['moodle']['filter'] = null;
-            $this->YUI_config->debug = false;
-        }
-
-        // Include the YUI config log filters.
-        if (!empty($CFG->yuilogexclude) && is_array($CFG->yuilogexclude)) {
-            $this->YUI_config->logExclude = $CFG->yuilogexclude;
-        }
-        if (!empty($CFG->yuiloginclude) && is_array($CFG->yuiloginclude)) {
-            $this->YUI_config->logInclude = $CFG->yuiloginclude;
-        }
-        if (!empty($CFG->yuiloglevel)) {
-            $this->YUI_config->logLevel = $CFG->yuiloglevel;
-        }
-
-        // Add the moodle group's module data.
-        $this->YUI_config->add_moodle_metadata();
-
-        // Every page should include definition of following modules.
-        $this->js_module($this->find_module('core_filepicker'));
-        $this->js_module($this->find_module('core_comment'));
-    }
-
-    /**
-     * Return the safe config values that get set for javascript in "M.cfg".
-     *
-     * @since 2.9
-     * @return array List of safe config values that are available to javascript.
-     */
-    public function get_config_for_javascript(moodle_page $page, renderer_base $renderer) {
-        global $CFG;
-
-        if (empty($this->M_cfg)) {
-
-            $iconsystem = \core\output\icon_system::instance();
-
-            // It is possible that the $page->context is null, so we can't use $page->context->id.
-            $contextid = null;
-            $contextinstanceid = null;
-            if (!is_null($page->context)) {
-                $contextid = $page->context->id;
-                $contextinstanceid = $page->context->instanceid;
-                $courseid = $page->course->id;
-                $coursecontext = context_course::instance($courseid);
-            }
-
-            $this->M_cfg = array(
-                'wwwroot'               => $CFG->wwwroot,
-                'homeurl'               => $page->navigation->action,
-                'sesskey'               => sesskey(),
-                'sessiontimeout'        => $CFG->sessiontimeout,
-                'sessiontimeoutwarning' => $CFG->sessiontimeoutwarning,
-                'themerev'              => theme_get_revision(),
-                'slasharguments'        => (int)(!empty($CFG->slasharguments)),
-                'theme'                 => $page->theme->name,
-                'iconsystemmodule'      => $iconsystem->get_amd_name(),
-                'jsrev'                 => $this->get_jsrev(),
-                'admin'                 => $CFG->admin,
-                'svgicons'              => $page->theme->use_svg_icons(),
-                'usertimezone'          => usertimezone(),
-                'language'              => current_language(),
-                'courseId'              => isset($courseid) ? (int) $courseid : 0,
-                'courseContextId'       => isset($coursecontext) ? $coursecontext->id : 0,
-                'contextid'             => $contextid,
-                'contextInstanceId'     => (int) $contextinstanceid,
-                'langrev'               => get_string_manager()->get_revision(),
-                'templaterev'           => $this->get_templaterev(),
-                'siteId'                => (int) SITEID,
-            );
-            if ($CFG->debugdeveloper) {
-                $this->M_cfg['developerdebug'] = true;
-            }
-            if (defined('BEHAT_SITE_RUNNING')) {
-                $this->M_cfg['behatsiterunning'] = true;
-            }
-
-        }
-        return $this->M_cfg;
-    }
-
-    /**
-     * Initialise with the bits of JavaScript that every Moodle page should have.
-     *
-     * @param moodle_page $page
-     * @param core_renderer $renderer
-     */
-    protected function init_requirements_data(moodle_page $page, core_renderer $renderer) {
-        global $CFG;
-
-        // Init the js config.
-        $this->get_config_for_javascript($page, $renderer);
-
-        // Accessibility stuff.
-        $this->skip_link_to('maincontent', get_string('tocontent', 'access'));
-
-        // Add strings used on many pages.
-        $this->string_for_js('confirmation', 'admin');
-        $this->string_for_js('cancel', 'moodle');
-        $this->string_for_js('yes', 'moodle');
-
-        // Alter links in top frame to break out of frames.
-        if ($page->pagelayout === 'frametop') {
-            $this->js_init_call('M.util.init_frametop');
-        }
-
-        // Include block drag/drop if editing is on
-        if ($page->user_is_editing()) {
-            $params = array(
-                'regions' => $page->blocks->get_regions(),
-                'pagehash' => $page->get_edited_page_hash(),
-            );
-            if (!empty($page->cm->id)) {
-                $params['cmid'] = $page->cm->id;
-            }
-            // Strings for drag and drop.
-            $this->strings_for_js(array('movecontent',
-                                        'tocontent',
-                                        'emptydragdropregion'),
-                                  'moodle');
-            $page->requires->yui_module('moodle-core-blocks', 'M.core_blocks.init_dragdrop', array($params), null, true);
-            $page->requires->js_call_amd('core_block/edit', 'init', ['pagehash' => $page->get_edited_page_hash()]);
-        }
-
-        // Include the YUI CSS Modules.
-        $page->requires->set_yuicssmodules($page->theme->yuicssmodules);
-    }
-
-    /**
-     * Determine the correct JS Revision to use for this load.
-     *
-     * @return int the jsrev to use.
-     */
-    public function get_jsrev() {
-        global $CFG;
-
-        if (empty($CFG->cachejs)) {
-            $jsrev = -1;
-        } else if (empty($CFG->jsrev)) {
-            $jsrev = 1;
-        } else {
-            $jsrev = $CFG->jsrev;
-        }
-
-        return $jsrev;
-    }
-
-    /**
-     * Determine the correct Template revision to use for this load.
-     *
-     * @return int the templaterev to use.
-     */
-    protected function get_templaterev() {
-        global $CFG;
-
-        if (empty($CFG->cachetemplates)) {
-            $templaterev = -1;
-        } else if (empty($CFG->templaterev)) {
-            $templaterev = 1;
-        } else {
-            $templaterev = $CFG->templaterev;
-        }
-
-        return $templaterev;
-    }
-
-    /**
-     * Ensure that the specified JavaScript file is linked to from this page.
-     *
-     * NOTE: This function is to be used in RARE CASES ONLY, please store your JS in module.js file
-     * and use $PAGE->requires->js_init_call() instead or use /yui/ subdirectories for YUI modules.
-     *
-     * By default the link is put at the end of the page, since this gives best page-load performance.
-     *
-     * Even if a particular script is requested more than once, it will only be linked
-     * to once.
-     *
-     * @param string|moodle_url $url The path to the .js file, relative to $CFG->dirroot / $CFG->wwwroot.
-     *      For example '/mod/mymod/customscripts.js'; use moodle_url for external scripts
-     * @param bool $inhead initialise in head
-     */
-    public function js($url, $inhead = false) {
-        if ($url == '/question/qengine.js') {
-            debugging('The question/qengine.js has been deprecated. ' .
-                'Please use core_question/question_engine', DEBUG_DEVELOPER);
-        }
-        $url = $this->js_fix_url($url);
-        $where = $inhead ? 'head' : 'footer';
-        $this->jsincludes[$where][$url->out()] = $url;
-    }
-
-    /**
-     * Request inclusion of jQuery library in the page.
-     *
-     * NOTE: this should not be used in official Moodle distribution!
-     *
-     * {@link https://moodledev.io/docs/guides/javascript/jquery}
-     */
-    public function jquery() {
-        $this->jquery_plugin('jquery');
-    }
-
-    /**
-     * Request inclusion of jQuery plugin.
-     *
-     * NOTE: this should not be used in official Moodle distribution!
-     *
-     * jQuery plugins are located in plugin/jquery/* subdirectory,
-     * plugin/jquery/plugins.php lists all available plugins.
-     *
-     * Included core plugins:
-     *   - jQuery UI
-     *
-     * Add-ons may include extra jQuery plugins in jquery/ directory,
-     * plugins.php file defines the mapping between plugin names and
-     * necessary page includes.
-     *
-     * Examples:
-     * <code>
-     *   // file: mod/xxx/view.php
-     *   $PAGE->requires->jquery();
-     *   $PAGE->requires->jquery_plugin('ui');
-     *   $PAGE->requires->jquery_plugin('ui-css');
-     * </code>
-     *
-     * <code>
-     *   // file: theme/yyy/lib.php
-     *   function theme_yyy_page_init(moodle_page $page) {
-     *       $page->requires->jquery();
-     *       $page->requires->jquery_plugin('ui');
-     *       $page->requires->jquery_plugin('ui-css');
-     *   }
-     * </code>
-     *
-     * <code>
-     *   // file: blocks/zzz/block_zzz.php
-     *   public function get_required_javascript() {
-     *       parent::get_required_javascript();
-     *       $this->page->requires->jquery();
-     *       $page->requires->jquery_plugin('ui');
-     *       $page->requires->jquery_plugin('ui-css');
-     *   }
-     * </code>
-     *
-     * {@link https://moodledev.io/docs/guides/javascript/jquery}
-     *
-     * @param string $plugin name of the jQuery plugin as defined in jquery/plugins.php
-     * @param string $component name of the component
-     * @return bool success
-     */
-    public function jquery_plugin($plugin, $component = 'core') {
-        global $CFG;
-
-        if ($this->headdone) {
-            debugging('Can not add jQuery plugins after starting page output!');
-            return false;
-        }
-
-        if ($component !== 'core' and in_array($plugin, array('jquery', 'ui', 'ui-css'))) {
-            debugging("jQuery plugin '$plugin' is included in Moodle core, other components can not use the same name.", DEBUG_DEVELOPER);
-            $component = 'core';
-        } else if ($component !== 'core' and strpos($component, '_') === false) {
-            // Let's normalise the legacy activity names, Frankenstyle rulez!
-            $component = 'mod_' . $component;
-        }
-
-        if (empty($this->jqueryplugins) and ($component !== 'core' or $plugin !== 'jquery')) {
-            // Make sure the jQuery itself is always loaded first,
-            // the order of all other plugins depends on order of $PAGE_>requires->.
-            $this->jquery_plugin('jquery', 'core');
-        }
-
-        if (isset($this->jqueryplugins[$plugin])) {
-            // No problem, we already have something, first Moodle plugin to register the jQuery plugin wins.
-            return true;
-        }
-
-        $componentdir = core_component::get_component_directory($component);
-        if (!file_exists($componentdir) or !file_exists("$componentdir/jquery/plugins.php")) {
-            debugging("Can not load jQuery plugin '$plugin', missing plugins.php in component '$component'.", DEBUG_DEVELOPER);
-            return false;
-        }
-
-        $plugins = array();
-        require("$componentdir/jquery/plugins.php");
-
-        if (!isset($plugins[$plugin])) {
-            debugging("jQuery plugin '$plugin' can not be found in component '$component'.", DEBUG_DEVELOPER);
-            return false;
-        }
-
-        $this->jqueryplugins[$plugin] = new stdClass();
-        $this->jqueryplugins[$plugin]->plugin    = $plugin;
-        $this->jqueryplugins[$plugin]->component = $component;
-        $this->jqueryplugins[$plugin]->urls      = array();
-
-        foreach ($plugins[$plugin]['files'] as $file) {
-            if ($CFG->debugdeveloper) {
-                if (!file_exists("$componentdir/jquery/$file")) {
-                    debugging("Invalid file '$file' specified in jQuery plugin '$plugin' in component '$component'");
-                    continue;
-                }
-                $file = str_replace('.min.css', '.css', $file);
-                $file = str_replace('.min.js', '.js', $file);
-            }
-            if (!file_exists("$componentdir/jquery/$file")) {
-                debugging("Invalid file '$file' specified in jQuery plugin '$plugin' in component '$component'");
-                continue;
-            }
-            if (!empty($CFG->slasharguments)) {
-                $url = new moodle_url("/theme/jquery.php");
-                $url->set_slashargument("/$component/$file");
-
-            } else {
-                // This is not really good, we need slasharguments for relative links, this means no caching...
-                $path = realpath("$componentdir/jquery/$file");
-                if (strpos($path, $CFG->dirroot) === 0) {
-                    $url = $CFG->wwwroot.preg_replace('/^'.preg_quote($CFG->dirroot, '/').'/', '', $path);
-                    // Replace all occurences of backslashes characters in url to forward slashes.
-                    $url = str_replace('\\', '/', $url);
-                    $url = new moodle_url($url);
-                } else {
-                    // Bad luck, fix your server!
-                    debugging("Moodle jQuery integration requires 'slasharguments' setting to be enabled.");
-                    continue;
-                }
-            }
-            $this->jqueryplugins[$plugin]->urls[] = $url;
-        }
-
-        return true;
-    }
-
-    /**
-     * Request replacement of one jQuery plugin by another.
-     *
-     * This is useful when themes want to replace the jQuery UI theme,
-     * the problem is that theme can not prevent others from including the core ui-css plugin.
-     *
-     * Example:
-     *  1/ generate new jQuery UI theme and place it into theme/yourtheme/jquery/
-     *  2/ write theme/yourtheme/jquery/plugins.php
-     *  3/ init jQuery from theme
-     *
-     * <code>
-     *   // file theme/yourtheme/lib.php
-     *   function theme_yourtheme_page_init($page) {
-     *       $page->requires->jquery_plugin('yourtheme-ui-css', 'theme_yourtheme');
-     *       $page->requires->jquery_override_plugin('ui-css', 'yourtheme-ui-css');
-     *   }
-     * </code>
-     *
-     * This code prevents loading of standard 'ui-css' which my be requested by other plugins,
-     * the 'yourtheme-ui-css' gets loaded only if some other code requires jquery.
-     *
-     * {@link https://moodledev.io/docs/guides/javascript/jquery}
-     *
-     * @param string $oldplugin original plugin
-     * @param string $newplugin the replacement
-     */
-    public function jquery_override_plugin($oldplugin, $newplugin) {
-        if ($this->headdone) {
-            debugging('Can not override jQuery plugins after starting page output!');
-            return;
-        }
-        $this->jquerypluginoverrides[$oldplugin] = $newplugin;
-    }
-
-    /**
-     * Return jQuery related markup for page start.
-     * @return string
-     */
-    protected function get_jquery_headcode() {
-        if (empty($this->jqueryplugins['jquery'])) {
-            // If nobody requested jQuery then do not bother to load anything.
-            // This may be useful for themes that want to override 'ui-css' only if requested by something else.
-            return '';
-        }
-
-        $included = array();
-        $urls = array();
-
-        foreach ($this->jqueryplugins as $name => $unused) {
-            if (isset($included[$name])) {
-                continue;
-            }
-            if (array_key_exists($name, $this->jquerypluginoverrides)) {
-                // The following loop tries to resolve the replacements,
-                // use max 100 iterations to prevent infinite loop resulting
-                // in blank page.
-                $cyclic = true;
-                $oldname = $name;
-                for ($i=0; $i<100; $i++) {
-                    $name = $this->jquerypluginoverrides[$name];
-                    if (!array_key_exists($name, $this->jquerypluginoverrides)) {
-                        $cyclic = false;
-                        break;
-                    }
-                }
-                if ($cyclic) {
-                    // We can not do much with cyclic references here, let's use the old plugin.
-                    $name = $oldname;
-                    debugging("Cyclic overrides detected for jQuery plugin '$name'");
-
-                } else if (empty($name)) {
-                    // Developer requested removal of the plugin.
-                    continue;
-
-                } else if (!isset($this->jqueryplugins[$name])) {
-                    debugging("Unknown jQuery override plugin '$name' detected");
-                    $name = $oldname;
-
-                } else if (isset($included[$name])) {
-                    // The plugin was already included, easy.
-                    continue;
-                }
-            }
-
-            $plugin = $this->jqueryplugins[$name];
-            $urls = array_merge($urls, $plugin->urls);
-            $included[$name] = true;
-        }
-
-        $output = '';
-        $attributes = array('rel' => 'stylesheet', 'type' => 'text/css');
-        foreach ($urls as $url) {
-            if (preg_match('/\.js$/', $url)) {
-                $output .= html_writer::script('', $url);
-            } else if (preg_match('/\.css$/', $url)) {
-                $attributes['href'] = $url;
-                $output .= html_writer::empty_tag('link', $attributes) . "\n";
-            }
-        }
-
-        return $output;
-    }
-
-    /**
-     * Returns the actual url through which a JavaScript file is served.
-     *
-     * @param moodle_url|string $url full moodle url, or shortened path to script.
-     * @throws coding_exception if the given $url isn't a shortened url starting with / or a moodle_url instance.
-     * @return moodle_url
-     */
-    protected function js_fix_url($url) {
-        global $CFG;
-
-        if ($url instanceof moodle_url) {
-            // If the URL is external to Moodle, it won't be handled by Moodle (!).
-            if ($url->is_local_url()) {
-                $localurl = $url->out_as_local_url();
-                // Check if the URL points to a Moodle PHP resource.
-                if (strpos($localurl, '.php') !== false) {
-                    // It's a Moodle PHP resource e.g. a resource already served by the proper Moodle Handler.
-                    return $url;
-                }
-                // It's a local resource: we need to further examine it.
-                return $this->js_fix_url($url->out_as_local_url(false));
-            }
-            // The URL is not a Moodle resource.
-            return $url;
-        } else if (null !== $url && strpos($url, '/') === 0) {
-            // Fix the admin links if needed.
-            if ($CFG->admin !== 'admin') {
-                if (strpos($url, "/admin/") === 0) {
-                    $url = preg_replace("|^/admin/|", "/$CFG->admin/", $url);
-                }
-            }
-            if (debugging()) {
-                // Check file existence only when in debug mode.
-                if (!file_exists($CFG->dirroot . strtok($url, '?'))) {
-                    throw new coding_exception('Attempt to require a JavaScript file that does not exist.', $url);
-                }
-            }
-            if (substr($url, -3) === '.js') {
-                $jsrev = $this->get_jsrev();
-                if (empty($CFG->slasharguments)) {
-                    return new moodle_url('/lib/javascript.php', ['rev' => $jsrev, 'jsfile' => $url]);
-                } else {
-                    $returnurl = new moodle_url('/lib/javascript.php');
-                    $returnurl->set_slashargument('/'.$jsrev.$url);
-                    return $returnurl;
-                }
-            } else {
-                return new moodle_url($url);
-            }
-        } else {
-            throw new coding_exception('Invalid JS url, it has to be shortened url starting with / or moodle_url instance.', $url);
-        }
-    }
-
-    /**
-     * Find out if JS module present and return details.
-     *
-     * @param string $component name of component in frankenstyle, ex: core_group, mod_forum
-     * @return array description of module or null if not found
-     */
-    protected function find_module($component) {
-        global $CFG, $PAGE;
-
-        $module = null;
-
-        if (strpos($component, 'core_') === 0) {
-            // Must be some core stuff - list here is not complete, this is just the stuff used from multiple places
-            // so that we do nto have to repeat the definition of these modules over and over again.
-            switch($component) {
-                case 'core_filepicker':
-                    $module = array('name'     => 'core_filepicker',
-                                    'fullpath' => '/repository/filepicker.js',
-                                    'requires' => array(
-                                        'base', 'node', 'node-event-simulate', 'json', 'async-queue', 'io-base', 'io-upload-iframe', 'io-form',
-                                        'yui2-treeview', 'panel', 'cookie', 'datatable', 'datatable-sort', 'resize-plugin', 'dd-plugin',
-                                        'escape', 'moodle-core_filepicker', 'moodle-core-notification-dialogue'
-                                    ),
-                                    'strings'  => array(array('lastmodified', 'moodle'), array('name', 'moodle'), array('type', 'repository'), array('size', 'repository'),
-                                                        array('invalidjson', 'repository'), array('error', 'moodle'), array('info', 'moodle'),
-                                                        array('nofilesattached', 'repository'), array('filepicker', 'repository'), array('logout', 'repository'),
-                                                        array('nofilesavailable', 'repository'), array('norepositoriesavailable', 'repository'),
-                                                        array('fileexistsdialogheader', 'repository'), array('fileexistsdialog_editor', 'repository'),
-                                                        array('fileexistsdialog_filemanager', 'repository'), array('renameto', 'repository'),
-                                                        array('referencesexist', 'repository'), array('select', 'repository')
-                                                    ));
-                    break;
-                case 'core_comment':
-                    $module = array('name'     => 'core_comment',
-                                    'fullpath' => '/comment/comment.js',
-                                    'requires' => array('base', 'io-base', 'node', 'json', 'yui2-animation', 'overlay', 'escape'),
-                                    'strings' => array(array('confirmdeletecomments', 'admin'), array('yes', 'moodle'), array('no', 'moodle'))
-                                );
-                    break;
-                case 'core_role':
-                    $module = array('name'     => 'core_role',
-                                    'fullpath' => '/admin/roles/module.js',
-                                    'requires' => array('node', 'cookie'));
-                    break;
-                case 'core_completion':
-                    break;
-                case 'core_message':
-                    $module = array('name'     => 'core_message',
-                                    'requires' => array('base', 'node', 'event', 'node-event-simulate'),
-                                    'fullpath' => '/message/module.js');
-                    break;
-                case 'core_group':
-                    $module = array('name'     => 'core_group',
-                                    'fullpath' => '/group/module.js',
-                                    'requires' => array('node', 'overlay', 'event-mouseenter'));
-                    break;
-                case 'core_question_engine':
-                    $module = array('name'     => 'core_question_engine',
-                                    'fullpath' => '/question/qengine.js',
-                                    'requires' => array('node', 'event'));
-                    break;
-                case 'core_rating':
-                    $module = array('name'     => 'core_rating',
-                                    'fullpath' => '/rating/module.js',
-                                    'requires' => array('node', 'event', 'overlay', 'io-base', 'json'));
-                    break;
-                case 'core_dndupload':
-                    $module = array('name'     => 'core_dndupload',
-                                    'fullpath' => '/lib/form/dndupload.js',
-                                    'requires' => array('node', 'event', 'json', 'core_filepicker'),
-                                    'strings'  => array(array('uploadformlimit', 'moodle'), array('droptoupload', 'moodle'), array('maxfilesreached', 'moodle'),
-                                                        array('dndenabled_inbox', 'moodle'), array('fileexists', 'moodle'), array('maxbytesfile', 'error'),
-                                                        array('sizegb', 'moodle'), array('sizemb', 'moodle'), array('sizekb', 'moodle'), array('sizeb', 'moodle'),
-                                                        array('maxareabytesreached', 'moodle'), array('serverconnection', 'error'),
-                                                        array('changesmadereallygoaway', 'moodle'), array('complete', 'moodle')
-                                                    ));
-                    break;
-            }
-
-        } else {
-            if ($dir = core_component::get_component_directory($component)) {
-                if (file_exists("$dir/module.js")) {
-                    if (strpos($dir, $CFG->dirroot.'/') === 0) {
-                        $dir = substr($dir, strlen($CFG->dirroot));
-                        $module = array('name'=>$component, 'fullpath'=>"$dir/module.js", 'requires' => array());
-                    }
-                }
-            }
-        }
-
-        return $module;
-    }
-
-    /**
-     * Append YUI3 module to default YUI3 JS loader.
-     * The structure of module array is described at {@link http://developer.yahoo.com/yui/3/yui/}
-     *
-     * @param string|array $module name of module (details are autodetected), or full module specification as array
-     * @return void
-     */
-    public function js_module($module) {
-        global $CFG;
-
-        if (empty($module)) {
-            throw new coding_exception('Missing YUI3 module name or full description.');
-        }
-
-        if (is_string($module)) {
-            $module = $this->find_module($module);
-        }
-
-        if (empty($module) or empty($module['name']) or empty($module['fullpath'])) {
-            throw new coding_exception('Missing YUI3 module details.');
-        }
-
-        $module['fullpath'] = $this->js_fix_url($module['fullpath'])->out(false);
-        // Add all needed strings.
-        if (!empty($module['strings'])) {
-            foreach ($module['strings'] as $string) {
-                $identifier = $string[0];
-                $component = isset($string[1]) ? $string[1] : 'moodle';
-                $a = isset($string[2]) ? $string[2] : null;
-                $this->string_for_js($identifier, $component, $a);
-            }
-        }
-        unset($module['strings']);
-
-        // Process module requirements and attempt to load each. This allows
-        // moodle modules to require each other.
-        if (!empty($module['requires'])){
-            foreach ($module['requires'] as $requirement) {
-                $rmodule = $this->find_module($requirement);
-                if (is_array($rmodule)) {
-                    $this->js_module($rmodule);
-                }
-            }
-        }
-
-        if ($this->headdone) {
-            $this->extramodules[$module['name']] = $module;
-        } else {
-            $this->YUI_config->add_module_config($module['name'], $module);
-        }
-    }
-
-    /**
-     * Returns true if the module has already been loaded.
-     *
-     * @param string|array $module
-     * @return bool True if the module has already been loaded
-     */
-    protected function js_module_loaded($module) {
-        if (is_string($module)) {
-            $modulename = $module;
-        } else {
-            $modulename = $module['name'];
-        }
-        return array_key_exists($modulename, $this->YUI_config->modules) ||
-               array_key_exists($modulename, $this->extramodules);
-    }
-
-    /**
-     * Ensure that the specified CSS file is linked to from this page.
-     *
-     * Because stylesheet links must go in the <head> part of the HTML, you must call
-     * this function before {@link get_head_code()} is called. That normally means before
-     * the call to print_header. If you call it when it is too late, an exception
-     * will be thrown.
-     *
-     * Even if a particular style sheet is requested more than once, it will only
-     * be linked to once.
-     *
-     * Please note use of this feature is strongly discouraged,
-     * it is suitable only for places where CSS is submitted directly by teachers.
-     * (Students must not be allowed to submit any external CSS because it may
-     * contain embedded javascript!). Example of correct use is mod/data.
-     *
-     * @param string $stylesheet The path to the .css file, relative to $CFG->wwwroot.
-     *   For example:
-     *      $PAGE->requires->css('mod/data/css.php?d='.$data->id);
-     */
-    public function css($stylesheet) {
-        global $CFG;
-
-        if ($this->headdone) {
-            throw new coding_exception('Cannot require a CSS file after &lt;head> has been printed.', $stylesheet);
-        }
-
-        if ($stylesheet instanceof moodle_url) {
-            // ok
-        } else if (strpos($stylesheet, '/') === 0) {
-            $stylesheet = new moodle_url($stylesheet);
-        } else {
-            throw new coding_exception('Invalid stylesheet parameter.', $stylesheet);
-        }
-
-        $this->cssurls[$stylesheet->out()] = $stylesheet;
-    }
-
-    /**
-     * Add theme stylesheet to page - do not use from plugin code,
-     * this should be called only from the core renderer!
-     *
-     * @param moodle_url $stylesheet
-     * @return void
-     */
-    public function css_theme(moodle_url $stylesheet) {
-        $this->cssthemeurls[] = $stylesheet;
-    }
-
-    /**
-     * Ensure that a skip link to a given target is printed at the top of the <body>.
-     *
-     * You must call this function before {@link get_top_of_body_code()}, (if not, an exception
-     * will be thrown). That normally means you must call this before the call to print_header.
-     *
-     * If you ask for a particular skip link to be printed, it is then your responsibility
-     * to ensure that the appropriate <a name="..."> tag is printed in the body of the
-     * page, so that the skip link goes somewhere.
-     *
-     * Even if a particular skip link is requested more than once, only one copy of it will be output.
-     *
-     * @param string $target the name of anchor this link should go to. For example 'maincontent'.
-     * @param string $linktext The text to use for the skip link. Normally get_string('skipto', 'access', ...);
-     */
-    public function skip_link_to($target, $linktext) {
-        if ($this->topofbodydone) {
-            debugging('Page header already printed, can not add skip links any more, code needs to be fixed.');
-            return;
-        }
-        $this->skiplinks[$target] = $linktext;
-    }
-
-    /**
-     * !!!DEPRECATED!!! please use js_init_call() if possible
-     * Ensure that the specified JavaScript function is called from an inline script
-     * somewhere on this page.
-     *
-     * By default the call will be put in a script tag at the
-     * end of the page after initialising Y instance, since this gives best page-load
-     * performance and allows you to use YUI3 library.
-     *
-     * If you request that a particular function is called several times, then
-     * that is what will happen (unlike linking to a CSS or JS file, where only
-     * one link will be output).
-     *
-     * The main benefit of the method is the automatic encoding of all function parameters.
-     *
-     * @deprecated
-     *
-     * @param string $function the name of the JavaScritp function to call. Can
-     *      be a compound name like 'Y.Event.purgeElement'. Can also be
-     *      used to create and object by using a 'function name' like 'new user_selector'.
-     * @param array $arguments and array of arguments to be passed to the function.
-     *      When generating the function call, this will be escaped using json_encode,
-     *      so passing objects and arrays should work.
-     * @param bool $ondomready If tru the function is only called when the dom is
-     *      ready for manipulation.
-     * @param int $delay The delay before the function is called.
-     */
-    public function js_function_call($function, array $arguments = null, $ondomready = false, $delay = 0) {
-        $where = $ondomready ? 'ondomready' : 'normal';
-        $this->jscalls[$where][] = array($function, $arguments, $delay);
-    }
-
-    /**
-     * This function appends a block of code to the AMD specific javascript block executed
-     * in the page footer, just after loading the requirejs library.
-     *
-     * The code passed here can rely on AMD module loading, e.g. require('jquery', function($) {...});
-     *
-     * @param string $code The JS code to append.
-     */
-    public function js_amd_inline($code) {
-        $this->amdjscode[] = $code;
-    }
-
-    /**
-     * Load an AMD module and eventually call its method.
-     *
-     * This function creates a minimal inline JS snippet that requires an AMD module and eventually calls a single
-     * function from the module with given arguments. If it is called multiple times, it will be create multiple
-     * snippets.
-     *
-     * @param string $fullmodule The name of the AMD module to load, formatted as <component name>/<module name>.
-     * @param string $func Optional function from the module to call, defaults to just loading the AMD module.
-     * @param array $params The params to pass to the function (will be serialized into JSON).
-     */
-    public function js_call_amd($fullmodule, $func = null, $params = array()) {
-        global $CFG;
-
-        $modulepath = explode('/', $fullmodule);
-
-        $modname = clean_param(array_shift($modulepath), PARAM_COMPONENT);
-        foreach ($modulepath as $module) {
-            $modname .= '/' . clean_param($module, PARAM_ALPHANUMEXT);
-        }
-
-        $functioncode = [];
-        if ($func !== null) {
-            $func = clean_param($func, PARAM_ALPHANUMEXT);
-
-            $jsonparams = array();
-            foreach ($params as $param) {
-                $jsonparams[] = json_encode($param);
-            }
-            $strparams = implode(', ', $jsonparams);
-            if ($CFG->debugdeveloper) {
-                $toomanyparamslimit = 1024;
-                if (strlen($strparams) > $toomanyparamslimit) {
-                    debugging('Too much data passed as arguments to js_call_amd("' . $fullmodule . '", "' . $func .
-                        '"). Generally there are better ways to pass lots of data from PHP to JavaScript, for example via Ajax, ' .
-                        'data attributes, ... . This warning is triggered if the argument string becomes longer than ' .
-                        $toomanyparamslimit . ' characters.', DEBUG_DEVELOPER);
-                }
-            }
-
-            $functioncode[] = "amd.{$func}({$strparams});";
-        }
-
-        $functioncode[] = "M.util.js_complete('{$modname}');";
-
-        $initcode = implode(' ', $functioncode);
-        $js = "M.util.js_pending('{$modname}'); require(['{$modname}'], function(amd) {{$initcode}});";
-
-        $this->js_amd_inline($js);
-    }
-
-    /**
-     * Creates a JavaScript function call that requires one or more modules to be loaded.
-     *
-     * This function can be used to include all of the standard YUI module types within JavaScript:
-     *     - YUI3 modules    [node, event, io]
-     *     - YUI2 modules    [yui2-*]
-     *     - Moodle modules  [moodle-*]
-     *     - Gallery modules [gallery-*]
-     *
-     * Before writing new code that makes extensive use of YUI, you should consider it's replacement AMD/JQuery.
-     * @see js_call_amd()
-     *
-     * @param array|string $modules One or more modules
-     * @param string $function The function to call once modules have been loaded
-     * @param array $arguments An array of arguments to pass to the function
-     * @param string $galleryversion Deprecated: The gallery version to use
-     * @param bool $ondomready
-     */
-    public function yui_module($modules, $function, array $arguments = null, $galleryversion = null, $ondomready = false) {
-        if (!is_array($modules)) {
-            $modules = array($modules);
-        }
-
-        if ($galleryversion != null) {
-            debugging('The galleryversion parameter to yui_module has been deprecated since Moodle 2.3.');
-        }
-
-        $jscode = 'Y.use('.join(',', array_map('json_encode', convert_to_array($modules))).',function() {'.js_writer::function_call($function, $arguments).'});';
-        if ($ondomready) {
-            $jscode = "Y.on('domready', function() { $jscode });";
-        }
-        $this->jsinitcode[] = $jscode;
-    }
-
-    /**
-     * Set the CSS Modules to be included from YUI.
-     *
-     * @param array $modules The list of YUI CSS Modules to include.
-     */
-    public function set_yuicssmodules(array $modules = array()) {
-        $this->yuicssmodules = $modules;
-    }
-
-    /**
-     * Ensure that the specified JavaScript function is called from an inline script
-     * from page footer.
-     *
-     * @param string $function the name of the JavaScritp function to with init code,
-     *      usually something like 'M.mod_mymodule.init'
-     * @param array $extraarguments and array of arguments to be passed to the function.
-     *      The first argument is always the YUI3 Y instance with all required dependencies
-     *      already loaded.
-     * @param bool $ondomready wait for dom ready (helps with some IE problems when modifying DOM)
-     * @param array $module JS module specification array
-     */
-    public function js_init_call($function, array $extraarguments = null, $ondomready = false, array $module = null) {
-        $jscode = js_writer::function_call_with_Y($function, $extraarguments);
-        if (!$module) {
-            // Detect module automatically.
-            if (preg_match('/M\.([a-z0-9]+_[^\.]+)/', $function, $matches)) {
-                $module = $this->find_module($matches[1]);
-            }
-        }
-
-        $this->js_init_code($jscode, $ondomready, $module);
-    }
-
-    /**
-     * Add short static javascript code fragment to page footer.
-     * This is intended primarily for loading of js modules and initialising page layout.
-     * Ideally the JS code fragment should be stored in plugin renderer so that themes
-     * may override it.
-     *
-     * @param string $jscode
-     * @param bool $ondomready wait for dom ready (helps with some IE problems when modifying DOM)
-     * @param array $module JS module specification array
-     */
-    public function js_init_code($jscode, $ondomready = false, array $module = null) {
-        $jscode = trim($jscode, " ;\n"). ';';
-
-        $uniqid = html_writer::random_id();
-        $startjs = " M.util.js_pending('" . $uniqid . "');";
-        $endjs = " M.util.js_complete('" . $uniqid . "');";
-
-        if ($module) {
-            $this->js_module($module);
-            $modulename = $module['name'];
-            $jscode = "$startjs Y.use('$modulename', function(Y) { $jscode $endjs });";
-        }
-
-        if ($ondomready) {
-            $jscode = "$startjs Y.on('domready', function() { $jscode $endjs });";
-        }
-
-        $this->jsinitcode[] = $jscode;
-    }
-
-    /**
-     * Make a language string available to JavaScript.
-     *
-     * All the strings will be available in a M.str object in the global namespace.
-     * So, for example, after a call to $PAGE->requires->string_for_js('course', 'moodle');
-     * then the JavaScript variable M.str.moodle.course will be 'Course', or the
-     * equivalent in the current language.
-     *
-     * The arguments to this function are just like the arguments to get_string
-     * except that $component is not optional, and there are some aspects to consider
-     * when the string contains {$a} placeholder.
-     *
-     * If the string does not contain any {$a} placeholder, you can simply use
-     * M.str.component.identifier to obtain it. If you prefer, you can call
-     * M.util.get_string(identifier, component) to get the same result.
-     *
-     * If you need to use {$a} placeholders, there are two options. Either the
-     * placeholder should be substituted in PHP on server side or it should
-     * be substituted in Javascript at client side.
-     *
-     * To substitute the placeholder at server side, just provide the required
-     * value for the placeholder when you require the string. Because each string
-     * is only stored once in the JavaScript (based on $identifier and $module)
-     * you cannot get the same string with two different values of $a. If you try,
-     * an exception will be thrown. Once the placeholder is substituted, you can
-     * use M.str or M.util.get_string() as shown above:
-     *
-     *     // Require the string in PHP and replace the placeholder.
-     *     $PAGE->requires->string_for_js('fullnamedisplay', 'moodle', $USER);
-     *     // Use the result of the substitution in Javascript.
-     *     alert(M.str.moodle.fullnamedisplay);
-     *
-     * To substitute the placeholder at client side, use M.util.get_string()
-     * function. It implements the same logic as {@link get_string()}:
-     *
-     *     // Require the string in PHP but keep {$a} as it is.
-     *     $PAGE->requires->string_for_js('fullnamedisplay', 'moodle');
-     *     // Provide the values on the fly in Javascript.
-     *     user = { firstname : 'Harry', lastname : 'Potter' }
-     *     alert(M.util.get_string('fullnamedisplay', 'moodle', user);
-     *
-     * If you do need the same string expanded with different $a values in PHP
-     * on server side, then the solution is to put them in your own data structure
-     * (e.g. and array) that you pass to JavaScript with {@link data_for_js()}.
-     *
-     * @param string $identifier the desired string.
-     * @param string $component the language file to look in.
-     * @param mixed $a any extra data to add into the string (optional).
-     */
-    public function string_for_js($identifier, $component, $a = null) {
-        if (!$component) {
-            throw new coding_exception('The $component parameter is required for page_requirements_manager::string_for_js().');
-        }
-        if (isset($this->stringsforjs_as[$component][$identifier]) and $this->stringsforjs_as[$component][$identifier] !== $a) {
-            throw new coding_exception("Attempt to re-define already required string '$identifier' " .
-                    "from lang file '$component' with different \$a parameter?");
-        }
-        if (!isset($this->stringsforjs[$component][$identifier])) {
-            $this->stringsforjs[$component][$identifier] = new lang_string($identifier, $component, $a);
-            $this->stringsforjs_as[$component][$identifier] = $a;
-        }
-    }
-
-    /**
-     * Make an array of language strings available for JS.
-     *
-     * This function calls the above function {@link string_for_js()} for each requested
-     * string in the $identifiers array that is passed to the argument for a single module
-     * passed in $module.
-     *
-     * <code>
-     * $PAGE->requires->strings_for_js(array('one', 'two', 'three'), 'mymod', array('a', null, 3));
-     *
-     * // The above is identical to calling:
-     *
-     * $PAGE->requires->string_for_js('one', 'mymod', 'a');
-     * $PAGE->requires->string_for_js('two', 'mymod');
-     * $PAGE->requires->string_for_js('three', 'mymod', 3);
-     * </code>
-     *
-     * @param array $identifiers An array of desired strings
-     * @param string $component The module to load for
-     * @param mixed $a This can either be a single variable that gets passed as extra
-     *         information for every string or it can be an array of mixed data where the
-     *         key for the data matches that of the identifier it is meant for.
-     *
-     */
-    public function strings_for_js($identifiers, $component, $a = null) {
-        foreach ($identifiers as $key => $identifier) {
-            if (is_array($a) && array_key_exists($key, $a)) {
-                $extra = $a[$key];
-            } else {
-                $extra = $a;
-            }
-            $this->string_for_js($identifier, $component, $extra);
-        }
-    }
-
-    /**
-     * !!!!!!DEPRECATED!!!!!! please use js_init_call() for everything now.
-     *
-     * Make some data from PHP available to JavaScript code.
-     *
-     * For example, if you call
-     * <pre>
-     *      $PAGE->requires->data_for_js('mydata', array('name' => 'Moodle'));
-     * </pre>
-     * then in JavsScript mydata.name will be 'Moodle'.
-     *
-     * @deprecated
-     * @param string $variable the the name of the JavaScript variable to assign the data to.
-     *      Will probably work if you use a compound name like 'mybuttons.button[1]', but this
-     *      should be considered an experimental feature.
-     * @param mixed $data The data to pass to JavaScript. This will be escaped using json_encode,
-     *      so passing objects and arrays should work.
-     * @param bool $inhead initialise in head
-     * @return void
-     */
-    public function data_for_js($variable, $data, $inhead=false) {
-        $where = $inhead ? 'head' : 'footer';
-        $this->jsinitvariables[$where][] = array($variable, $data);
-    }
-
-    /**
-     * Creates a YUI event handler.
-     *
-     * @param mixed $selector standard YUI selector for elements, may be array or string, element id is in the form "#idvalue"
-     * @param string $event A valid DOM event (click, mousedown, change etc.)
-     * @param string $function The name of the function to call
-     * @param array  $arguments An optional array of argument parameters to pass to the function
-     */
-    public function event_handler($selector, $event, $function, array $arguments = null) {
-        $this->eventhandlers[] = array('selector'=>$selector, 'event'=>$event, 'function'=>$function, 'arguments'=>$arguments);
-    }
-
-    /**
-     * Returns code needed for registering of event handlers.
-     * @return string JS code
-     */
-    protected function get_event_handler_code() {
-        $output = '';
-        foreach ($this->eventhandlers as $h) {
-            $output .= js_writer::event_handler($h['selector'], $h['event'], $h['function'], $h['arguments']);
-        }
-        return $output;
-    }
-
-    /**
-     * Get the inline JavaScript code that need to appear in a particular place.
-     * @param bool $ondomready
-     * @return string
-     */
-    protected function get_javascript_code($ondomready) {
-        $where = $ondomready ? 'ondomready' : 'normal';
-        $output = '';
-        if ($this->jscalls[$where]) {
-            foreach ($this->jscalls[$where] as $data) {
-                $output .= js_writer::function_call($data[0], $data[1], $data[2]);
-            }
-            if (!empty($ondomready)) {
-                $output = "    Y.on('domready', function() {\n$output\n});";
-            }
-        }
-        return $output;
-    }
-
-    /**
-     * Returns js code to be executed when Y is available.
-     * @return string
-     */
-    protected function get_javascript_init_code() {
-        if (count($this->jsinitcode)) {
-            return implode("\n", $this->jsinitcode) . "\n";
-        }
-        return '';
-    }
-
-    /**
-     * Returns js code to load amd module loader, then insert inline script tags
-     * that contain require() calls using RequireJS.
-     * @return string
-     */
-    protected function get_amd_footercode() {
-        global $CFG;
-        $output = '';
-
-        // We will cache JS if cachejs is not set, or it is true.
-        $cachejs = !isset($CFG->cachejs) || $CFG->cachejs;
-        $jsrev = $this->get_jsrev();
-
-        $jsloader = new moodle_url('/lib/javascript.php');
-        $jsloader->set_slashargument('/' . $jsrev . '/');
-        $requirejsloader = new moodle_url('/lib/requirejs.php');
-        $requirejsloader->set_slashargument('/' . $jsrev . '/');
-
-        $requirejsconfig = file_get_contents($CFG->dirroot . '/lib/requirejs/moodle-config.js');
-
-        // No extension required unless slash args is disabled.
-        $jsextension = '.js';
-        if (!empty($CFG->slasharguments)) {
-            $jsextension = '';
-        }
-
-        $minextension = '.min';
-        if (!$cachejs) {
-            $minextension = '';
-        }
-
-        $requirejsconfig = str_replace('[BASEURL]', $requirejsloader, $requirejsconfig);
-        $requirejsconfig = str_replace('[JSURL]', $jsloader, $requirejsconfig);
-        $requirejsconfig = str_replace('[JSMIN]', $minextension, $requirejsconfig);
-        $requirejsconfig = str_replace('[JSEXT]', $jsextension, $requirejsconfig);
-
-        $output .= html_writer::script($requirejsconfig);
-        if ($cachejs) {
-            $output .= html_writer::script('', $this->js_fix_url('/lib/requirejs/require.min.js'));
-        } else {
-            $output .= html_writer::script('', $this->js_fix_url('/lib/requirejs/require.js'));
-        }
-
-        // First include must be to a module with no dependencies, this prevents multiple requests.
-        $prefix = <<<EOF
-M.util.js_pending("core/first");
-require(['core/first'], function() {
-
-EOF;
-
-        if (during_initial_install()) {
-            // Do not run a prefetch during initial install as the DB is not available to service WS calls.
-            $prefetch = '';
-        } else {
-            $prefetch = "require(['core/prefetch'])\n";
-        }
-
-        $suffix = <<<EOF
-
-    M.util.js_complete("core/first");
-});
-EOF;
-
-        $output .= html_writer::script($prefix . $prefetch . implode(";\n", $this->amdjscode) . $suffix);
-        return $output;
-    }
-
-    /**
-     * Returns basic YUI3 CSS code.
-     *
-     * @return string
-     */
-    protected function get_yui3lib_headcss() {
-        global $CFG;
-
-        $yuiformat = '-min';
-        if ($this->yui3loader->filter === 'RAW') {
-            $yuiformat = '';
-        }
-
-        $code = '';
-        if ($this->yui3loader->combine) {
-            if (!empty($this->yuicssmodules)) {
-                $modules = array();
-                foreach ($this->yuicssmodules as $module) {
-                    $modules[] = "$CFG->yui3version/$module/$module-min.css";
-                }
-                $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->comboBase.implode('&amp;', $modules).'" />';
-            }
-            $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->local_comboBase.'rollup/'.$CFG->yui3version.'/yui-moodlesimple' . $yuiformat . '.css" />';
-
-        } else {
-            if (!empty($this->yuicssmodules)) {
-                foreach ($this->yuicssmodules as $module) {
-                    $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->base.$module.'/'.$module.'-min.css" />';
-                }
-            }
-            $code .= '<link rel="stylesheet" type="text/css" href="'.$this->yui3loader->local_comboBase.'rollup/'.$CFG->yui3version.'/yui-moodlesimple' . $yuiformat . '.css" />';
-        }
-
-        if ($this->yui3loader->filter === 'RAW') {
-            $code = str_replace('-min.css', '.css', $code);
-        } else if ($this->yui3loader->filter === 'DEBUG') {
-            $code = str_replace('-min.css', '.css', $code);
-        }
-        return $code;
-    }
-
-    /**
-     * Returns basic YUI3 JS loading code.
-     *
-     * @return string
-     */
-    protected function get_yui3lib_headcode() {
-        global $CFG;
-
-        $jsrev = $this->get_jsrev();
-
-        $yuiformat = '-min';
-        if ($this->yui3loader->filter === 'RAW') {
-            $yuiformat = '';
-        }
-
-        $format = '-min';
-        if ($this->YUI_config->groups['moodle']['filter'] === 'DEBUG') {
-            $format = '-debug';
-        }
-
-        $rollupversion = $CFG->yui3version;
-        if (!empty($CFG->yuipatchlevel)) {
-            $rollupversion .= '_' . $CFG->yuipatchlevel;
-        }
-
-        $baserollups = array(
-            'rollup/' . $rollupversion . "/yui-moodlesimple{$yuiformat}.js",
-        );
-
-        if ($this->yui3loader->combine) {
-            return '<script src="' .
-                    $this->yui3loader->local_comboBase .
-                    implode('&amp;', $baserollups) .
-                    '"></script>';
-        } else {
-            $code = '';
-            foreach ($baserollups as $rollup) {
-                $code .= '<script src="'.$this->yui3loader->local_comboBase.$rollup.'"></script>';
-            }
-            return $code;
-        }
-
-    }
-
-    /**
-     * Returns html tags needed for inclusion of theme CSS.
-     *
-     * @return string
-     */
-    protected function get_css_code() {
-        // First of all the theme CSS, then any custom CSS
-        // Please note custom CSS is strongly discouraged,
-        // because it can not be overridden by themes!
-        // It is suitable only for things like mod/data which accepts CSS from teachers.
-        $attributes = array('rel'=>'stylesheet', 'type'=>'text/css');
-
-        // Add the YUI code first. We want this to be overridden by any Moodle CSS.
-        $code = $this->get_yui3lib_headcss();
-
-        // This line of code may look funny but it is currently required in order
-        // to avoid MASSIVE display issues in Internet Explorer.
-        // As of IE8 + YUI3.1.1 the reference stylesheet (firstthemesheet) gets
-        // ignored whenever another resource is added until such time as a redraw
-        // is forced, usually by moving the mouse over the affected element.
-        $code .= html_writer::tag('script', '/** Required in order to fix style inclusion problems in IE with YUI **/', array('id'=>'firstthemesheet', 'type'=>'text/css'));
-
-        $urls = $this->cssthemeurls + $this->cssurls;
-        foreach ($urls as $url) {
-            $attributes['href'] = $url;
-            $code .= html_writer::empty_tag('link', $attributes) . "\n";
-            // This id is needed in first sheet only so that theme may override YUI sheets loaded on the fly.
-            unset($attributes['id']);
-        }
-
-        return $code;
-    }
-
-    /**
-     * Adds extra modules specified after printing of page header.
-     *
-     * @return string
-     */
-    protected function get_extra_modules_code() {
-        if (empty($this->extramodules)) {
-            return '';
-        }
-        return html_writer::script(js_writer::function_call('M.yui.add_module', array($this->extramodules)));
-    }
-
-    /**
-     * Generate any HTML that needs to go inside the <head> tag.
-     *
-     * Normally, this method is called automatically by the code that prints the
-     * <head> tag. You should not normally need to call it in your own code.
-     *
-     * @param moodle_page $page
-     * @param core_renderer $renderer
-     * @return string the HTML code to to inside the <head> tag.
-     */
-    public function get_head_code(moodle_page $page, core_renderer $renderer) {
-        global $CFG;
-
-        // Note: the $page and $output are not stored here because it would
-        // create circular references in memory which prevents garbage collection.
-        $this->init_requirements_data($page, $renderer);
-
-        $output = '';
-
-        // Add all standard CSS for this page.
-        $output .= $this->get_css_code();
-
-        // Set up the M namespace.
-        $js = "var M = {}; M.yui = {};\n";
-
-        // Capture the time now ASAP during page load. This minimises the lag when
-        // we try to relate times on the server to times in the browser.
-        // An example of where this is used is the quiz countdown timer.
-        $js .= "M.pageloadstarttime = new Date();\n";
-
-        // Add a subset of Moodle configuration to the M namespace.
-        $js .= js_writer::set_variable('M.cfg', $this->M_cfg, false);
-
-        // Set up global YUI3 loader object - this should contain all code needed by plugins.
-        // Note: in JavaScript just use "YUI().use('overlay', function(Y) { .... });",
-        //       this needs to be done before including any other script.
-        $js .= $this->YUI_config->get_config_functions();
-        $js .= js_writer::set_variable('YUI_config', $this->YUI_config, false) . "\n";
-        $js .= "M.yui.loader = {modules: {}};\n"; // Backwards compatibility only, not used any more.
-        $js = $this->YUI_config->update_header_js($js);
-
-        $output .= html_writer::script($js);
-
-        // Add variables.
-        if ($this->jsinitvariables['head']) {
-            $js = '';
-            foreach ($this->jsinitvariables['head'] as $data) {
-                list($var, $value) = $data;
-                $js .= js_writer::set_variable($var, $value, true);
-            }
-            $output .= html_writer::script($js);
-        }
-
-        // Mark head sending done, it is not possible to anything there.
-        $this->headdone = true;
-
-        return $output;
-    }
-
-    /**
-     * Generate any HTML that needs to go at the start of the <body> tag.
-     *
-     * Normally, this method is called automatically by the code that prints the
-     * <head> tag. You should not normally need to call it in your own code.
-     *
-     * @param renderer_base $renderer
-     * @return string the HTML code to go at the start of the <body> tag.
-     */
-    public function get_top_of_body_code(renderer_base $renderer) {
-        global $CFG;
-
-        // First the skip links.
-        $output = $renderer->render_skip_links($this->skiplinks);
-
-        // Include the Polyfills.
-        $output .= html_writer::script('', $this->js_fix_url('/lib/polyfills/polyfill.js'));
-
-        // YUI3 JS needs to be loaded early in the body. It should be cached well by the browser.
-        $output .= $this->get_yui3lib_headcode();
-
-        // Add hacked jQuery support, it is not intended for standard Moodle distribution!
-        $output .= $this->get_jquery_headcode();
-
-        // Link our main JS file, all core stuff should be there.
-        $output .= html_writer::script('', $this->js_fix_url('/lib/javascript-static.js'));
-
-        // All the other linked things from HEAD - there should be as few as possible.
-        if ($this->jsincludes['head']) {
-            foreach ($this->jsincludes['head'] as $url) {
-                $output .= html_writer::script('', $url);
-            }
-        }
-
-        // Then the clever trick for hiding of things not needed when JS works.
-        $output .= html_writer::script("document.body.className += ' jsenabled';") . "\n";
-        $this->topofbodydone = true;
-        return $output;
-    }
-
-    /**
-     * Generate any HTML that needs to go at the end of the page.
-     *
-     * Normally, this method is called automatically by the code that prints the
-     * page footer. You should not normally need to call it in your own code.
-     *
-     * @return string the HTML code to to at the end of the page.
-     */
-    public function get_end_code() {
-        global $CFG;
-        $output = '';
-
-        // Set the log level for the JS logging.
-        $logconfig = new stdClass();
-        $logconfig->level = 'warn';
-        if ($CFG->debugdeveloper) {
-            $logconfig->level = 'trace';
-        }
-        $this->js_call_amd('core/log', 'setConfig', array($logconfig));
-        // Add any global JS that needs to run on all pages.
-        $this->js_call_amd('core/page_global', 'init');
-        $this->js_call_amd('core/utility');
-
-        // Call amd init functions.
-        $output .= $this->get_amd_footercode();
-
-        // Add other requested modules.
-        $output .= $this->get_extra_modules_code();
-
-        $this->js_init_code('M.util.js_complete("init");', true);
-
-        // All the other linked scripts - there should be as few as possible.
-        if ($this->jsincludes['footer']) {
-            foreach ($this->jsincludes['footer'] as $url) {
-                $output .= html_writer::script('', $url);
-            }
-        }
-
-        // Add all needed strings.
-        // First add core strings required for some dialogues.
-        $this->strings_for_js(array(
-            'confirm',
-            'yes',
-            'no',
-            'areyousure',
-            'closebuttontitle',
-            'unknownerror',
-            'error',
-            'file',
-            'url',
-            // TODO MDL-70830 shortforms should preload the collapseall/expandall strings properly.
-            'collapseall',
-            'expandall',
-        ), 'moodle');
-        $this->strings_for_js(array(
-            'debuginfo',
-            'line',
-            'stacktrace',
-        ), 'debug');
-        $this->string_for_js('labelsep', 'langconfig');
-        if (!empty($this->stringsforjs)) {
-            $strings = array();
-            foreach ($this->stringsforjs as $component=>$v) {
-                foreach($v as $indentifier => $langstring) {
-                    $strings[$component][$indentifier] = $langstring->out();
-                }
-            }
-            $output .= html_writer::script(js_writer::set_variable('M.str', $strings));
-        }
-
-        // Add variables.
-        if ($this->jsinitvariables['footer']) {
-            $js = '';
-            foreach ($this->jsinitvariables['footer'] as $data) {
-                list($var, $value) = $data;
-                $js .= js_writer::set_variable($var, $value, true);
-            }
-            $output .= html_writer::script($js);
-        }
-
-        $inyuijs = $this->get_javascript_code(false);
-        $ondomreadyjs = $this->get_javascript_code(true);
-        $jsinit = $this->get_javascript_init_code();
-        $handlersjs = $this->get_event_handler_code();
-
-        // There is a global Y, make sure it is available in your scope.
-        $js = "(function() {{$inyuijs}{$ondomreadyjs}{$jsinit}{$handlersjs}})();";
-
-        $output .= html_writer::script($js);
-
-        return $output;
-    }
-
-    /**
-     * Have we already output the code in the <head> tag?
-     *
-     * @return bool
-     */
-    public function is_head_done() {
-        return $this->headdone;
-    }
-
-    /**
-     * Have we already output the code at the start of the <body> tag?
-     *
-     * @return bool
-     */
-    public function is_top_of_body_done() {
-        return $this->topofbodydone;
-    }
-
-    /**
-     * Should we generate a bit of content HTML that is only required once  on
-     * this page (e.g. the contents of the modchooser), now? Basically, we call
-     * {@link has_one_time_item_been_created()}, and if the thing has not already
-     * been output, we return true to tell the caller to generate it, and also
-     * call {@link set_one_time_item_created()} to record the fact that it is
-     * about to be generated.
-     *
-     * That is, a typical usage pattern (in a renderer method) is:
-     * <pre>
-     * if (!$this->page->requires->should_create_one_time_item_now($thing)) {
-     *     return '';
-     * }
-     * // Else generate it.
-     * </pre>
-     *
-     * @param string $thing identifier for the bit of content. Should be of the form
-     *      frankenstyle_things, e.g. core_course_modchooser.
-     * @return bool if true, the caller should generate that bit of output now, otherwise don't.
-     */
-    public function should_create_one_time_item_now($thing) {
-        if ($this->has_one_time_item_been_created($thing)) {
-            return false;
-        }
-
-        $this->set_one_time_item_created($thing);
-        return true;
-    }
-
-    /**
-     * Has a particular bit of HTML that is only required once  on this page
-     * (e.g. the contents of the modchooser) already been generated?
-     *
-     * Normally, you can use the {@link should_create_one_time_item_now()} helper
-     * method rather than calling this method directly.
-     *
-     * @param string $thing identifier for the bit of content. Should be of the form
-     *      frankenstyle_things, e.g. core_course_modchooser.
-     * @return bool whether that bit of output has been created.
-     */
-    public function has_one_time_item_been_created($thing) {
-        return isset($this->onetimeitemsoutput[$thing]);
-    }
-
-    /**
-     * Indicate that a particular bit of HTML that is only required once on this
-     * page (e.g. the contents of the modchooser) has been generated (or is about to be)?
-     *
-     * Normally, you can use the {@link should_create_one_time_item_now()} helper
-     * method rather than calling this method directly.
-     *
-     * @param string $thing identifier for the bit of content. Should be of the form
-     *      frankenstyle_things, e.g. core_course_modchooser.
-     */
-    public function set_one_time_item_created($thing) {
-        if ($this->has_one_time_item_been_created($thing)) {
-            throw new coding_exception($thing . ' is only supposed to be ouput ' .
-                    'once per page, but it seems to be being output again.');
-        }
-        return $this->onetimeitemsoutput[$thing] = true;
-    }
-}
-
-/**
- * This class represents the YUI configuration.
- *
- * @copyright 2013 Andrew Nicols
- * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since Moodle 2.5
- * @package core
- * @category output
- */
-class YUI_config {
-    /**
-     * These settings must be public so that when the object is converted to json they are exposed.
-     * Note: Some of these are camelCase because YUI uses camelCase variable names.
-     *
-     * The settings are described and documented in the YUI API at:
-     * - http://yuilibrary.com/yui/docs/api/classes/config.html
-     * - http://yuilibrary.com/yui/docs/api/classes/Loader.html
-     */
-    public $debug = false;
-    public $base;
-    public $comboBase;
-    public $combine;
-    public $filter = null;
-    public $insertBefore = 'firstthemesheet';
-    public $groups = array();
-    public $modules = array();
-    /** @var array The log sources that should be not be logged. */
-    public $logInclude = [];
-    /** @var array Tog sources that should be logged. */
-    public $logExclude = [];
-    /** @var string The minimum log level for YUI logging statements. */
-    public $logLevel;
-
-    /**
-     * @var array List of functions used by the YUI Loader group pattern recognition.
-     */
-    protected $jsconfigfunctions = array();
-
-    /**
-     * Create a new group within the YUI_config system.
-     *
-     * @param string $name The name of the group. This must be unique and
-     * not previously used.
-     * @param array $config The configuration for this group.
-     * @return void
-     */
-    public function add_group($name, $config) {
-        if (isset($this->groups[$name])) {
-            throw new coding_exception("A YUI configuration group for '{$name}' already exists. To make changes to this group use YUI_config->update_group().");
-        }
-        $this->groups[$name] = $config;
-    }
-
-    /**
-     * Update an existing group configuration
-     *
-     * Note, any existing configuration for that group will be wiped out.
-     * This includes module configuration.
-     *
-     * @param string $name The name of the group. This must be unique and
-     * not previously used.
-     * @param array $config The configuration for this group.
-     * @return void
-     */
-    public function update_group($name, $config) {
-        if (!isset($this->groups[$name])) {
-            throw new coding_exception('The Moodle YUI module does not exist. You must define the moodle module config using YUI_config->add_module_config first.');
-        }
-        $this->groups[$name] = $config;
-    }
-
-    /**
-     * Set the value of a configuration function used by the YUI Loader's pattern testing.
-     *
-     * Only the body of the function should be passed, and not the whole function wrapper.
-     *
-     * The JS function your write will be passed a single argument 'name' containing the
-     * name of the module being loaded.
-     *
-     * @param $function String the body of the JavaScript function. This should be used i
-     * @return string the name of the function to use in the group pattern configuration.
-     */
-    public function set_config_function($function) {
-        $configname = 'yui' . (count($this->jsconfigfunctions) + 1) . 'ConfigFn';
-        if (isset($this->jsconfigfunctions[$configname])) {
-            throw new coding_exception("A YUI config function with this name already exists. Config function names must be unique.");
-        }
-        $this->jsconfigfunctions[$configname] = $function;
-        return '@' . $configname . '@';
-    }
-
-    /**
-     * Allow setting of the config function described in {@see set_config_function} from a file.
-     * The contents of this file are then passed to set_config_function.
-     *
-     * When jsrev is positive, the function is minified and stored in a MUC cache for subsequent uses.
-     *
-     * @param $file The path to the JavaScript function used for YUI configuration.
-     * @return string the name of the function to use in the group pattern configuration.
-     */
-    public function set_config_source($file) {
-        global $CFG;
-        $cache = cache::make('core', 'yuimodules');
-
-        // Attempt to get the metadata from the cache.
-        $keyname = 'configfn_' . $file;
-        $fullpath = $CFG->dirroot . '/' . $file;
-        if (!isset($CFG->jsrev) || $CFG->jsrev == -1) {
-            $cache->delete($keyname);
-            $configfn = file_get_contents($fullpath);
-        } else {
-            $configfn = $cache->get($keyname);
-            if ($configfn === false) {
-                require_once($CFG->libdir . '/jslib.php');
-                $configfn = core_minify::js_files(array($fullpath));
-                $cache->set($keyname, $configfn);
-            }
-        }
-        return $this->set_config_function($configfn);
-    }
-
-    /**
-     * Retrieve the list of JavaScript functions for YUI_config groups.
-     *
-     * @return string The complete set of config functions
-     */
-    public function get_config_functions() {
-        $configfunctions = '';
-        foreach ($this->jsconfigfunctions as $functionname => $function) {
-            $configfunctions .= "var {$functionname} = function(me) {";
-            $configfunctions .= $function;
-            $configfunctions .= "};\n";
-        }
-        return $configfunctions;
-    }
-
-    /**
-     * Update the header JavaScript with any required modification for the YUI Loader.
-     *
-     * @param $js String The JavaScript to manipulate.
-     * @return string the modified JS string.
-     */
-    public function update_header_js($js) {
-        // Update the names of the the configFn variables.
-        // The PHP json_encode function cannot handle literal names so we have to wrap
-        // them in @ and then replace them with literals of the same function name.
-        foreach ($this->jsconfigfunctions as $functionname => $function) {
-            $js = str_replace('"@' . $functionname . '@"', $functionname, $js);
-        }
-        return $js;
-    }
-
-    /**
-     * Add configuration for a specific module.
-     *
-     * @param string $name The name of the module to add configuration for.
-     * @param array $config The configuration for the specified module.
-     * @param string $group The name of the group to add configuration for.
-     * If not specified, then this module is added to the global
-     * configuration.
-     * @return void
-     */
-    public function add_module_config($name, $config, $group = null) {
-        if ($group) {
-            if (!isset($this->groups[$name])) {
-                throw new coding_exception('The Moodle YUI module does not exist. You must define the moodle module config using YUI_config->add_module_config first.');
-            }
-            if (!isset($this->groups[$group]['modules'])) {
-                $this->groups[$group]['modules'] = array();
-            }
-            $modules = &$this->groups[$group]['modules'];
-        } else {
-            $modules = &$this->modules;
-        }
-        $modules[$name] = $config;
-    }
-
-    /**
-     * Add the moodle YUI module metadata for the moodle group to the YUI_config instance.
-     *
-     * If js caching is disabled, metadata will not be served causing YUI to calculate
-     * module dependencies as each module is loaded.
-     *
-     * If metadata does not exist it will be created and stored in a MUC entry.
-     *
-     * @return void
-     */
-    public function add_moodle_metadata() {
-        global $CFG;
-        if (!isset($this->groups['moodle'])) {
-            throw new coding_exception('The Moodle YUI module does not exist. You must define the moodle module config using YUI_config->add_module_config first.');
-        }
-
-        if (!isset($this->groups['moodle']['modules'])) {
-            $this->groups['moodle']['modules'] = array();
-        }
-
-        $cache = cache::make('core', 'yuimodules');
-        if (!isset($CFG->jsrev) || $CFG->jsrev == -1) {
-            $metadata = array();
-            $metadata = $this->get_moodle_metadata();
-            $cache->delete('metadata');
-        } else {
-            // Attempt to get the metadata from the cache.
-            if (!$metadata = $cache->get('metadata')) {
-                $metadata = $this->get_moodle_metadata();
-                $cache->set('metadata', $metadata);
-            }
-        }
-
-        // Merge with any metadata added specific to this page which was added manually.
-        $this->groups['moodle']['modules'] = array_merge($this->groups['moodle']['modules'],
-                $metadata);
-    }
-
-    /**
-     * Determine the module metadata for all moodle YUI modules.
-     *
-     * This works through all modules capable of serving YUI modules, and attempts to get
-     * metadata for each of those modules.
-     *
-     * @return array of module metadata
-     */
-    private function get_moodle_metadata() {
-        $moodlemodules = array();
-        // Core isn't a plugin type or subsystem - handle it seperately.
-        if ($module = $this->get_moodle_path_metadata(core_component::get_component_directory('core'))) {
-            $moodlemodules = array_merge($moodlemodules, $module);
-        }
-
-        // Handle other core subsystems.
-        $subsystems = core_component::get_core_subsystems();
-        foreach ($subsystems as $subsystem => $path) {
-            if (is_null($path)) {
-                continue;
-            }
-            if ($module = $this->get_moodle_path_metadata($path)) {
-                $moodlemodules = array_merge($moodlemodules, $module);
-            }
-        }
-
-        // And finally the plugins.
-        $plugintypes = core_component::get_plugin_types();
-        foreach ($plugintypes as $plugintype => $pathroot) {
-            $pluginlist = core_component::get_plugin_list($plugintype);
-            foreach ($pluginlist as $plugin => $path) {
-                if ($module = $this->get_moodle_path_metadata($path)) {
-                    $moodlemodules = array_merge($moodlemodules, $module);
-                }
-            }
-        }
-
-        return $moodlemodules;
-    }
-
-    /**
-     * Helper function process and return the YUI metadata for all of the modules under the specified path.
-     *
-     * @param string $path the UNC path to the YUI src directory.
-     * @return array the complete array for frankenstyle directory.
-     */
-    private function get_moodle_path_metadata($path) {
-        // Add module metadata is stored in frankenstyle_modname/yui/src/yui_modname/meta/yui_modname.json.
-        $baseyui = $path . '/yui/src';
-        $modules = array();
-        if (is_dir($baseyui)) {
-            $items = new DirectoryIterator($baseyui);
-            foreach ($items as $item) {
-                if ($item->isDot() or !$item->isDir()) {
-                    continue;
-                }
-                $metafile = realpath($baseyui . '/' . $item . '/meta/' . $item . '.json');
-                if (!is_readable($metafile)) {
-                    continue;
-                }
-                $metadata = file_get_contents($metafile);
-                $modules = array_merge($modules, (array) json_decode($metadata));
-            }
-        }
-        return $modules;
-    }
-
-    /**
-     * Define YUI modules which we have been required to patch between releases.
-     *
-     * We must do this because we aggressively cache content on the browser, and we must also override use of the
-     * external CDN which will serve the true authoritative copy of the code without our patches.
-     *
-     * @param string $combobase The local combobase
-     * @param string $yuiversion The current YUI version
-     * @param int $patchlevel The patch level we're working to for YUI
-     * @param array $patchedmodules An array containing the names of the patched modules
-     * @return void
-     */
-    public function define_patched_core_modules($combobase, $yuiversion, $patchlevel, $patchedmodules) {
-        // The version we use is suffixed with a patchlevel so that we can get additional revisions between YUI releases.
-        $subversion = $yuiversion . '_' . $patchlevel;
-
-        if ($this->comboBase == $combobase) {
-            // If we are using the local combobase in the loader, we can add a group and still make use of the combo
-            // loader. We just need to specify a different root which includes a slightly different YUI version number
-            // to include our patchlevel.
-            $patterns = array();
-            $modules = array();
-            foreach ($patchedmodules as $modulename) {
-                // We must define the pattern and module here so that the loader uses our group configuration instead of
-                // the standard module definition. We may lose some metadata provided by upstream but this will be
-                // loaded when the module is loaded anyway.
-                $patterns[$modulename] = array(
-                    'group' => 'yui-patched',
-                );
-                $modules[$modulename] = array();
-            }
-
-            // Actually add the patch group here.
-            $this->add_group('yui-patched', array(
-                'combine' => true,
-                'root' => $subversion . '/',
-                'patterns' => $patterns,
-                'modules' => $modules,
-            ));
-
-        } else {
-            // The CDN is in use - we need to instead use the local combobase for this module and override the modules
-            // definition. We cannot use the local base - we must use the combobase because we cannot invalidate the
-            // local base in browser caches.
-            $fullpathbase = $combobase . $subversion . '/';
-            foreach ($patchedmodules as $modulename) {
-                $this->modules[$modulename] = array(
-                    'fullpath' => $fullpathbase . $modulename . '/' . $modulename . '-min.js'
-                );
-            }
-        }
-    }
-}
-
-/**
- * Invalidate all server and client side template caches.
- */
-function template_reset_all_caches() {
-    global $CFG;
-
-    $next = time();
-    if (isset($CFG->templaterev) and $next <= $CFG->templaterev and $CFG->templaterev - $next < 60 * 60) {
-        // This resolves problems when reset is requested repeatedly within 1s,
-        // the < 1h condition prevents accidental switching to future dates
-        // because we might not recover from it.
-        $next = $CFG->templaterev + 1;
-    }
-
-    set_config('templaterev', $next);
-}
-
-/**
- * Invalidate all server and client side JS caches.
- */
-function js_reset_all_caches() {
-    global $CFG;
-
-    $next = time();
-    if (isset($CFG->jsrev) and $next <= $CFG->jsrev and $CFG->jsrev - $next < 60*60) {
-        // This resolves problems when reset is requested repeatedly within 1s,
-        // the < 1h condition prevents accidental switching to future dates
-        // because we might not recover from it.
-        $next = $CFG->jsrev+1;
-    }
-
-    set_config('jsrev', $next);
-}
+// This file is deprecated, but it should never have been manually included by anything outside of lib/outputlib.php.
+// Throwing an exception here should be fine because removing the manual inclusion should have no impact.
+throw new \core\exception\coding_exception(
+    'This file should not be manually included by any component.',
+);
diff --git a/lib/pagelib.php b/lib/pagelib.php
index cd649a39d7a..169e0354a15 100644
--- a/lib/pagelib.php
+++ b/lib/pagelib.php
@@ -1034,9 +1034,6 @@ class moodle_page {
      * by the get_fragment() web service and not for use elsewhere.
      */
     public function start_collecting_javascript_requirements() {
-        global $CFG;
-        require_once($CFG->libdir.'/outputfragmentrequirementslib.php');
-
         // Check that the requirements manager has not already been switched.
         if (get_class($this->_requires) == 'fragment_requirements_manager') {
             throw new coding_exception('JavaScript collection has already been started.');
diff --git a/lib/table/classes/output/html_table.php b/lib/table/classes/output/html_table.php
new file mode 100644
index 00000000000..86cc3a3b4e2
--- /dev/null
+++ b/lib/table/classes/output/html_table.php
@@ -0,0 +1,207 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Holds all the information required to render a <table> by {@link core_renderer::table()}
+ *
+ * Example of usage:
+ * $t = new html_table();
+ * ... // set various properties of the object $t as described below
+ * echo html_writer::table($t);
+ *
+ * @copyright 2009 David Mudrak <david.mudrak@gmail.com>
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class html_table {
+
+    /**
+     * @var string Value to use for the id attribute of the table
+     */
+    public $id = null;
+
+    /**
+     * @var array Attributes of HTML attributes for the <table> element
+     */
+    public $attributes = array();
+
+    /**
+     * @var array An array of headings. The n-th array item is used as a heading of the n-th column.
+     * For more control over the rendering of the headers, an array of html_table_cell objects
+     * can be passed instead of an array of strings.
+     *
+     * Example of usage:
+     * $t->head = array('Student', 'Grade');
+     */
+    public $head;
+
+    /**
+     * @var array An array that can be used to make a heading span multiple columns.
+     * In this example, {@link html_table:$data} is supposed to have three columns. For the first two columns,
+     * the same heading is used. Therefore, {@link html_table::$head} should consist of two items.
+     *
+     * Example of usage:
+     * $t->headspan = array(2,1);
+     */
+    public $headspan;
+
+    /**
+     * @var array An array of column alignments.
+     * The value is used as CSS 'text-align' property. Therefore, possible
+     * values are 'left', 'right', 'center' and 'justify'. Specify 'right' or 'left' from the perspective
+     * of a left-to-right (LTR) language. For RTL, the values are flipped automatically.
+     *
+     * Examples of usage:
+     * $t->align = array(null, 'right');
+     * or
+     * $t->align[1] = 'right';
+     */
+    public $align;
+
+    /**
+     * @var array The value is used as CSS 'size' property.
+     *
+     * Examples of usage:
+     * $t->size = array('50%', '50%');
+     * or
+     * $t->size[1] = '120px';
+     */
+    public $size;
+
+    /**
+     * @var array An array of wrapping information.
+     * The only possible value is 'nowrap' that sets the
+     * CSS property 'white-space' to the value 'nowrap' in the given column.
+     *
+     * Example of usage:
+     * $t->wrap = array(null, 'nowrap');
+     */
+    public $wrap;
+
+    /**
+     * @var array Array of arrays or html_table_row objects containing the data. Alternatively, if you have
+     * $head specified, the string 'hr' (for horizontal ruler) can be used
+     * instead of an array of cells data resulting in a divider rendered.
+     *
+     * Example of usage with array of arrays:
+     * $row1 = array('Harry Potter', '76 %');
+     * $row2 = array('Hermione Granger', '100 %');
+     * $t->data = array($row1, $row2);
+     *
+     * Example with array of html_table_row objects: (used for more fine-grained control)
+     * $cell1 = new html_table_cell();
+     * $cell1->text = 'Harry Potter';
+     * $cell1->colspan = 2;
+     * $row1 = new html_table_row();
+     * $row1->cells[] = $cell1;
+     * $cell2 = new html_table_cell();
+     * $cell2->text = 'Hermione Granger';
+     * $cell3 = new html_table_cell();
+     * $cell3->text = '100 %';
+     * $row2 = new html_table_row();
+     * $row2->cells = array($cell2, $cell3);
+     * $t->data = array($row1, $row2);
+     */
+    public $data = [];
+
+    /**
+     * @deprecated since Moodle 2.0. Styling should be in the CSS.
+     * @var string Width of the table, percentage of the page preferred.
+     */
+    public $width = null;
+
+    /**
+     * @deprecated since Moodle 2.0. Styling should be in the CSS.
+     * @var string Alignment for the whole table. Can be 'right', 'left' or 'center' (default).
+     */
+    public $tablealign = null;
+
+    /**
+     * @deprecated since Moodle 2.0. Styling should be in the CSS.
+     * @var int Padding on each cell, in pixels
+     */
+    public $cellpadding = null;
+
+    /**
+     * @var int Spacing between cells, in pixels
+     * @deprecated since Moodle 2.0. Styling should be in the CSS.
+     */
+    public $cellspacing = null;
+
+    /**
+     * @var array Array of classes to add to particular rows, space-separated string.
+     * Class 'lastrow' is added automatically for the last row in the table.
+     *
+     * Example of usage:
+     * $t->rowclasses[9] = 'tenth'
+     */
+    public $rowclasses;
+
+    /**
+     * @var array An array of classes to add to every cell in a particular column,
+     * space-separated string. Class 'cell' is added automatically by the renderer.
+     * Classes 'c0' or 'c1' are added automatically for every odd or even column,
+     * respectively. Class 'lastcol' is added automatically for all last cells
+     * in a row.
+     *
+     * Example of usage:
+     * $t->colclasses = array(null, 'grade');
+     */
+    public $colclasses;
+
+    /**
+     * @var string Description of the contents for screen readers.
+     *
+     * The "summary" attribute on the "table" element is not supported in HTML5.
+     * Consider describing the structure of the table in a "caption" element or in a "figure" element containing the table;
+     * or, simplify the structure of the table so that no description is needed.
+     *
+     * @deprecated since Moodle 3.9.
+     */
+    public $summary;
+
+    /**
+     * @var string Caption for the table, typically a title.
+     *
+     * Example of usage:
+     * $t->caption = "TV Guide";
+     */
+    public $caption;
+
+    /**
+     * @var bool Whether to hide the table's caption from sighted users.
+     *
+     * Example of usage:
+     * $t->caption = "TV Guide";
+     * $t->captionhide = true;
+     */
+    public $captionhide = false;
+
+    /** @var bool Whether to make the table to be scrolled horizontally with ease. Make table responsive across all viewports. */
+    public $responsive = true;
+
+    /** @var string class name to add to this html table. */
+    public $class;
+
+    /**
+     * Constructor
+     */
+    public function __construct() {
+        $this->attributes['class'] = '';
+    }
+}
diff --git a/lib/table/classes/output/html_table_cell.php b/lib/table/classes/output/html_table_cell.php
new file mode 100644
index 00000000000..bc4c8ab31fb
--- /dev/null
+++ b/lib/table/classes/output/html_table_cell.php
@@ -0,0 +1,82 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Component representing a table cell.
+ *
+ * @copyright 2009 Nicolas Connault
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class html_table_cell {
+
+    /**
+     * @var string Value to use for the id attribute of the cell.
+     */
+    public $id = null;
+
+    /**
+     * @var string The contents of the cell.
+     */
+    public $text;
+
+    /**
+     * @var string Abbreviated version of the contents of the cell.
+     */
+    public $abbr = null;
+
+    /**
+     * @var int Number of columns this cell should span.
+     */
+    public $colspan = null;
+
+    /**
+     * @var int Number of rows this cell should span.
+     */
+    public $rowspan = null;
+
+    /**
+     * @var string Defines a way to associate header cells and data cells in a table.
+     */
+    public $scope = null;
+
+    /**
+     * @var bool Whether or not this cell is a header cell.
+     */
+    public $header = null;
+
+    /**
+     * @var string Value to use for the style attribute of the table cell
+     */
+    public $style = null;
+
+    /**
+     * @var array Attributes of additional HTML attributes for the <td> element
+     */
+    public $attributes = array();
+
+    /**
+     * Constructs a table cell
+     *
+     * @param string $text
+     */
+    public function __construct($text = null) {
+        $this->text = $text;
+        $this->attributes['class'] = '';
+    }
+}
diff --git a/lib/table/classes/output/html_table_row.php b/lib/table/classes/output/html_table_row.php
new file mode 100644
index 00000000000..8a0a366bd17
--- /dev/null
+++ b/lib/table/classes/output/html_table_row.php
@@ -0,0 +1,63 @@
+<?php
+// This file is part of Moodle - http://moodle.org/
+//
+// Moodle is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Moodle is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Component representing a table row.
+ *
+ * @copyright 2009 Nicolas Connault
+ * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+ * @since Moodle 2.0
+ * @package core
+ * @category output
+ */
+class html_table_row {
+
+    /**
+     * @var string Value to use for the id attribute of the row.
+     */
+    public $id = null;
+
+    /**
+     * @var array Array of html_table_cell objects
+     */
+    public $cells = array();
+
+    /**
+     * @var string Value to use for the style attribute of the table row
+     */
+    public $style = null;
+
+    /**
+     * @var array Attributes of additional HTML attributes for the <tr> element
+     */
+    public $attributes = array();
+
+    /**
+     * Constructor
+     * @param array $cells
+     */
+    public function __construct(array $cells=null) {
+        $this->attributes['class'] = '';
+        $cells = (array)$cells;
+        foreach ($cells as $cell) {
+            if ($cell instanceof html_table_cell) {
+                $this->cells[] = $cell;
+            } else {
+                $this->cells[] = new html_table_cell($cell);
+            }
+        }
+    }
+}
diff --git a/lib/tests/coverage.php b/lib/tests/coverage.php
index 0c8faeeff83..2d6961cdd8c 100644
--- a/lib/tests/coverage.php
+++ b/lib/tests/coverage.php
@@ -82,13 +82,7 @@ return new class extends phpunit_coverage_info {
         'myprofilelib.php',
         'navigationlib.php',
         'oauthlib.php',
-        'outputactions.php',
-        'outputcomponents.php',
-        'outputfactories.php',
-        'outputfragmentrequirementslib.php',
         'outputlib.php',
-        'outputrenderers.php',
-        'outputrequirementslib.php',
         'pagelib.php',
         'pdflib.php',
         'phpminimumversionlib.php',
diff --git a/lib/tests/fixtures/test_renderer_factory.php b/lib/tests/fixtures/test_renderer_factory.php
index 4d32622c496..fcfb0d06c80 100644
--- a/lib/tests/fixtures/test_renderer_factory.php
+++ b/lib/tests/fixtures/test_renderer_factory.php
@@ -14,20 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Test factory for lib/outputfactories.php.
- *
- * @package   core
- * @category  phpunit
- * @copyright 2014 Damyon Wiese
- * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-
-defined('MOODLE_INTERNAL') || die();
-
-global $CFG;
-require_once($CFG->libdir . '/outputfactories.php');
-
 /**
  * This is renderer factory testing of the classname autoloading.
  *
diff --git a/lib/tests/html_writer_test.php b/lib/tests/html_writer_test.php
index f40b823ee7b..7823a0def9d 100644
--- a/lib/tests/html_writer_test.php
+++ b/lib/tests/html_writer_test.php
@@ -14,20 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
-/**
- * Unit tests for the html_writer class.
- *
- * @package   core
- * @category  phpunit
- * @copyright 2010 Tim Hunt
- * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
-
-defined('MOODLE_INTERNAL') || die();
-
-global $CFG;
-require_once($CFG->libdir . '/outputcomponents.php');
-
 /**
  * Unit tests for the html_writer class.
  *
@@ -36,8 +22,7 @@ require_once($CFG->libdir . '/outputcomponents.php');
  * @covers \html_writer
  * @coversDefaultClass \html_writer
  */
-class html_writer_test extends basic_testcase {
-
+final class html_writer_test extends basic_testcase {
     /**
      * @covers ::start_tag
      */
diff --git a/lib/tests/outputcomponents_test.php b/lib/tests/outputcomponents_test.php
index 7ba5b6c7944..444351e9f79 100644
--- a/lib/tests/outputcomponents_test.php
+++ b/lib/tests/outputcomponents_test.php
@@ -27,11 +27,6 @@ use theme_config;
 use url_select;
 use user_picture;
 
-defined('MOODLE_INTERNAL') || die();
-
-global $CFG;
-require_once($CFG->libdir . '/outputcomponents.php');
-
 /**
  * Unit tests for lib/outputcomponents.php.
  *
@@ -40,8 +35,7 @@ require_once($CFG->libdir . '/outputcomponents.php');
  * @copyright 2011 David Mudrak <david@moodle.com>
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class outputcomponents_test extends \advanced_testcase {
-
+final class outputcomponents_test extends \advanced_testcase {
     /**
      * Tests user_picture::fields.
      *
diff --git a/lib/tests/outputfactories_test.php b/lib/tests/outputfactories_test.php
index b0e17ba0333..f235de37a8c 100644
--- a/lib/tests/outputfactories_test.php
+++ b/lib/tests/outputfactories_test.php
@@ -18,12 +18,6 @@ namespace core;
 
 use test_output_factory;
 
-defined('MOODLE_INTERNAL') || die();
-
-global $CFG;
-require_once($CFG->libdir . '/outputfactories.php');
-require_once($CFG->libdir . '/tests/fixtures/test_renderer_factory.php');
-
 /**
  * Unit tests for lib/outputfactories.php.
  *
@@ -32,7 +26,15 @@ require_once($CFG->libdir . '/tests/fixtures/test_renderer_factory.php');
  * @copyright 2014 Damyon Wiese
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class outputfactories_test extends \advanced_testcase {
+final class outputfactories_test extends \advanced_testcase {
+    #[\Override]
+    public static function setUpBeforeClass(): void {
+        global $CFG;
+
+        require_once($CFG->libdir . '/tests/fixtures/test_renderer_factory.php');
+
+        parent::setUpBeforeClass();
+    }
 
     public function test_nonautoloaded_classnames(): void {
         global $PAGE;
diff --git a/lib/tests/outputrequirementslib_test.php b/lib/tests/outputrequirementslib_test.php
index 2209b567066..32535a6a17f 100644
--- a/lib/tests/outputrequirementslib_test.php
+++ b/lib/tests/outputrequirementslib_test.php
@@ -16,12 +16,6 @@
 
 namespace core;
 
-defined('MOODLE_INTERNAL') || die();
-
-global $CFG;
-require_once($CFG->libdir . '/outputrequirementslib.php');
-
-
 /**
  * Unit tests for lib/outputrequirementslibphp.
  *
@@ -30,7 +24,7 @@ require_once($CFG->libdir . '/outputrequirementslib.php');
  * @copyright 2012 Petr Škoda
  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class outputrequirementslib_test extends \advanced_testcase {
+final class outputrequirementslib_test extends \advanced_testcase {
     public function test_string_for_js(): void {
         $this->resetAfterTest();
 
diff --git a/mod/wiki/parser/utils.php b/mod/wiki/parser/utils.php
index f489ffd4360..cb65a369bff 100644
--- a/mod/wiki/parser/utils.php
+++ b/mod/wiki/parser/utils.php
@@ -9,8 +9,6 @@
  * @package mod_wiki
  */
 
-require_once($CFG->dirroot . "/lib/outputcomponents.php");
-
 class parser_utils {
 
     public static function h($tag, $text = null, $options = array(), $escape_text = false) {
@@ -95,4 +93,3 @@ class parser_utils {
         return $url;
     }
 }
-