resources/src/mediawiki/mediawiki.Title.js

   1 /*!
   2  * @author Neil Kandalgaonkar, 2010
   3  * @author Timo Tijhof, 2011-2013
   4  * @since 1.18
   5  */
   6 ( function ( mw, $ ) {
   7         /*jshint latedef:false */
   8
   9         /**
  10          * @class mw.Title
  11          *
  12          * Parse titles into an object structure. Note that when using the constructor
  13          * directly, passing invalid titles will result in an exception. Use #newFromText to use the
  14          * logic directly and get null for invalid titles which is easier to work with.
  15          *
  16          * @constructor
  17          * @param {string} title Title of the page. If no second argument given,
  18          *  this will be searched for a namespace
  19          * @param {number} [namespace=NS_MAIN] If given, will used as default namespace for the given title
  20          * @throws {Error} When the title is invalid
  21          */
  22         function Title( title, namespace ) {
  23                 var parsed = parse( title, namespace );
  24                 if ( !parsed ) {
  25                         throw new Error( 'Unable to parse title' );
  26                 }
  27
  28                 this.namespace = parsed.namespace;
  29                 this.title = parsed.title;
  30                 this.ext = parsed.ext;
  31                 this.fragment = parsed.fragment;
  32
  33                 return this;
  34         }
  35
  36         /* Private members */
  37
  38         var
  39
  40         /**
  41          * @private
  42          * @static
  43          * @property NS_MAIN
  44          */
  45         NS_MAIN = 0,
  46
  47         /**
  48          * @private
  49          * @static
  50          * @property NS_TALK
  51          */
  52         NS_TALK = 1,
  53
  54         /**
  55          * @private
  56          * @static
  57          * @property NS_SPECIAL
  58          */
  59         NS_SPECIAL = -1,
  60
  61         /**
  62          * @private
  63          * @static
  64          * @property NS_MEDIA
  65          */
  66         NS_MEDIA = -2,
  67
  68         /**
  69          * @private
  70          * @static
  71          * @property NS_FILE
  72          */
  73         NS_FILE = 6,
  74
  75         /**
  76          * @private
  77          * @static
  78          * @property FILENAME_MAX_BYTES
  79          */
  80         FILENAME_MAX_BYTES = 240,
  81
  82         /**
  83          * @private
  84          * @static
  85          * @property TITLE_MAX_BYTES
  86          */
  87         TITLE_MAX_BYTES = 255,
  88
  89         /**
  90          * Get the namespace id from a namespace name (either from the localized, canonical or alias
  91          * name).
  92          *
  93          * Example: On a German wiki this would return 6 for any of 'File', 'Datei', 'Image' or
  94          * even 'Bild'.
  95          *
  96          * @private
  97          * @static
  98          * @method getNsIdByName
  99          * @param {string} ns Namespace name (case insensitive, leading/trailing space ignored)
 100          * @return {number|boolean} Namespace id or boolean false
 101          */
 102         getNsIdByName = function ( ns ) {
 103                 var id;
 104
 105                 // Don't cast non-strings to strings, because null or undefined should not result in
 106                 // returning the id of a potential namespace called "Null:" (e.g. on null.example.org/wiki)
 107                 // Also, toLowerCase throws exception on null/undefined, because it is a String method.
 108                 if ( typeof ns !== 'string' ) {
 109                         return false;
 110                 }
 111                 ns = ns.toLowerCase();
 112                 id = mw.config.get( 'wgNamespaceIds' )[ ns ];
 113                 if ( id === undefined ) {
 114                         return false;
 115                 }
 116                 return id;
 117         },
 118
 119         rUnderscoreTrim = /^_+|_+$/g,
 120
 121         rSplit = /^(.+?)_*:_*(.*)$/,
 122
 123         // See MediaWikiTitleCodec.php#getTitleInvalidRegex
 124         rInvalid = new RegExp(
 125                 '[^' + mw.config.get( 'wgLegalTitleChars' ) + ']' +
 126                 // URL percent encoding sequences interfere with the ability
 127                 // to round-trip titles -- you can't link to them consistently.
 128                 '|%[0-9A-Fa-f]{2}' +
 129                 // XML/HTML character references produce similar issues.
 130                 '|&[A-Za-z0-9\u0080-\uFFFF]+;' +
 131                 '|&#[0-9]+;' +
 132                 '|&#x[0-9A-Fa-f]+;'
 133         ),
 134
 135         // From MediaWikiTitleCodec.php#L225 @26fcab1f18c568a41
 136         // "Clean up whitespace" in function MediaWikiTitleCodec::splitTitleString()
 137         rWhitespace = /[ _\u0009\u00A0\u1680\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\s]+/g,
 138
 139         /**
 140          * Slightly modified from Flinfo. Credit goes to Lupo and Flominator.
 141          * @private
 142          * @static
 143          * @property sanitationRules
 144          */
 145         sanitationRules = [
 146                 // "signature"
 147                 {
 148                         pattern: /~{3}/g,
 149                         replace: '',
 150                         generalRule: true
 151                 },
 152                 // Space, underscore, tab, NBSP and other unusual spaces
 153                 {
 154                         pattern: rWhitespace,
 155                         replace: ' ',
 156                         generalRule: true
 157                 },
 158                 // unicode bidi override characters: Implicit, Embeds, Overrides
 159                 {
 160                         pattern: /[\u200E\u200F\u202A-\u202E]/g,
 161                         replace: '',
 162                         generalRule: true
 163                 },
 164                 // control characters
 165                 {
 166                         pattern: /[\x00-\x1f\x7f]/g,
 167                         replace: '',
 168                         generalRule: true
 169                 },
 170                 // URL encoding (possibly)
 171                 {
 172                         pattern: /%([0-9A-Fa-f]{2})/g,
 173                         replace: '% $1',
 174                         generalRule: true
 175                 },
 176                 // HTML-character-entities
 177                 {
 178                         pattern: /&(([A-Za-z0-9\x80-\xff]+|#[0-9]+|#x[0-9A-Fa-f]+);)/g,
 179                         replace: '& $1',
 180                         generalRule: true
 181                 },
 182                 // slash, colon (not supported by file systems like NTFS/Windows, Mac OS 9 [:], ext4 [/])
 183                 {
 184                         pattern: /[:\/#]/g,
 185                         replace: '-',
 186                         fileRule: true
 187                 },
 188                 // brackets, greater than
 189                 {
 190                         pattern: /[\]\}>]/g,
 191                         replace: ')',
 192                         generalRule: true
 193                 },
 194                 // brackets, lower than
 195                 {
 196                         pattern: /[\[\{<]/g,
 197                         replace: '(',
 198                         generalRule: true
 199                 },
 200                 // everything that wasn't covered yet
 201                 {
 202                         pattern: new RegExp( rInvalid.source, 'g' ),
 203                         replace: '-',
 204                         generalRule: true
 205                 },
 206                 // directory structures
 207                 {
 208                         pattern: /^(\.|\.\.|\.\/.*|\.\.\/.*|.*\/\.\/.*|.*\/\.\.\/.*|.*\/\.|.*\/\.\.)$/g,
 209                         replace: '',
 210                         generalRule: true
 211                 }
 212         ],
 213
 214         /**
 215          * Internal helper for #constructor and #newFromtext.
 216          *
 217          * Based on Title.php#secureAndSplit
 218          *
 219          * @private
 220          * @static
 221          * @method parse
 222          * @param {string} title
 223          * @param {number} [defaultNamespace=NS_MAIN]
 224          * @return {Object|boolean}
 225          */
 226         parse = function ( title, defaultNamespace ) {
 227                 var namespace, m, id, i, fragment, ext;
 228
 229                 namespace = defaultNamespace === undefined ? NS_MAIN : defaultNamespace;
 230
 231                 title = title
 232                         // Normalise whitespace to underscores and remove duplicates
 233                         .replace( /[ _\s]+/g, '_' )
 234                         // Trim underscores
 235                         .replace( rUnderscoreTrim, '' );
 236
 237                 // Process initial colon
 238                 if ( title !== '' && title[ 0 ] === ':' ) {
 239                         // Initial colon means main namespace instead of specified default
 240                         namespace = NS_MAIN;
 241                         title = title
 242                                 // Strip colon
 243                                 .slice( 1 )
 244                                 // Trim underscores
 245                                 .replace( rUnderscoreTrim, '' );
 246                 }
 247
 248                 if ( title === '' ) {
 249                         return false;
 250                 }
 251
 252                 // Process namespace prefix (if any)
 253                 m = title.match( rSplit );
 254                 if ( m ) {
 255                         id = getNsIdByName( m[ 1 ] );
 256                         if ( id !== false ) {
 257                                 // Ordinary namespace
 258                                 namespace = id;
 259                                 title = m[ 2 ];
 260
 261                                 // For Talk:X pages, make sure X has no "namespace" prefix
 262                                 if ( namespace === NS_TALK && ( m = title.match( rSplit ) ) ) {
 263                                         // Disallow titles like Talk:File:x (subject should roundtrip: talk:file:x -> file:x -> file_talk:x)
 264                                         if ( getNsIdByName( m[ 1 ] ) !== false ) {
 265                                                 return false;
 266                                         }
 267                                 }
 268                         }
 269                 }
 270
 271                 // Process fragment
 272                 i = title.indexOf( '#' );
 273                 if ( i === -1 ) {
 274                         fragment = null;
 275                 } else {
 276                         fragment = title
 277                                 // Get segment starting after the hash
 278                                 .slice( i + 1 )
 279                                 // Convert to text
 280                                 // NB: Must not be trimmed ("Example#_foo" is not the same as "Example#foo")
 281                                 .replace( /_/g, ' ' );
 282
 283                         title = title
 284                                 // Strip hash
 285                                 .slice( 0, i )
 286                                 // Trim underscores, again (strips "_" from "bar" in "Foo_bar_#quux")
 287                                 .replace( rUnderscoreTrim, '' );
 288                 }
 289
 290                 // Reject illegal characters
 291                 if ( title.match( rInvalid ) ) {
 292                         return false;
 293                 }
 294
 295                 // Disallow titles that browsers or servers might resolve as directory navigation
 296                 if (
 297                         title.indexOf( '.' ) !== -1 && (
 298                                 title === '.' || title === '..' ||
 299                                 title.indexOf( './' ) === 0 ||
 300                                 title.indexOf( '../' ) === 0 ||
 301                                 title.indexOf( '/./' ) !== -1 ||
 302                                 title.indexOf( '/../' ) !== -1 ||
 303                                 title.slice( -2 ) === '/.' ||
 304                                 title.slice( -3 ) === '/..'
 305                         )
 306                 ) {
 307                         return false;
 308                 }
 309
 310                 // Disallow magic tilde sequence
 311                 if ( title.indexOf( '~~~' ) !== -1 ) {
 312                         return false;
 313                 }
 314
 315                 // Disallow titles exceeding the TITLE_MAX_BYTES byte size limit (size of underlying database field)
 316                 // Except for special pages, e.g. [[Special:Block/Long name]]
 317                 // Note: The PHP implementation also asserts that even in NS_SPECIAL, the title should
 318                 // be less than 512 bytes.
 319                 if ( namespace !== NS_SPECIAL && $.byteLength( title ) > TITLE_MAX_BYTES ) {
 320                         return false;
 321                 }
 322
 323                 // Can't make a link to a namespace alone.
 324                 if ( title === '' && namespace !== NS_MAIN ) {
 325                         return false;
 326                 }
 327
 328                 // Any remaining initial :s are illegal.
 329                 if ( title[ 0 ] === ':' ) {
 330                         return false;
 331                 }
 332
 333                 // For backwards-compatibility with old mw.Title, we separate the extension from the
 334                 // rest of the title.
 335                 i = title.lastIndexOf( '.' );
 336                 if ( i === -1 || title.length <= i + 1 ) {
 337                         // Extensions are the non-empty segment after the last dot
 338                         ext = null;
 339                 } else {
 340                         ext = title.slice( i + 1 );
 341                         title = title.slice( 0, i );
 342                 }
 343
 344                 return {
 345                         namespace: namespace,
 346                         title: title,
 347                         ext: ext,
 348                         fragment: fragment
 349                 };
 350         },
 351
 352         /**
 353          * Convert db-key to readable text.
 354          *
 355          * @private
 356          * @static
 357          * @method text
 358          * @param {string} s
 359          * @return {string}
 360          */
 361         text = function ( s ) {
 362                 if ( s !== null && s !== undefined ) {
 363                         return s.replace( /_/g, ' ' );
 364                 } else {
 365                         return '';
 366                 }
 367         },
 368
 369         /**
 370          * Sanitizes a string based on a rule set and a filter
 371          *
 372          * @private
 373          * @static
 374          * @method sanitize
 375          * @param {string} s
 376          * @param {Array} filter
 377          * @return {string}
 378          */
 379         sanitize = function ( s, filter ) {
 380                 var i, ruleLength, rule, m, filterLength,
 381                         rules = sanitationRules;
 382
 383                 for ( i = 0, ruleLength = rules.length; i < ruleLength; ++i ) {
 384                         rule = rules[ i ];
 385                         for ( m = 0, filterLength = filter.length; m < filterLength; ++m ) {
 386                                 if ( rule[ filter[ m ] ] ) {
 387                                         s = s.replace( rule.pattern, rule.replace );
 388                                 }
 389                         }
 390                 }
 391                 return s;
 392         },
 393
 394         /**
 395          * Cuts a string to a specific byte length, assuming UTF-8
 396          * or less, if the last character is a multi-byte one
 397          *
 398          * @private
 399          * @static
 400          * @method trimToByteLength
 401          * @param {string} s
 402          * @param {number} length
 403          * @return {string}
 404          */
 405         trimToByteLength = function ( s, length ) {
 406                 var byteLength, chopOffChars, chopOffBytes;
 407
 408                 // bytelength is always greater or equal to the length in characters
 409                 s = s.substr( 0, length );
 410                 while ( ( byteLength = $.byteLength( s ) ) > length ) {
 411                         // Calculate how many characters can be safely removed
 412                         // First, we need to know how many bytes the string exceeds the threshold
 413                         chopOffBytes = byteLength - length;
 414                         // A character in UTF-8 is at most 4 bytes
 415                         // One character must be removed in any case because the
 416                         // string is too long
 417                         chopOffChars = Math.max( 1, Math.floor( chopOffBytes / 4 ) );
 418                         s = s.substr( 0, s.length - chopOffChars );
 419                 }
 420                 return s;
 421         },
 422
 423         /**
 424          * Cuts a file name to a specific byte length
 425          *
 426          * @private
 427          * @static
 428          * @method trimFileNameToByteLength
 429          * @param {string} name without extension
 430          * @param {string} extension file extension
 431          * @return {string} The full name, including extension
 432          */
 433         trimFileNameToByteLength = function ( name, extension ) {
 434                 // There is a special byte limit for file names and ... remember the dot
 435                 return trimToByteLength( name, FILENAME_MAX_BYTES - extension.length - 1 ) + '.' + extension;
 436         },
 437
 438         // Polyfill for ES5 Object.create
 439         createObject = Object.create || ( function () {
 440                 return function ( o ) {
 441                         function Title() {}
 442                         if ( o !== Object( o ) ) {
 443                                 throw new Error( 'Cannot inherit from a non-object' );
 444                         }
 445                         Title.prototype = o;
 446                         return new Title();
 447                 };
 448         }() );
 449
 450         /* Static members */
 451
 452         /**
 453          * Constructor for Title objects with a null return instead of an exception for invalid titles.
 454          *
 455          * @static
 456          * @param {string} title
 457          * @param {number} [namespace=NS_MAIN] Default namespace
 458          * @return {mw.Title|null} A valid Title object or null if the title is invalid
 459          */
 460         Title.newFromText = function ( title, namespace ) {
 461                 var t, parsed = parse( title, namespace );
 462                 if ( !parsed ) {
 463                         return null;
 464                 }
 465
 466                 t = createObject( Title.prototype );
 467                 t.namespace = parsed.namespace;
 468                 t.title = parsed.title;
 469                 t.ext = parsed.ext;
 470                 t.fragment = parsed.fragment;
 471
 472                 return t;
 473         };
 474
 475         /**
 476          * Constructor for Title objects from user input altering that input to
 477          * produce a title that MediaWiki will accept as legal
 478          *
 479          * @static
 480          * @param {string} title
 481          * @param {number} [defaultNamespace=NS_MAIN]
 482          *  If given, will used as default namespace for the given title.
 483          * @param {Object} [options] additional options
 484          * @param {string} [options.fileExtension='']
 485          *  If the title is about to be created for the Media or File namespace,
 486          *  ensures the resulting Title has the correct extension. Useful, for example
 487          *  on systems that predict the type by content-sniffing, not by file extension.
 488          *  If different from empty string, `forUploading` is assumed.
 489          * @param {boolean} [options.forUploading=true]
 490          *  Makes sure that a file is uploadable under the title returned.
 491          *  There are pages in the file namespace under which file upload is impossible.
 492          *  Automatically assumed if the title is created in the Media namespace.
 493          * @return {mw.Title|null} A valid Title object or null if the input cannot be turned into a valid title
 494          */
 495         Title.newFromUserInput = function ( title, defaultNamespace, options ) {
 496                 var namespace, m, id, ext, parts;
 497
 498                 // defaultNamespace is optional; check whether options moves up
 499                 if ( arguments.length < 3 && $.type( defaultNamespace ) === 'object' ) {
 500                         options = defaultNamespace;
 501                         defaultNamespace = undefined;
 502                 }
 503
 504                 // merge options into defaults
 505                 options = $.extend( {
 506                         fileExtension: '',
 507                         forUploading: true
 508                 }, options );
 509
 510                 namespace = defaultNamespace === undefined ? NS_MAIN : defaultNamespace;
 511
 512                 // Normalise whitespace and remove duplicates
 513                 title = $.trim( title.replace( rWhitespace, ' ' ) );
 514
 515                 // Process initial colon
 516                 if ( title !== '' && title[ 0 ] === ':' ) {
 517                         // Initial colon means main namespace instead of specified default
 518                         namespace = NS_MAIN;
 519                         title = title
 520                                 // Strip colon
 521                                 .substr( 1 )
 522                                 // Trim underscores
 523                                 .replace( rUnderscoreTrim, '' );
 524                 }
 525
 526                 // Process namespace prefix (if any)
 527                 m = title.match( rSplit );
 528                 if ( m ) {
 529                         id = getNsIdByName( m[ 1 ] );
 530                         if ( id !== false ) {
 531                                 // Ordinary namespace
 532                                 namespace = id;
 533                                 title = m[ 2 ];
 534                         }
 535                 }
 536
 537                 if ( namespace === NS_MEDIA
 538                         || ( ( options.forUploading || options.fileExtension ) && ( namespace === NS_FILE ) )
 539                 ) {
 540
 541                         title = sanitize( title, [ 'generalRule', 'fileRule' ] );
 542
 543                         // Operate on the file extension
 544                         // Although it is possible having spaces between the name and the ".ext" this isn't nice for
 545                         // operating systems hiding file extensions -> strip them later on
 546                         parts = title.split( '.' );
 547
 548                         if ( parts.length > 1 ) {
 549
 550                                 // Get the last part, which is supposed to be the file extension
 551                                 ext = parts.pop();
 552
 553                                 if ( options.fileExtension ) {
 554                                         // Does the supplied file name carry the desired file extension?
 555                                         if ( Title.normalizeExtension( ext ) !== Title.normalizeExtension( options.fileExtension ) ) {
 556                                                 // No, push back, whatever there was after the dot
 557                                                 parts.push( ext );
 558                                         }
 559
 560                                         // Always canonicalize to the desired file extension (e.g. 'jpeg' to 'jpg')
 561                                         ext = options.fileExtension;
 562                                 }
 563
 564                                 // Remove whitespace of the name part (that W/O extension)
 565                                 title = $.trim( parts.join( '.' ) );
 566
 567                                 // Cut, if too long and append file extension
 568                                 title = trimFileNameToByteLength( title, ext );
 569
 570                         } else {
 571
 572                                 // Missing file extension
 573                                 title = $.trim( parts.join( '.' ) );
 574
 575                                 if ( options.fileExtension ) {
 576
 577                                         // Cut, if too long and append the desired file extension
 578                                         title = trimFileNameToByteLength( title, options.fileExtension );
 579
 580                                 } else {
 581
 582                                         // Name has no file extension and a fallback wasn't provided either
 583                                         return null;
 584                                 }
 585                         }
 586                 } else {
 587
 588                         title = sanitize( title, [ 'generalRule' ] );
 589
 590                         // Cut titles exceeding the TITLE_MAX_BYTES byte size limit
 591                         // (size of underlying database field)
 592                         if ( namespace !== NS_SPECIAL ) {
 593                                 title = trimToByteLength( title, TITLE_MAX_BYTES );
 594                         }
 595                 }
 596
 597                 // Any remaining initial :s are illegal.
 598                 title = title.replace( /^\:+/, '' );
 599
 600                 return Title.newFromText( title, namespace );
 601         };
 602
 603         /**
 604          * Sanitizes a file name as supplied by the user, originating in the user's file system
 605          * so it is most likely a valid MediaWiki title and file name after processing.
 606          * Returns null on fatal errors.
 607          *
 608          * @static
 609          * @param {string} uncleanName The unclean file name including file extension but
 610          *   without namespace
 611          * @param {string} [fileExtension] the desired file extension
 612          * @return {mw.Title|null} A valid Title object or null if the title is invalid
 613          */
 614         Title.newFromFileName = function ( uncleanName, fileExtension ) {
 615
 616                 return Title.newFromUserInput( 'File:' + uncleanName, {
 617                         fileExtension: fileExtension,
 618                         forUploading: true
 619                 } );
 620         };
 621
 622         /**
 623          * Get the file title from an image element
 624          *
 625          *     var title = mw.Title.newFromImg( $( 'img:first' ) );
 626          *
 627          * @static
 628          * @param {HTMLElement|jQuery} img The image to use as a base
 629          * @return {mw.Title|null} The file title or null if unsuccessful
 630          */
 631         Title.newFromImg = function ( img ) {
 632                 var matches, i, regex, src, decodedSrc,
 633
 634                         // thumb.php-generated thumbnails
 635                         thumbPhpRegex = /thumb\.php/,
 636                         regexes = [
 637                                 // Thumbnails
 638                                 /\/[a-f0-9]\/[a-f0-9]{2}\/([^\s\/]+)\/[^\s\/]+-(?:\1|thumbnail)[^\s\/]*$/,
 639
 640                                 // Thumbnails in non-hashed upload directories
 641                                 /\/([^\s\/]+)\/[^\s\/]+-(?:\1|thumbnail)[^\s\/]*$/,
 642
 643                                 // Full size images
 644                                 /\/[a-f0-9]\/[a-f0-9]{2}\/([^\s\/]+)$/,
 645
 646                                 // Full-size images in non-hashed upload directories
 647                                 /\/([^\s\/]+)$/
 648                         ],
 649
 650                         recount = regexes.length;
 651
 652                 src = img.jquery ? img[ 0 ].src : img.src;
 653
 654                 matches = src.match( thumbPhpRegex );
 655
 656                 if ( matches ) {
 657                         return mw.Title.newFromText( 'File:' + mw.util.getParamValue( 'f', src ) );
 658                 }
 659
 660                 decodedSrc = decodeURIComponent( src );
 661
 662                 for ( i = 0; i < recount; i++ ) {
 663                         regex = regexes[ i ];
 664                         matches = decodedSrc.match( regex );
 665
 666                         if ( matches && matches[ 1 ] ) {
 667                                 return mw.Title.newFromText( 'File:' + matches[ 1 ] );
 668                         }
 669                 }
 670
 671                 return null;
 672         };
 673
 674         /**
 675          * Whether this title exists on the wiki.
 676          *
 677          * @static
 678          * @param {string|mw.Title} title prefixed db-key name (string) or instance of Title
 679          * @return {boolean|null} Boolean if the information is available, otherwise null
 680          */
 681         Title.exists = function ( title ) {
 682                 var match,
 683                         type = $.type( title ),
 684                         obj = Title.exist.pages;
 685
 686                 if ( type === 'string' ) {
 687                         match = obj[ title ];
 688                 } else if ( type === 'object' && title instanceof Title ) {
 689                         match = obj[ title.toString() ];
 690                 } else {
 691                         throw new Error( 'mw.Title.exists: title must be a string or an instance of Title' );
 692                 }
 693
 694                 if ( typeof match === 'boolean' ) {
 695                         return match;
 696                 }
 697
 698                 return null;
 699         };
 700
 701         /**
 702          * Store page existence
 703          *
 704          * @static
 705          * @property {Object} exist
 706          * @property {Object} exist.pages Keyed by title. Boolean true value indicates page does exist.
 707          *
 708          * @property {Function} exist.set The setter function.
 709          *
 710          *  Example to declare existing titles:
 711          *
 712          *     Title.exist.set( ['User:John_Doe', ...] );
 713          *
 714          *  Example to declare titles nonexistent:
 715          *
 716          *     Title.exist.set( ['File:Foo_bar.jpg', ...], false );
 717          *
 718          * @property {string|Array} exist.set.titles Title(s) in strict prefixedDb title form
 719          * @property {boolean} [exist.set.state=true] State of the given titles
 720          * @return {boolean}
 721          */
 722         Title.exist = {
 723                 pages: {},
 724
 725                 set: function ( titles, state ) {
 726                         titles = $.isArray( titles ) ? titles : [ titles ];
 727                         state = state === undefined ? true : !!state;
 728                         var i,
 729                                 pages = this.pages,
 730                                 len = titles.length;
 731
 732                         for ( i = 0; i < len; i++ ) {
 733                                 pages[ titles[ i ] ] = state;
 734                         }
 735                         return true;
 736                 }
 737         };
 738
 739         /**
 740          * Normalize a file extension to the common form, making it lowercase and checking some synonyms,
 741          * and ensure it's clean. Extensions with non-alphanumeric characters will be discarded.
 742          * Keep in sync with File::normalizeExtension() in PHP.
 743          *
 744          * @param {string} extension File extension (without the leading dot)
 745          * @return {string} File extension in canonical form
 746          */
 747         Title.normalizeExtension = function ( extension ) {
 748                 var
 749                         lower = extension.toLowerCase(),
 750                         squish = {
 751                                 htm: 'html',
 752                                 jpeg: 'jpg',
 753                                 mpeg: 'mpg',
 754                                 tiff: 'tif',
 755                                 ogv: 'ogg'
 756                         };
 757                 if ( squish.hasOwnProperty( lower ) ) {
 758                         return squish[ lower ];
 759                 } else if ( /^[0-9a-z]+$/.test( lower ) ) {
 760                         return lower;
 761                 } else {
 762                         return '';
 763                 }
 764         };
 765
 766         /* Public members */
 767
 768         Title.prototype = {
 769                 constructor: Title,
 770
 771                 /**
 772                  * Get the namespace number
 773                  *
 774                  * Example: 6 for "File:Example_image.svg".
 775                  *
 776                  * @return {number}
 777                  */
 778                 getNamespaceId: function () {
 779                         return this.namespace;
 780                 },
 781
 782                 /**
 783                  * Get the namespace prefix (in the content language)
 784                  *
 785                  * Example: "File:" for "File:Example_image.svg".
 786                  * In #NS_MAIN this is '', otherwise namespace name plus ':'
 787                  *
 788                  * @return {string}
 789                  */
 790                 getNamespacePrefix: function () {
 791                         return this.namespace === NS_MAIN ?
 792                                 '' :
 793                                 ( mw.config.get( 'wgFormattedNamespaces' )[ this.namespace ].replace( / /g, '_' ) + ':' );
 794                 },
 795
 796                 /**
 797                  * Get the page name without extension or namespace prefix
 798                  *
 799                  * Example: "Example_image" for "File:Example_image.svg".
 800                  *
 801                  * For the page title (full page name without namespace prefix), see #getMain.
 802                  *
 803                  * @return {string}
 804                  */
 805                 getName: function () {
 806                         if (
 807                                 $.inArray( this.namespace, mw.config.get( 'wgCaseSensitiveNamespaces' ) ) !== -1 ||
 808                                 !this.title.length
 809                         ) {
 810                                 return this.title;
 811                         }
 812                         return this.title[ 0 ].toUpperCase() + this.title.slice( 1 );
 813                 },
 814
 815                 /**
 816                  * Get the page name (transformed by #text)
 817                  *
 818                  * Example: "Example image" for "File:Example_image.svg".
 819                  *
 820                  * For the page title (full page name without namespace prefix), see #getMainText.
 821                  *
 822                  * @return {string}
 823                  */
 824                 getNameText: function () {
 825                         return text( this.getName() );
 826                 },
 827
 828                 /**
 829                  * Get the extension of the page name (if any)
 830                  *
 831                  * @return {string|null} Name extension or null if there is none
 832                  */
 833                 getExtension: function () {
 834                         return this.ext;
 835                 },
 836
 837                 /**
 838                  * Shortcut for appendable string to form the main page name.
 839                  *
 840                  * Returns a string like ".json", or "" if no extension.
 841                  *
 842                  * @return {string}
 843                  */
 844                 getDotExtension: function () {
 845                         return this.ext === null ? '' : '.' + this.ext;
 846                 },
 847
 848                 /**
 849                  * Get the main page name
 850                  *
 851                  * Example: "Example_image.svg" for "File:Example_image.svg".
 852                  *
 853                  * @return {string}
 854                  */
 855                 getMain: function () {
 856                         return this.getName() + this.getDotExtension();
 857                 },
 858
 859                 /**
 860                  * Get the main page name (transformed by #text)
 861                  *
 862                  * Example: "Example image.svg" for "File:Example_image.svg".
 863                  *
 864                  * @return {string}
 865                  */
 866                 getMainText: function () {
 867                         return text( this.getMain() );
 868                 },
 869
 870                 /**
 871                  * Get the full page name
 872                  *
 873                  * Example: "File:Example_image.svg".
 874                  * Most useful for API calls, anything that must identify the "title".
 875                  *
 876                  * @return {string}
 877                  */
 878                 getPrefixedDb: function () {
 879                         return this.getNamespacePrefix() + this.getMain();
 880                 },
 881
 882                 /**
 883                  * Get the full page name (transformed by #text)
 884                  *
 885                  * Example: "File:Example image.svg" for "File:Example_image.svg".
 886                  *
 887                  * @return {string}
 888                  */
 889                 getPrefixedText: function () {
 890                         return text( this.getPrefixedDb() );
 891                 },
 892
 893                 /**
 894                  * Get the page name relative to a namespace
 895                  *
 896                  * Example:
 897                  *
 898                  * - "Foo:Bar" relative to the Foo namespace becomes "Bar".
 899                  * - "Bar" relative to any non-main namespace becomes ":Bar".
 900                  * - "Foo:Bar" relative to any namespace other than Foo stays "Foo:Bar".
 901                  *
 902                  * @param {number} namespace The namespace to be relative to
 903                  * @return {string}
 904                  */
 905                 getRelativeText: function ( namespace ) {
 906                         if ( this.getNamespaceId() === namespace ) {
 907                                 return this.getMainText();
 908                         } else if ( this.getNamespaceId() === NS_MAIN ) {
 909                                 return ':' + this.getPrefixedText();
 910                         } else {
 911                                 return this.getPrefixedText();
 912                         }
 913                 },
 914
 915                 /**
 916                  * Get the fragment (if any).
 917                  *
 918                  * Note that this method (by design) does not include the hash character and
 919                  * the value is not url encoded.
 920                  *
 921                  * @return {string|null}
 922                  */
 923                 getFragment: function () {
 924                         return this.fragment;
 925                 },
 926
 927                 /**
 928                  * Get the URL to this title
 929                  *
 930                  * @see mw.util#getUrl
 931                  * @param {Object} [params] A mapping of query parameter names to values,
 932                  *     e.g. `{ action: 'edit' }`.
 933                  * @return {string}
 934                  */
 935                 getUrl: function ( params ) {
 936                         return mw.util.getUrl( this.toString(), params );
 937                 },
 938
 939                 /**
 940                  * Whether this title exists on the wiki.
 941                  *
 942                  * @see #static-method-exists
 943                  * @return {boolean|null} Boolean if the information is available, otherwise null
 944                  */
 945                 exists: function () {
 946                         return Title.exists( this );
 947                 }
 948         };
 949
 950         /**
 951          * @alias #getPrefixedDb
 952          * @method
 953          */
 954         Title.prototype.toString = Title.prototype.getPrefixedDb;
 955
 956         /**
 957          * @alias #getPrefixedText
 958          * @method
 959          */
 960         Title.prototype.toText = Title.prototype.getPrefixedText;
 961
 962         // Expose
 963         mw.Title = Title;
 964
 965 }( mediaWiki, jQuery ) );