text: YUI.add('moodle-core-actionmenu', function (Y, NAME) {
  
  /**
   * Provides drop down menus for list of action links.
   *
   * @module moodle-core-actionmenu
   */
  
  var BODY = Y.one(Y.config.doc.body),
      CSS = {
          MENUSHOWN: 'action-menu-shown'
      },
      SELECTOR = {
          CAN_RECEIVE_FOCUS_SELECTOR: 'input:not([type="hidden"]), a[href], button, textarea, select, [tabindex]',
          MENU: '.moodle-actionmenu[data-enhance=moodle-core-actionmenu]',
          MENUBAR: '[role="menubar"]',
          MENUITEM: '[role="menuitem"]',
          MENUCONTENT: '.menu[data-rel=menu-content]',
          MENUCONTENTCHILD: 'li a',
          MENUCHILD: '.menu li a',
          TOGGLE: '.toggle-display',
          KEEPOPEN: '[data-keepopen="1"]',
          MENUBARITEMS: [
              '[role="menubar"] > [role="menuitem"]',
              '[role="menubar"] > [role="presentation"] > [role="menuitem"]'
          ],
          MENUITEMS: [
              '> [role="menuitem"]',
              '> [role="presentation"] > [role="menuitem"]'
          ]
      },
      ACTIONMENU,
      ALIGN = {
          TL: 'tl',
          TR: 'tr',
          BL: 'bl',
          BR: 'br'
      },
      ATTRS = { // Totara: Attribute names
          LOADER_URL: 'data-loader-url',
          LOADER_PARAMS: 'data-loader-params',
          LOADER_LOADING: 'data-loader-loading'
      };
  
  /**
   * Action menu support.
   * This converts a generic list of links into a drop down menu opened by hovering or clicking
   * on a menu icon.
   *
   * @namespace M.core.actionmenu
   * @class ActionMenu
   * @constructor
   * @extends Base
   */
  ACTIONMENU = function() {
      ACTIONMENU.superclass.constructor.apply(this, arguments);
  };
  ACTIONMENU.prototype = {
  
      /**
       * The dialogue used for all action menu displays.
       * @property type
       * @type M.core.dialogue
       * @protected
       */
      dialogue: null,
  
      /**
       * An array of events attached during the display of the dialogue.
       * @property events
       * @type Object
       * @protected
       */
      events: [],
  
      /**
       * The node that owns the currently displayed menu.
       *
       * @property owner
       * @type Node
       * @default null
       */
      owner: null,
  
      /**
       * The menu button that toggles this open.
       *
       * @property menulink
       * @type Node
       * @protected
       */
      menulink: null,
  
      /**
       * The set of menu nodes.
       *
       * @property menuChildren
       * @type NodeList
       * @protected
       */
      menuChildren: null,
  
      /**
       * The first menu item.
       *
       * @property firstMenuChild
       * @type Node
       * @protected
       */
      firstMenuChild: null,
  
      /**
       * The last menu item.
       *
       * @property lastMenuChild
       * @type Node
       * @protected
       */
      lastMenuChild: null,
  
      /**
       * Called during the initialisation process of the object.
       *
       * @method initializer
       */
      initializer: function() {
          Y.all(SELECTOR.MENU).each(this.enhance, this);
          BODY.delegate('key', this.moveMenuItem, 'down:37,39', SELECTOR.MENUBARITEMS.join(','), this);
  
          BODY.delegate('click', this.toggleMenu, SELECTOR.MENU + ' ' + SELECTOR.TOGGLE, this);
          BODY.delegate('key', this.showIfHidden, 'down:enter,38,40', SELECTOR.MENU + ' ' + SELECTOR.TOGGLE, this);
  
          // Ensure that we toggle on menuitems when the spacebar is pressed.
          BODY.delegate('key', function(e) {
              e.currentTarget.simulate('click');
              e.preventDefault();
          }, 'down:32', SELECTOR.MENUBARITEMS.join(','));
      },
  
      /**
       * Enhances a menu adding aria attributes and flagging it as functional.
       *
       * @method enhance
       * @param {Node} menu
       * @return boolean
       */
      enhance: function(menu) {
          var menucontent = menu.one(SELECTOR.MENUCONTENT),
              align;
          if (!menucontent) {
              return false;
          }
          align = menucontent.getData('align') || this.get('align').join('-');
          menu.one(SELECTOR.TOGGLE).set('aria-haspopup', true);
          menu.one(SELECTOR.TOGGLE).set('aria-expanded', false);
          menucontent.set('aria-hidden', true);
          if (!menucontent.hasClass('align-' + align)) {
              menucontent.addClass('align-' + align);
          }
          if (menucontent.getDOMNode().childElementCount) {
              menu.setAttribute('data-enhanced', '1');
          }
      },
  
      /**
       * Handle movement between menu items in a menubar.
       *
       * @method moveMenuItem
       * @param {EventFacade} e The event generating the move request
       * @chainable
       */
      moveMenuItem: function(e) {
          var nextFocus,
              menuitem = e.target.ancestor(SELECTOR.MENUITEM, true);
  
          if (e.keyCode === 37) {
              nextFocus = this.getMenuItem(menuitem, true);
          } else if (e.keyCode === 39) {
              nextFocus = this.getMenuItem(menuitem);
          }
  
          if (nextFocus) {
              nextFocus.focus();
          }
          return this;
      },
  
      /**
       * Get the next menuitem in a menubar.
       *
       * @method getMenuItem
       * @param {Node} currentItem The currently focused item in the menubar
       * @param {Boolean} [previous=false] Move backwards in the menubar instead of forwards
       * @return {Node|null} The next item, or null if none was found
       */
      getMenuItem: function(currentItem, previous) {
          var menubar = currentItem.ancestor(SELECTOR.MENUBAR),
              menuitems,
              next;
  
          if (!menubar) {
              return null;
          }
  
          menuitems = menubar.all(SELECTOR.MENUITEMS.join(','));
  
          if (!menuitems) {
              return null;
          }
  
          var childCount = menuitems.size();
  
          if (childCount === 1) {
              // Only one item, exit now because we should already be on it.
              return null;
          }
  
          // Determine the next child.
          var index = 0,
              direction = 1,
              checkCount = 0;
  
          // Work out the index of the currently selected item.
          for (index = 0; index < childCount; index++) {
              if (menuitems.item(index) === currentItem) {
                  break;
              }
          }
  
          // Check that the menu item was found - otherwise return null.
          if (menuitems.item(index) !== currentItem) {
              return null;
          }
  
          // Reverse the direction if we want the previous item.
          if (previous) {
              direction = -1;
          }
  
          do {
              // Update the index in the direction of travel.
              index += direction;
  
              next = menuitems.item(index);
  
              // Check that we don't loop multiple times.
              checkCount++;
          } while (next && next.hasAttribute('hidden'));
  
          return next;
      },
  
      /**
       * Hides the menu if it is visible.
       * @param {EventFacade} e
       * @method hideMenu
       */
      hideMenu: function(e) {
          if (this.dialogue) {
              this.dialogue.removeClass('show');
              this.dialogue.one(SELECTOR.MENUCONTENT).set('aria-hidden', true);
              this.dialogue.one(SELECTOR.TOGGLE).set('aria-expanded', false);
              this.dialogue = null;
          }
          for (var i in this.events) {
              if (this.events[i].detach) {
                  this.events[i].detach();
              }
          }
          this.events = [];
          if (this.owner) {
              this.owner.removeClass(CSS.MENUSHOWN);
              this.owner = null;
          }
  
          if (this.menulink) {
              if (e.type != 'click') {
                  this.menulink.focus();
              }
              this.menulink = null;
          }
      },
  
      showIfHidden: function(e) {
          var menu = e.target.ancestor(SELECTOR.MENU),
              menuvisible = (menu.hasClass('show'));
  
          if (!menuvisible) {
              e.preventDefault();
              this.showMenu(e, menu);
          }
          return this;
      },
  
      /**
       * Toggles the display of the menu.
       * @method toggleMenu
       * @param {EventFacade} e
       */
      toggleMenu: function(e) {
          var menu = e.target.ancestor(SELECTOR.MENU),
              menuvisible = (menu.hasClass('show'));
  
          // Prevent event propagation as it will trigger the hideIfOutside event handler in certain situations.
          e.halt(true);
          this.hideMenu(e);
          if (menuvisible) {
              // The menu was visible and the user has clicked to toggle it again.
              return;
          }
          this.showMenu(e, menu);
      },
  
      /**
       * Handle keyboard events when the menu is open. We respond to:
       * * escape (exit)
       * * tab (move to next menu item)
       * * up/down (move to previous/next menu item)
       *
       * @method handleKeyboardEvent
       * @param {EventFacade} e The key event
       */
      handleKeyboardEvent: function(e) {
          var next;
          var markEventHandled = function(e) {
              e.preventDefault();
              e.stopPropagation();
          };
  
          // Handle when the menu is still selected.
          if (e.currentTarget.ancestor(SELECTOR.TOGGLE, true)) {
              if ((e.keyCode === 40 || (e.keyCode === 9 && !e.shiftKey)) && this.firstMenuChild) {
                  this.firstMenuChild.focus();
                  markEventHandled(e);
              } else if (e.keyCode === 38 && this.lastMenuChild) {
                  this.lastMenuChild.focus();
                  markEventHandled(e);
              } else if (e.keyCode === 9 && e.shiftKey) {
                  this.hideMenu(e);
                  markEventHandled(e);
              }
              return this;
          }
  
          if (e.keyCode === 27) {
              // The escape key was pressed so close the menu.
              this.hideMenu(e);
              markEventHandled(e);
  
          } else if (e.keyCode === 32) {
              // The space bar was pressed. Trigger a click.
              markEventHandled(e);
              e.currentTarget.simulate('click');
          } else if (e.keyCode === 9) {
              // The tab key was pressed. Tab moves forwards, Shift + Tab moves backwards through the menu options.
              // We only override the Shift + Tab on the first option, and Tab on the last option to change where the
              // focus is moved to.
              if (e.target === this.firstMenuChild && e.shiftKey) {
                  this.hideMenu(e);
                  markEventHandled(e);
              } else if (e.target === this.lastMenuChild && !e.shiftKey) {
                  if (this.hideMenu(e)) {
                      // Determine the next selector and focus on it.
                      next = this.menulink.next(SELECTOR.CAN_RECEIVE_FOCUS_SELECTOR);
                      if (next) {
                          next.focus();
                          markEventHandled(e);
                      }
                  }
              }
  
          } else if (e.keyCode === 38 || e.keyCode === 40) {
              // The up (38) or down (40) key was pushed.
              // On cursor moves we loops through the menu rather than exiting it as in the tab behaviour.
              var found = false,
                  index = 0,
                  direction = 1,
                  checkCount = 0;
  
              // Determine which menu item is currently selected.
              while (!found && index < this.menuChildren.size()) {
                  if (this.menuChildren.item(index) === e.currentTarget) {
                      found = true;
                  } else {
                      index++;
                  }
              }
  
              if (!found) {
                  return;
              }
  
              if (e.keyCode === 38) {
                  // Moving up so reverse the direction.
                  direction = -1;
              }
  
              // Try to find the next
              do {
                  index += direction;
                  if (index < 0) {
                      index = this.menuChildren.size() - 1;
                  } else if (index >= this.menuChildren.size()) {
                      // Handle wrapping.
                      index = 0;
                  }
                  next = this.menuChildren.item(index);
  
                  // Add a counter to ensure we don't get stuck in a loop if there's only one visible menu item.
                  checkCount++;
              } while (checkCount < this.menuChildren.size() && next !== e.currentTarget && next.hasClass('hidden'));
  
              if (next) {
                  next.focus();
                  markEventHandled(e);
              }
          }
      },
  
      /**
       * Hides the menu if the event happened outside the menu.
       *
       * @protected
       * @method hideIfOutside
       * @param {EventFacade} e
       */
      hideIfOutside: function(e) {
          if (!e.target.ancestor(SELECTOR.MENUCONTENT, true)) {
              this.hideMenu(e);
          }
      },
  
      /**
       * Displays the menu with the given content and alignment.
       *
       * @method showMenu
       * @param {EventFacade} e
       * @param {Node} menu
       * @return M.core.dialogue
       */
      showMenu: function(e, menu) {
          var ownerselector = menu.getData('owner'),
              menucontent = menu.one(SELECTOR.MENUCONTENT);
          this.owner = (ownerselector) ? menu.ancestor(ownerselector) : null;
          this.dialogue = menu;
          menu.addClass('show');
          if (this.owner) {
              this.owner.addClass(CSS.MENUSHOWN);
              this.menulink = this.owner.one(SELECTOR.TOGGLE);
          } else {
              this.menulink = e.target.ancestor(SELECTOR.TOGGLE, true);
          }
          this.constrain(menucontent.set('aria-hidden', false));
  
          // Set aria expanded when opening menu
          this.menulink.set('aria-expanded', true);
  
          // Totara: Support delayload
          this.delayLoadMenu(menu, function() {
              if (this.dialogue === menu) {
                  this.menuChildren = this.dialogue.all(SELECTOR.MENUCHILD);
                  if (this.menuChildren.size() > 0) {
                      this.firstMenuChild = this.menuChildren.item(0);
                      this.lastMenuChild = this.menuChildren.item(this.menuChildren.size() - 1);
  
                      this.firstMenuChild.focus();
                  }
              }
          }.bind(this));
  
          // Close the menu if the user presses escape.
          this.events.push(BODY.on('key', this.hideMenu, 'esc', this));
  
          // Close the menu if the user clicks outside the menu.
          this.events.push(BODY.on('click', this.hideIfOutside, this));
  
          // Close the menu if the user focuses outside the menu.
          this.events.push(BODY.delegate('focus', this.hideIfOutside, '*', this));
  
          // Check keyboard changes.
          this.events.push(
              menu.delegate('key', this.handleKeyboardEvent,
                            'down:9, 27, 38, 40, 32', SELECTOR.MENUCHILD + ', ' + SELECTOR.TOGGLE, this)
              );
  
          // Close the menu after a button was pushed.
          this.events.push(menu.delegate('click', function(e) {
              if (e.currentTarget.test(SELECTOR.KEEPOPEN)) {
                  return;
              }
              this.hideMenu(e);
          }, SELECTOR.MENUCHILD, this));
  
          return true;
      },
  
      /**
       * Delayload the content of the menu by AJAX request.
       *
       * @protected
       * @method delayLoadMenu
       * @param {Node} menu
       * @param {Function} resolveCallback
       *
       * @since Totara 13
       */
      delayLoadMenu: function(menu, resolveCallback) {
          var url = menu.getAttribute(ATTRS.LOADER_URL);
          if (!url) {
              resolveCallback(false);
              return;
          }
          // Clean up URL.
          url = url.replace(/\.+/g, '.');
          url = M.cfg.wwwroot + '/' + url;
  
          // Prevent reentrance.
          if (menu.getAttribute(ATTRS.LOADER_LOADING)) {
              resolveCallback(false);
              return;
          }
          menu.setAttribute(ATTRS.LOADER_LOADING, '1');
  
          var params = JSON.parse(menu.getAttribute(ATTRS.LOADER_PARAMS) || '{}');
          params.ajax = '1';
          params.sesskey = M.cfg.sesskey;
  
          var key = 'totara-actionmenu-ajax-' + menu.get('id');
          M.util.js_pending(key);
  
          // Format:
          // - method is POST
          // - backend script must define AJAX_SCRIPT
          // - JSON-encoded template data of core/action_menu as response
  
          Y.io(url, {
              method: 'POST',
              /* global build_querystring:false */
              data: build_querystring(params),
              context: this,
              on: {
                  success: function(txid, response) {
                      var json = Y.JSON.parse(response.responseText);
                      if (json.error) {
                          // No js_complete here to let behat catch the failure.
                          throw new Error('AJAX request failed');
                      }
                      require(['core/templates'], function(templates) {
                          templates.render('core/action_menu', json).then(function(html) {
                              var menucontent = menu.one(SELECTOR.MENUCONTENT);
                              menucontent.empty();
                              // Extract secondary actions from the rendered HTML, append them to the real menu
                              var children = Y.Node.create(html).all(SELECTOR.MENUCONTENT + ' li');
                              menucontent.append(children);
                              // We are done.
                              menu.setAttribute(ATTRS.LOADER_URL, '');
                              menu.setAttribute(ATTRS.LOADER_PARAMS, '');
                              menu.setAttribute(ATTRS.LOADER_LOADING, '');
                              resolveCallback(true);
                              M.util.js_complete(key);
                          }).fail(function() {
                              // No js_complete here to let behat catch the failure.
                              throw new Error('Could not render the template');
                          });
                      });
                  },
                  failure: function() {
                      // AJAX request timed out. Leave a user the opportunity to retry it.
                      menu.setAttribute(ATTRS.LOADER_LOADING, '');
                      M.util.js_complete(key);
                  }
              }
          });
      },
  
      /**
       * Constrains the node to its the page width.
       *
       * @method constrain
       * @param {Node} node
       */
      constrain: function(node) {
          var selector = node.getData('constraint'),
              nx = node.getX(),
              ny = node.getY(),
              nwidth = node.get('offsetWidth'),
              nheight = node.get('offsetHeight'),
              cx = 0,
              cy = 0,
              cwidth,
              cheight,
              coverflow = 'auto',
              newwidth = null,
              newheight = null,
              newleft = null,
              newtop = null,
              boxshadow = null;
  
          if (selector) {
              selector = node.ancestor(selector);
          }
          if (selector) {
              cwidth = selector.get('offsetWidth');
              cheight = selector.get('offsetHeight');
              cx = selector.getX();
              cy = selector.getY();
              coverflow = selector.getStyle('overflow') || 'auto';
          } else {
              cwidth = node.get('docWidth');
              cheight = node.get('docHeight');
          }
  
          // Constrain X.
          // First up if the width is more than the constrain its easily full width + full height.
          if (nwidth > cwidth) {
              // The width of the constraint.
              newwidth = nwidth = cwidth;
              // The constraints xpoint.
              newleft = nx = cx;
          } else {
              if (nx < cx) {
                  // If nx is less than cx we need to move it right.
                  newleft = nx = cx;
              } else if (nx + nwidth >= cx + cwidth) {
                  // The top right of the node is outside of the constraint, move it in.
                  newleft = cx + cwidth - nwidth;
              }
          }
  
          // Constrain Y.
          if (nheight > cheight && coverflow.toLowerCase() === 'hidden') {
              // The node extends over the constrained area and would be clipped.
              // Reduce the height of the node and force its overflow to scroll.
              newheight = nheight = cheight;
              node.setStyle('overflow', 'auto');
          }
          // If the node is below the top of the constraint AND
          //    the node is longer than the constraint allows.
          if (ny >= cy && ny + nheight > cy + cheight) {
              // Move it up.
              newtop = cy + cheight - nheight;
              try {
                  boxshadow = node.getStyle('boxShadow').replace(/.*? (\d+)px \d+px$/, '$1');
                  if (new RegExp(/^\d+$/).test(boxshadow) && newtop - cy > boxshadow) {
                      newtop -= boxshadow;
                  }
              } catch (ex) {
              }
          }
  
          if (newleft !== null) {
              node.setX(newleft);
          }
          if (newtop !== null) {
              node.setY(newtop);
          }
          if (newwidth !== null) {
              node.setStyle('width', newwidth.toString() + 'px');
          }
          if (newheight !== null) {
              node.setStyle('height', newheight.toString() + 'px');
          }
      }
  };
  
  Y.extend(ACTIONMENU, Y.Base, ACTIONMENU.prototype, {
      NAME: 'moodle-core-actionmenu',
      ATTRS: {
          align: {
              value: [
                  ALIGN.TR, // The dialogue.
                  ALIGN.BR  // The button
              ]
          }
      }
  });
  
  M.core = M.core || {};
  M.core.actionmenu = M.core.actionmenu || {};
  
  /**
   *
   * @static
   * @property M.core.actionmenu.instance
   * @type {ACTIONMENU}
   */
  M.core.actionmenu.instance = null;
  
  /**
   * Init function - will only ever create one instance of the actionmenu class.
   *
   * @method M.core.actionmenu.init
   * @static
   * @param {Object} params
   */
  M.core.actionmenu.init = M.core.actionmenu.init || function(params) {
      M.core.actionmenu.instance = M.core.actionmenu.instance || new ACTIONMENU(params);
  };
  
  /**
   * Registers a new DOM node with the action menu causing it to be enhanced if required.
   *
   * @method M.core.actionmenu.newDOMNode
   * @param node
   * @return {boolean}
   */
  M.core.actionmenu.newDOMNode = function(node) {
      if (M.core.actionmenu.instance === null) {
          return true;
      }
      node.all(SELECTOR.MENU).each(M.core.actionmenu.instance.enhance, M.core.actionmenu.instance);
  };
  
  
  }, '@VERSION@', {"requires": ["base", "event", "node-event-simulate"]});
  