gadget-Morebits.js

//  /**  * morebits.js  * ===========  * A library full of lots of goodness for user scripts on MediaWiki wikis, including Wiki Tiếng Việt.  *  * The highlights include:  *   - Morebits.quickForm class - generates quick HTML forms on the fly  *   - Morebits.wiki.api class - makes calls to the MediaWiki API  *   - Morebits.wiki.page class - modifies pages on the wiki (edit, revert, delete, etc.)  *   - Morebits.wikitext class - contains some utilities for dealing with wikitext  *   - Morebits.status class - a rough-and-ready status message displayer, used by the Morebits.wiki classes  *   - Morebits.simpleWindow class - a wrapper for jQuery UI Dialog with a custom look and extra features  *  * Dependencies:  *   - The whole thing relies on jQuery.  But most wikis should provide this by default.  *   - Morebits.quickForm, Morebits.simpleWindow, and Morebits.status rely on the "morebits.css" file for their styling.  *   - Morebits.simpleWindow and Morebits.quickForm tooltips rely on jquery UI Dialog (from ResourceLoader module name 'jquery.ui').  *   - To create a gadget based on morebits.js, use this syntax in MediaWiki:Gadgets-definition:  *       * GadgetName[ResourceLoader|dependencies=mediawiki.user,mediawiki.util,mediawiki.Title,jquery.ui]|morebits.js|morebits.css|GadgetName.js  *   - Alternatively, you can configure morebits.js as a hidden gadget in MediaWiki:Gadgets-definition:  *       * morebits[ResourceLoader|dependencies=mediawiki.user,mediawiki.util,mediawiki.Title,jquery.ui|hidden]|morebits.js|morebits.css  *     and then load ext.gadget.morebits as one of the dependencies for the new gadget  *  * All the stuff here works on all browsers for which MediaWiki provides JavaScript support.  *  * This library is maintained by the maintainers of Twinkle.  * For queries, suggestions, help, etc., head to [[Wikipedia talk:Twinkle]] on English Wikipedia [http://en.wikipedia.org].  * The latest development source is available at [https://github.com/azatoth/twinkle/blob/master/morebits.js].  */   (function (window, document, $) { // Wrap entire file with anonymous function  var Morebits = {}; window.Morebits = Morebits;  // allow global access    /**  * **************** Morebits.userIsInGroup() ****************  * Simple helper function to see what groups a user might belong  * @param {string} group  eg. `sysop`, `extendedconfirmed`, etc  * @returns {boolean}  */ Morebits.userIsInGroup = function (group) { return mw.config.get('wgUserGroups').indexOf(group) !== -1; }; // Used a lot Morebits.userIsSysop = Morebits.userIsInGroup('sysop');    /**  * **************** Morebits.sanitizeIPv6() ****************  * JavaScript translation of the MediaWiki core function IP::sanitizeIP() in  * includes/utils/IP.php.  * Converts an IPv6 address to the canonical form stored and used by MediaWiki.  * @param {string} address - The IPv6 address  * @returns {string}  */ Morebits.sanitizeIPv6 = function (address) { address = address.trim(); if (address === '') { return null; } if (!mw.util.isIPv6Address(address)) { return address; // nothing else to do for IPv4 addresses or invalid ones } // Remove any whitespaces, convert to upper case address = address.toUpperCase(); // Expand zero abbreviations var abbrevPos = address.indexOf('::'); if (abbrevPos > -1) { // We know this is valid IPv6. Find the last index of the // address before any CIDR number (e.g. "a:b:c::/24"). var CIDRStart = address.indexOf('/'); var addressEnd = CIDRStart > -1 ? CIDRStart - 1 : address.length - 1; // If the '::' is at the beginning... var repeat, extra, pad; if (abbrevPos === 0) { repeat = '0:'; extra = address === '::' ? '0' : ''; // for the address '::' pad = 9; // 7+2 (due to '::') // If the '::' is at the end... } else if (abbrevPos === (addressEnd - 1)) { repeat = ':0'; extra = ''; pad = 9; // 7+2 (due to '::') // If the '::' is in the middle... } else { repeat = ':0'; extra = ':'; pad = 8; // 6+2 (due to '::') } var replacement = repeat; pad -= address.split(':').length - 1; for (var i = 1; i < pad; i++) { replacement += repeat; } replacement += extra; address = address.replace('::', replacement); } // Remove leading zeros from each bloc as needed address = address.replace(/(^|:)0+([0-9A-Fa-f]{1,4})/g, '$1$2');  return address; };    /**  * **************** Morebits.quickForm ****************  * Morebits.quickForm is a class for creation of simple and standard forms without much  * specific coding.  *  * Index to Morebits.quickForm element types:  *  *   select    A combo box (aka drop-down).  *              - Attributes: name, label, multiple, size, list, event, disabled  *   option    An element for a combo box.  *              - Attributes: value, label, selected, disabled  *   optgroup  A group of "option"s.  *              - Attributes: label, list  *   field     A fieldset (aka group box).  *              - Attributes: name, label, disabled  *   checkbox  A checkbox. Must use "list" parameter.  *              - Attributes: name, list, event  *              - Attributes (within list): name, label, value, checked, disabled, event, subgroup  *   radio     A radio button. Must use "list" parameter.  *              - Attributes: name, list, event  *              - Attributes (within list): name, label, value, checked, disabled, event, subgroup  *   input     A text box.  *              - Attributes: name, label, value, size, disabled, required, readonly, maxlength, event  *   dyninput  A set of text boxes with "Remove" buttons and an "Add" button.  *              - Attributes: name, label, min, max, sublabel, value, size, maxlength, event  *   hidden    An invisible form field.  *              - Attributes: name, value  *   header    A level 5 header.  *              - Attributes: label  *   div       A generic placeholder element or label.  *              - Attributes: name, label  *   submit    A submit button. Morebits.simpleWindow moves these to the footer of the dialog.  *              - Attributes: name, label, disabled  *   button    A generic button.  *              - Attributes: name, label, disabled, event  *   textarea  A big, multi-line text box.  *              - Attributes: name, label, value, cols, rows, disabled, required, readonly  *   fragment  A DocumentFragment object.  *              - No attributes, and no global attributes except adminonly  *  * Global attributes: id, className, style, tooltip, extra, adminonly  */  /**  * @constructor  * @param {event} event - Function to execute when form is submitted  * @param {string} [eventType=submit] - Type of the event (default: submit)  */ Morebits.quickForm = function QuickForm(event, eventType) { this.root = new Morebits.quickForm.element({ type: 'form', event: event, eventType: eventType }); };  /**  * Renders the HTML output of the quickForm  * @returns {HTMLElement}  */ Morebits.quickForm.prototype.render = function QuickFormRender() { var ret = this.root.render(); ret.names = {}; return ret; };  /**  * Append element to the form  * @param {(Object|Morebits.quickForm.element)} data - a quickform element, or the object with which  * a quickform element is constructed.  * @returns {Morebits.quickForm.element} - same as what is passed to the function  */ Morebits.quickForm.prototype.append = function QuickFormAppend(data) { return this.root.append(data); };  /**  * @constructor  * @param {Object} data - Object representing the quickform element. See class documentation  * comment for available types and attributes for each.  */ Morebits.quickForm.element = function QuickFormElement(data) { this.data = data; this.childs = []; this.id = Morebits.quickForm.element.id++; };  Morebits.quickForm.element.id = 0;  /**  * Appends an element to current element  * @param {Morebits.quickForm.element} data  A quickForm element or the object required to  * create the quickForm element  * @returns {Morebits.quickForm.element} The same element passed in  */ Morebits.quickForm.element.prototype.append = function QuickFormElementAppend(data) { var child; if (data instanceof Morebits.quickForm.element) { child = data; } else { child = new Morebits.quickForm.element(data); } this.childs.push(child); return child; };  /**  * Renders the HTML output for the quickForm element  * This should be called without parameters: form.render()  * @returns {HTMLElement}  */ Morebits.quickForm.element.prototype.render = function QuickFormElementRender(internal_subgroup_id) { var currentNode = this.compute(this.data, internal_subgroup_id);  for (var i = 0; i < this.childs.length; ++i) { // do not pass internal_subgroup_id to recursive calls currentNode[1].appendChild(this.childs[i].render()); } return currentNode[0]; };  Morebits.quickForm.element.prototype.compute = function QuickFormElementCompute(data, in_id) { var node; var childContainder = null; var label; var id = (in_id ? in_id + '_' : '') + 'node_' + this.id; if (data.adminonly && !Morebits.userIsSysop) { // hell hack alpha data.type = 'hidden'; }  var i, current, subnode; switch (data.type) { case 'form': node = document.createElement('form'); node.className = 'quickform'; node.setAttribute('action', 'javascript:void(0);'); if (data.event) { node.addEventListener(data.eventType || 'submit', data.event, false); } break; case 'fragment': node = document.createDocumentFragment(); // fragments can't have any attributes, so just return it straight away return [ node, node ]; case 'select': node = document.createElement('div');  node.setAttribute('id', 'div_' + id); if (data.label) { label = node.appendChild(document.createElement('label')); label.setAttribute('for', id); label.appendChild(document.createTextNode(data.label)); } var select = node.appendChild(document.createElement('select')); if (data.event) { select.addEventListener('change', data.event, false); } if (data.multiple) { select.setAttribute('multiple', 'multiple'); } if (data.size) { select.setAttribute('size', data.size); } if (data.disabled) { select.setAttribute('disabled', 'disabled'); } select.setAttribute('name', data.name);  if (data.list) { for (i = 0; i < data.list.length; ++i) {  current = data.list[i];  if (current.list) { current.type = 'optgroup'; } else { current.type = 'option'; }  subnode = this.compute(current); select.appendChild(subnode[0]); } } childContainder = select; break; case 'option': node = document.createElement('option'); node.values = data.value; node.setAttribute('value', data.value); if (data.selected) { node.setAttribute('selected', 'selected'); } if (data.disabled) { node.setAttribute('disabled', 'disabled'); } node.setAttribute('label', data.label); node.appendChild(document.createTextNode(data.label)); break; case 'optgroup': node = document.createElement('optgroup'); node.setAttribute('label', data.label);  if (data.list) { for (i = 0; i < data.list.length; ++i) {  current = data.list[i]; current.type = 'option'; // must be options here  subnode = this.compute(current); node.appendChild(subnode[0]); } } break; case 'field': node = document.createElement('fieldset'); label = node.appendChild(document.createElement('legend')); label.appendChild(document.createTextNode(data.label)); if (data.name) { node.setAttribute('name', data.name); } if (data.disabled) { node.setAttribute('disabled', 'disabled'); } break; case 'checkbox': case 'radio': node = document.createElement('div'); if (data.list) { for (i = 0; i < data.list.length; ++i) { var cur_id = id + '_' + i; current = data.list[i]; var cur_div; if (current.type === 'header') { // inline hack cur_div = node.appendChild(document.createElement('h6')); cur_div.appendChild(document.createTextNode(current.label)); if (current.tooltip) { Morebits.quickForm.element.generateTooltip(cur_div, current); } continue; } cur_div = node.appendChild(document.createElement('div')); subnode = cur_div.appendChild(document.createElement('input')); subnode.values = current.value; subnode.setAttribute('value', current.value); subnode.setAttribute('type', data.type); subnode.setAttribute('id', cur_id); subnode.setAttribute('name', current.name || data.name);  // If name is provided on the individual checkbox, add a data-single // attribute which indicates it isn't part of a list of checkboxes with // same name. Used in getInputData() if (current.name) { subnode.setAttribute('data-single', 'data-single'); }  if (current.checked) { subnode.setAttribute('checked', 'checked'); } if (current.disabled) { subnode.setAttribute('disabled', 'disabled'); } label = cur_div.appendChild(document.createElement('label')); label.appendChild(document.createTextNode(current.label)); label.setAttribute('for', cur_id); if (current.tooltip) { Morebits.quickForm.element.generateTooltip(label, current); } // styles go on the label, doesn't make sense to style a checkbox/radio if (current.style) { label.setAttribute('style', current.style); }  var event; if (current.subgroup) { var tmpgroup = current.subgroup;  if (!Array.isArray(tmpgroup)) { tmpgroup = [ tmpgroup ]; }  var subgroupRaw = new Morebits.quickForm.element({ type: 'div', id: id + '_' + i + '_subgroup' }); $.each(tmpgroup, function(idx, el) { var newEl = $.extend({}, el); if (!newEl.type) { newEl.type = data.type; } newEl.name = (current.name || data.name) + '.' + newEl.name; subgroupRaw.append(newEl); });  var subgroup = subgroupRaw.render(cur_id); subgroup.className = 'quickformSubgroup'; subnode.subgroup = subgroup; subnode.shown = false;  event = function(e) { if (e.target.checked) { e.target.parentNode.appendChild(e.target.subgroup); if (e.target.type === 'radio') { var name = e.target.name; if (e.target.form.names[name] !== undefined) { e.target.form.names[name].parentNode.removeChild(e.target.form.names[name].subgroup); } e.target.form.names[name] = e.target; } } else { e.target.parentNode.removeChild(e.target.subgroup); } }; subnode.addEventListener('change', event, true); if (current.checked) { subnode.parentNode.appendChild(subgroup); } } else if (data.type === 'radio') { event = function(e) { if (e.target.checked) { var name = e.target.name; if (e.target.form.names[name] !== undefined) { e.target.form.names[name].parentNode.removeChild(e.target.form.names[name].subgroup); } delete e.target.form.names[name]; } }; subnode.addEventListener('change', event, true); } // add users' event last, so it can interact with the subgroup if (data.event) { subnode.addEventListener('change', data.event, false); } else if (current.event) { subnode.addEventListener('change', current.event, true); } } } if (data.shiftClickSupport && data.type === 'checkbox') { Morebits.checkboxShiftClickSupport(Morebits.quickForm.getElements(node, data.name)); } break; case 'input': node = document.createElement('div'); node.setAttribute('id', 'div_' + id);  if (data.label) { label = node.appendChild(document.createElement('label')); label.appendChild(document.createTextNode(data.label)); label.setAttribute('for', data.id || id); }  subnode = node.appendChild(document.createElement('input')); if (data.value) { subnode.setAttribute('value', data.value); } subnode.setAttribute('name', data.name); subnode.setAttribute('type', 'text'); if (data.size) { subnode.setAttribute('size', data.size); } if (data.disabled) { subnode.setAttribute('disabled', 'disabled'); } if (data.required) { subnode.setAttribute('required', 'required'); } if (data.readonly) { subnode.setAttribute('readonly', 'readonly'); } if (data.maxlength) { subnode.setAttribute('maxlength', data.maxlength); } if (data.event) { subnode.addEventListener('keyup', data.event, false); } childContainder = subnode; break; case 'dyninput': var min = data.min || 1; var max = data.max || Infinity;  node = document.createElement('div');  label = node.appendChild(document.createElement('h5')); label.appendChild(document.createTextNode(data.label));  var listNode = node.appendChild(document.createElement('div'));  var more = this.compute({ type: 'button', label: 'more', disabled: min >= max, event: function(e) { var new_node = new Morebits.quickForm.element(e.target.sublist); e.target.area.appendChild(new_node.render());  if (++e.target.counter >= e.target.max) { e.target.setAttribute('disabled', 'disabled'); } e.stopPropagation(); } });  node.appendChild(more[0]); var moreButton = more[1];  var sublist = { type: '_dyninput_element', label: data.sublabel || data.label, name: data.name, value: data.value, size: data.size, remove: false, maxlength: data.maxlength, event: data.event };  for (i = 0; i < min; ++i) { var elem = new Morebits.quickForm.element(sublist); listNode.appendChild(elem.render()); } sublist.remove = true; sublist.morebutton = moreButton; sublist.listnode = listNode;  moreButton.sublist = sublist; moreButton.area = listNode; moreButton.max = max - min; moreButton.counter = 0; break; case '_dyninput_element': // Private, similar to normal input node = document.createElement('div');  if (data.label) { label = node.appendChild(document.createElement('label')); label.appendChild(document.createTextNode(data.label)); label.setAttribute('for', id); }  subnode = node.appendChild(document.createElement('input')); if (data.value) { subnode.setAttribute('value', data.value); } subnode.setAttribute('name', data.name); subnode.setAttribute('type', 'text'); if (data.size) { subnode.setAttribute('size', data.size); } if (data.maxlength) { subnode.setAttribute('maxlength', data.maxlength); } if (data.event) { subnode.addEventListener('keyup', data.event, false); } if (data.remove) { var remove = this.compute({ type: 'button', label: 'remove', event: function(e) { var list = e.target.listnode; var node = e.target.inputnode; var more = e.target.morebutton;  list.removeChild(node); --more.counter; more.removeAttribute('disabled'); e.stopPropagation(); } }); node.appendChild(remove[0]); var removeButton = remove[1]; removeButton.inputnode = node; removeButton.listnode = data.listnode; removeButton.morebutton = data.morebutton; } break; case 'hidden': node = document.createElement('input'); node.setAttribute('type', 'hidden'); node.values = data.value; node.setAttribute('value', data.value); node.setAttribute('name', data.name); break; case 'header': node = document.createElement('h5'); node.appendChild(document.createTextNode(data.label)); break; case 'div': node = document.createElement('div'); if (data.name) { node.setAttribute('name', data.name); } if (data.label) { if (!Array.isArray(data.label)) { data.label = [ data.label ]; } var result = document.createElement('span'); result.className = 'quickformDescription'; for (i = 0; i < data.label.length; ++i) { if (typeof data.label[i] === 'string') { result.appendChild(document.createTextNode(data.label[i])); } else if (data.label[i] instanceof Element) { result.appendChild(data.label[i]); } } node.appendChild(result); } break; case 'submit': node = document.createElement('span'); childContainder = node.appendChild(document.createElement('input')); childContainder.setAttribute('type', 'submit'); if (data.label) { childContainder.setAttribute('value', data.label); } childContainder.setAttribute('name', data.name || 'submit'); if (data.disabled) { childContainder.setAttribute('disabled', 'disabled'); } break; case 'button': node = document.createElement('span'); childContainder = node.appendChild(document.createElement('input')); childContainder.setAttribute('type', 'button'); if (data.label) { childContainder.setAttribute('value', data.label); } childContainder.setAttribute('name', data.name); if (data.disabled) { childContainder.setAttribute('disabled', 'disabled'); } if (data.event) { childContainder.addEventListener('click', data.event, false); } break; case 'textarea': node = document.createElement('div'); node.setAttribute('id', 'div_' + id); if (data.label) { label = node.appendChild(document.createElement('h5')); var labelElement = document.createElement('label'); labelElement.textContent = data.label; labelElement.setAttribute('for', data.id || id); label.appendChild(labelElement); } subnode = node.appendChild(document.createElement('textarea')); subnode.setAttribute('name', data.name); if (data.cols) { subnode.setAttribute('cols', data.cols); } if (data.rows) { subnode.setAttribute('rows', data.rows); } if (data.disabled) { subnode.setAttribute('disabled', 'disabled'); } if (data.required) { subnode.setAttribute('required', 'required'); } if (data.readonly) { subnode.setAttribute('readonly', 'readonly'); } if (data.value) { subnode.value = data.value; } childContainder = subnode; break; default: throw new Error('Morebits.quickForm: unknown element type ' + data.type.toString()); }  if (!childContainder) { childContainder = node; } if (data.tooltip) { Morebits.quickForm.element.generateTooltip(label || node, data); }  if (data.extra) { childContainder.extra = data.extra; } if (data.style) { childContainder.setAttribute('style', data.style); } if (data.className) { childContainder.className = childContainder.className ? childContainder.className + ' ' + data.className : data.className; } childContainder.setAttribute('id', data.id || id);  return [ node, childContainder ]; };  /**  * Create a jquery.ui-based tooltip.  * @requires jquery.ui  * @param {HTMLElement} node - the HTML element beside which a tooltip is to be generated  * @param {Object} data - tooltip-related configuration data  */ Morebits.quickForm.element.generateTooltip = function QuickFormElementGenerateTooltip(node, data) { var tooltipButton = node.appendChild(document.createElement('span')); tooltipButton.className = 'morebits-tooltipButton'; tooltipButton.title = data.tooltip; // Provides the content for jQuery UI tooltipButton.appendChild(document.createTextNode('?')); $(tooltipButton).tooltip({ position: { my: 'left top', at: 'center bottom', collision: 'flipfit' }, // Deprecated in UI 1.12, but MW stuck on 1.9.2 indefinitely; see #398 and T71386 tooltipClass: 'morebits-ui-tooltip' }); };   // Some utility methods for manipulating quickForms after their creation: // (None of these work for "dyninput" type fields at present)  /**  * Returns an object containing all filled form data entered by the user, with the object  * keys being the form element names. Disabled fields will be ignored, but not hidden fields.  * @param {HTMLFormElement} form  * @returns {Object} with field names as keys, input data as values  */ Morebits.quickForm.getInputData = function(form) { var result = {};  for (var i = 0; i < form.elements.length; i++) { var field = form.elements[i]; if (field.disabled || !field.name || !field.type || field.type === 'submit' || field.type === 'button') { continue; }  // For elements in subgroups, quickform prepends element names with // name of the parent group followed by a period, get rid of that. var fieldNameNorm = field.name.slice(field.name.indexOf('.') + 1);  switch (field.type) { case 'radio': if (field.checked) { result[fieldNameNorm] = field.value; } break; case 'checkbox': if (field.dataset.single) { result[fieldNameNorm] = field.checked; // boolean } else { result[fieldNameNorm] = result[fieldNameNorm] || []; if (field.checked) { result[fieldNameNorm].push(field.value); } } break; case 'select-multiple': result[fieldNameNorm] = $(field).val(); // field.value doesn't work break; case 'text': // falls through case 'textarea': result[fieldNameNorm] = field.value.trim(); break; default: // could be select-one, date, number, email, etc if (field.value) { result[fieldNameNorm] = field.value; } break; } } return result; };   /**  * Returns all form elements with a given field name or ID  * @param {HTMLFormElement} form  * @param {string} fieldName - the name or id of the fields  * @returns {HTMLElement[]} - array of matching form elements  */ Morebits.quickForm.getElements = function QuickFormGetElements(form, fieldName) { var $form = $(form); fieldName = $.escapeSelector(fieldName); // sanitize input var $elements = $form.find('[name="' + fieldName + '"]'); if ($elements.length > 0) { return $elements.toArray(); } $elements = $form.find('#' + fieldName); return $elements.toArray(); };  /**  * Searches the array of elements for a checkbox or radio button with a certain  * `value` attribute, and returns the first such element. Returns null if not found.  * @param {HTMLInputElement[]} elementArray - array of checkbox or radio elements  * @param {string} value - value to search for  * @returns {HTMLInputElement}  */ Morebits.quickForm.getCheckboxOrRadio = function QuickFormGetCheckboxOrRadio(elementArray, value) { var found = $.grep(elementArray, function(el) { return el.value === value; }); if (found.length > 0) { return found[0]; } return null; };  /**  * Returns the 
 containing the form element, or the form element itself  * May not work as expected on checkboxes or radios  * @param {HTMLElement} element  * @returns {HTMLElement}  */ Morebits.quickForm.getElementContainer = function QuickFormGetElementContainer(element) { // for divs, headings and fieldsets, the container is the element itself if (element instanceof HTMLFieldSetElement || element instanceof HTMLDivElement || element instanceof HTMLHeadingElement) { return element; }  // for others, just return the parent node return element.parentNode; };  /**  * Gets the HTML element that contains the label of the given form element  * (mainly for internal use)  * @param {(HTMLElement|Morebits.quickForm.element)} element  * @returns {HTMLElement}  */ Morebits.quickForm.getElementLabelObject = function QuickFormGetElementLabelObject(element) { // for buttons, divs and headers, the label is on the element itself if (element.type === 'button' || element.type === 'submit' || element instanceof HTMLDivElement || element instanceof HTMLHeadingElement) { return element; // for fieldsets, the label is the child 
 element } else if (element instanceof HTMLFieldSetElement) { return element.getElementsByTagName('legend')[0]; // for textareas, the label is the sibling 
 element } else if (element instanceof HTMLTextAreaElement) { return element.parentNode.getElementsByTagName('h5')[0]; } // for others, the label is the sibling  element return element.parentNode.getElementsByTagName('label')[0]; };  /**  * Gets the label text of the element  * @param {(HTMLElement|Morebits.quickForm.element)} element  * @returns {string}  */ Morebits.quickForm.getElementLabel = function QuickFormGetElementLabel(element) { var labelElement = Morebits.quickForm.getElementLabelObject(element);  if (!labelElement) { return null; } return labelElement.firstChild.textContent; };  /**  * Sets the label of the element to the given text  * @param {(HTMLElement|Morebits.quickForm.element)} element  * @param {string} labelText  * @returns {boolean} true if succeeded, false if the label element is unavailable  */ Morebits.quickForm.setElementLabel = function QuickFormSetElementLabel(element, labelText) { var labelElement = Morebits.quickForm.getElementLabelObject(element);  if (!labelElement) { return false; } labelElement.firstChild.textContent = labelText; return true; };  /**  * Stores the element's current label, and temporarily sets the label to the given text  * @param {(HTMLElement|Morebits.quickForm.element)} element  * @param {string} temporaryLabelText  * @returns {boolean} true if succeeded, false if the label element is unavailable  */ Morebits.quickForm.overrideElementLabel = function QuickFormOverrideElementLabel(element, temporaryLabelText) { if (!element.hasAttribute('data-oldlabel')) { element.setAttribute('data-oldlabel', Morebits.quickForm.getElementLabel(element)); } return Morebits.quickForm.setElementLabel(element, temporaryLabelText); };  /**  * Restores the label stored by overrideElementLabel  * @param {(HTMLElement|Morebits.quickForm.element)} element  * @returns {boolean} true if succeeded, false if the label element is unavailable  */ Morebits.quickForm.resetElementLabel = function QuickFormResetElementLabel(element) { if (element.hasAttribute('data-oldlabel')) { return Morebits.quickForm.setElementLabel(element, element.getAttribute('data-oldlabel')); } return null; };  /**  * Shows or hides a form element plus its label and tooltip  * @param {(HTMLElement|jQuery|string)} element  HTML/jQuery element, or jQuery selector string  * @param {boolean} [visibility] Skip this to toggle visibility  */ Morebits.quickForm.setElementVisibility = function QuickFormSetElementVisibility(element, visibility) { $(element).toggle(visibility); };  /**  * Shows or hides the "question mark" icon (which displays the tooltip) next to a form element  * @param {(HTMLElement|jQuery)} element  * @param {boolean} [visibility] Skip this to toggle visibility  */ Morebits.quickForm.setElementTooltipVisibility = function QuickFormSetElementTooltipVisibility(element, visibility) { $(Morebits.quickForm.getElementContainer(element)).find('.morebits-tooltipButton').toggle(visibility); };    /**  * **************** HTMLFormElement ****************  */  /**  * Returns an array containing the values of elements with the given name, that has it's  * checked property set to true. (i.e. a checkbox or a radiobutton is checked), or select  * options that have selected set to true. (don't try to mix selects with radio/checkboxes,  * please)  * Type is optional and can specify if either radio or checkbox (for the event  * that both checkboxes and radiobuttons have the same name.  */ HTMLFormElement.prototype.getChecked = function(name, type) { var elements = this.elements[name]; if (!elements) { return []; } var return_array = []; var i; if (elements instanceof HTMLSelectElement) { var options = elements.options; for (i = 0; i < options.length; ++i) { if (options[i].selected) { if (options[i].values) { return_array.push(options[i].values); } else { return_array.push(options[i].value); }  } } } else if (elements instanceof HTMLInputElement) { if (type && elements.type !== type) { return []; } else if (elements.checked) { return [ elements.value ]; } } else { for (i = 0; i < elements.length; ++i) { if (elements[i].checked) { if (type && elements[i].type !== type) { continue; } if (elements[i].values) { return_array.push(elements[i].values); } else { return_array.push(elements[i].value); } } } } return return_array; };  /**  * getUnchecked:  *   Does the same as getChecked above, but with unchecked elements.  */  HTMLFormElement.prototype.getUnchecked = function(name, type) { var elements = this.elements[name]; if (!elements) { return []; } var return_array = []; var i; if (elements instanceof HTMLSelectElement) { var options = elements.options; for (i = 0; i < options.length; ++i) { if (!options[i].selected) { if (options[i].values) { return_array.push(options[i].values); } else { return_array.push(options[i].value); }  } } } else if (elements instanceof HTMLInputElement) { if (type && elements.type !== type) { return []; } else if (!elements.checked) { return [ elements.value ]; } } else { for (i = 0; i < elements.length; ++i) { if (!elements[i].checked) { if (type && elements[i].type !== type) { continue; } if (elements[i].values) { return_array.push(elements[i].values); } else { return_array.push(elements[i].value); } } } } return return_array; };   /**  * @deprecated as of September 2020, use Morebits.string.escapeRegExp or  * mw.util.escapeRegExp  */ RegExp.escape = function(text, space_fix) { if (space_fix) { console.log('NOTE: RegExp.escape from Morebits was deprecated September 2020, please replace it with Morebits.string.escapeRegExp'); // eslint-disable-line no-console return Morebits.string.escapeRegExp(text); } console.log('NOTE: RegExp.escape from Morebits was deprecated September 2020, please replace it with mw.util.escapeRegExp'); // eslint-disable-line no-console return mw.util.escapeRegExp(text); };   /**  * **************** String; Morebits.string ****************  */  Morebits.string = { // Helper functions to change case of a string toUpperCaseFirstChar: function(str) { str = str.toString(); return str.substr(0, 1).toUpperCase() + str.substr(1); }, toLowerCaseFirstChar: function(str) { str = str.toString(); return str.substr(0, 1).toLowerCase() + str.substr(1); },  /**  * Gives an array of substrings of `str` starting with `start` and  * ending with `end`, which is not in `skiplist`  * @param {string} str  * @param {string} start  * @param {string} end  * @param {(string[]|string)} [skiplist]  * @returns {String[]}  */ splitWeightedByKeys: function(str, start, end, skiplist) { if (start.length !== end.length) { throw new Error('start marker and end marker must be of the same length'); } var level = 0; var initial = null; var result = []; if (!Array.isArray(skiplist)) { if (skiplist === undefined) { skiplist = []; } else if (typeof skiplist === 'string') { skiplist = [ skiplist ]; } else { throw new Error('non-applicable skiplist parameter'); } } for (var i = 0; i < str.length; ++i) { for (var j = 0; j < skiplist.length; ++j) { if (str.substr(i, skiplist[j].length) === skiplist[j]) { i += skiplist[j].length - 1; continue; } } if (str.substr(i, start.length) === start) { if (initial === null) { initial = i; } ++level; i += start.length - 1; } else if (str.substr(i, end.length) === end) { --level; i += end.length - 1; } if (!level && initial !== null) { result.push(str.substring(initial, i + 1)); initial = null; } }  return result; },  /**  * Formats freeform "reason" (from a textarea) for deletion/other templates  * that are going to be substituted, (e.g. PROD, XFD, RPP)  * @param {string} str  * @returns {string}  */ formatReasonText: function(str) { var result = str.toString().trim(); var unbinder = new Morebits.unbinder(result); unbinder.unbind('', ''); unbinder.content = unbinder.content.replace(/\|/g, '{{subst:!}}'); return unbinder.rebind(); },  /**  * Formats a "reason" (from a textarea) for inclusion in a userspace log  * @param {string} str  * @returns {string}  */ formatReasonForLog: function(str) { return str // handle line breaks, which otherwise break numbering .replace(/\n+/g, '{{pb}}') // put an extra # in front before bulleted or numbered list items .replace(/^(#+)/mg, '#$1') .replace(/^(\*+)/mg, '#$1'); },  /**  * Like `String.prototype.replace()`, but escapes any dollar signs in the replacement string.  * Useful when the the replacement string is arbitrary, such as a username or freeform user input,  * and could contain dollar signs.  * @param {string} string - text in which to replace  * @param {(string|RegExp)} pattern  * @param {string} replacement  * @returns {string}  */ safeReplace: function morebitsStringSafeReplace(string, pattern, replacement) { return string.replace(pattern, replacement.replace(/\$/g, '$$$$')); },  /**  * Determine if user input expiration will be translated to an  * infinite-length by MW: https://phabricator.wikimedia.org/T68646  * @param {string} expiry  * @returns {boolean}  */ isInfinity: function morebitsStringIsInfinity(expiry) { return ['indefinite', 'infinity', 'infinite', 'never'].indexOf(expiry) !== -1; },  /**  * Escapes a string to be used in a RegExp, replacing spaces and  * underscores with `[ _]` as they are often equivalent  * Replaced RegExp.escape September 2020  * @param {string} text - string to be escaped  * @returns {string} - the escaped text  */ escapeRegExp: function(text) { return mw.util.escapeRegExp(text).replace(/ |_/g, '[_ ]'); } };   /**  * **************** Morebits.array ****************  */  Morebits.array = { /**  * @returns {Array} a copy of the array with duplicates removed  */ uniq: function(arr) { if (!Array.isArray(arr)) { throw 'A non-array object passed to Morebits.array.uniq'; } return arr.filter(function(item, idx) { return arr.indexOf(item) === idx; }); },  /**  * @returns {Array} a copy of the array with the first instance of each value  * removed; subsequent instances of those values (duplicates) remain  */ dups: function(arr) { if (!Array.isArray(arr)) { throw 'A non-array object passed to Morebits.array.dups'; } return arr.filter(function(item, idx) { return arr.indexOf(item) !== idx; }); },   /**  * Break up an array into smaller arrays.  * @param {Array} arr  * @param {number} size - Size of each chunk (except the last, which could be different)  * @returns {Array} an array of these smaller arrays  */ chunk: function(arr, size) { if (!Array.isArray(arr)) { throw 'A non-array object passed to Morebits.array.chunk'; } if (typeof size !== 'number' || size <= 0) { // pretty impossible to do anything :) return [ arr ]; // we return an array consisting of this array. } var numChunks = Math.ceil(arr.length / size); var result = new Array(numChunks); for (var i = 0; i < numChunks; i++) { result[i] = arr.slice(i * size, (i + 1) * size); } return result; } };  /**  * ************ Morebits.select2 ***************  * Utilities to enhance select2 menus  * See twinklewarn, twinklexfd, twinkleblock for sample usages  */ Morebits.select2 = {  matchers: { /**  * Custom matcher in which if the optgroup name matches, all options in that  * group are shown, like in jquery.chosen  */ optgroupFull: function(params, data) { var originalMatcher = $.fn.select2.defaults.defaults.matcher; var result = originalMatcher(params, data);  if (result && params.term && data.text.toUpperCase().indexOf(params.term.toUpperCase()) !== -1) { result.children = data.children; } return result; },  /** Custom matcher that matches from the beginning of words only */ wordBeginning: function(params, data) { var originalMatcher = $.fn.select2.defaults.defaults.matcher; var result = originalMatcher(params, data); if (!params.term || (result && new RegExp('\\b' + mw.util.escapeRegExp(params.term), 'i').test(result.text))) { return result; } return null; } },  /** Underline matched part of options */ highlightSearchMatches: function(data) { var searchTerm = Morebits.select2SearchQuery; if (!searchTerm || data.loading) { return data.text; } var idx = data.text.toUpperCase().indexOf(searchTerm.toUpperCase()); if (idx < 0) { return data.text; }  return $('').append( data.text.slice(0, idx), $('').css('text-decoration', 'underline').text(data.text.slice(idx, idx + searchTerm.length)), data.text.slice(idx + searchTerm.length) ); },  /** Intercept query as it is happening, for use in highlightSearchMatches */ queryInterceptor: function(params) { Morebits.select2SearchQuery = params && params.term; },  /**  * Open dropdown and begin search when the .select2-selection has focus and a key is pressed  * https://github.com/select2/select2/issues/3279#issuecomment-442524147  */ autoStart: function(ev) { if (ev.which < 48) { return; } var target = $(ev.target).closest('.select2-container'); if (!target.length) { return; } target = target.prev(); target.select2('open'); var search = target.data('select2').dropdown.$search || target.data('select2').selection.$search; search.focus(); }  };   /**  * **************** Morebits.pageNameNorm ****************  * Stores a normalized version of the wgPageName variable (underscores converted to spaces).  * For queen/king/whatever and country!  */ Morebits.pageNameNorm = mw.config.get('wgPageName').replace(/_/g, ' ');   /**  * *************** Morebits.pageNameRegex *****************  * For a page name 'Foo bar', returns the string '[Ff]oo bar'  * @param {string} pageName - page name without namespace  * @returns {string}  */ Morebits.pageNameRegex = function(pageName) { return '[' + pageName[0].toUpperCase() + pageName[0].toLowerCase() + ']' + pageName.slice(1); };   /**  * **************** Morebits.unbinder ****************  * Used for temporarily hiding a part of a string while processing the rest of it.  *  * eg.  var u = new Morebits.unbinder("Hello world  world");  *      u.unbind('');  *      u.content = u.content.replace(/world/g, 'earth');  *      u.rebind(); // gives "Hello earth  earth"  *  * Text within the 'unbinded' part (in this case, the HTML comment) remains intact  * unbind() can be called multiple times to unbind multiple parts of the string.  *  * Used by Morebits.wikitext.page.commentOutImage  */  /**  * @constructor  * @param {string} string  */ Morebits.unbinder = function Unbinder(string) { if (typeof string !== 'string') { throw new Error('không phải là 1 chuỗi'); } this.content = string; this.counter = 0; this.history = {}; this.prefix = '%UNIQ::' + Math.random() + '::'; this.postfix = '::UNIQ%'; };  Morebits.unbinder.prototype = { /**  * @param {string} prefix  * @param {string} postfix  */ unbind: function UnbinderUnbind(prefix, postfix) { var re = new RegExp(prefix + '([\\s\\S]*?)' + postfix, 'g'); this.content = this.content.replace(re, Morebits.unbinder.getCallback(this)); },  /** @returns {string} The output */ rebind: function UnbinderRebind() { var content = this.content; content.self = this; for (var current in this.history) { if (Object.prototype.hasOwnProperty.call(this.history, current)) { content = content.replace(current, this.history[current]); } } return content; }, prefix: null, // %UNIQ::0.5955981644938324:: postfix: null, // ::UNIQ% content: null, // string counter: null, // 0++ history: null // {} };  Morebits.unbinder.getCallback = function UnbinderGetCallback(self) { return function UnbinderCallback(match) { var current = self.prefix + self.counter + self.postfix; self.history[current] = match; ++self.counter; return current; }; };    /**  * **************** Morebits.date ****************  */  /**  * @constructor  * Create a date object. MediaWiki timestamp format is also acceptable,  * in addition to everything that JS Date() accepts.  */ Morebits.date = function() { var args = Array.prototype.slice.call(arguments);  if (typeof args[0] === 'string') { // Attempt to remove a comma and paren-wrapped timezone, to get MediaWiki timestamps to parse // Firefox (at least in 75) seems to be okay with the comma, though args[0] = args[0].replace(/(\d\d:\d\d),/, '$1').replace(/\(UTC\)/, 'UTC'); } this._d = new (Function.prototype.bind.apply(Date, [Date].concat(args))); };  Morebits.date.localeData = { months: ['Tháng 1', 'Tháng 2', 'Tháng 3', 'Tháng 4', 'Tháng 5', 'Tháng 6', 'Tháng 7', 'Tháng 8', 'Tháng 9', 'Tháng 10', 'Tháng 11', 'Tháng 12'], monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], days: ['Chủ Nhật', 'Thứ Hai', 'Thứ Ba', 'Thứ Tư', 'Thứ Năm', 'Thứ Sáu', 'Thứ Bảy'], daysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], relativeTimes: { thisDay: '[Hôm nay lúc] h:mm A', prevDay: '[Ngày hôm qua lúc] h:mm A', nextDay: '[Ngày mai lúc] h:mm A', thisWeek: 'dddd [lúc] h:mm A', pastWeek: '[Lần cuối] dddd [lúc] h:mm A', other: 'YYYY-MM-DD' } };  // Allow native Date.prototype methods to be used on Morebits.date objects Object.getOwnPropertyNames(Date.prototype).forEach(function(func) { Morebits.date.prototype[func] = function() { return this._d[func].apply(this._d, Array.prototype.slice.call(arguments)); }; });  $.extend(Morebits.date.prototype, {  isValid: function() { return !isNaN(this.getTime()); },  /** @param {(Date|Morebits.date)} date */ isBefore: function(date) { return this.getTime() < date.getTime(); }, isAfter: function(date) { return this.getTime() > date.getTime(); },  /** @return {string} */ getUTCMonthName: function() { return Morebits.date.localeData.months[this.getUTCMonth()]; }, getUTCMonthNameAbbrev: function() { return Morebits.date.localeData.monthsShort[this.getUTCMonth()]; }, getMonthName: function() { return Morebits.date.localeData.months[this.getMonth()]; }, getMonthNameAbbrev: function() { return Morebits.date.localeData.monthsShort[this.getMonth()]; }, getUTCDayName: function() { return Morebits.date.localeData.days[this.getUTCDay()]; }, getUTCDayNameAbbrev: function() { return Morebits.date.localeData.daysShort[this.getUTCDay()]; }, getDayName: function() { return Morebits.date.localeData.days[this.getDay()]; }, getDayNameAbbrev: function() { return Morebits.date.localeData.daysShort[this.getDay()]; },  /**  * Add a given number of minutes, hours, days, months or years to the date.  * This is done in-place. The modified date object is also returned, allowing chaining.  * @param {number} number - should be an integer  * @param {string} unit  * @throws {Error} if invalid or unsupported unit is given  * @returns {Morebits.date}  */ add: function(number, unit) { // mapping time units with getter/setter function names var unitMap = { seconds: 'Seconds', minutes: 'Minutes', hours: 'Hours', days: 'Date', months: 'Month', years: 'FullYear' }; var unitNorm = unitMap[unit] || unitMap[unit + 's']; // so that both singular and  plural forms work if (unitNorm) { this['set' + unitNorm](this['get' + unitNorm]() + number); return this; } throw new Error('Invalid unit "' + unit + '": Only ' + Object.keys(unitMap).join(', ') + ' are allowed.'); },  /**  * Subtracts a given number of minutes, hours, days, months or years to the date.  * This is done in-place. The modified date object is also returned, allowing chaining.  * @param {number} number - should be an integer  * @param {string} unit  * @throws {Error} if invalid or unsupported unit is given  * @returns {Morebits.date}  */ subtract: function(number, unit) { return this.add(-number, unit); },  /**  * Formats the date into a string per the given format string.  * Replacement syntax is a subset of that in moment.js.  * @param {string} formatstr  * @param {(string|number)} [zone=system] - 'system' (for browser-default time zone),  * 'utc' (for UTC), or specify a time zone as number of minutes past UTC.  * @returns {string}  */ format: function(formatstr, zone) { var udate = this; // create a new date object that will contain the date to display as system time if (zone === 'utc') { udate = new Morebits.date(this.getTime()).add(this.getTimezoneOffset(), 'minutes'); } else if (typeof zone === 'number') { // convert to utc, then add the utc offset given udate = new Morebits.date(this.getTime()).add(this.getTimezoneOffset() + zone, 'minutes'); }  var pad = function(num) { return num < 10 ? '0' + num : num; }; var h24 = udate.getHours(), m = udate.getMinutes(), s = udate.getSeconds(); var D = udate.getDate(), M = udate.getMonth() + 1, Y = udate.getFullYear(); var h12 = h24 % 12 || 12, amOrPm = h24 >= 12 ? 'PM' : 'AM'; var replacementMap = { 'HH': pad(h24), 'H': h24, 'hh': pad(h12), 'h': h12, 'A': amOrPm, 'mm': pad(m), 'm': m, 'ss': pad(s), 's': s, 'dddd': udate.getDayName(), 'ddd': udate.getDayNameAbbrev(), 'd': udate.getDay(), 'DD': pad(D), 'D': D, 'MMMM': udate.getMonthName(), 'MMM': udate.getMonthNameAbbrev(), 'MM': pad(M), 'M': M, 'YYYY': Y, 'YY': pad(Y % 100), 'Y': Y };  var unbinder = new Morebits.unbinder(formatstr); // escape stuff between [...] unbinder.unbind('\\[', '\\]'); unbinder.content = unbinder.content.replace( /* Regex notes:  * d(d{2,3})? matches exactly 1, 3 or 4 occurrences of 'd' ('dd' is treated as a double match of 'd')  * Y{1,2}(Y{2})? matches exactly 1, 2 or 4 occurrences of 'Y'  */ /H{1,2}|h{1,2}|m{1,2}|s{1,2}|d(d{2,3})?|D{1,2}|M{1,4}|Y{1,2}(Y{2})?|A/g, function(match) { return replacementMap[match]; } ); return unbinder.rebind().replace(/\[(.*?)\]/g, '$1'); },  /**  * Gives a readable relative time string such as "Yesterday at 6:43 PM" or "Last Thursday at 11:45 AM".  * Similar to calendar in moment.js, but with time zone support.  * @param {(string|number)} [zone=system] - 'system' (for browser-default time zone),  * 'utc' (for UTC), or specify a time zone as number of minutes past UTC  * @returns {string}  */ calendar: function(zone) { // Zero out the hours, minutes, seconds and milliseconds - keeping only the date; // find the difference. Note that setHours() returns the same thing as getTime(). var dateDiff = (new Date().setHours(0, 0, 0, 0) - new Date(this).setHours(0, 0, 0, 0)) / 8.64e7; switch (true) { case dateDiff === 0: return this.format(Morebits.date.localeData.relativeTimes.thisDay, zone); case dateDiff === 1: return this.format(Morebits.date.localeData.relativeTimes.prevDay, zone); case dateDiff > 0 && dateDiff < 7: return this.format(Morebits.date.localeData.relativeTimes.pastWeek, zone); case dateDiff === -1: return this.format(Morebits.date.localeData.relativeTimes.nextDay, zone); case dateDiff < 0 && dateDiff > -7: return this.format(Morebits.date.localeData.relativeTimes.thisWeek, zone); default: return this.format(Morebits.date.localeData.relativeTimes.other, zone); } },  /**  * @returns {RegExp} that matches wikitext section titles such as ==December 2019== or  * === Jan 2018 ===  */ monthHeaderRegex: function() { return new RegExp('^==+\\s*(?:' + this.getUTCMonthName() + '|' + this.getUTCMonthNameAbbrev() + ')\\s+' + this.getUTCFullYear() + '\\s*==+', 'mg'); },  /**  * Creates a wikitext section header with the month and year.  * @param {number} [level=2] - Header level (default 2)  * @returns {string}  */ monthHeader: function(level) { level = level || 2; var header = Array(level + 1).join('='); // String.prototype.repeat not supported in IE 11 return header + ' ' + this.getUTCMonthName() + ' ' + this.getUTCFullYear() + ' ' + header; }  });   /**  * **************** Morebits.wiki ****************  * Various objects for wiki editing and API access  */ Morebits.wiki = {};  /**  * Determines whether the current page is a redirect or soft redirect  * (fails to detect soft redirects on edit, history, etc. pages)  * @returns {boolean}  */ Morebits.wiki.isPageRedirect = function wikipediaIsPageRedirect() { return !!(mw.config.get('wgIsRedirect') || document.getElementById('softredirect')); };    /**  * **************** Morebits.wiki.actionCompleted ****************  *  *    Use of Morebits.wiki.actionCompleted():  *    Every call to Morebits.wiki.api.post() results in the dispatch of  *    an asynchronous callback. Each callback can in turn  *    make an additional call to Morebits.wiki.api.post() to continue a  *    processing sequence. At the conclusion of the final callback  *    of a processing sequence, it is not possible to simply return to the  *    original caller because there is no call stack leading back to  *    the original context. Instead, Morebits.wiki.actionCompleted.event() is  *    called to display the result to the user and to perform an optional  *    page redirect.  *  *    The determination of when to call Morebits.wiki.actionCompleted.event()  *    is managed through the globals Morebits.wiki.numberOfActionsLeft and  *    Morebits.wiki.nbrOfCheckpointsLeft. Morebits.wiki.numberOfActionsLeft is  *    incremented at the start of every Morebits.wiki.api call and decremented  *    after the completion of a callback function. If a callback function  *    does not create a new Morebits.wiki.api object before exiting, it is the  *    final step in the processing chain and Morebits.wiki.actionCompleted.event()  *    will then be called.  *  *    Optionally, callers may use Morebits.wiki.addCheckpoint() to indicate that  *    processing is not complete upon the conclusion of the final callback function.  *    This is used for batch operations. The end of a batch is signaled by calling  *    Morebits.wiki.removeCheckpoint().  */  Morebits.wiki.numberOfActionsLeft = 0; Morebits.wiki.nbrOfCheckpointsLeft = 0;  Morebits.wiki.actionCompleted = function(self) { if (--Morebits.wiki.numberOfActionsLeft <= 0 && Morebits.wiki.nbrOfCheckpointsLeft <= 0) { Morebits.wiki.actionCompleted.event(self); } };  // Change per action wanted Morebits.wiki.actionCompleted.event = function() { if (Morebits.wiki.actionCompleted.notice) { Morebits.status.actionCompleted(Morebits.wiki.actionCompleted.notice); } if (Morebits.wiki.actionCompleted.redirect) { // if it isn't a URL, make it one. TODO: This breaks on the articles 'http://', 'ftp://', and similar ones. if (!(/^\w+:\/\//).test(Morebits.wiki.actionCompleted.redirect)) { Morebits.wiki.actionCompleted.redirect = mw.util.getUrl(Morebits.wiki.actionCompleted.redirect); if (Morebits.wiki.actionCompleted.followRedirect === false) { Morebits.wiki.actionCompleted.redirect += '?redirect=no'; } } window.setTimeout(function() { window.location = Morebits.wiki.actionCompleted.redirect; }, Morebits.wiki.actionCompleted.timeOut); } };  Morebits.wiki.actionCompleted.timeOut = typeof window.wpActionCompletedTimeOut === 'undefined' ? 5000 : window.wpActionCompletedTimeOut; Morebits.wiki.actionCompleted.redirect = null; Morebits.wiki.actionCompleted.notice = null;  Morebits.wiki.addCheckpoint = function() { ++Morebits.wiki.nbrOfCheckpointsLeft; };  Morebits.wiki.removeCheckpoint = function() { if (--Morebits.wiki.nbrOfCheckpointsLeft <= 0 && Morebits.wiki.numberOfActionsLeft <= 0) { Morebits.wiki.actionCompleted.event(); } };  /**  * **************** Morebits.wiki.api ****************  * An easy way to talk to the MediaWiki API.  */  /**  * In new code, the use of the last 3 parameters should be avoided, instead use setStatusElement() to bind the  * status element (if needed) and use .then() or .catch() on the promise returned by post(), rather than specify  * the onSuccess or onFailure callbacks.  * @constructor  * @param {string} currentAction - The current action (required)  * @param {Object} query - The query (required)  * @param {Function} [onSuccess] - The function to call when request gotten  * @param {Morebits.status} [statusElement] - A Morebits.status object to use for status messages (optional)  * @param {Function} [onError] - The function to call if an error occurs (optional)  */ Morebits.wiki.api = function(currentAction, query, onSuccess, statusElement, onError) { this.currentAction = currentAction; this.query = query; this.query.assert = 'user'; this.onSuccess = onSuccess; this.onError = onError; if (statusElement) { this.setStatusElement(statusElement); } else { this.statelem = new Morebits.status(currentAction); } if (!query.format) { this.query.format = 'xml'; } else if (query.format === 'json' && !query.formatversion) { this.query.formatversion = '2'; } else if (['xml', 'json'].indexOf(query.format) === -1) { this.statelem.error('Invalid API format: only xml and json are supported.'); }  // Ignore tags for queries and most common unsupported actions, produces warnings if (query.action && ['query', 'review', 'stabilize', 'pagetriageaction', 'watch'].indexOf(query.action) !== -1) { delete query.tags; } else if (!query.tags && morebitsWikiChangeTag) { query.tags = morebitsWikiChangeTag; } };  Morebits.wiki.api.prototype = { currentAction: '', onSuccess: null, onError: null, parent: window,  // use global context if there is no parent object query: null, response: null, responseXML: null,  // use `response` instead; retained for backwards compatibility statelem: null,  // this non-standard name kept for backwards compatibility statusText: null, // result received from the API, normally "success" or "error" errorCode: null, // short text error code, if any, as documented in the MediaWiki API errorText: null, // full error description, if any badtokenRetry: false, // set to true if this on a retry attempted after a badtoken error  /**  * Keep track of parent object for callbacks  * @param {*} parent      */ setParent: function(parent) { this.parent = parent; },  /** @param {Morebits.status} statusElement */ setStatusElement: function(statusElement) { this.statelem = statusElement; this.statelem.status(this.currentAction); },  /**  * Carries out the request.  * @param {Object} callerAjaxParameters Do not specify a parameter unless you really  * really want to give jQuery some extra parameters  * @returns {promise} - a jQuery promise object that is resolved or rejected with the api object.  */ post: function(callerAjaxParameters) {  ++Morebits.wiki.numberOfActionsLeft;  var queryString = $.map(this.query, function(val, i) { if (Array.isArray(val)) { return encodeURIComponent(i) + '=' + val.map(encodeURIComponent).join('|'); } else if (val !== undefined) { return encodeURIComponent(i) + '=' + encodeURIComponent(val); } }).join('&').replace(/^(.*?)(\btoken=[^&]*)&(.*)/, '$1$3&$2'); // token should always be the last item in the query string (bug TW-B-0013)  var ajaxparams = $.extend({}, { context: this, type: this.query.action === 'query' ? 'GET' : 'POST', url: mw.util.wikiScript('api'), data: queryString, dataType: this.query.format, headers: { 'Api-User-Agent': morebitsWikiApiUserAgent } }, callerAjaxParameters);  return $.ajax(ajaxparams).then(  function onAPIsuccess(response, statusText) { this.statusText = statusText; this.response = this.responseXML = response; if (this.query.format === 'json') { this.errorCode = response.error && response.error.code; this.errorText = response.error && response.error.info; } else { this.errorCode = $(response).find('error').attr('code'); this.errorText = $(response).find('error').attr('info'); }  if (typeof this.errorCode === 'string') { // the API didn't like what we told it, e.g., bad edit token or an error creating a page return this.returnError(callerAjaxParameters); }  // invoke success callback if one was supplied if (this.onSuccess) { // set the callback context to this.parent for new code and supply the API object // as the first argument to the callback (for legacy code) this.onSuccess.call(this.parent, this); } else { this.statelem.info('đã xong'); }  Morebits.wiki.actionCompleted();  return $.Deferred().resolveWith(this.parent, [this]); },  // only network and server errors reach here - complaints from the API itself are caught in success() function onAPIfailure(jqXHR, statusText, errorThrown) { this.statusText = statusText; this.errorThrown = errorThrown; // frequently undefined this.errorText = statusText + ' "' + jqXHR.statusText + '" occurred while contacting the API.'; return this.returnError(); }  ); },  returnError: function(callerAjaxParameters) { if (this.errorCode === 'badtoken' && !this.badtokenRetry) { this.statelem.warn('Mã token không hợp lệ. Nhận mã mới và thử lại ...'); this.badtokenRetry = true; // Get a new CSRF token and retry. If the original action needs a different // type of action than CSRF, we do one pointless retry before bailing out return Morebits.wiki.api.getToken().then(function(token) { this.query.token = token; return this.post(callerAjaxParameters); }); }  this.statelem.error(this.errorText + ' (' + this.errorCode + ')');  // invoke failure callback if one was supplied if (this.onError) {  // set the callback context to this.parent for new code and supply the API object // as the first argument to the callback for legacy code this.onError.call(this.parent, this); } // don't complete the action so that the error remains displayed  return $.Deferred().rejectWith(this.parent, [this]); },  getStatusElement: function() { return this.statelem; },  getErrorCode: function() { return this.errorCode; },  getErrorText: function() { return this.errorText; },  getXML: function() { // retained for backwards compatibility, use getResponse() instead return this.responseXML; },  getResponse: function() { return this.response; }  };  // Custom user agent header, used by WMF for server-side logging // See https://lists.wikimedia.org/pipermail/mediawiki-api-announce/2014-November/000075.html var morebitsWikiApiUserAgent = 'morebits.js ([[w:WT:TW]])';  /**  * Sets the custom user agent header  * @param {string} ua   User agent  */ Morebits.wiki.api.setApiUserAgent = function(ua) { morebitsWikiApiUserAgent = (ua ? ua + ' ' : '') + 'morebits.js ([[w:WT:TW]])'; };  // Default change/revision tag applied to Morebits actions when no other tags are specified // Off by default per [[Special:Permalink/970618849#Adding tags to Twinkle edits and actions]] var morebitsWikiChangeTag = '';   /** Get a new CSRF token on encountering token errors */ Morebits.wiki.api.getToken = function() { var tokenApi = new Morebits.wiki.api('Đang lấy token', { action: 'query', meta: 'tokens', type: 'csrf' }); return tokenApi.post().then(function(apiobj) { return $(apiobj.responseXML).find('tokens').attr('csrftoken'); }); };   /**  * **************** Morebits.wiki.page ****************  * Uses the MediaWiki API to load a page and optionally edit it, move it, etc.  *  * Callers are not permitted to directly access the properties of this class!  * All property access is through the appropriate get___() or set___() method.  *  * Callers should set Morebits.wiki.actionCompleted.notice and Morebits.wiki.actionCompleted.redirect  * before the first call to Morebits.wiki.page.load().  *  * Each of the callback functions takes one parameter, which is a  * reference to the Morebits.wiki.page object that registered the callback.  * Callback functions may invoke any Morebits.wiki.page prototype method using this reference.  *  *  * HIGHLIGHTS:  *  * Constructor: Morebits.wiki.page(pageName, currentAction)  *    pageName - the name of the page, prefixed by the namespace (if any)  *               (for the current page, use mw.config.get('wgPageName'))  *    currentAction - a string describing the action about to be undertaken (optional)  *  * onSuccess and onFailure are callback functions called when the operation is a success or failure  * if enclosed in [brackets], it indicates that it is optional  *  * load(onSuccess, [onFailure]): Loads the text for the page  *  * getPageText(): returns a string containing the text of the page after a successful load()  *  * save([onSuccess], [onFailure]):  Saves the text set via setPageText() for the page.  * Must be preceded by calling load().  *    Warning: Calling save() can result in additional calls to the previous load() callbacks to  *             recover from edit conflicts!  *             In this case, callers must make the same edit to the new pageText and reinvoke save().  *             This behavior can be disabled with setMaxConflictRetries(0).  *  * append([onSuccess], [onFailure]): Adds the text provided via setAppendText() to the end of  * the page. Does not require calling load() first.  *  * prepend([onSuccess], [onFailure]): Adds the text provided via setPrependText() to the start  * of the page. Does not require calling load() first.  *  * move([onSuccess], [onFailure]): Moves a page to another title  *  * patrol(): Patrols a page; ignores errors  *  * triage(): Marks page as reviewed using PageTriage, which implies patrolled; ignores most errors  *  * deletePage([onSuccess], [onFailure]): Deletes a page (for admins only)  *  * undeletePage([onSuccess], [onFailure]): Undeletes a page (for admins only)  *  * protect([onSuccess], [onFailure]): Protects a page  *  * getPageName(): returns a string containing the name of the loaded page, including the namespace  *  * setPageText(pageText) sets the updated page text that will be saved when save() is called  *  * setAppendText(appendText) sets the text that will be appended to the page when append() is called  *  * setPrependText(prependText) sets the text that will be prepended to the page when prepend() is called  *  * setCallbackParameters(callbackParameters)  *    callbackParameters - an object for use in a callback function  *  * getCallbackParameters(): returns the object previous set by setCallbackParameters()  *  *    Callback notes: callbackParameters is for use by the caller only. The parameters  *                    allow a caller to pass the proper context into its callback function.  *                    Callers must ensure that any changes to the callbackParameters object  *                    within a load() callback still permit a proper re-entry into the  *                    load() callback if an edit conflict is detected upon calling save().  *  * getStatusElement(): returns the Status element created by the constructor  *  * exists(): returns true if the page existed on the wiki when it was last loaded  *  * getCurrentID(): returns a string containing the current revision ID of the page  *  * lookupCreation(onSuccess): Retrieves the username and timestamp of page creation  *    onSuccess - callback function which is called when the username and timestamp  *                are found within the callback.  *                The username can be retrieved using the getCreator() function;  *                the timestamp can be retrieved using the getCreationTimestamp() function  *  * getCreator(): returns the user who created the page following lookupCreation()  *  * getCreationTimestamp(): returns an ISOString timestamp of page creation following lookupCreation()  *  */  /**  * Call sequence for common operations (optional final user callbacks not shown):  *  *    Edit current contents of a page (no edit conflict):  *       .load(userTextEditCallback) -> ctx.loadApi.post() -> ctx.loadApi.post.success() ->  *             ctx.fnLoadSuccess() -> userTextEditCallback() -> .save() ->  *             ctx.saveApi.post() -> ctx.loadApi.post.success() -> ctx.fnSaveSuccess()  *  *    Edit current contents of a page (with edit conflict):  *       .load(userTextEditCallback) -> ctx.loadApi.post() -> ctx.loadApi.post.success() ->  *             ctx.fnLoadSuccess() -> userTextEditCallback() -> .save() ->  *             ctx.saveApi.post() -> ctx.loadApi.post.success() -> ctx.fnSaveError() ->  *             ctx.loadApi.post() -> ctx.loadApi.post.success() ->  *             ctx.fnLoadSuccess() -> userTextEditCallback() -> .save() ->  *             ctx.saveApi.post() -> ctx.loadApi.post.success() -> ctx.fnSaveSuccess()  *  *    Append to a page (similar for prepend):  *       .append() -> ctx.loadApi.post() -> ctx.loadApi.post.success() ->  *             ctx.fnLoadSuccess() -> ctx.fnAutoSave() -> .save() ->  *             ctx.saveApi.post() -> ctx.loadApi.post.success() -> ctx.fnSaveSuccess()  *  *    Notes:  *       1. All functions following Morebits.wiki.api.post() are invoked asynchronously  *          from the jQuery AJAX library.  *       2. The sequence for append/prepend could be slightly shortened, but it would require  *          significant duplication of code for little benefit.  */  /**  * @constructor  * @param {string} pageName The name of the page, prefixed by the namespace (if any)  * For the current page, use mw.config.get('wgPageName')  * @param {string} [currentAction] A string describing the action about to be undertaken (optional)  */ Morebits.wiki.page = function(pageName, currentAction) {  if (!currentAction) { currentAction = 'Đang mở trang "' + pageName + '"'; }  /**  * Private context variables  *  * This context is not visible to the outside, thus all the data here  * must be accessed via getter and setter functions.  */ var ctx = { // backing fields for public properties pageName: pageName, pageExists: false, editSummary: null, changeTags: null, callbackParameters: null, statusElement: new Morebits.status(currentAction),  // - edit pageText: null, editMode: 'all',  // save() replaces entire contents of the page by default appendText: null,   // can't reuse pageText for this because pageText is needed to follow a redirect prependText: null,  // can't reuse pageText for this because pageText is needed to follow a redirect createOption: null, minorEdit: false, botEdit: false, pageSection: null, maxConflictRetries: 2, maxRetries: 2, followRedirect: false, followCrossNsRedirect: true, watchlistOption: 'nochange', creator: null, timestamp: null,  // - revert revertOldID: null,  // - move moveDestination: null, moveTalkPage: false, moveSubpages: false, moveSuppressRedirect: false,  // - protect protectEdit: null, protectMove: null, protectCreate: null, protectCascade: false,  // - creation lookup lookupNonRedirectCreator: false,  // - stabilize (FlaggedRevs) flaggedRevs: null,  // internal status pageLoaded: false, csrfToken: null, loadTime: null, lastEditTime: null, pageID: null, revertCurID: null, revertUser: null, fullyProtected: false, suppressProtectWarning: false, conflictRetries: 0, retries: 0,  // callbacks onLoadSuccess: null, onLoadFailure: null, onSaveSuccess: null, onSaveFailure: null, onLookupCreationSuccess: null, onMoveSuccess: null, onMoveFailure: null, onDeleteSuccess: null, onDeleteFailure: null, onUndeleteSuccess: null, onUndeleteFailure: null, onProtectSuccess: null, onProtectFailure: null, onStabilizeSuccess: null, onStabilizeFailure: null,  // internal objects loadQuery: null, loadApi: null, saveApi: null, lookupCreationApi: null, moveApi: null, moveProcessApi: null, patrolApi: null, patrolProcessApi: null, triageApi: null, triageProcessApi: null, deleteApi: null, deleteProcessApi: null, undeleteApi: null, undeleteProcessApi: null, protectApi: null, protectProcessApi: null, stabilizeApi: null, stabilizeProcessApi: null };  var emptyFunction = function() { };  /**  * Loads the text for the page  * @param {Function} onSuccess - callback function which is called when the load has succeeded  * @param {Function} [onFailure] - callback function which is called when the load fails (optional)  */ this.load = function(onSuccess, onFailure) { ctx.onLoadSuccess = onSuccess; ctx.onLoadFailure = onFailure || emptyFunction;  // Need to be able to do something after the page loads if (!onSuccess) { ctx.statusElement.error('Internal error: no onSuccess callback provided to load()!'); ctx.onLoadFailure(this); return; }  ctx.loadQuery = { action: 'query', prop: 'info|revisions', curtimestamp: '', meta: 'tokens', type: 'csrf', titles: ctx.pageName // don't need rvlimit=1 because we don't need rvstartid here and only one actual rev is returned by default };  if (ctx.editMode === 'all') { ctx.loadQuery.rvprop = 'content|timestamp';  // get the page content at the same time, if needed } else if (ctx.editMode === 'revert') { ctx.loadQuery.rvprop = 'timestamp'; ctx.loadQuery.rvlimit = 1; ctx.loadQuery.rvstartid = ctx.revertOldID; }  if (ctx.followRedirect) { ctx.loadQuery.redirects = '';  // follow all redirects } if (typeof ctx.pageSection === 'number') { ctx.loadQuery.rvsection = ctx.pageSection; } if (Morebits.userIsSysop) { ctx.loadQuery.inprop = 'protection'; }  ctx.loadApi = new Morebits.wiki.api('Đang lấy trang...', ctx.loadQuery, fnLoadSuccess, ctx.statusElement, ctx.onLoadFailure); ctx.loadApi.setParent(this); ctx.loadApi.post(); };  /**  * Saves the text for the page to Wikipedia  * Must be preceded by successfully calling load().  *  * Warning: Calling save() can result in additional calls to the previous load() callbacks  * to recover from edit conflicts!  * In this case, callers must make the same edit to the new pageText and reinvoke save().  * This behavior can be disabled with setMaxConflictRetries(0).  * @param {Function} [onSuccess] - callback function which is called when the save has  * succeeded (optional)  * @param {Function} [onFailure] - callback function which is called when the save fails  * (optional)  */ this.save = function(onSuccess, onFailure) { ctx.onSaveSuccess = onSuccess; ctx.onSaveFailure = onFailure || emptyFunction;  // are we getting our editing token from mw.user.tokens? var canUseMwUserToken = fnCanUseMwUserToken('edit');  if (!ctx.pageLoaded && !canUseMwUserToken) { ctx.statusElement.error('Internal error: attempt to save a page that has not been loaded!'); ctx.onSaveFailure(this); return; } if (!ctx.editSummary) { ctx.statusElement.error('Internal error: edit summary not set before save!'); ctx.onSaveFailure(this); return; }  // shouldn't happen if canUseMwUserToken === true if (ctx.fullyProtected && !ctx.suppressProtectWarning && !confirm('Bạn chuẩn bị chỉnh sửa trang được bảo vệ hoàn toàn "' + ctx.pageName + (ctx.fullyProtected === 'infinity' ? '" (được bảo vệ vô thời hạn)' : '" (bảo vệ hết hạn ' + new Morebits.date(ctx.fullyProtected).calendar('utc') + ' (UTC))') + '.  \n\nNhấp vào OK để tiếp tục chỉnh sửa hoặc Cancel để bỏ qua chỉnh sửa này.')) { ctx.statusElement.error('Chỉnh sửa trang được bảo vệ hoàn toàn đã bị hủy bỏ.'); ctx.onSaveFailure(this); return; }  ctx.retries = 0;  var query = { action: 'edit', title: ctx.pageName, summary: ctx.editSummary, token: canUseMwUserToken ? mw.user.tokens.get('csrfToken') : ctx.csrfToken, watchlist: ctx.watchlistOption };  if (ctx.changeTags) { query.tags = ctx.changeTags; }  if (typeof ctx.pageSection === 'number') { query.section = ctx.pageSection; }  // Set minor edit attribute. If these parameters are present with any value, it is interpreted as true if (ctx.minorEdit) { query.minor = true; } else { query.notminor = true;  // force Twinkle config to override user preference setting for "all edits are minor" }  // Set bot edit attribute. If this paramter is present with any value, it is interpreted as true if (ctx.botEdit) { query.bot = true; }  switch (ctx.editMode) { case 'append': if (ctx.appendText === null) { ctx.statusElement.error('Internal error: append text not set before save!'); ctx.onSaveFailure(this); return; } query.appendtext = ctx.appendText;  // use mode to append to current page contents break; case 'prepend': if (ctx.prependText === null) { ctx.statusElement.error('Internal error: prepend text not set before save!'); ctx.onSaveFailure(this); return; } query.prependtext = ctx.prependText;  // use mode to prepend to current page contents break; case 'revert': query.undo = ctx.revertCurID; query.undoafter = ctx.revertOldID; if (ctx.lastEditTime) { query.basetimestamp = ctx.lastEditTime; // check that page hasn't been edited since it was loaded } query.starttimestamp = ctx.loadTime; // check that page hasn't been deleted since it was loaded (don't recreate bad stuff) break; default: // 'all' query.text = ctx.pageText; // replace entire contents of the page if (ctx.lastEditTime) { query.basetimestamp = ctx.lastEditTime; // check that page hasn't been edited since it was loaded } query.starttimestamp = ctx.loadTime; // check that page hasn't been deleted since it was loaded (don't recreate bad stuff) break; }  if (['recreate', 'createonly', 'nocreate'].indexOf(ctx.createOption) !== -1) { query[ctx.createOption] = ''; }  if (canUseMwUserToken && ctx.followRedirect) { query.redirect = true; }  ctx.saveApi = new Morebits.wiki.api('Đang lưu trang...', query, fnSaveSuccess, ctx.statusElement, fnSaveError); ctx.saveApi.setParent(this); ctx.saveApi.post(); };  /**  * Adds the text provided via setAppendText() to the end of the page.  * Does not require calling load() first.  * @param {Function} [onSuccess] - callback function which is called when the method has succeeded (optional)  * @param {Function} [onFailure] - callback function which is called when the method fails (optional)  */ this.append = function(onSuccess, onFailure) { ctx.editMode = 'append';  if (fnCanUseMwUserToken('edit')) { this.save(onSuccess, onFailure); } else { ctx.onSaveSuccess = onSuccess; ctx.onSaveFailure = onFailure || emptyFunction; this.load(fnAutoSave, ctx.onSaveFailure); } };  /**  * Adds the text provided via setPrependText() to the start of the page.  * Does not require calling load() first.  * @param {Function}  [onSuccess] - callback function which is called when the method has succeeded (optional)  * @param {Function}  [onFailure] - callback function which is called when the method fails (optional)  */ this.prepend = function(onSuccess, onFailure) { ctx.editMode = 'prepend';  if (fnCanUseMwUserToken('edit')) { this.save(onSuccess, onFailure); } else { ctx.onSaveSuccess = onSuccess; ctx.onSaveFailure = onFailure || emptyFunction; this.load(fnAutoSave, ctx.onSaveFailure); } };  /** @returns {string} string containing the name of the loaded page, including the namespace */ this.getPageName = function() { return ctx.pageName; };  /** @returns {string} string containing the text of the page after a successful load() */ this.getPageText = function() { return ctx.pageText; };  /** @param {string} pageText - updated page text that will be saved when save() is called */ this.setPageText = function(pageText) { ctx.editMode = 'all'; ctx.pageText = pageText; };  /** @param {string} appendText - text that will be appended to the page when append() is called */ this.setAppendText = function(appendText) { ctx.editMode = 'append'; ctx.appendText = appendText; };  /** @param {string} prependText - text that will be prepended to the page when prepend() is called */ this.setPrependText = function(prependText) { ctx.editMode = 'prepend'; ctx.prependText = prependText; };    // Edit-related setter methods: /** @param {string} summary - text of the edit summary that will be used when save() is called */ this.setEditSummary = function(summary) { ctx.editSummary = summary; };  /**  * Set any custom tag(s) to be applied to the API action  * A number of actions don't support it, most notably watch, review  * and stabilize (T247721), and pagetriageaction (T252980)  *  * @param {string|string[]} tags - String or array of tag(s)  */ this.setChangeTags = function(tags) { ctx.changeTags = tags; };   /**  * @param {string} createOption - can take the following four values:  *     `recreate`   - create the page if it does not exist, or edit it if it exists.  *     `createonly` - create the page if it does not exist, but return an error if it  *                    already exists.  *     `nocreate`   - don't create the page, only edit it if it already exists.  *     null         - create the page if it does not exist, unless it was deleted in the moment  *                    between loading the page and saving the edit (default)  *  */ this.setCreateOption = function(createOption) { ctx.createOption = createOption; };  /** @param {boolean} minorEdit - set true to mark the edit as a minor edit. */ this.setMinorEdit = function(minorEdit) { ctx.minorEdit = minorEdit; };  /** @param {boolean} botEdit - set true to mark the edit as a bot edit */ this.setBotEdit = function(botEdit) { ctx.botEdit = botEdit; };  /**  * @param {number} pageSection - integer specifying the section number to load or save.  * If specified as `null`, the entire page will be retrieved.  */ this.setPageSection = function(pageSection) { ctx.pageSection = pageSection; };  /**  * @param {number} maxConflictRetries - number of retries for save errors involving an edit conflict or  * loss of token. Default: 2  */ this.setMaxConflictRetries = function(maxConflictRetries) { ctx.maxConflictRetries = maxConflictRetries; };  /**  * @param {number} maxRetries - number of retries for save errors not involving an edit conflict or  * loss of token. Default: 2  */ this.setMaxRetries = function(maxRetries) { ctx.maxRetries = maxRetries; };  /**  * @param {boolean} watchlistOption  *     True  - page will be added to the user's watchlist when save() is called  *     False - watchlist status of the page will not be changed (default)  */ this.setWatchlist = function(watchlistOption) { if (watchlistOption) { ctx.watchlistOption = 'watch'; } else { ctx.watchlistOption = 'nochange'; } };  /**  * @param {boolean} watchlistOption  *     True  - page watchlist status will be set based on the user's  *             preference settings when save() is called.  *     False - watchlist status of the page will not be changed (default)  *  *    Watchlist notes:  *       1. The MediaWiki API value of 'unwatch', which explicitly removes the page from the  *          user's watchlist, is not used.  *       2. If both setWatchlist() and setWatchlistFromPreferences() are called,  *          the last call takes priority.  *       3. Twinkle modules should use the appropriate preference to set the watchlist options.  *       4. Most Twinkle modules use setWatchlist().  *          setWatchlistFromPreferences() is only needed for the few Twinkle watchlist preferences  *          that accept a string value of 'default'.  */ this.setWatchlistFromPreferences = function(watchlistOption) { if (watchlistOption) { ctx.watchlistOption = 'preferences'; } else { ctx.watchlistOption = 'nochange'; } };  /**  * @param {boolean} followRedirect  *     true  - a maximum of one redirect will be followed.  *             In the event of a redirect, a message is displayed to the user and  *             the redirect target can be retrieved with getPageName().  *     false - (default) the requested pageName will be used without regard to any  *             redirect.  * @param {boolean} followCrossNsRedirect  *      Not applicable if followRedirect is not set true.  *      true - (default) follow redirect even if it is a cross-namespace redirect  *      false - don't follow redirect if it is cross-namespace, edit the redirect itself  */ this.setFollowRedirect = function(followRedirect, followCrossNsRedirect) { if (ctx.pageLoaded) { ctx.statusElement.error('Internal error: cannot change redirect setting after the page has been loaded!'); return; } ctx.followRedirect = followRedirect; ctx.followCrossNsRedirect = typeof followCrossNsRedirect !== 'undefined' ? followCrossNsRedirect : ctx.followCrossNsRedirect; };  // lookup-creation setter function /**  * @param {boolean} flag - if set true, the author and timestamp of the first non-redirect  * version of the page is retrieved.  *  * Warning:  * 1. If there are no revisions among the first 50 that are non-redirects, or if there are  *    less 50 revisions and all are redirects, the original creation is retrived.  * 2. Revisions that the user is not privileged to access (revdeled/suppressed) will be treated  *    as non-redirects.  * 3. Must not be used when the page has a non-wikitext contentmodel  *    such as Modulespace Lua or user JavaScript/CSS  */ this.setLookupNonRedirectCreator = function(flag) { ctx.lookupNonRedirectCreator = flag; };  // Move-related setter functions /** @param {string} destination */ this.setMoveDestination = function(destination) { ctx.moveDestination = destination; };  /** @param {boolean} flag */ this.setMoveTalkPage = function(flag) { ctx.moveTalkPage = !!flag; };  /** @param {boolean} flag */ this.setMoveSubpages = function(flag) { ctx.moveSubpages = !!flag; };  /** @param {boolean} flag */ this.setMoveSuppressRedirect = function(flag) { ctx.moveSuppressRedirect = !!flag; };  // Protect-related setter functions /**  * @param {string} level  The right required for the specific action  * e.g. autoconfirmed, sysop, templateeditor, extendedconfirmed (enWiki)  * @param {string} [expiry=infinity]  */ this.setEditProtection = function(level, expiry) { ctx.protectEdit = { level: level, expiry: expiry || 'infinity' }; };  this.setMoveProtection = function(level, expiry) { ctx.protectMove = { level: level, expiry: expiry || 'infinity' }; };  this.setCreateProtection = function(level, expiry) { ctx.protectCreate = { level: level, expiry: expiry || 'infinity' }; };  this.setCascadingProtection = function(flag) { ctx.protectCascade = !!flag; };  this.suppressProtectWarning = function() { ctx.suppressProtectWarning = true; };  // Revert-related getters/setters: this.setOldID = function(oldID) { ctx.revertOldID = oldID; };  /** @returns {string} string containing the current revision ID of the page */ this.getCurrentID = function() { return ctx.revertCurID; };  /** @returns {string} last editor of the page */ this.getRevisionUser = function() { return ctx.revertUser; };  /** @returns {string} ISO 8601 timestamp at which the page was last edited. */ this.getLastEditTime = function() { return ctx.lastEditTime; };  // Miscellaneous getters/setters:  /**  * `callbackParameters` - an object for use in a callback function  *  * Callback notes: callbackParameters is for use by the caller only. The parameters  * allow a caller to pass the proper context into its callback function.  * Callers must ensure that any changes to the callbackParameters object  * within a load() callback still permit a proper re-entry into the  * load() callback if an edit conflict is detected upon calling save().  */ this.setCallbackParameters = function(callbackParameters) { ctx.callbackParameters = callbackParameters; };  /**  * @returns the object previous set by setCallbackParameters()  */ this.getCallbackParameters = function() { return ctx.callbackParameters; };  /**  * @returns {Morebits.status} Status element created by the constructor  */ this.getStatusElement = function() { return ctx.statusElement; };  /**  * @param {string} level  The right required for edits not to require  * review. Possible options: none, autoconfirmed, review (not on enWiki).  * @param {string} [expiry=infinity]  */ this.setFlaggedRevs = function(level, expiry) { ctx.flaggedRevs = { level: level, expiry: expiry || 'infinity' }; };  /**  * @returns {boolean} true if the page existed on the wiki when it was last loaded  */ this.exists = function() { return ctx.pageExists; };  /**  * @returns {string} Page ID of the page loaded. 0 if the page doesn't  * exist.  */ this.getPageID = function() { return ctx.pageID; };  /**  * @returns {string} ISO 8601 timestamp at which the page was last loaded  */ this.getLoadTime = function() { return ctx.loadTime; };  /**  * @returns {string} the user who created the page following lookupCreation()  */ this.getCreator = function() { return ctx.creator; };  /**  * @returns {string} the ISOString timestamp of page creation following lookupCreation()  */ this.getCreationTimestamp = function() { return ctx.timestamp; };  /**  * Retrieves the username of the user who created the page as well as  * the timestamp of creation  * @param {Function} onSuccess - callback function (required) which is  * called when the username and timestamp are found within the callback.  * The username can be retrieved using the getCreator() function;  * the timestamp can be retrieved using the getCreationTimestamp() function  * Prior to June 2019 known as lookupCreator  */ this.lookupCreation = function(onSuccess) { if (!onSuccess) { ctx.statusElement.error('Internal error: no onSuccess callback provided to lookupCreation()!'); return; } ctx.onLookupCreationSuccess = onSuccess;  var query = { 'action': 'query', 'prop': 'revisions', 'titles': ctx.pageName, 'rvlimit': 1, 'rvprop': 'user|timestamp', 'rvdir': 'newer' };  // Only the wikitext content model can reliably handle // rvsection, others return an error when paired with the // content rvprop. Relatedly, non-wikitext models don't // understand the #REDIRECT concept, so we shouldn't attempt // the redirect resolution in fnLookupCreationSuccess if (ctx.lookupNonRedirectCreator) { query.rvsection = 0; query.rvprop += '|content'; }  if (ctx.followRedirect) { query.redirects = '';  // follow all redirects }  ctx.lookupCreationApi = new Morebits.wiki.api('Đang lấy thông tin tạo trang', query, fnLookupCreationSuccess, ctx.statusElement); ctx.lookupCreationApi.setParent(this); ctx.lookupCreationApi.post(); };  /**  * Reverts a page to revertOldID  * @param {Function} [onSuccess] - callback function to run on success (optional)  * @param {Function} [onFailure] - callback function to run on failure (optional)  */ this.revert = function(onSuccess, onFailure) { ctx.onSaveSuccess = onSuccess; ctx.onSaveFailure = onFailure || emptyFunction;  if (!ctx.revertOldID) { ctx.statusElement.error('Internal error: revision ID to revert to was not set before revert!'); ctx.onSaveFailure(this); return; }  ctx.editMode = 'revert'; this.load(fnAutoSave, ctx.onSaveFailure); };  /**  * Moves a page to another title  * @param {Function} [onSuccess] - callback function to run on success (optional)  * @param {Function} [onFailure] - callback function to run on failure (optional)  */ this.move = function(onSuccess, onFailure) { ctx.onMoveSuccess = onSuccess; ctx.onMoveFailure = onFailure || emptyFunction;  if (!ctx.editSummary) { ctx.statusElement.error('Internal error: move reason not set before move (use setEditSummary function)!'); ctx.onMoveFailure(this); return; } if (!ctx.moveDestination) { ctx.statusElement.error('Internal error: destination page name was not set before move!'); ctx.onMoveFailure(this); return; }  if (fnCanUseMwUserToken('move')) { fnProcessMove.call(this, this); } else { var query = fnNeedTokenInfoQuery('move');  ctx.moveApi = new Morebits.wiki.api('đang lấy token...', query, fnProcessMove, ctx.statusElement, ctx.onMoveFailure); ctx.moveApi.setParent(this); ctx.moveApi.post(); } };  /**  * Marks the page as patrolled, using rcid (if available) or revid  *  * Patrolling as such doesn't need to rely on loading the page in  * question; simply passing a revid to the API is sufficient, so in  * those cases just using Morebits.wiki.api is probably preferable.  *  * No error handling since we don't actually care about the errors  */ this.patrol = function() { if (!Morebits.userIsSysop && !Morebits.userIsInGroup('patroller')) { return; }  // If a link is present, don't need to check if it's patrolled if ($('.patrollink').length) { var patrolhref = $('.patrollink a').attr('href'); ctx.rcid = mw.util.getParamValue('rcid', patrolhref); fnProcessPatrol(this, this); } else { var patrolQuery = { action: 'query', prop: 'info', meta: 'tokens', type: 'patrol', // as long as we're querying, might as well get a token list: 'recentchanges', // check if the page is unpatrolled titles: ctx.pageName, rcprop: 'patrolled', rctitle: ctx.pageName, rclimit: 1 };  ctx.patrolApi = new Morebits.wiki.api('đang lấy token...', patrolQuery, fnProcessPatrol); ctx.patrolApi.setParent(this); ctx.patrolApi.post(); } };  /**  * Marks the page as reviewed by the PageTriage extension  * https://www.mediawiki.org/wiki/Extension:PageTriage  *  * Referred to as "review" on-wiki  *  * Will, by it's nature, mark as patrolled as well. Falls back to  * patrolling if not in an appropriate namespace.  *  * Doesn't inherently rely on loading the page in question; simply  * passing a pageid to the API is sufficient, so in those cases just  * using Morebits.wiki.api is probably preferable.  *  * No error handling since we don't actually care about the errors  */ this.triage = function() { // Fall back to patrol if not a valid triage namespace  if (!Morebits.userIsSysop && !Morebits.userIsInGroup('patroller')) { return; }  // If on the page in question, don't need to query for page ID if (new mw.Title(Morebits.pageNameNorm).getPrefixedText() === new mw.Title(ctx.pageName).getPrefixedText()) { ctx.pageID = mw.config.get('wgArticleId'); fnProcessTriageList(this, this); } else { var query = fnNeedTokenInfoQuery('triage'); statelem.status('Hàm triage bị lỗi 3...'); ctx.triageApi = new Morebits.wiki.api('retrieving token...', query, fnProcessTriageList); ctx.triageApi.setParent(this); ctx.triageApi.post(); }  /*if (mw.config.get("pageTriageNamespaces").indexOf(new mw.Title(ctx.pageName).getNamespaceId()) === -1) { this.patrol(); } else { if (!Morebits.userIsSysop && !Morebits.userIsInGroup('patroller')) { return; }  // If on the page in question, don't need to query for page ID if (new mw.Title(Morebits.pageNameNorm).getPrefixedText() === new mw.Title(ctx.pageName).getPrefixedText()) { ctx.pageID = mw.config.get('wgArticleId'); fnProcessTriageList(this, this); } else { var query = fnNeedTokenInfoQuery('triage'); statelem.status('Hàm triage bị lỗi 3...'); ctx.triageApi = new Morebits.wiki.api('retrieving token...', query, fnProcessTriageList); ctx.triageApi.setParent(this); ctx.triageApi.post(); } }*/ };  // |delete| is a reserved word in some flavours of JS /**  * Deletes a page (for admins only)  * @param {Function} [onSuccess] - callback function to run on success (optional)  * @param {Function} [onFailure] - callback function to run on failure (optional)  */ this.deletePage = function(onSuccess, onFailure) { ctx.onDeleteSuccess = onSuccess; ctx.onDeleteFailure = onFailure || emptyFunction;  // if a non-admin tries to do this, don't bother if (!Morebits.userIsSysop && !Morebits.userIsInGroup('eliminator')) { ctx.statusElement.error('Cannot delete page: only admins can do that'); ctx.onDeleteFailure(this); return; } if (!ctx.editSummary) { ctx.statusElement.error('Internal error: delete reason not set before delete (use setEditSummary function)!'); ctx.onDeleteFailure(this); return; }  if (fnCanUseMwUserToken('delete')) { fnProcessDelete.call(this, this); } else { var query = fnNeedTokenInfoQuery('delete');  ctx.deleteApi = new Morebits.wiki.api('đang lấy token...', query, fnProcessDelete, ctx.statusElement, ctx.onDeleteFailure); ctx.deleteApi.setParent(this); ctx.deleteApi.post(); } };  /**  * Undeletes a page (for admins only)  * @param {Function} [onSuccess] - callback function to run on success (optional)  * @param {Function} [onFailure] - callback function to run on failure (optional)  */ this.undeletePage = function(onSuccess, onFailure) { ctx.onUndeleteSuccess = onSuccess; ctx.onUndeleteFailure = onFailure || emptyFunction;  // if a non-admin tries to do this, don't bother if (!Morebits.userIsSysop && !Morebits.userIsInGroup('eliminator')) { ctx.statusElement.error('Cannot undelete page: only admins can do that'); ctx.onUndeleteFailure(this); return; } if (!ctx.editSummary) { ctx.statusElement.error('Internal error: undelete reason not set before undelete (use setEditSummary function)!'); ctx.onUndeleteFailure(this); return; }  if (fnCanUseMwUserToken('undelete')) { fnProcessUndelete.call(this, this); } else { var query = fnNeedTokenInfoQuery('undelete');  ctx.undeleteApi = new Morebits.wiki.api('đang lấy token...', query, fnProcessUndelete, ctx.statusElement, ctx.onUndeleteFailure); ctx.undeleteApi.setParent(this); ctx.undeleteApi.post(); } };  /**  * Protects a page (for admins only)  * @param {Function} [onSuccess] - callback function to run on success (optional)  * @param {Function} [onFailure] - callback function to run on failure (optional)  */ this.protect = function(onSuccess, onFailure) { ctx.onProtectSuccess = onSuccess; ctx.onProtectFailure = onFailure || emptyFunction;  // if a non-admin tries to do this, don't bother if (!Morebits.userIsSysop && !Morebits.userIsInGroup('eliminator')) { ctx.statusElement.error('Cannot protect page: only admins can do that'); ctx.onProtectFailure(this); return; } if (!ctx.protectEdit && !ctx.protectMove && !ctx.protectCreate) { ctx.statusElement.error('Internal error: you must set edit and/or move and/or create protection before calling protect()!'); ctx.onProtectFailure(this); return; } if (!ctx.editSummary) { ctx.statusElement.error('Internal error: protection reason not set before protect (use setEditSummary function)!'); ctx.onProtectFailure(this); return; }  // because of the way MW API interprets protection levels // (absolute, not differential), we always need to request // protection levels from the server var query = fnNeedTokenInfoQuery('protect');  ctx.protectApi = new Morebits.wiki.api('đang lấy token...', query, fnProcessProtect, ctx.statusElement, ctx.onProtectFailure); ctx.protectApi.setParent(this); ctx.protectApi.post(); };  /**  * Apply FlaggedRevs protection-style settings  * only works where $wgFlaggedRevsProtection = true (i.e. where FlaggedRevs  * settings appear on the wiki's "protect" tab)  * @param {function} [onSuccess]  * @param {function} [onFailure]  */ this.stabilize = function(onSuccess, onFailure) { ctx.onStabilizeSuccess = onSuccess; ctx.onStabilizeFailure = onFailure || emptyFunction;  // if a non-admin tries to do this, don't bother if (!Morebits.userIsSysop) { ctx.statusElement.error('Không thể áp dụng cài đặt FlaggedRevs: chỉ quản trị viên mới có thể làm điều đó'); ctx.onStabilizeFailure(this); return; } if (!ctx.flaggedRevs) { ctx.statusElement.error('Lỗi nội bộ: bạn phải đặt flaggedRevs trước khi gọi stable ()!'); ctx.onStabilizeFailure(this); return; } if (!ctx.editSummary) { ctx.statusElement.error('Lỗi nội bộ: lý do không được đặt trước khi gọi stable () (sử dụng hàm setEditSummary)!'); ctx.onStabilizeFailure(this); return; }  if (fnCanUseMwUserToken('stabilize')) { fnProcessStabilize.call(this, this); } else { var query = fnNeedTokenInfoQuery('stabilize');  ctx.stabilizeApi = new Morebits.wiki.api('đang lấy token...', query, fnProcessStabilize, ctx.statusElement, ctx.onStabilizeFailure); ctx.stabilizeApi.setParent(this); ctx.stabilizeApi.post(); } };  /*  * Private member functions  * These are not exposed outside  */  /**  * Determines whether we can save an API call by using the csrf token sent with the page  * HTML, or whether we need to ask the server for more info (e.g. protection expiry).  *  * Only applicable for csrf token actions, e.g. not patrol  *  * Currently used for append, prepend, deletePage, undeletePage, move,  * and stabilize.  Can't use for protect since it always needs to  * request protection status.  *  * @param {string} [action=edit]  The action being undertaken, e.g.  * "edit" or "delete". In practice, only "edit" or "notedit" matters.  * @returns {boolean}  */ var fnCanUseMwUserToken = function(action) { action = typeof action !== 'undefined' ? action : 'edit'; // IE doesn't support default parameters  // API-based redirect resolution only works for action=query and // action=edit in append/prepend modes (and section=new, but we don't // really support that) if (ctx.followRedirect) { if (!ctx.followCrossNsRedirect) { return false; // must load the page to check for cross namespace redirects } if (action !== 'edit' || (ctx.editMode !== 'append' && ctx.editMode !== 'prepend')) { return false; } }  // do we need to fetch the edit protection expiry? if (Morebits.userIsSysop && !ctx.suppressProtectWarning) { if (new mw.Title(Morebits.pageNameNorm).getPrefixedText() === new mw.Title(ctx.pageName).getPrefixedText()) { return false; }  // wgRestrictionEdit is null on non-existent pages, // so this neatly handles nonexistent pages var editRestriction = mw.config.get('wgRestrictionEdit'); if (!editRestriction || editRestriction.indexOf('sysop') !== -1) { return false; } }  return !!mw.user.tokens.get('csrfToken'); };  /**  * When functions can't use fnCanUseMwUserToken or require checking  * protection, maintain the query in one place. Used for delete,  * undelete, protect, stabilize, and move (basically, just not load)  *  * @param {string} action  The action being undertaken, e.g. "edit" or  * "delete"  */ var fnNeedTokenInfoQuery = function(action) { var query = { action: 'query', meta: 'tokens', type: 'csrf', titles: ctx.pageName }; // Protection not checked for flagged-revs or non-sysop moves if (action !== 'stabilize' && (action !== 'move' || Morebits.userIsSysop)) { query.prop = 'info'; query.inprop = 'protection'; } if (ctx.followRedirect && action !== 'undelete') { query.redirects = ''; // follow all redirects } return query; };  // callback from loadSuccess() for append() and prepend() threads var fnAutoSave = function(pageobj) { pageobj.save(ctx.onSaveSuccess, ctx.onSaveFailure); };  // callback from loadApi.post() var fnLoadSuccess = function() { var xml = ctx.loadApi.getXML();  if (!fnCheckPageName(xml, ctx.onLoadFailure)) { return; // abort }  ctx.pageExists = $(xml).find('page').attr('missing') !== ''; if (ctx.pageExists) { ctx.pageText = $(xml).find('rev').text(); ctx.pageID = $(xml).find('page').attr('pageid'); } else { ctx.pageText = '';  // allow for concatenation, etc. ctx.pageID = 0; // nonexistent in response, matches wgArticleId } ctx.csrfToken = $(xml).find('tokens').attr('csrftoken'); if (!ctx.csrfToken) { ctx.statusElement.error('Không truy xuất được mã token chỉnh sửa.'); ctx.onLoadFailure(this); return; } ctx.loadTime = $(xml).find('api').attr('curtimestamp'); if (!ctx.loadTime) { ctx.statusElement.error('Không truy xuất được nhãn thời gian hiện tại.'); ctx.onLoadFailure(this); return; }  // extract protection info, to alert admins when they are about to edit a protected page if (Morebits.userIsSysop) { var editprot = $(xml).find('pr[type="edit"]'); if (editprot.length > 0 && editprot.attr('level') === 'sysop') { ctx.fullyProtected = editprot.attr('expiry'); } else { ctx.fullyProtected = false; } }  ctx.lastEditTime = $(xml).find('rev').attr('timestamp'); ctx.revertCurID = $(xml).find('page').attr('lastrevid');  if (ctx.editMode === 'revert') { ctx.revertCurID = $(xml).find('rev').attr('revid'); if (!ctx.revertCurID) { ctx.statusElement.error('Không truy xuất được ID của bản sửa đổi hiện tại.'); ctx.onLoadFailure(this); return; } ctx.revertUser = $(xml).find('rev').attr('user'); if (!ctx.revertUser) { if ($(xml).find('rev').attr('userhidden') === '') {  // username was RevDel'd or oversighted ctx.revertUser = '