|
|
| 1번째 줄: |
1번째 줄: |
| function isCompatible(ua) {
| |
| return !!((function() {
| |
| 'use strict';
| |
| return !this && Function.prototype.bind;
| |
| }()) && 'querySelector' in document && 'localStorage' in window && !ua.match(/MSIE 10|NetFront|Opera Mini|S40OviBrowser|MeeGo|Android.+Glass|^Mozilla\/5\.0 .+ Gecko\/$|googleweblight|PLAYSTATION|PlayStation/));
| |
| }
| |
| if (!isCompatible(navigator.userAgent)) {
| |
| document.documentElement.className = document.documentElement.className.replace(/(^|\s)client-js(\s|$)/, '$1client-nojs$2');
| |
| while (window.NORLQ && NORLQ[0]) {
| |
| NORLQ.shift()();
| |
| }
| |
| NORLQ = {
| |
| push: function(fn) {
| |
| fn();
| |
| }
| |
| };
| |
| RLQ = {
| |
| push: function() {}
| |
| };
| |
| } else {
| |
| if (window.performance && performance.mark) {
| |
| performance.mark('mwStartup');
| |
| }(function() {
| |
| 'use strict';
| |
| var con = window.console;
| |
|
| |
|
| function logError(topic, data) {
| |
| var e = data.exception;
| |
| var msg = (e ? 'Exception' : 'Error') + ' in ' + data.source + (data.module ? ' in module ' + data.module : '') + (e ? ':' : '.');
| |
| con.log(msg);
| |
| if (e) {
| |
| con.warn(e);
| |
| }
| |
| }
| |
|
| |
| function Map() {
| |
| this.values = Object.create(null);
| |
| }
| |
| Map.prototype = {
| |
| constructor: Map,
| |
| get: function(selection, fallback) {
| |
| if (
| |
| arguments.length < 2) {
| |
| fallback = null;
| |
| }
| |
| if (typeof selection === 'string') {
| |
| return selection in this.values ? this.values[selection] : fallback;
| |
| }
| |
| var results;
| |
| if (Array.isArray(selection)) {
| |
| results = {};
| |
| for (var i = 0; i < selection.length; i++) {
| |
| if (typeof selection[i] === 'string') {
| |
| results[selection[i]] = selection[i] in this.values ? this.values[selection[i]] : fallback;
| |
| }
| |
| }
| |
| return results;
| |
| }
| |
| if (selection === undefined) {
| |
| results = {};
| |
| for (var key in this.values) {
| |
| results[key] = this.values[key];
| |
| }
| |
| return results;
| |
| }
| |
| return fallback;
| |
| },
| |
| set: function(selection, value) {
| |
| if (arguments.length > 1) {
| |
| if (typeof selection === 'string') {
| |
| this.values[selection] = value;
| |
| return true;
| |
| }
| |
| } else if (typeof selection === 'object') {
| |
| for (var key in selection) {
| |
| this.values[key] = selection[key];
| |
| }
| |
| return true;
| |
| }
| |
| return false;
| |
| },
| |
| exists: function(selection) {
| |
| return typeof selection === 'string' && selection in this.values;
| |
| }
| |
| };
| |
| var log = function() {};
| |
| log.warn = Function.prototype.bind.call(con.warn, con);
| |
| var mw = {
| |
| now: function() {
| |
| var perf = window.performance;
| |
| var navStart = perf && perf.timing && perf.timing.
| |
| navigationStart;
| |
| mw.now = navStart && perf.now ? function() {
| |
| return navStart + perf.now();
| |
| } : Date.now;
| |
| return mw.now();
| |
| },
| |
| trackQueue: [],
| |
| track: function(topic, data) {
| |
| mw.trackQueue.push({
| |
| topic: topic,
| |
| data: data
| |
| });
| |
| },
| |
| trackError: function(topic, data) {
| |
| mw.track(topic, data);
| |
| logError(topic, data);
| |
| },
| |
| Map: Map,
| |
| config: new Map(),
| |
| messages: new Map(),
| |
| templates: new Map(),
| |
| log: log
| |
| };
| |
| window.mw = window.mediaWiki = mw;
| |
| }());
| |
| (function() {
| |
| 'use strict';
| |
| var StringSet, store, hasOwn = Object.hasOwnProperty;
| |
|
| |
| function defineFallbacks() {
| |
| StringSet = window.Set || function() {
| |
| var set = Object.create(null);
| |
| return {
| |
| add: function(value) {
| |
| set[value] = true;
| |
| },
| |
| has: function(value) {
| |
| return value in set;
| |
| }
| |
| };
| |
| };
| |
| }
| |
| defineFallbacks();
| |
|
| |
| function fnv132(str) {
| |
| var hash = 0x811C9DC5;
| |
| for (var i = 0; i < str.length; i++) {
| |
| hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
| |
| hash ^= str.charCodeAt(i);
| |
| }
| |
| hash = (hash >>> 0).toString(36).slice(0, 5);
| |
| while (hash.length < 5) {
| |
| hash = '0' + hash;
| |
| }
| |
| return hash;
| |
| }
| |
| var isES6Supported = typeof Promise === 'function' && Promise.prototype.finally && /./g.flags === 'g' && (function() {
| |
| try {
| |
| new Function('(a = 0) => a');
| |
| return true;
| |
| } catch (e) {
| |
| return false;
| |
| }
| |
| }());
| |
| var registry = Object.create(null),
| |
| sources = Object.create(null),
| |
| handlingPendingRequests = false,
| |
| pendingRequests = [],
| |
| queue = [],
| |
| jobs = [],
| |
| willPropagate = false,
| |
| errorModules = [],
| |
| baseModules = ["jquery", "mediawiki.base"],
| |
| marker = document.querySelector('meta[name="ResourceLoaderDynamicStyles"]'),
| |
| lastCssBuffer, rAF = window.requestAnimationFrame || setTimeout;
| |
|
| |
| function addToHead(el, nextNode) {
| |
| if (nextNode && nextNode.parentNode) {
| |
| nextNode.parentNode.insertBefore(el, nextNode);
| |
| } else {
| |
| document.head.appendChild(el);
| |
| }
| |
| }
| |
|
| |
| function newStyleTag(text, nextNode) {
| |
| var el = document.createElement('style');
| |
| el.appendChild(document.createTextNode(text));
| |
| addToHead(el, nextNode);
| |
| return el;
| |
| }
| |
|
| |
| function flushCssBuffer(cssBuffer) {
| |
| if (cssBuffer === lastCssBuffer) {
| |
| lastCssBuffer = null;
| |
| }
| |
| newStyleTag(cssBuffer.cssText, marker);
| |
| for (var i = 0; i < cssBuffer.callbacks.length; i++) {
| |
| cssBuffer.callbacks[i]();
| |
| }
| |
| }
| |
|
| |
| function addEmbeddedCSS(cssText, callback) {
| |
| if (!lastCssBuffer || cssText.slice(0, 7) ===
| |
| '@import') {
| |
| lastCssBuffer = {
| |
| cssText: '',
| |
| callbacks: []
| |
| };
| |
| rAF(flushCssBuffer.bind(null, lastCssBuffer));
| |
| }
| |
| lastCssBuffer.cssText += '\n' + cssText;
| |
| lastCssBuffer.callbacks.push(callback);
| |
| }
| |
|
| |
| function getCombinedVersion(modules) {
| |
| var hashes = modules.reduce(function(result, module) {
| |
| return result + registry[module].version;
| |
| }, '');
| |
| return fnv132(hashes);
| |
| }
| |
|
| |
| function allReady(modules) {
| |
| for (var i = 0; i < modules.length; i++) {
| |
| if (mw.loader.getState(modules[i]) !== 'ready') {
| |
| return false;
| |
| }
| |
| }
| |
| return true;
| |
| }
| |
|
| |
| function allWithImplicitReady(module) {
| |
| return allReady(registry[module].dependencies) && (baseModules.indexOf(module) !== -1 || allReady(baseModules));
| |
| }
| |
|
| |
| function anyFailed(modules) {
| |
| for (var i = 0; i < modules.length; i++) {
| |
| var state = mw.loader.getState(modules[i]);
| |
| if (state === 'error' || state === 'missing') {
| |
| return modules[i];
| |
| }
| |
| }
| |
| return false;
| |
| }
| |
|
| |
| function doPropagation() {
| |
| var didPropagate = true;
| |
| var module;
| |
| while (didPropagate) {
| |
| didPropagate = false;
| |
| while (errorModules.length) {
| |
| var errorModule = errorModules.shift(),
| |
| baseModuleError = baseModules.indexOf(errorModule) !== -1;
| |
| for (module in registry) {
| |
| if (registry[module].state !== 'error' && registry[module].state !== 'missing') {
| |
| if (baseModuleError && baseModules.indexOf(module) === -1) {
| |
| registry[module].state = 'error';
| |
| didPropagate = true;
| |
| } else if (registry[module].dependencies.indexOf(errorModule) !== -1) {
| |
| registry[module].state = 'error';
| |
| errorModules.push(module);
| |
| didPropagate = true;
| |
| }
| |
| }
| |
| }
| |
| }
| |
| for (module in registry) {
| |
| if (registry[module].state === 'loaded' && allWithImplicitReady(module)) {
| |
| execute(module);
| |
| didPropagate = true;
| |
| }
| |
| }
| |
| for (var i = 0; i < jobs.length; i++) {
| |
| var job = jobs[i];
| |
| var failed = anyFailed(job.dependencies);
| |
| if (failed !== false || allReady(job.dependencies)) {
| |
| jobs.splice(i, 1);
| |
| i -= 1;
| |
| try {
| |
| if (failed !== false && job.error) {
| |
| job.error(new Error('Failed dependency: ' + failed), job.dependencies);
| |
| } else if (failed === false && job.ready) {
| |
| job.ready();
| |
| }
| |
| } catch (e) {
| |
| mw.trackError('resourceloader.exception', {
| |
| exception: e,
| |
| source: 'load-callback'
| |
| });
| |
| }
| |
| didPropagate = true;
| |
| }
| |
| }
| |
| }
| |
| willPropagate = false;
| |
| }
| |
|
| |
| function setAndPropagate(module, state) {
| |
| registry[module].state = state;
| |
| if (state === 'ready') {
| |
| store.add(module);
| |
| } else if (state === 'error' || state === 'missing') {
| |
| errorModules.push(module);
| |
| } else if (state !== 'loaded') {
| |
| return;
| |
| }
| |
| if (willPropagate) {
| |
| return;
| |
| }
| |
| willPropagate = true;
| |
| mw.requestIdleCallback(doPropagation, {
| |
| timeout: 1
| |
| });
| |
| }
| |
|
| |
| function sortDependencies(module, resolved, unresolved) {
| |
| if (!(module in registry)) {
| |
| throw new Error('Unknown module: ' + module);
| |
| }
| |
| if (typeof registry[module].skip === 'string') {
| |
| var skip = (new Function(registry[module].skip)());
| |
| registry[module].skip = !!skip;
| |
| if (skip) {
| |
| registry[module].dependencies = [];
| |
| setAndPropagate(module, 'ready');
| |
| return;
| |
| }
| |
| }
| |
| if (!unresolved) {
| |
| unresolved = new StringSet();
| |
| }
| |
| var deps = registry[module].dependencies;
| |
| unresolved.add(module);
| |
| for (var i = 0; i < deps.length; i++) {
| |
| if (resolved.indexOf(deps[i]) === -1) {
| |
| if (unresolved.has(deps[i])) {
| |
| throw new Error('Circular reference detected: ' + module + ' -> ' + deps[i]);
| |
| }
| |
| sortDependencies(deps[i], resolved, unresolved);
| |
| }
| |
| }
| |
| resolved.push(module);
| |
| }
| |
|
| |
| function resolve(modules) {
| |
| var resolved = baseModules.slice();
| |
| for (var i = 0; i < modules.length; i++) {
| |
| sortDependencies(modules[i], resolved);
| |
| }
| |
| return resolved;
| |
| }
| |
|
| |
| function resolveStubbornly(modules) {
| |
| var resolved = baseModules.slice();
| |
| for (var i = 0; i < modules.length; i++) {
| |
| var saved = resolved.slice();
| |
| try {
| |
| sortDependencies(modules[i], resolved);
| |
| } catch (err) {
| |
| resolved = saved;
| |
| mw.log.warn('Skipped unavailable module ' + modules[i]);
| |
| if (modules[i] in registry) {
| |
| mw.trackError('resourceloader.exception', {
| |
| exception: err,
| |
| source: 'resolve'
| |
| });
| |
| }
| |
| }
| |
| }
| |
| return resolved;
| |
| }
| |
|
| |
| function resolveRelativePath(relativePath, basePath) {
| |
| var relParts = relativePath.match(/^((?:\.\.?\/)+)(.*)$/);
| |
| if (!relParts) {
| |
| return null;
| |
| }
| |
| var baseDirParts = basePath.split('/');
| |
| baseDirParts.pop();
| |
| var prefixes = relParts[1].split('/');
| |
| prefixes.pop();
| |
| var prefix;
| |
| while ((prefix = prefixes.pop()) !== undefined) {
| |
| if (prefix === '..') {
| |
| baseDirParts.pop();
| |
| }
| |
| }
| |
| return (baseDirParts.length ? baseDirParts.join('/') + '/' : '') + relParts[2];
| |
| }
| |
|
| |
| function makeRequireFunction(moduleObj, basePath) {
| |
| return function require(moduleName) {
| |
| var fileName = resolveRelativePath(moduleName, basePath);
| |
| if (fileName === null) {
| |
| return mw.loader.require(moduleName);
| |
| }
| |
| if (hasOwn.call(moduleObj.packageExports, fileName)) {
| |
| return moduleObj.packageExports[fileName];
| |
| }
| |
| var scriptFiles = moduleObj.script.files;
| |
| if (!hasOwn.call(scriptFiles, fileName)) {
| |
| throw new Error('Cannot require undefined file ' + fileName);
| |
| }
| |
| var result, fileContent = scriptFiles[fileName];
| |
| if (typeof fileContent === 'function') {
| |
| var moduleParam = {
| |
| exports: {}
| |
| };
| |
| fileContent(makeRequireFunction(moduleObj, fileName), moduleParam, moduleParam.exports);
| |
| result = moduleParam.exports;
| |
| } else {
| |
| result = fileContent;
| |
| }
| |
| moduleObj.packageExports[fileName] = result;
| |
| return result;
| |
| };
| |
| }
| |
|
| |
| function addScript(src, callback) {
| |
| var script = document.createElement('script');
| |
| script.src = src;
| |
| script.onload = script.onerror = function() {
| |
| if (script.parentNode) {
| |
| script.parentNode.removeChild(script);
| |
| }
| |
| if (callback) {
| |
| callback();
| |
| callback = null;
| |
| }
| |
| };
| |
| document.head.appendChild(script);
| |
| return script;
| |
| }
| |
|
| |
| function queueModuleScript(src, moduleName, callback) {
| |
| pendingRequests.push(function() {
| |
| if (moduleName !== 'jquery') {
| |
| window.require = mw.loader.
| |
| require;
| |
| window.module = registry[moduleName].module;
| |
| }
| |
| addScript(src, function() {
| |
| delete window.module;
| |
| callback();
| |
| if (pendingRequests[0]) {
| |
| pendingRequests.shift()();
| |
| } else {
| |
| handlingPendingRequests = false;
| |
| }
| |
| });
| |
| });
| |
| if (!handlingPendingRequests && pendingRequests[0]) {
| |
| handlingPendingRequests = true;
| |
| pendingRequests.shift()();
| |
| }
| |
| }
| |
|
| |
| function addLink(url, media, nextNode) {
| |
| var el = document.createElement('link');
| |
| el.rel = 'stylesheet';
| |
| if (media) {
| |
| el.media = media;
| |
| }
| |
| el.href = url;
| |
| addToHead(el, nextNode);
| |
| return el;
| |
| }
| |
|
| |
| function domEval(code) {
| |
| var script = document.createElement('script');
| |
| if (mw.config.get('wgCSPNonce') !== false) {
| |
| script.nonce = mw.config.get('wgCSPNonce');
| |
| }
| |
| script.text = code;
| |
| document.head.appendChild(script);
| |
| script.parentNode.removeChild(script);
| |
| }
| |
|
| |
| function enqueue(dependencies, ready, error) {
| |
| if (allReady(dependencies)) {
| |
| if (ready) {
| |
| ready();
| |
| }
| |
| return;
| |
| }
| |
| var failed = anyFailed(dependencies);
| |
| if (failed !== false) {
| |
| if (error) {
| |
| error(new Error('Dependency ' + failed + ' failed to load'), dependencies);
| |
| }
| |
| return;
| |
| }
| |
| if (ready || error) {
| |
| jobs.push({
| |
| dependencies: dependencies.filter(function(module) {
| |
| var state = registry[module].state;
| |
| return state === 'registered' || state === 'loaded' || state === 'loading' || state === 'executing';
| |
| }),
| |
| ready: ready,
| |
| error: error
| |
| });
| |
| }
| |
| dependencies.forEach(function(module) {
| |
| if (registry[module].state === 'registered' && queue.indexOf(module) === -1) {
| |
| queue.push(module);
| |
| }
| |
| });
| |
| mw.loader.work();
| |
| }
| |
|
| |
| function execute(module) {
| |
| if (registry[module].state !== 'loaded') {
| |
| throw new Error('Module in state "' + registry[module].state + '" may not execute: ' + module);
| |
| }
| |
| registry[module].state = 'executing';
| |
| var runScript = function() {
| |
| var script = registry[module].script;
| |
| var markModuleReady = function() {
| |
| setAndPropagate(module, 'ready');
| |
| };
| |
| var nestedAddScript = function(arr, offset) {
| |
| if (offset >= arr.length) {
| |
| markModuleReady();
| |
| return;
| |
| }
| |
| queueModuleScript(arr[offset], module, function() {
| |
| nestedAddScript(arr, offset + 1);
| |
| });
| |
| };
| |
| try {
| |
| if (Array.isArray(script)) {
| |
| nestedAddScript(script, 0);
| |
| } else if (typeof script === 'function') {
| |
| if (module === 'jquery') {
| |
| script();
| |
| } else {
| |
| script(window.$, window.$, mw.loader.require,
| |
| registry[module].module);
| |
| }
| |
| markModuleReady();
| |
| } else if (typeof script === 'object' && script !== null) {
| |
| var mainScript = script.files[script.main];
| |
| if (typeof mainScript !== 'function') {
| |
| throw new Error('Main file in module ' + module + ' must be a function');
| |
| }
| |
| mainScript(makeRequireFunction(registry[module], script.main), registry[module].module, registry[module].module.exports);
| |
| markModuleReady();
| |
| } else if (typeof script === 'string') {
| |
| domEval(script);
| |
| markModuleReady();
| |
| } else {
| |
| markModuleReady();
| |
| }
| |
| } catch (e) {
| |
| setAndPropagate(module, 'error');
| |
| mw.trackError('resourceloader.exception', {
| |
| exception: e,
| |
| module: module,
| |
| source: 'module-execute'
| |
| });
| |
| }
| |
| };
| |
| if (registry[module].messages) {
| |
| mw.messages.set(registry[module].messages);
| |
| }
| |
| if (registry[module].templates) {
| |
| mw.templates.set(module, registry[module].templates);
| |
| }
| |
| var cssPending = 0;
| |
| var cssHandle = function() {
| |
| cssPending++;
| |
| return function() {
| |
| cssPending--;
| |
| if (cssPending === 0) {
| |
| var runScriptCopy = runScript;
| |
| runScript = undefined;
| |
| runScriptCopy();
| |
| }
| |
| };
| |
| };
| |
| var style = registry[module].style;
| |
| if (style) {
| |
| if ('css' in style) {
| |
| for (var i = 0; i < style.css.length; i++) {
| |
| addEmbeddedCSS(style.css[i], cssHandle());
| |
| }
| |
| }
| |
| if ('url' in style) {
| |
| for (var media in style.url) {
| |
| var urls = style.url[media];
| |
| for (var j = 0; j < urls.length; j++) {
| |
| addLink(urls[j], media, marker);
| |
| }
| |
| }
| |
| }
| |
| }
| |
| if (module === 'user') {
| |
| var siteDeps;
| |
| var siteDepErr;
| |
| try {
| |
| siteDeps = resolve(['site']);
| |
| } catch (e) {
| |
| siteDepErr = e;
| |
| runScript();
| |
| }
| |
| if (!siteDepErr) {
| |
| enqueue(siteDeps, runScript, runScript);
| |
| }
| |
| } else if (cssPending === 0) {
| |
| runScript();
| |
| }
| |
| }
| |
|
| |
| function sortQuery(o) {
| |
| var sorted = {};
| |
| var list = [];
| |
| for (var key in o) {
| |
| list.push(key);
| |
| }
| |
| list.sort();
| |
| for (var i = 0; i < list.length; i++) {
| |
| sorted[list[i]] = o[list[i]];
| |
| }
| |
| return sorted;
| |
| }
| |
|
| |
| function buildModulesString(moduleMap) {
| |
| var str = [];
| |
| var list = [];
| |
| var p;
| |
|
| |
| function restore(suffix) {
| |
| return p + suffix;
| |
| }
| |
| for (var prefix in moduleMap) {
| |
| p = prefix === '' ? '' : prefix + '.';
| |
| str.push(p + moduleMap[prefix].join(','));
| |
| list.push.apply(list, moduleMap[prefix].map(restore));
| |
| }
| |
| return {
| |
| str: str.join('|'),
| |
| list: list
| |
| };
| |
| }
| |
|
| |
| function makeQueryString(params) {
| |
| var str = '';
| |
| for (var key in params) {
| |
| str += (str ? '&' : '') + encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
| |
| }
| |
| return str;
| |
| }
| |
|
| |
| function batchRequest(batch) {
| |
| if (!batch.length) {
| |
| return;
| |
| }
| |
| var sourceLoadScript, currReqBase, moduleMap;
| |
|
| |
| function doRequest() {
| |
| var query = Object.create(currReqBase),
| |
| packed = buildModulesString(moduleMap);
| |
| query.modules = packed.str;
| |
| query.version = getCombinedVersion(packed.list);
| |
| query = sortQuery(query);
| |
| addScript(sourceLoadScript + '?' + makeQueryString(query));
| |
| }
| |
| batch.sort();
| |
| var reqBase = {
| |
| "lang": "ko",
| |
| "skin": "liberty"
| |
| };
| |
| var splits = Object.create(null);
| |
| for (var b = 0; b < batch.length; b++) {
| |
| var bSource = registry[batch[b]].source;
| |
| var bGroup = registry[batch[b]].group;
| |
| if (!splits[bSource]) {
| |
| splits[bSource] = Object.create(null);
| |
| }
| |
| if (!splits[bSource][bGroup]) {
| |
| splits[bSource][bGroup] = [];
| |
| }
| |
| splits[bSource][bGroup].push(batch[b]);
| |
| }
| |
| for (var source in splits) {
| |
| sourceLoadScript = sources[source];
| |
| for (var group in splits[source]) {
| |
| var modules = splits[source][group];
| |
| currReqBase = Object.create(reqBase);
| |
| if (group === 0 && mw.config.get('wgUserName') !== null) {
| |
| currReqBase.user = mw.config.get('wgUserName');
| |
| }
| |
| var currReqBaseLength = makeQueryString(currReqBase).length + 23;
| |
| var length = 0;
| |
| moduleMap = Object.create(null);
| |
| for (var i = 0; i < modules.length; i++) {
| |
| var lastDotIndex = modules[i].lastIndexOf('.'),
| |
| prefix = modules[i].slice(0, Math.max(0, lastDotIndex)),
| |
| suffix = modules[i].slice(lastDotIndex + 1),
| |
| bytesAdded = moduleMap[prefix] ? suffix.length + 3 : modules[i].length + 3;
| |
| if (length && length + currReqBaseLength + bytesAdded > mw.loader.maxQueryLength) {
| |
| doRequest();
| |
| length = 0;
| |
| moduleMap = Object.create(null);
| |
| }
| |
| if (!moduleMap[prefix]) {
| |
| moduleMap[prefix] = [];
| |
| }
| |
| length += bytesAdded;
| |
| moduleMap[prefix].push(suffix);
| |
| }
| |
| doRequest();
| |
| }
| |
| }
| |
| }
| |
|
| |
| function asyncEval(implementations, cb) {
| |
| if (!implementations.length) {
| |
| return;
| |
| }
| |
| mw.requestIdleCallback(function() {
| |
| try {
| |
| domEval(implementations.join(';'));
| |
| } catch (err) {
| |
| cb(err);
| |
| }
| |
| });
| |
| }
| |
|
| |
| function getModuleKey(module) {
| |
| return module in registry ? (module + '@' + registry[module].version) : null;
| |
| }
| |
|
| |
| function splitModuleKey(key) {
| |
| var index = key.lastIndexOf('@');
| |
| if (index === -1 || index === 0) {
| |
| return {
| |
| name: key,
| |
| version: ''
| |
| };
| |
| }
| |
| return {
| |
| name: key.slice(0, index),
| |
| version: key.slice(index + 1)
| |
| };
| |
| }
| |
|
| |
| function registerOne(module, version, dependencies, group, source, skip) {
| |
| if (module in registry) {
| |
| throw new Error('module already registered: ' + module);
| |
| }
| |
| version = String(version || '');
| |
| if (version.slice(-1) === '!') {
| |
| if (!isES6Supported) {
| |
| return;
| |
| }
| |
| version = version.slice(0, -1);
| |
| }
| |
| registry[module] = {
| |
| module: {
| |
| exports: {}
| |
| },
| |
| packageExports: {},
| |
| version: version,
| |
| dependencies: dependencies || [],
| |
| group: typeof group === 'undefined' ? null : group,
| |
| source: typeof source === 'string' ? source : 'local',
| |
| state: 'registered',
| |
| skip: typeof skip === 'string' ? skip : null
| |
| };
| |
| }
| |
| mw.loader = {
| |
| moduleRegistry: registry,
| |
| maxQueryLength: 2000,
| |
| addStyleTag: newStyleTag,
| |
| addScriptTag: addScript,
| |
| addLinkTag: addLink,
| |
| enqueue: enqueue,
| |
| resolve: resolve,
| |
| work: function() {
| |
| store.init();
| |
| var q = queue.length,
| |
| storedImplementations = [],
| |
| storedNames = [],
| |
| requestNames = [],
| |
| batch = new StringSet();
| |
| while (q--) {
| |
| var module = queue[q];
| |
| if (mw.loader.getState(module) === 'registered' && !batch.has(module)) {
| |
| registry[module].state = 'loading';
| |
| batch.add(module);
| |
| var implementation = store.get(
| |
| module);
| |
| if (implementation) {
| |
| storedImplementations.push(implementation);
| |
| storedNames.push(module);
| |
| } else {
| |
| requestNames.push(module);
| |
| }
| |
| }
| |
| }
| |
| queue = [];
| |
| asyncEval(storedImplementations, function(err) {
| |
| store.stats.failed++;
| |
| store.clear();
| |
| mw.trackError('resourceloader.exception', {
| |
| exception: err,
| |
| source: 'store-eval'
| |
| });
| |
| var failed = storedNames.filter(function(name) {
| |
| return registry[name].state === 'loading';
| |
| });
| |
| batchRequest(failed);
| |
| });
| |
| batchRequest(requestNames);
| |
| },
| |
| addSource: function(ids) {
| |
| for (var id in ids) {
| |
| if (id in sources) {
| |
| throw new Error('source already registered: ' + id);
| |
| }
| |
| sources[id] = ids[id];
| |
| }
| |
| },
| |
| register: function(modules) {
| |
| if (typeof modules !== 'object') {
| |
| registerOne.apply(null, arguments);
| |
| return;
| |
| }
| |
|
| |
| function resolveIndex(dep) {
| |
| return typeof dep === 'number' ? modules[dep][0] : dep;
| |
| }
| |
| for (var i = 0; i < modules.length; i++) {
| |
| var deps = modules[i][2];
| |
| if (deps) {
| |
| for (var j = 0; j < deps.length; j++) {
| |
| deps[j] = resolveIndex(deps[j]);
| |
| }
| |
| }
| |
| registerOne.apply(null, modules[i]);
| |
| }
| |
| },
| |
| implement: function(module, script, style, messages, templates) {
| |
| var split = splitModuleKey(module),
| |
| name = split.name,
| |
| version = split.version;
| |
| if (!(name in registry)) {
| |
| mw.loader.register(name);
| |
| }
| |
| if (registry[name].script !== undefined) {
| |
| throw new Error('module already implemented: ' + name);
| |
| }
| |
| if (version) {
| |
| registry[name].version = version;
| |
| }
| |
| registry[name].script = script || null;
| |
| registry[name].style = style || null;
| |
| registry[name].messages = messages || null;
| |
| registry[name].templates = templates || null;
| |
| if (registry[name].state !== 'error' && registry[name].state !== 'missing') {
| |
| setAndPropagate(name, 'loaded');
| |
| }
| |
| },
| |
| load: function(modules, type) {
| |
| if (typeof modules === 'string' && /^(https?:)?\/?\//.test(modules)) {
| |
| if (type === 'text/css') {
| |
| addLink(modules);
| |
| } else if (type === 'text/javascript' || type === undefined) {
| |
| addScript(modules);
| |
| } else {
| |
| throw new Error('Invalid type ' + type);
| |
| }
| |
| } else {
| |
| modules = typeof modules === 'string' ? [modules] : modules;
| |
| enqueue(resolveStubbornly(modules));
| |
| }
| |
| },
| |
| state: function(states) {
| |
| for (var module in states) {
| |
| if (!(module in registry)) {
| |
| mw.loader.register(module);
| |
| }
| |
| setAndPropagate(module, states[module]);
| |
| }
| |
| },
| |
| getState: function(module) {
| |
| return module in registry ? registry[module].state : null;
| |
| },
| |
| require: function(moduleName) {
| |
| if (mw.loader.getState(moduleName) !== 'ready') {
| |
| throw new Error('Module "' + moduleName + '" is not loaded');
| |
| }
| |
| return registry[moduleName].module.exports;
| |
| }
| |
| };
| |
| var hasPendingWrites = false;
| |
|
| |
| function flushWrites() {
| |
| store.prune();
| |
| while (store.queue.length) {
| |
| store.set(store.queue.shift());
| |
| }
| |
| try {
| |
| localStorage.removeItem(store.key);
| |
| var data = JSON.stringify(store);
| |
| localStorage.setItem(store.key, data);
| |
| } catch (e) {
| |
| mw.trackError('resourceloader.exception', {
| |
| exception: e,
| |
| source: 'store-localstorage-update'
| |
| });
| |
| }
| |
| hasPendingWrites = false;
| |
| }
| |
| mw.loader.store = store = {
| |
| enabled: null,
| |
| items: {},
| |
| queue: [],
| |
| stats: {
| |
| hits: 0,
| |
| misses: 0,
| |
| expired: 0,
| |
| failed: 0
| |
| },
| |
| toJSON: function() {
| |
| return {
| |
| items: store.items,
| |
| vary: store.vary,
| |
| asOf: Math.ceil(Date.now() / 1e7)
| |
| };
| |
| },
| |
| key: "MediaWikiModuleStore:fbnwiki",
| |
| vary: "liberty:1:ko",
| |
| init: function() {
| |
| if (this.enabled === null) {
| |
| this.enabled = false;
| |
| if (true) {
| |
| this.load();
| |
| } else {
| |
| this.clear();
| |
| }
| |
| }
| |
| },
| |
| load: function() {
| |
| try {
| |
| var raw = localStorage.getItem(this.key);
| |
| this
| |
| .enabled = true;
| |
| var data = JSON.parse(raw);
| |
| if (data && data.vary === this.vary && data.items && Date.now() < (data.asOf * 1e7) + 259e7) {
| |
| this.items = data.items;
| |
| }
| |
| } catch (e) {}
| |
| },
| |
| get: function(module) {
| |
| if (this.enabled) {
| |
| var key = getModuleKey(module);
| |
| if (key in this.items) {
| |
| this.stats.hits++;
| |
| return this.items[key];
| |
| }
| |
| this.stats.misses++;
| |
| }
| |
| return false;
| |
| },
| |
| add: function(module) {
| |
| if (this.enabled) {
| |
| this.queue.push(module);
| |
| this.requestUpdate();
| |
| }
| |
| },
| |
| set: function(module) {
| |
| var args, encodedScript, descriptor = registry[module],
| |
| key = getModuleKey(module);
| |
| if (key in this.items || !descriptor || descriptor.state !== 'ready' || !descriptor.version || descriptor.group === 1 || descriptor.group === 0 || [descriptor.script, descriptor.style, descriptor.messages, descriptor.templates].indexOf(undefined) !== -1) {
| |
| return;
| |
| }
| |
| try {
| |
| if (typeof descriptor.script === 'function') {
| |
| encodedScript = String(descriptor.script);
| |
| } else if (typeof descriptor.script === 'object' && descriptor.script && !Array.isArray(descriptor.script)) {
| |
| encodedScript = '{' + 'main:' + JSON.stringify(descriptor.script.main) + ',' +
| |
| 'files:{' + Object.keys(descriptor.script.files).map(function(file) {
| |
| var value = descriptor.script.files[file];
| |
| return JSON.stringify(file) + ':' + (typeof value === 'function' ? value : JSON.stringify(value));
| |
| }).join(',') + '}}';
| |
| } else {
| |
| encodedScript = JSON.stringify(descriptor.script);
| |
| }
| |
| args = [JSON.stringify(key), encodedScript, JSON.stringify(descriptor.style), JSON.stringify(descriptor.messages), JSON.stringify(descriptor.templates)];
| |
| } catch (e) {
| |
| mw.trackError('resourceloader.exception', {
| |
| exception: e,
| |
| source: 'store-localstorage-json'
| |
| });
| |
| return;
| |
| }
| |
| var src = 'mw.loader.implement(' + args.join(',') + ');';
| |
| if (src.length > 1e5) {
| |
| return;
| |
| }
| |
| this.items[key] = src;
| |
| },
| |
| prune: function() {
| |
| for (var key in this.items) {
| |
| if (getModuleKey(splitModuleKey(key).name) !== key) {
| |
| this.stats.expired++;
| |
| delete this.items[key];
| |
| }
| |
| }
| |
| },
| |
| clear: function() {
| |
| this.items = {};
| |
| try {
| |
| localStorage.removeItem(this.key);
| |
| } catch (e) {}
| |
| },
| |
| requestUpdate: function() {
| |
| if (!hasPendingWrites) {
| |
| hasPendingWrites = true;
| |
| setTimeout(function() {
| |
| mw.requestIdleCallback(flushWrites);
| |
| }, 2000);
| |
| }
| |
| }
| |
| };
| |
| }());
| |
| mw.
| |
| requestIdleCallbackInternal = function(callback) {
| |
| setTimeout(function() {
| |
| var start = mw.now();
| |
| callback({
| |
| didTimeout: false,
| |
| timeRemaining: function() {
| |
| return Math.max(0, 50 - (mw.now() - start));
| |
| }
| |
| });
| |
| }, 1);
| |
| };
| |
| mw.requestIdleCallback = window.requestIdleCallback ? window.requestIdleCallback.bind(window) : mw.requestIdleCallbackInternal;
| |
| (function() {
| |
| var queue;
| |
| mw.loader.addSource({
| |
| "local": "/load.php"
| |
| });
| |
| mw.loader.register([
| |
| ["site", "0yfef", [1]],
| |
| ["site.styles", "rv9qy", [], 2],
| |
| ["filepage", "1ljys"],
| |
| ["user", "1tdkc", [], 0],
| |
| ["user.styles", "18fec", [], 0],
| |
| ["user.options", "12s5i", [], 1],
| |
| ["mediawiki.skinning.interface", "li3qj"],
| |
| ["jquery.makeCollapsible.styles", "1gqq5"],
| |
| ["mediawiki.skinning.content.parsoid", "1d280"],
| |
| ["jquery", "ef683"],
| |
| ["es6-polyfills", "1ihgd", [], null, null, "return Array.prototype.find\u0026\u0026Array.prototype.findIndex\u0026\u0026Array.prototype.includes\u0026\u0026typeof Promise==='function'\u0026\u0026Promise.prototype.finally;"],
| |
| ["web2017-polyfills", "5cxhc", [10], null, null,
| |
| "return'IntersectionObserver'in window\u0026\u0026typeof fetch==='function'\u0026\u0026typeof URL==='function'\u0026\u0026'toJSON'in URL.prototype;"
| |
| ],
| |
| ["mediawiki.base", "19aqs", [9]],
| |
| ["jquery.chosen", "fjvzv"],
| |
| ["jquery.client", "1jnox"],
| |
| ["jquery.color", "1y5ur"],
| |
| ["jquery.confirmable", "iie8m", [104]],
| |
| ["jquery.cookie", "emj1l"],
| |
| ["jquery.form", "1djyv"],
| |
| ["jquery.fullscreen", "1lanf"],
| |
| ["jquery.highlightText", "a2wnf", [80]],
| |
| ["jquery.hoverIntent", "1cahm"],
| |
| ["jquery.i18n", "1pu0k", [103]],
| |
| ["jquery.lengthLimit", "k5zgm", [64]],
| |
| ["jquery.makeCollapsible", "o5drd", [7, 80]],
| |
| ["jquery.spinner", "9br9t", [26]],
| |
| ["jquery.spinner.styles", "153wt"],
| |
| ["jquery.suggestions", "1g6wh", [20]],
| |
| ["jquery.tablesorter", "17w3p", [29, 105, 80]],
| |
| ["jquery.tablesorter.styles", "vfgav"],
| |
| ["jquery.textSelection", "m1do8", [14]],
| |
| ["jquery.tipsy", "1rhhm"],
| |
| ["jquery.ui", "k8yii"],
| |
| ["moment", "12iqd", [101, 80]],
| |
| ["vue", "eyq5j!"],
| |
| ["@vue/composition-api", "scw0q!", [34]],
| |
| ["vuex", "1twvy!", [34]],
| |
| ["@wikimedia/codex", "hdqk2!", [34]],
| |
| ["@wikimedia/codex-search", "9lsei!", [
| |
| 34
| |
| ]],
| |
| ["mediawiki.template", "bca94"],
| |
| ["mediawiki.template.mustache", "199kg", [39]],
| |
| ["mediawiki.apipretty", "wiuwr"],
| |
| ["mediawiki.api", "1hdsk", [70, 104]],
| |
| ["mediawiki.content.json", "f49yo"],
| |
| ["mediawiki.confirmCloseWindow", "116pk"],
| |
| ["mediawiki.debug", "lt46u", [187]],
| |
| ["mediawiki.diff", "paqy5"],
| |
| ["mediawiki.diff.styles", "yhce5"],
| |
| ["mediawiki.feedback", "oltus", [286, 195]],
| |
| ["mediawiki.feedlink", "12foc"],
| |
| ["mediawiki.filewarning", "1brek", [187, 199]],
| |
| ["mediawiki.ForeignApi", "6vgsr", [52]],
| |
| ["mediawiki.ForeignApi.core", "llzm2", [77, 42, 184]],
| |
| ["mediawiki.helplink", "wjdrt"],
| |
| ["mediawiki.hlist", "15zvc"],
| |
| ["mediawiki.htmlform", "a8sap", [23, 80]],
| |
| ["mediawiki.htmlform.ooui", "1m5pb", [187]],
| |
| ["mediawiki.htmlform.styles", "ob4wt"],
| |
| ["mediawiki.htmlform.ooui.styles", "as95t"],
| |
| ["mediawiki.icon", "17xpk"],
| |
| ["mediawiki.inspect", "88qa7", [64, 80]],
| |
| ["mediawiki.notification", "1445x", [80, 86]],
| |
| ["mediawiki.notification.convertmessagebox", "1kd6x", [61]],
| |
| ["mediawiki.notification.convertmessagebox.styles", "19vc0"],
| |
| ["mediawiki.String", "1vc9s"],
| |
| [
| |
| "mediawiki.pager.styles", "eo2ge"
| |
| ],
| |
| ["mediawiki.pager.tablePager", "1tupc"],
| |
| ["mediawiki.pulsatingdot", "1i1zo"],
| |
| ["mediawiki.searchSuggest", "1tj0e", [27, 42]],
| |
| ["mediawiki.storage", "2gicm", [80]],
| |
| ["mediawiki.Title", "1cw9f", [64, 80]],
| |
| ["mediawiki.Upload", "ooev2", [42]],
| |
| ["mediawiki.ForeignUpload", "14sdx", [51, 71]],
| |
| ["mediawiki.Upload.Dialog", "v3bgk", [74]],
| |
| ["mediawiki.Upload.BookletLayout", "s6cw5", [71, 78, 33, 190, 195, 200, 201]],
| |
| ["mediawiki.ForeignStructuredUpload.BookletLayout", "17bnm", [72, 74, 108, 167, 161]],
| |
| ["mediawiki.toc", "1jhap", [83]],
| |
| ["mediawiki.Uri", "7vjqw", [80]],
| |
| ["mediawiki.user", "5mz30", [42, 83]],
| |
| ["mediawiki.userSuggest", "1hhzv", [27, 42]],
| |
| ["mediawiki.util", "to7en", [14, 11]],
| |
| ["mediawiki.checkboxtoggle", "159pl"],
| |
| ["mediawiki.checkboxtoggle.styles", "1b0zv"],
| |
| ["mediawiki.cookie", "1rwr9", [17]],
| |
| ["mediawiki.experiments", "dhcyy"],
| |
| ["mediawiki.editfont.styles", "1rala"],
| |
| ["mediawiki.visibleTimeout", "xcitq"],
| |
| ["mediawiki.action.edit", "mstk4", [30, 88, 42, 85, 163]],
| |
| ["mediawiki.action.edit.styles", "ra6er"],
| |
| [
| |
| "mediawiki.action.edit.collapsibleFooter", "za3yf", [24, 59, 69]
| |
| ],
| |
| ["mediawiki.action.edit.preview", "zrghj", [25, 114, 78]],
| |
| ["mediawiki.action.history", "psppn", [24]],
| |
| ["mediawiki.action.history.styles", "w2lii"],
| |
| ["mediawiki.action.protect", "ymezb", [23, 187]],
| |
| ["mediawiki.action.view.metadata", "5e7wy", [99]],
| |
| ["mediawiki.action.view.postEdit", "1nkbh", [104, 61, 187, 206]],
| |
| ["mediawiki.action.view.redirect", "iqcjx"],
| |
| ["mediawiki.action.view.redirectPage", "iy19o"],
| |
| ["mediawiki.action.edit.editWarning", "ihdqq", [30, 44, 104]],
| |
| ["mediawiki.action.view.filepage", "144az"],
| |
| ["mediawiki.action.styles", "1jp30"],
| |
| ["mediawiki.language", "1wesf", [102]],
| |
| ["mediawiki.cldr", "w8zqb", [103]],
| |
| ["mediawiki.libs.pluralruleparser", "1kwne"],
| |
| ["mediawiki.jqueryMsg", "bcqas", [64, 101, 80, 5]],
| |
| ["mediawiki.language.months", "1yuv4", [101]],
| |
| ["mediawiki.language.names", "41ki5", [101]],
| |
| ["mediawiki.language.specialCharacters", "rchei", [101]],
| |
| ["mediawiki.libs.jpegmeta", "1h4oh"],
| |
| ["mediawiki.page.gallery", "1n4q2", [110, 80]],
| |
| ["mediawiki.page.gallery.styles",
| |
| "l984x"
| |
| ],
| |
| ["mediawiki.page.gallery.slideshow", "1smjn", [42, 190, 209, 211]],
| |
| ["mediawiki.page.ready", "1g8ac", [42]],
| |
| ["mediawiki.page.watch.ajax", "es038", [42]],
| |
| ["mediawiki.page.preview", "37tu6", [24, 30, 42, 46, 47, 187]],
| |
| ["mediawiki.page.image.pagination", "iyctm", [25, 80]],
| |
| ["mediawiki.rcfilters.filters.base.styles", "1b366"],
| |
| ["mediawiki.rcfilters.highlightCircles.seenunseen.styles", "1mwgh"],
| |
| ["mediawiki.rcfilters.filters.ui", "17j0x", [24, 77, 78, 158, 196, 203, 205, 206, 207, 209, 210]],
| |
| ["mediawiki.interface.helpers.styles", "1rfep"],
| |
| ["mediawiki.special", "16rtv"],
| |
| ["mediawiki.special.apisandbox", "16gpc", [24, 77, 178, 164, 186]],
| |
| ["mediawiki.special.block", "1sepj", [55, 161, 177, 168, 178, 175, 203]],
| |
| ["mediawiki.misc-authed-ooui", "g3hvq", [56, 158, 163]],
| |
| ["mediawiki.misc-authed-pref", "16eja", [5]],
| |
| ["mediawiki.misc-authed-curate", "1hvtz", [16, 25, 42]],
| |
| ["mediawiki.special.changeslist", "1gjem"],
| |
| ["mediawiki.special.changeslist.watchlistexpiry", "1gqgj", [120, 206]],
| |
| ["mediawiki.special.changeslist.enhanced", "1kflq"],
| |
| [
| |
| "mediawiki.special.changeslist.legend", "14ir0"
| |
| ],
| |
| ["mediawiki.special.changeslist.legend.js", "qa88i", [24, 83]],
| |
| ["mediawiki.special.contributions", "1luqq", [24, 104, 161, 186]],
| |
| ["mediawiki.special.edittags", "1fdd4", [13, 23]],
| |
| ["mediawiki.special.import.styles.ooui", "1hzv9"],
| |
| ["mediawiki.special.changecredentials", "f9fqt"],
| |
| ["mediawiki.special.changeemail", "10bxu"],
| |
| ["mediawiki.special.preferences.ooui", "12bpi", [44, 85, 62, 69, 168, 163, 195]],
| |
| ["mediawiki.special.preferences.styles.ooui", "j78lb"],
| |
| ["mediawiki.special.revisionDelete", "cvqd5", [163]],
| |
| ["mediawiki.special.search", "11pp3", [180]],
| |
| ["mediawiki.special.search.commonsInterwikiWidget", "fbtxd", [77, 42]],
| |
| ["mediawiki.special.search.interwikiwidget.styles", "11r2m"],
| |
| ["mediawiki.special.search.styles", "965wf"],
| |
| ["mediawiki.special.unwatchedPages", "1ifn8", [42]],
| |
| ["mediawiki.special.upload", "me44v", [25, 42, 44, 108, 120, 39]],
| |
| ["mediawiki.special.userlogin.common.styles", "7spfn"],
| |
| ["mediawiki.special.userlogin.login.styles", "ztgtl"],
| |
| ["mediawiki.special.createaccount",
| |
| "zqc6b", [42]
| |
| ],
| |
| ["mediawiki.special.userlogin.signup.styles", "en8j6"],
| |
| ["mediawiki.special.userrights", "4k0n6", [23, 62]],
| |
| ["mediawiki.special.watchlist", "m2tug", [42, 187, 206]],
| |
| ["mediawiki.ui", "1ozuu"],
| |
| ["mediawiki.ui.checkbox", "nywkr"],
| |
| ["mediawiki.ui.radio", "zb4tx"],
| |
| ["mediawiki.ui.anchor", "1yxgk"],
| |
| ["mediawiki.ui.button", "1enat"],
| |
| ["mediawiki.ui.input", "13lwo"],
| |
| ["mediawiki.ui.icon", "1e9uc"],
| |
| ["mediawiki.widgets", "1fzky", [42, 159, 190, 200, 201]],
| |
| ["mediawiki.widgets.styles", "1x5du"],
| |
| ["mediawiki.widgets.AbandonEditDialog", "f4488", [195]],
| |
| ["mediawiki.widgets.DateInputWidget", "11daz", [162, 33, 190, 211]],
| |
| ["mediawiki.widgets.DateInputWidget.styles", "1dh4p"],
| |
| ["mediawiki.widgets.visibleLengthLimit", "m325n", [23, 187]],
| |
| ["mediawiki.widgets.datetime", "8boni", [80, 187, 206, 210, 211]],
| |
| ["mediawiki.widgets.expiry", "m5uji", [164, 33, 190]],
| |
| ["mediawiki.widgets.CheckMatrixWidget", "k9si1", [187]],
| |
| ["mediawiki.widgets.CategoryMultiselectWidget", "864qf", [51, 190]],
| |
| ["mediawiki.widgets.SelectWithInputWidget", "yzuek", [169, 190]],
| |
| [
| |
| "mediawiki.widgets.SelectWithInputWidget.styles", "vkr7h"
| |
| ],
| |
| ["mediawiki.widgets.SizeFilterWidget", "1clfy", [171, 190]],
| |
| ["mediawiki.widgets.SizeFilterWidget.styles", "ceybj"],
| |
| ["mediawiki.widgets.MediaSearch", "sm07l", [51, 78, 190]],
| |
| ["mediawiki.widgets.Table", "fvtg6", [190]],
| |
| ["mediawiki.widgets.TagMultiselectWidget", "1erse", [190]],
| |
| ["mediawiki.widgets.UserInputWidget", "jsk5k", [42, 190]],
| |
| ["mediawiki.widgets.UsersMultiselectWidget", "1m6vb", [42, 190]],
| |
| ["mediawiki.widgets.NamespacesMultiselectWidget", "pwj2l", [190]],
| |
| ["mediawiki.widgets.TitlesMultiselectWidget", "gt95w", [158]],
| |
| ["mediawiki.widgets.TagMultiselectWidget.styles", "1rjw4"],
| |
| ["mediawiki.widgets.SearchInputWidget", "z70j2", [68, 158, 206]],
| |
| ["mediawiki.widgets.SearchInputWidget.styles", "9327p"],
| |
| ["mediawiki.watchstar.widgets", "qo1rt", [186]],
| |
| ["mediawiki.deflate", "1ci7b"],
| |
| ["oojs", "ewqeo"],
| |
| ["mediawiki.router", "1fux1", [184]],
| |
| ["oojs-ui", "1jh3r", [193, 190, 195]],
| |
| ["oojs-ui-core", "jr0b9", [101, 184, 189, 188, 197]],
| |
| ["oojs-ui-core.styles", "7bnuv"],
| |
| ["oojs-ui-core.icons",
| |
| "844ye"
| |
| ],
| |
| ["oojs-ui-widgets", "1cn0i", [187, 192]],
| |
| ["oojs-ui-widgets.styles", "z4zs1"],
| |
| ["oojs-ui-widgets.icons", "167g8"],
| |
| ["oojs-ui-toolbars", "zww4y", [187, 194]],
| |
| ["oojs-ui-toolbars.icons", "1f70c"],
| |
| ["oojs-ui-windows", "6qfp1", [187, 196]],
| |
| ["oojs-ui-windows.icons", "1bxxx"],
| |
| ["oojs-ui.styles.indicators", "1ljmc"],
| |
| ["oojs-ui.styles.icons-accessibility", "1xr69"],
| |
| ["oojs-ui.styles.icons-alerts", "c5h4n"],
| |
| ["oojs-ui.styles.icons-content", "7tpt9"],
| |
| ["oojs-ui.styles.icons-editing-advanced", "1pe09"],
| |
| ["oojs-ui.styles.icons-editing-citation", "1vznc"],
| |
| ["oojs-ui.styles.icons-editing-core", "vnetl"],
| |
| ["oojs-ui.styles.icons-editing-list", "tjp8d"],
| |
| ["oojs-ui.styles.icons-editing-styling", "10yrg"],
| |
| ["oojs-ui.styles.icons-interactions", "1h1qg"],
| |
| ["oojs-ui.styles.icons-layout", "hc14y"],
| |
| ["oojs-ui.styles.icons-location", "jhgr7"],
| |
| ["oojs-ui.styles.icons-media", "1s41i"],
| |
| ["oojs-ui.styles.icons-moderation", "1o6tf"],
| |
| ["oojs-ui.styles.icons-movement", "3pt5g"],
| |
| ["oojs-ui.styles.icons-user", "1oxtg"],
| |
| ["oojs-ui.styles.icons-wikimedia",
| |
| "1q04u"
| |
| ],
| |
| ["skins.monobook.styles", "1jh7u"],
| |
| ["skins.monobook.scripts", "vl9le", [78, 199]],
| |
| ["skins.timeless", "15bvm"],
| |
| ["skins.timeless.js", "158q7"],
| |
| ["skins.vector.user", "1b93e", [], 0],
| |
| ["skins.vector.user.styles", "1rlz1", [], 0],
| |
| ["skins.vector.search", "1ovmt!", [38, 77]],
| |
| ["skins.vector.styles.legacy", "16qf9"],
| |
| ["skins.vector.styles", "1oe9m"],
| |
| ["skins.vector.icons.js", "11fwm"],
| |
| ["skins.vector.icons", "1u31b"],
| |
| ["skins.vector.es6", "3hh3q!", [84, 112, 113, 69, 78, 223]],
| |
| ["skins.vector.js", "1uiwa", [112, 223]],
| |
| ["skins.vector.legacy.js", "omaiv", [112]],
| |
| ["skins.liberty.styles", "1mnw5"],
| |
| ["skins.liberty.ads", "g57lx"],
| |
| ["skins.liberty.bootstrap", "ivdpu"],
| |
| ["skins.liberty.layoutjs", "i4fzs", [83]],
| |
| ["skins.liberty.liverc", "1bf0f", [80]],
| |
| ["skins.liberty.loginjs", "10s7q", [80]],
| |
| ["ext.categoryTree", "ncl6k", [42]],
| |
| ["ext.categoryTree.styles", "1d80w"],
| |
| ["ext.cite.styles", "1y312"],
| |
| ["ext.cite.style", "gn7m1"],
| |
| ["ext.cite.visualEditor.core", "1vmkp", ["ext.visualEditor.mwcore", "ext.visualEditor.mwtransclusion"]],
| |
| ["ext.cite.visualEditor",
| |
| "1gyq6", [237, 236, 238, "ext.visualEditor.base", "ext.visualEditor.mediawiki", 199, 202, 206]
| |
| ],
| |
| ["ext.cite.ux-enhancements", "1va4k"],
| |
| ["ext.citeThisPage", "zt3yx"],
| |
| ["ext.codeEditor", "1ma6m", [243], 3],
| |
| ["jquery.codeEditor", "5r2xs", [245, 244, 272, 195], 3],
| |
| ["ext.codeEditor.icons", "1mo16"],
| |
| ["ext.codeEditor.ace", "1brj0", [], 4],
| |
| ["ext.codeEditor.ace.modes", "1o3y6", [245], 4],
| |
| ["ext.confirmEdit.editPreview.ipwhitelist.styles", "11y4q"],
| |
| ["ext.confirmEdit.visualEditor", "rlq1b", [283]],
| |
| ["ext.confirmEdit.simpleCaptcha", "14a9d"],
| |
| ["ext.inputBox.styles", "1d5ae"],
| |
| ["ext.interwiki.specialpage", "lsm82"],
| |
| ["mmv", "qbxjt", [15, 19, 31, 77, 257]],
| |
| ["mmv.ui.ondemandshareddependencies", "py41v", [252, 186]],
| |
| ["mmv.ui.download.pane", "1djwt", [151, 158, 253]],
| |
| ["mmv.ui.reuse.shareembed", "1vlhm", [158, 253]],
| |
| ["mmv.ui.tipsyDialog", "1vews", [252]],
| |
| ["mmv.bootstrap", "lgyc9", [185, 155, 157, 259]],
| |
| ["mmv.bootstrap.autostart", "dgnjl", [257]],
| |
| ["mmv.head", "1vrgu", [69, 78]],
| |
| ["ext.nuke.confirm", "1snx1", [104]],
| |
| ["ext.oath.totp.showqrcode", "vp9jv"],
| |
| [
| |
| "ext.oath.totp.showqrcode.styles", "16j3z"
| |
| ],
| |
| ["pdfhandler.messages", "11swy"],
| |
| ["ext.ReplaceText", "1ola7"],
| |
| ["ext.ReplaceTextStyles", "1doqs"],
| |
| ["ext.spamBlacklist.visualEditor", "xlus7"],
| |
| ["ext.pygments", "3yewq"],
| |
| ["ext.pygments.linenumbers", "1ra7j", [80]],
| |
| ["ext.geshi.visualEditor", "xlbcm", ["ext.visualEditor.mwcore", 201]],
| |
| ["mediawiki.api.titleblacklist", "63y45", [42]],
| |
| ["ext.titleblacklist.visualEditor", "105v1"],
| |
| ["ext.wikiEditor", "178lv", [30, 32, 107, 78, 158, 202, 203, 204, 205, 209, 39], 3],
| |
| ["ext.wikiEditor.styles", "1jyx4", [], 3],
| |
| ["ext.wikiEditor.images", "1qpkc"],
| |
| ["ext.wikiEditor.realtimepreview", "1ajwe", [272, 274, 114, 67, 69, 206]],
| |
| ["ext.scribunto.errors", "1micz", [190]],
| |
| ["ext.scribunto.logs", "c053i"],
| |
| ["ext.scribunto.edit", "1s9qo", [25, 42]],
| |
| ["ext.MultiMaps", "16adw"],
| |
| ["ext.MultiMaps.Leaflet", "i1160"],
| |
| ["ext.MultiMaps.Google", "hf6j0"],
| |
| ["ext.MultiMaps.Yandex", "naofk"],
| |
| ["ext.confirmEdit.CaptchaInputWidget", "amvgg", [187]],
| |
| ["ext.gadget.autonum", "oxvge", [], 2],
| |
| ["ext.gadget.ReferenceTooltips", "1rlmh", [], 2],
| |
| [
| |
| "mediawiki.messagePoster", "13b1w", [51]
| |
| ]
| |
| ]);
| |
| mw.config.set(window.RLCONF || {});
| |
| mw.loader.state(window.RLSTATE || {});
| |
| mw.loader.load(window.RLPAGEMODULES || []);
| |
| queue = window.RLQ || [];
| |
| RLQ = [];
| |
| RLQ.push = function(fn) {
| |
| if (typeof fn === 'function') {
| |
| fn();
| |
| } else {
| |
| RLQ[RLQ.length] = fn;
| |
| }
| |
| };
| |
| while (queue[0]) {
| |
| RLQ.push(queue.shift());
| |
| }
| |
| NORLQ = {
| |
| push: function() {}
| |
| };
| |
| }());
| |
| }
| |