[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-includes/ -> l10n.php (source)

   1  <?php
   2  /**
   3   * Core Translation API
   4   *
   5   * @package WordPress
   6   * @subpackage i18n
   7   * @since 1.2.0
   8   */
   9  
  10  /**
  11   * Retrieves the current locale.
  12   *
  13   * If the locale is set, then it will filter the locale in the {@see 'locale'}
  14   * filter hook and return the value.
  15   *
  16   * If the locale is not set already, then the WPLANG constant is used if it is
  17   * defined. Then it is filtered through the {@see 'locale'} filter hook and
  18   * the value for the locale global set and the locale is returned.
  19   *
  20   * The process to get the locale should only be done once, but the locale will
  21   * always be filtered using the {@see 'locale'} hook.
  22   *
  23   * @since 1.5.0
  24   *
  25   * @global string $locale           The current locale.
  26   * @global string $wp_local_package Locale code of the package.
  27   *
  28   * @return string The locale of the blog or from the {@see 'locale'} hook.
  29   */
  30  function get_locale() {
  31      global $locale, $wp_local_package;
  32  
  33      if ( isset( $locale ) ) {
  34          /** This filter is documented in wp-includes/l10n.php */
  35          return apply_filters( 'locale', $locale );
  36      }
  37  
  38      if ( isset( $wp_local_package ) ) {
  39          $locale = $wp_local_package;
  40      }
  41  
  42      // WPLANG was defined in wp-config.
  43      if ( defined( 'WPLANG' ) ) {
  44          $locale = WPLANG;
  45      }
  46  
  47      // If multisite, check options.
  48      if ( is_multisite() ) {
  49          // Don't check blog option when installing.
  50          if ( wp_installing() ) {
  51              $ms_locale = get_site_option( 'WPLANG' );
  52          } else {
  53              $ms_locale = get_option( 'WPLANG' );
  54              if ( false === $ms_locale ) {
  55                  $ms_locale = get_site_option( 'WPLANG' );
  56              }
  57          }
  58  
  59          if ( false !== $ms_locale ) {
  60              $locale = $ms_locale;
  61          }
  62      } else {
  63          $db_locale = get_option( 'WPLANG' );
  64          if ( false !== $db_locale ) {
  65              $locale = $db_locale;
  66          }
  67      }
  68  
  69      if ( empty( $locale ) ) {
  70          $locale = 'en_US';
  71      }
  72  
  73      /**
  74       * Filters the locale ID of the WordPress installation.
  75       *
  76       * @since 1.5.0
  77       *
  78       * @param string $locale The locale ID.
  79       */
  80      return apply_filters( 'locale', $locale );
  81  }
  82  
  83  /**
  84   * Retrieves the locale of a user.
  85   *
  86   * If the user has a locale set to a non-empty string then it will be
  87   * returned. Otherwise it returns the locale of get_locale().
  88   *
  89   * @since 4.7.0
  90   *
  91   * @param int|WP_User $user User's ID or a WP_User object. Defaults to current user.
  92   * @return string The locale of the user.
  93   */
  94  function get_user_locale( $user = 0 ) {
  95      $user_object = false;
  96  
  97      if ( 0 === $user && function_exists( 'wp_get_current_user' ) ) {
  98          $user_object = wp_get_current_user();
  99      } elseif ( $user instanceof WP_User ) {
 100          $user_object = $user;
 101      } elseif ( $user && is_numeric( $user ) ) {
 102          $user_object = get_user_by( 'id', $user );
 103      }
 104  
 105      if ( ! $user_object ) {
 106          return get_locale();
 107      }
 108  
 109      $locale = $user_object->locale;
 110  
 111      return $locale ? $locale : get_locale();
 112  }
 113  
 114  /**
 115   * Determines the current locale desired for the request.
 116   *
 117   * @since 5.0.0
 118   *
 119   * @global string $pagenow The filename of the current screen.
 120   *
 121   * @return string The determined locale.
 122   */
 123  function determine_locale() {
 124      /**
 125       * Filters the locale for the current request prior to the default determination process.
 126       *
 127       * Using this filter allows to override the default logic, effectively short-circuiting the function.
 128       *
 129       * @since 5.0.0
 130       *
 131       * @param string|null $locale The locale to return and short-circuit. Default null.
 132       */
 133      $determined_locale = apply_filters( 'pre_determine_locale', null );
 134  
 135      if ( $determined_locale && is_string( $determined_locale ) ) {
 136          return $determined_locale;
 137      }
 138  
 139      if (
 140          isset( $GLOBALS['pagenow'] ) && 'wp-login.php' === $GLOBALS['pagenow'] &&
 141          ( ! empty( $_GET['wp_lang'] ) || ! empty( $_COOKIE['wp_lang'] ) )
 142      ) {
 143          if ( ! empty( $_GET['wp_lang'] ) ) {
 144              $determined_locale = sanitize_locale_name( $_GET['wp_lang'] );
 145          } else {
 146              $determined_locale = sanitize_locale_name( $_COOKIE['wp_lang'] );
 147          }
 148      } elseif (
 149          is_admin() ||
 150          ( isset( $_GET['_locale'] ) && 'user' === $_GET['_locale'] && wp_is_json_request() )
 151      ) {
 152          $determined_locale = get_user_locale();
 153      } elseif (
 154          ( ! empty( $_REQUEST['language'] ) || isset( $GLOBALS['wp_local_package'] ) )
 155          && wp_installing()
 156      ) {
 157          if ( ! empty( $_REQUEST['language'] ) ) {
 158              $determined_locale = sanitize_locale_name( $_REQUEST['language'] );
 159          } else {
 160              $determined_locale = $GLOBALS['wp_local_package'];
 161          }
 162      }
 163  
 164      if ( ! $determined_locale ) {
 165          $determined_locale = get_locale();
 166      }
 167  
 168      /**
 169       * Filters the locale for the current request.
 170       *
 171       * @since 5.0.0
 172       *
 173       * @param string $determined_locale The locale.
 174       */
 175      return apply_filters( 'determine_locale', $determined_locale );
 176  }
 177  
 178  /**
 179   * Retrieves the translation of $text.
 180   *
 181   * If there is no translation, or the text domain isn't loaded, the original text is returned.
 182   *
 183   * *Note:* Don't use translate() directly, use __() or related functions.
 184   *
 185   * @since 2.2.0
 186   * @since 5.5.0 Introduced `gettext-{$domain}` filter.
 187   *
 188   * @param string $text   Text to translate.
 189   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 190   *                       Default 'default'.
 191   * @return string Translated text.
 192   */
 193  function translate( $text, $domain = 'default' ) {
 194      $translations = get_translations_for_domain( $domain );
 195      $translation  = $translations->translate( $text );
 196  
 197      /**
 198       * Filters text with its translation.
 199       *
 200       * @since 2.0.11
 201       *
 202       * @param string $translation Translated text.
 203       * @param string $text        Text to translate.
 204       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 205       */
 206      $translation = apply_filters( 'gettext', $translation, $text, $domain );
 207  
 208      /**
 209       * Filters text with its translation for a domain.
 210       *
 211       * The dynamic portion of the hook name, `$domain`, refers to the text domain.
 212       *
 213       * @since 5.5.0
 214       *
 215       * @param string $translation Translated text.
 216       * @param string $text        Text to translate.
 217       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 218       */
 219      $translation = apply_filters( "gettext_{$domain}", $translation, $text, $domain );
 220  
 221      return $translation;
 222  }
 223  
 224  /**
 225   * Removes last item on a pipe-delimited string.
 226   *
 227   * Meant for removing the last item in a string, such as 'Role name|User role'. The original
 228   * string will be returned if no pipe '|' characters are found in the string.
 229   *
 230   * @since 2.8.0
 231   *
 232   * @param string $text A pipe-delimited string.
 233   * @return string Either $text or everything before the last pipe.
 234   */
 235  function before_last_bar( $text ) {
 236      $last_bar = strrpos( $text, '|' );
 237      if ( false === $last_bar ) {
 238          return $text;
 239      } else {
 240          return substr( $text, 0, $last_bar );
 241      }
 242  }
 243  
 244  /**
 245   * Retrieves the translation of $text in the context defined in $context.
 246   *
 247   * If there is no translation, or the text domain isn't loaded, the original text is returned.
 248   *
 249   * *Note:* Don't use translate_with_gettext_context() directly, use _x() or related functions.
 250   *
 251   * @since 2.8.0
 252   * @since 5.5.0 Introduced `gettext_with_context-{$domain}` filter.
 253   *
 254   * @param string $text    Text to translate.
 255   * @param string $context Context information for the translators.
 256   * @param string $domain  Optional. Text domain. Unique identifier for retrieving translated strings.
 257   *                        Default 'default'.
 258   * @return string Translated text on success, original text on failure.
 259   */
 260  function translate_with_gettext_context( $text, $context, $domain = 'default' ) {
 261      $translations = get_translations_for_domain( $domain );
 262      $translation  = $translations->translate( $text, $context );
 263  
 264      /**
 265       * Filters text with its translation based on context information.
 266       *
 267       * @since 2.8.0
 268       *
 269       * @param string $translation Translated text.
 270       * @param string $text        Text to translate.
 271       * @param string $context     Context information for the translators.
 272       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 273       */
 274      $translation = apply_filters( 'gettext_with_context', $translation, $text, $context, $domain );
 275  
 276      /**
 277       * Filters text with its translation based on context information for a domain.
 278       *
 279       * The dynamic portion of the hook name, `$domain`, refers to the text domain.
 280       *
 281       * @since 5.5.0
 282       *
 283       * @param string $translation Translated text.
 284       * @param string $text        Text to translate.
 285       * @param string $context     Context information for the translators.
 286       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 287       */
 288      $translation = apply_filters( "gettext_with_context_{$domain}", $translation, $text, $context, $domain );
 289  
 290      return $translation;
 291  }
 292  
 293  /**
 294   * Retrieves the translation of $text.
 295   *
 296   * If there is no translation, or the text domain isn't loaded, the original text is returned.
 297   *
 298   * @since 2.1.0
 299   *
 300   * @param string $text   Text to translate.
 301   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 302   *                       Default 'default'.
 303   * @return string Translated text.
 304   */
 305  function __( $text, $domain = 'default' ) {
 306      return translate( $text, $domain );
 307  }
 308  
 309  /**
 310   * Retrieves the translation of $text and escapes it for safe use in an attribute.
 311   *
 312   * If there is no translation, or the text domain isn't loaded, the original text is returned.
 313   *
 314   * @since 2.8.0
 315   *
 316   * @param string $text   Text to translate.
 317   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 318   *                       Default 'default'.
 319   * @return string Translated text on success, original text on failure.
 320   */
 321  function esc_attr__( $text, $domain = 'default' ) {
 322      return esc_attr( translate( $text, $domain ) );
 323  }
 324  
 325  /**
 326   * Retrieves the translation of $text and escapes it for safe use in HTML output.
 327   *
 328   * If there is no translation, or the text domain isn't loaded, the original text
 329   * is escaped and returned.
 330   *
 331   * @since 2.8.0
 332   *
 333   * @param string $text   Text to translate.
 334   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 335   *                       Default 'default'.
 336   * @return string Translated text.
 337   */
 338  function esc_html__( $text, $domain = 'default' ) {
 339      return esc_html( translate( $text, $domain ) );
 340  }
 341  
 342  /**
 343   * Displays translated text.
 344   *
 345   * @since 1.2.0
 346   *
 347   * @param string $text   Text to translate.
 348   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 349   *                       Default 'default'.
 350   */
 351  function _e( $text, $domain = 'default' ) {
 352      echo translate( $text, $domain );
 353  }
 354  
 355  /**
 356   * Displays translated text that has been escaped for safe use in an attribute.
 357   *
 358   * Encodes `< > & " '` (less than, greater than, ampersand, double quote, single quote).
 359   * Will never double encode entities.
 360   *
 361   * If you need the value for use in PHP, use esc_attr__().
 362   *
 363   * @since 2.8.0
 364   *
 365   * @param string $text   Text to translate.
 366   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 367   *                       Default 'default'.
 368   */
 369  function esc_attr_e( $text, $domain = 'default' ) {
 370      echo esc_attr( translate( $text, $domain ) );
 371  }
 372  
 373  /**
 374   * Displays translated text that has been escaped for safe use in HTML output.
 375   *
 376   * If there is no translation, or the text domain isn't loaded, the original text
 377   * is escaped and displayed.
 378   *
 379   * If you need the value for use in PHP, use esc_html__().
 380   *
 381   * @since 2.8.0
 382   *
 383   * @param string $text   Text to translate.
 384   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 385   *                       Default 'default'.
 386   */
 387  function esc_html_e( $text, $domain = 'default' ) {
 388      echo esc_html( translate( $text, $domain ) );
 389  }
 390  
 391  /**
 392   * Retrieves translated string with gettext context.
 393   *
 394   * Quite a few times, there will be collisions with similar translatable text
 395   * found in more than two places, but with different translated context.
 396   *
 397   * By including the context in the pot file, translators can translate the two
 398   * strings differently.
 399   *
 400   * @since 2.8.0
 401   *
 402   * @param string $text    Text to translate.
 403   * @param string $context Context information for the translators.
 404   * @param string $domain  Optional. Text domain. Unique identifier for retrieving translated strings.
 405   *                        Default 'default'.
 406   * @return string Translated context string without pipe.
 407   */
 408  function _x( $text, $context, $domain = 'default' ) {
 409      return translate_with_gettext_context( $text, $context, $domain );
 410  }
 411  
 412  /**
 413   * Displays translated string with gettext context.
 414   *
 415   * @since 3.0.0
 416   *
 417   * @param string $text    Text to translate.
 418   * @param string $context Context information for the translators.
 419   * @param string $domain  Optional. Text domain. Unique identifier for retrieving translated strings.
 420   *                        Default 'default'.
 421   */
 422  function _ex( $text, $context, $domain = 'default' ) {
 423      echo _x( $text, $context, $domain );
 424  }
 425  
 426  /**
 427   * Translates string with gettext context, and escapes it for safe use in an attribute.
 428   *
 429   * If there is no translation, or the text domain isn't loaded, the original text
 430   * is escaped and returned.
 431   *
 432   * @since 2.8.0
 433   *
 434   * @param string $text    Text to translate.
 435   * @param string $context Context information for the translators.
 436   * @param string $domain  Optional. Text domain. Unique identifier for retrieving translated strings.
 437   *                        Default 'default'.
 438   * @return string Translated text.
 439   */
 440  function esc_attr_x( $text, $context, $domain = 'default' ) {
 441      return esc_attr( translate_with_gettext_context( $text, $context, $domain ) );
 442  }
 443  
 444  /**
 445   * Translates string with gettext context, and escapes it for safe use in HTML output.
 446   *
 447   * If there is no translation, or the text domain isn't loaded, the original text
 448   * is escaped and returned.
 449   *
 450   * @since 2.9.0
 451   *
 452   * @param string $text    Text to translate.
 453   * @param string $context Context information for the translators.
 454   * @param string $domain  Optional. Text domain. Unique identifier for retrieving translated strings.
 455   *                        Default 'default'.
 456   * @return string Translated text.
 457   */
 458  function esc_html_x( $text, $context, $domain = 'default' ) {
 459      return esc_html( translate_with_gettext_context( $text, $context, $domain ) );
 460  }
 461  
 462  /**
 463   * Translates and retrieves the singular or plural form based on the supplied number.
 464   *
 465   * Used when you want to use the appropriate form of a string based on whether a
 466   * number is singular or plural.
 467   *
 468   * Example:
 469   *
 470   *     printf( _n( '%s person', '%s people', $count, 'text-domain' ), number_format_i18n( $count ) );
 471   *
 472   * @since 2.8.0
 473   * @since 5.5.0 Introduced `ngettext-{$domain}` filter.
 474   *
 475   * @param string $single The text to be used if the number is singular.
 476   * @param string $plural The text to be used if the number is plural.
 477   * @param int    $number The number to compare against to use either the singular or plural form.
 478   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
 479   *                       Default 'default'.
 480   * @return string The translated singular or plural form.
 481   */
 482  function _n( $single, $plural, $number, $domain = 'default' ) {
 483      $translations = get_translations_for_domain( $domain );
 484      $translation  = $translations->translate_plural( $single, $plural, $number );
 485  
 486      /**
 487       * Filters the singular or plural form of a string.
 488       *
 489       * @since 2.2.0
 490       *
 491       * @param string $translation Translated text.
 492       * @param string $single      The text to be used if the number is singular.
 493       * @param string $plural      The text to be used if the number is plural.
 494       * @param int    $number      The number to compare against to use either the singular or plural form.
 495       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 496       */
 497      $translation = apply_filters( 'ngettext', $translation, $single, $plural, $number, $domain );
 498  
 499      /**
 500       * Filters the singular or plural form of a string for a domain.
 501       *
 502       * The dynamic portion of the hook name, `$domain`, refers to the text domain.
 503       *
 504       * @since 5.5.0
 505       *
 506       * @param string $translation Translated text.
 507       * @param string $single      The text to be used if the number is singular.
 508       * @param string $plural      The text to be used if the number is plural.
 509       * @param int    $number      The number to compare against to use either the singular or plural form.
 510       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 511       */
 512      $translation = apply_filters( "ngettext_{$domain}", $translation, $single, $plural, $number, $domain );
 513  
 514      return $translation;
 515  }
 516  
 517  /**
 518   * Translates and retrieves the singular or plural form based on the supplied number, with gettext context.
 519   *
 520   * This is a hybrid of _n() and _x(). It supports context and plurals.
 521   *
 522   * Used when you want to use the appropriate form of a string with context based on whether a
 523   * number is singular or plural.
 524   *
 525   * Example of a generic phrase which is disambiguated via the context parameter:
 526   *
 527   *     printf( _nx( '%s group', '%s groups', $people, 'group of people', 'text-domain' ), number_format_i18n( $people ) );
 528   *     printf( _nx( '%s group', '%s groups', $animals, 'group of animals', 'text-domain' ), number_format_i18n( $animals ) );
 529   *
 530   * @since 2.8.0
 531   * @since 5.5.0 Introduced `ngettext_with_context-{$domain}` filter.
 532   *
 533   * @param string $single  The text to be used if the number is singular.
 534   * @param string $plural  The text to be used if the number is plural.
 535   * @param int    $number  The number to compare against to use either the singular or plural form.
 536   * @param string $context Context information for the translators.
 537   * @param string $domain  Optional. Text domain. Unique identifier for retrieving translated strings.
 538   *                        Default 'default'.
 539   * @return string The translated singular or plural form.
 540   */
 541  function _nx( $single, $plural, $number, $context, $domain = 'default' ) {
 542      $translations = get_translations_for_domain( $domain );
 543      $translation  = $translations->translate_plural( $single, $plural, $number, $context );
 544  
 545      /**
 546       * Filters the singular or plural form of a string with gettext context.
 547       *
 548       * @since 2.8.0
 549       *
 550       * @param string $translation Translated text.
 551       * @param string $single      The text to be used if the number is singular.
 552       * @param string $plural      The text to be used if the number is plural.
 553       * @param int    $number      The number to compare against to use either the singular or plural form.
 554       * @param string $context     Context information for the translators.
 555       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 556       */
 557      $translation = apply_filters( 'ngettext_with_context', $translation, $single, $plural, $number, $context, $domain );
 558  
 559      /**
 560       * Filters the singular or plural form of a string with gettext context for a domain.
 561       *
 562       * The dynamic portion of the hook name, `$domain`, refers to the text domain.
 563       *
 564       * @since 5.5.0
 565       *
 566       * @param string $translation Translated text.
 567       * @param string $single      The text to be used if the number is singular.
 568       * @param string $plural      The text to be used if the number is plural.
 569       * @param int    $number      The number to compare against to use either the singular or plural form.
 570       * @param string $context     Context information for the translators.
 571       * @param string $domain      Text domain. Unique identifier for retrieving translated strings.
 572       */
 573      $translation = apply_filters( "ngettext_with_context_{$domain}", $translation, $single, $plural, $number, $context, $domain );
 574  
 575      return $translation;
 576  }
 577  
 578  /**
 579   * Registers plural strings in POT file, but does not translate them.
 580   *
 581   * Used when you want to keep structures with translatable plural
 582   * strings and use them later when the number is known.
 583   *
 584   * Example:
 585   *
 586   *     $message = _n_noop( '%s post', '%s posts', 'text-domain' );
 587   *     ...
 588   *     printf( translate_nooped_plural( $message, $count, 'text-domain' ), number_format_i18n( $count ) );
 589   *
 590   * @since 2.5.0
 591   *
 592   * @param string $singular Singular form to be localized.
 593   * @param string $plural   Plural form to be localized.
 594   * @param string $domain   Optional. Text domain. Unique identifier for retrieving translated strings.
 595   *                         Default null.
 596   * @return array {
 597   *     Array of translation information for the strings.
 598   *
 599   *     @type string      $0        Singular form to be localized. No longer used.
 600   *     @type string      $1        Plural form to be localized. No longer used.
 601   *     @type string      $singular Singular form to be localized.
 602   *     @type string      $plural   Plural form to be localized.
 603   *     @type null        $context  Context information for the translators.
 604   *     @type string|null $domain   Text domain.
 605   * }
 606   */
 607  function _n_noop( $singular, $plural, $domain = null ) {
 608      return array(
 609          0          => $singular,
 610          1          => $plural,
 611          'singular' => $singular,
 612          'plural'   => $plural,
 613          'context'  => null,
 614          'domain'   => $domain,
 615      );
 616  }
 617  
 618  /**
 619   * Registers plural strings with gettext context in POT file, but does not translate them.
 620   *
 621   * Used when you want to keep structures with translatable plural
 622   * strings and use them later when the number is known.
 623   *
 624   * Example of a generic phrase which is disambiguated via the context parameter:
 625   *
 626   *     $messages = array(
 627   *          'people'  => _nx_noop( '%s group', '%s groups', 'people', 'text-domain' ),
 628   *          'animals' => _nx_noop( '%s group', '%s groups', 'animals', 'text-domain' ),
 629   *     );
 630   *     ...
 631   *     $message = $messages[ $type ];
 632   *     printf( translate_nooped_plural( $message, $count, 'text-domain' ), number_format_i18n( $count ) );
 633   *
 634   * @since 2.8.0
 635   *
 636   * @param string $singular Singular form to be localized.
 637   * @param string $plural   Plural form to be localized.
 638   * @param string $context  Context information for the translators.
 639   * @param string $domain   Optional. Text domain. Unique identifier for retrieving translated strings.
 640   *                         Default null.
 641   * @return array {
 642   *     Array of translation information for the strings.
 643   *
 644   *     @type string      $0        Singular form to be localized. No longer used.
 645   *     @type string      $1        Plural form to be localized. No longer used.
 646   *     @type string      $2        Context information for the translators. No longer used.
 647   *     @type string      $singular Singular form to be localized.
 648   *     @type string      $plural   Plural form to be localized.
 649   *     @type string      $context  Context information for the translators.
 650   *     @type string|null $domain   Text domain.
 651   * }
 652   */
 653  function _nx_noop( $singular, $plural, $context, $domain = null ) {
 654      return array(
 655          0          => $singular,
 656          1          => $plural,
 657          2          => $context,
 658          'singular' => $singular,
 659          'plural'   => $plural,
 660          'context'  => $context,
 661          'domain'   => $domain,
 662      );
 663  }
 664  
 665  /**
 666   * Translates and returns the singular or plural form of a string that's been registered
 667   * with _n_noop() or _nx_noop().
 668   *
 669   * Used when you want to use a translatable plural string once the number is known.
 670   *
 671   * Example:
 672   *
 673   *     $message = _n_noop( '%s post', '%s posts', 'text-domain' );
 674   *     ...
 675   *     printf( translate_nooped_plural( $message, $count, 'text-domain' ), number_format_i18n( $count ) );
 676   *
 677   * @since 3.1.0
 678   *
 679   * @param array  $nooped_plural {
 680   *     Array that is usually a return value from _n_noop() or _nx_noop().
 681   *
 682   *     @type string      $singular Singular form to be localized.
 683   *     @type string      $plural   Plural form to be localized.
 684   *     @type string|null $context  Context information for the translators.
 685   *     @type string|null $domain   Text domain.
 686   * }
 687   * @param int    $count         Number of objects.
 688   * @param string $domain        Optional. Text domain. Unique identifier for retrieving translated strings. If $nooped_plural contains
 689   *                              a text domain passed to _n_noop() or _nx_noop(), it will override this value. Default 'default'.
 690   * @return string Either $singular or $plural translated text.
 691   */
 692  function translate_nooped_plural( $nooped_plural, $count, $domain = 'default' ) {
 693      if ( $nooped_plural['domain'] ) {
 694          $domain = $nooped_plural['domain'];
 695      }
 696  
 697      if ( $nooped_plural['context'] ) {
 698          return _nx( $nooped_plural['singular'], $nooped_plural['plural'], $count, $nooped_plural['context'], $domain );
 699      } else {
 700          return _n( $nooped_plural['singular'], $nooped_plural['plural'], $count, $domain );
 701      }
 702  }
 703  
 704  /**
 705   * Loads a .mo file into the text domain $domain.
 706   *
 707   * If the text domain already exists, the translations will be merged. If both
 708   * sets have the same string, the translation from the original value will be taken.
 709   *
 710   * On success, the .mo file will be placed in the $l10n global by $domain
 711   * and will be a MO object.
 712   *
 713   * @since 1.5.0
 714   * @since 6.1.0 Added the `$locale` parameter.
 715   *
 716   * @global MO[]                   $l10n                   An array of all currently loaded text domains.
 717   * @global MO[]                   $l10n_unloaded          An array of all text domains that have been unloaded again.
 718   * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
 719   *
 720   * @param string $domain Text domain. Unique identifier for retrieving translated strings.
 721   * @param string $mofile Path to the .mo file.
 722   * @param string $locale Optional. Locale. Default is the current locale.
 723   * @return bool True on success, false on failure.
 724   */
 725  function load_textdomain( $domain, $mofile, $locale = null ) {
 726      /** @var WP_Textdomain_Registry $wp_textdomain_registry */
 727      global $l10n, $l10n_unloaded, $wp_textdomain_registry;
 728  
 729      $l10n_unloaded = (array) $l10n_unloaded;
 730  
 731      if ( ! is_string( $domain ) ) {
 732          return false;
 733      }
 734  
 735      /**
 736       * Filters whether to short-circuit loading .mo file.
 737       *
 738       * Returning a non-null value from the filter will effectively short-circuit
 739       * the loading, returning the passed value instead.
 740       *
 741       * @since 6.3.0
 742       *
 743       * @param bool|null   $loaded The result of loading a .mo file. Default null.
 744       * @param string      $domain Text domain. Unique identifier for retrieving translated strings.
 745       * @param string      $mofile Path to the MO file.
 746       * @param string|null $locale Locale.
 747       */
 748      $loaded = apply_filters( 'pre_load_textdomain', null, $domain, $mofile, $locale );
 749      if ( null !== $loaded ) {
 750          if ( true === $loaded ) {
 751              unset( $l10n_unloaded[ $domain ] );
 752          }
 753  
 754          return $loaded;
 755      }
 756  
 757      /**
 758       * Filters whether to override the .mo file loading.
 759       *
 760       * @since 2.9.0
 761       * @since 6.2.0 Added the `$locale` parameter.
 762       *
 763       * @param bool        $override Whether to override the .mo file loading. Default false.
 764       * @param string      $domain   Text domain. Unique identifier for retrieving translated strings.
 765       * @param string      $mofile   Path to the MO file.
 766       * @param string|null $locale   Locale.
 767       */
 768      $plugin_override = apply_filters( 'override_load_textdomain', false, $domain, $mofile, $locale );
 769  
 770      if ( true === (bool) $plugin_override ) {
 771          unset( $l10n_unloaded[ $domain ] );
 772  
 773          return true;
 774      }
 775  
 776      /**
 777       * Fires before the MO translation file is loaded.
 778       *
 779       * @since 2.9.0
 780       *
 781       * @param string $domain Text domain. Unique identifier for retrieving translated strings.
 782       * @param string $mofile Path to the .mo file.
 783       */
 784      do_action( 'load_textdomain', $domain, $mofile );
 785  
 786      /**
 787       * Filters MO file path for loading translations for a specific text domain.
 788       *
 789       * @since 2.9.0
 790       *
 791       * @param string $mofile Path to the MO file.
 792       * @param string $domain Text domain. Unique identifier for retrieving translated strings.
 793       */
 794      $mofile = apply_filters( 'load_textdomain_mofile', $mofile, $domain );
 795  
 796      if ( ! $locale ) {
 797          $locale = determine_locale();
 798      }
 799  
 800      $i18n_controller = WP_Translation_Controller::get_instance();
 801  
 802      // Ensures the correct locale is set as the current one, in case it was filtered.
 803      $i18n_controller->set_locale( $locale );
 804  
 805      /**
 806       * Filters the preferred file format for translation files.
 807       *
 808       * Can be used to disable the use of PHP files for translations.
 809       *
 810       * @since 6.5.0
 811       *
 812       * @param string $preferred_format Preferred file format. Possible values: 'php', 'mo'. Default: 'php'.
 813       * @param string $domain           The text domain.
 814       */
 815      $preferred_format = apply_filters( 'translation_file_format', 'php', $domain );
 816      if ( ! in_array( $preferred_format, array( 'php', 'mo' ), true ) ) {
 817          $preferred_format = 'php';
 818      }
 819  
 820      $translation_files = array();
 821  
 822      if ( 'mo' !== $preferred_format ) {
 823          $translation_files[] = substr_replace( $mofile, ".l10n.$preferred_format", - strlen( '.mo' ) );
 824      }
 825  
 826      $translation_files[] = $mofile;
 827  
 828      foreach ( $translation_files as $file ) {
 829          /**
 830           * Filters the file path for loading translations for the given text domain.
 831           *
 832           * Similar to the {@see 'load_textdomain_mofile'} filter with the difference that
 833           * the file path could be for an MO or PHP file.
 834           *
 835           * @since 6.5.0
 836           * @since 6.6.0 Added the `$locale` parameter.
 837           *
 838           * @param string $file   Path to the translation file to load.
 839           * @param string $domain The text domain.
 840           * @param string $locale The locale.
 841           */
 842          $file = (string) apply_filters( 'load_translation_file', $file, $domain, $locale );
 843  
 844          $success = $i18n_controller->load_file( $file, $domain, $locale );
 845  
 846          if ( $success ) {
 847              if ( isset( $l10n[ $domain ] ) && $l10n[ $domain ] instanceof MO ) {
 848                  $i18n_controller->load_file( $l10n[ $domain ]->get_filename(), $domain, $locale );
 849              }
 850  
 851              // Unset NOOP_Translations reference in get_translations_for_domain().
 852              unset( $l10n[ $domain ] );
 853  
 854              $l10n[ $domain ] = new WP_Translations( $i18n_controller, $domain );
 855  
 856              $wp_textdomain_registry->set( $domain, $locale, dirname( $file ) );
 857  
 858              return true;
 859          }
 860      }
 861  
 862      return false;
 863  }
 864  
 865  /**
 866   * Unloads translations for a text domain.
 867   *
 868   * @since 3.0.0
 869   * @since 6.1.0 Added the `$reloadable` parameter.
 870   *
 871   * @global MO[] $l10n          An array of all currently loaded text domains.
 872   * @global MO[] $l10n_unloaded An array of all text domains that have been unloaded again.
 873   *
 874   * @param string $domain     Text domain. Unique identifier for retrieving translated strings.
 875   * @param bool   $reloadable Whether the text domain can be loaded just-in-time again.
 876   * @return bool Whether textdomain was unloaded.
 877   */
 878  function unload_textdomain( $domain, $reloadable = false ) {
 879      global $l10n, $l10n_unloaded;
 880  
 881      $l10n_unloaded = (array) $l10n_unloaded;
 882  
 883      /**
 884       * Filters whether to override the text domain unloading.
 885       *
 886       * @since 3.0.0
 887       * @since 6.1.0 Added the `$reloadable` parameter.
 888       *
 889       * @param bool   $override   Whether to override the text domain unloading. Default false.
 890       * @param string $domain     Text domain. Unique identifier for retrieving translated strings.
 891       * @param bool   $reloadable Whether the text domain can be loaded just-in-time again.
 892       */
 893      $plugin_override = apply_filters( 'override_unload_textdomain', false, $domain, $reloadable );
 894  
 895      if ( $plugin_override ) {
 896          if ( ! $reloadable ) {
 897              $l10n_unloaded[ $domain ] = true;
 898          }
 899  
 900          return true;
 901      }
 902  
 903      /**
 904       * Fires before the text domain is unloaded.
 905       *
 906       * @since 3.0.0
 907       * @since 6.1.0 Added the `$reloadable` parameter.
 908       *
 909       * @param string $domain     Text domain. Unique identifier for retrieving translated strings.
 910       * @param bool   $reloadable Whether the text domain can be loaded just-in-time again.
 911       */
 912      do_action( 'unload_textdomain', $domain, $reloadable );
 913  
 914      // Since multiple locales are supported, reloadable text domains don't actually need to be unloaded.
 915      if ( ! $reloadable ) {
 916          WP_Translation_Controller::get_instance()->unload_textdomain( $domain );
 917      }
 918  
 919      if ( isset( $l10n[ $domain ] ) ) {
 920          if ( $l10n[ $domain ] instanceof NOOP_Translations ) {
 921              unset( $l10n[ $domain ] );
 922  
 923              return false;
 924          }
 925  
 926          unset( $l10n[ $domain ] );
 927  
 928          if ( ! $reloadable ) {
 929              $l10n_unloaded[ $domain ] = true;
 930          }
 931  
 932          return true;
 933      }
 934  
 935      return false;
 936  }
 937  
 938  /**
 939   * Loads default translated strings based on locale.
 940   *
 941   * Loads the .mo file in WP_LANG_DIR constant path from WordPress root.
 942   * The translated (.mo) file is named based on the locale.
 943   *
 944   * @see load_textdomain()
 945   *
 946   * @since 1.5.0
 947   *
 948   * @param string $locale Optional. Locale to load. Default is the value of get_locale().
 949   * @return bool Whether the textdomain was loaded.
 950   */
 951  function load_default_textdomain( $locale = null ) {
 952      if ( null === $locale ) {
 953          $locale = determine_locale();
 954      }
 955  
 956      // Unload previously loaded strings so we can switch translations.
 957      unload_textdomain( 'default', true );
 958  
 959      $return = load_textdomain( 'default', WP_LANG_DIR . "/$locale.mo", $locale );
 960  
 961      if ( ( is_multisite() || ( defined( 'WP_INSTALLING_NETWORK' ) && WP_INSTALLING_NETWORK ) ) && ! file_exists( WP_LANG_DIR . "/admin-$locale.mo" ) ) {
 962          load_textdomain( 'default', WP_LANG_DIR . "/ms-$locale.mo", $locale );
 963          return $return;
 964      }
 965  
 966      if ( is_admin() || wp_installing() || ( defined( 'WP_REPAIRING' ) && WP_REPAIRING ) ) {
 967          load_textdomain( 'default', WP_LANG_DIR . "/admin-$locale.mo", $locale );
 968      }
 969  
 970      if ( is_network_admin() || ( defined( 'WP_INSTALLING_NETWORK' ) && WP_INSTALLING_NETWORK ) ) {
 971          load_textdomain( 'default', WP_LANG_DIR . "/admin-network-$locale.mo", $locale );
 972      }
 973  
 974      return $return;
 975  }
 976  
 977  /**
 978   * Loads a plugin's translated strings.
 979   *
 980   * If the path is not given then it will be the root of the plugin directory.
 981   *
 982   * The .mo file should be named based on the text domain with a dash, and then the locale exactly.
 983   *
 984   * @since 1.5.0
 985   * @since 4.6.0 The function now tries to load the .mo file from the languages directory first.
 986   *
 987   * @param string       $domain          Unique identifier for retrieving translated strings
 988   * @param string|false $deprecated      Optional. Deprecated. Use the $plugin_rel_path parameter instead.
 989   *                                      Default false.
 990   * @param string|false $plugin_rel_path Optional. Relative path to WP_PLUGIN_DIR where the .mo file resides.
 991   *                                      Default false.
 992   * @return bool True when textdomain is successfully loaded, false otherwise.
 993   */
 994  function load_plugin_textdomain( $domain, $deprecated = false, $plugin_rel_path = false ) {
 995      /** @var WP_Textdomain_Registry $wp_textdomain_registry */
 996      global $wp_textdomain_registry;
 997  
 998      if ( ! is_string( $domain ) ) {
 999          return false;
1000      }
1001  
1002      /**
1003       * Filters a plugin's locale.
1004       *
1005       * @since 3.0.0
1006       *
1007       * @param string $locale The plugin's current locale.
1008       * @param string $domain Text domain. Unique identifier for retrieving translated strings.
1009       */
1010      $locale = apply_filters( 'plugin_locale', determine_locale(), $domain );
1011  
1012      $mofile = $domain . '-' . $locale . '.mo';
1013  
1014      // Try to load from the languages directory first.
1015      if ( load_textdomain( $domain, WP_LANG_DIR . '/plugins/' . $mofile, $locale ) ) {
1016          return true;
1017      }
1018  
1019      if ( false !== $plugin_rel_path ) {
1020          $path = WP_PLUGIN_DIR . '/' . trim( $plugin_rel_path, '/' );
1021      } elseif ( false !== $deprecated ) {
1022          _deprecated_argument( __FUNCTION__, '2.7.0' );
1023          $path = ABSPATH . trim( $deprecated, '/' );
1024      } else {
1025          $path = WP_PLUGIN_DIR;
1026      }
1027  
1028      $wp_textdomain_registry->set_custom_path( $domain, $path );
1029  
1030      return load_textdomain( $domain, $path . '/' . $mofile, $locale );
1031  }
1032  
1033  /**
1034   * Loads the translated strings for a plugin residing in the mu-plugins directory.
1035   *
1036   * @since 3.0.0
1037   * @since 4.6.0 The function now tries to load the .mo file from the languages directory first.
1038   *
1039   * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
1040   *
1041   * @param string $domain             Text domain. Unique identifier for retrieving translated strings.
1042   * @param string $mu_plugin_rel_path Optional. Relative to `WPMU_PLUGIN_DIR` directory in which the .mo
1043   *                                   file resides. Default empty string.
1044   * @return bool True when textdomain is successfully loaded, false otherwise.
1045   */
1046  function load_muplugin_textdomain( $domain, $mu_plugin_rel_path = '' ) {
1047      /** @var WP_Textdomain_Registry $wp_textdomain_registry */
1048      global $wp_textdomain_registry;
1049  
1050      if ( ! is_string( $domain ) ) {
1051          return false;
1052      }
1053  
1054      /** This filter is documented in wp-includes/l10n.php */
1055      $locale = apply_filters( 'plugin_locale', determine_locale(), $domain );
1056  
1057      $mofile = $domain . '-' . $locale . '.mo';
1058  
1059      // Try to load from the languages directory first.
1060      if ( load_textdomain( $domain, WP_LANG_DIR . '/plugins/' . $mofile, $locale ) ) {
1061          return true;
1062      }
1063  
1064      $path = WPMU_PLUGIN_DIR . '/' . ltrim( $mu_plugin_rel_path, '/' );
1065  
1066      $wp_textdomain_registry->set_custom_path( $domain, $path );
1067  
1068      return load_textdomain( $domain, $path . '/' . $mofile, $locale );
1069  }
1070  
1071  /**
1072   * Loads the theme's translated strings.
1073   *
1074   * If the current locale exists as a .mo file in the theme's root directory, it
1075   * will be included in the translated strings by the $domain.
1076   *
1077   * The .mo files must be named based on the locale exactly.
1078   *
1079   * @since 1.5.0
1080   * @since 4.6.0 The function now tries to load the .mo file from the languages directory first.
1081   *
1082   * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
1083   *
1084   * @param string       $domain Text domain. Unique identifier for retrieving translated strings.
1085   * @param string|false $path   Optional. Path to the directory containing the .mo file.
1086   *                             Default false.
1087   * @return bool True when textdomain is successfully loaded, false otherwise.
1088   */
1089  function load_theme_textdomain( $domain, $path = false ) {
1090      /** @var WP_Textdomain_Registry $wp_textdomain_registry */
1091      global $wp_textdomain_registry;
1092  
1093      if ( ! is_string( $domain ) ) {
1094          return false;
1095      }
1096  
1097      /**
1098       * Filters a theme's locale.
1099       *
1100       * @since 3.0.0
1101       *
1102       * @param string $locale The theme's current locale.
1103       * @param string $domain Text domain. Unique identifier for retrieving translated strings.
1104       */
1105      $locale = apply_filters( 'theme_locale', determine_locale(), $domain );
1106  
1107      $mofile = $domain . '-' . $locale . '.mo';
1108  
1109      // Try to load from the languages directory first.
1110      if ( load_textdomain( $domain, WP_LANG_DIR . '/themes/' . $mofile, $locale ) ) {
1111          return true;
1112      }
1113  
1114      if ( ! $path ) {
1115          $path = get_template_directory();
1116      }
1117  
1118      $wp_textdomain_registry->set_custom_path( $domain, $path );
1119  
1120      return load_textdomain( $domain, $path . '/' . $locale . '.mo', $locale );
1121  }
1122  
1123  /**
1124   * Loads the child theme's translated strings.
1125   *
1126   * If the current locale exists as a .mo file in the child theme's
1127   * root directory, it will be included in the translated strings by the $domain.
1128   *
1129   * The .mo files must be named based on the locale exactly.
1130   *
1131   * @since 2.9.0
1132   *
1133   * @param string       $domain Text domain. Unique identifier for retrieving translated strings.
1134   * @param string|false $path   Optional. Path to the directory containing the .mo file.
1135   *                             Default false.
1136   * @return bool True when the theme textdomain is successfully loaded, false otherwise.
1137   */
1138  function load_child_theme_textdomain( $domain, $path = false ) {
1139      if ( ! $path ) {
1140          $path = get_stylesheet_directory();
1141      }
1142      return load_theme_textdomain( $domain, $path );
1143  }
1144  
1145  /**
1146   * Loads the script translated strings.
1147   *
1148   * @since 5.0.0
1149   * @since 5.0.2 Uses load_script_translations() to load translation data.
1150   * @since 5.1.0 The `$domain` parameter was made optional.
1151   *
1152   * @see WP_Scripts::set_translations()
1153   *
1154   * @param string $handle Name of the script to register a translation domain to.
1155   * @param string $domain Optional. Text domain. Default 'default'.
1156   * @param string $path   Optional. The full file path to the directory containing translation files.
1157   * @return string|false The translated strings in JSON encoding on success,
1158   *                      false if the script textdomain could not be loaded.
1159   */
1160  function load_script_textdomain( $handle, $domain = 'default', $path = '' ) {
1161      $wp_scripts = wp_scripts();
1162  
1163      if ( ! isset( $wp_scripts->registered[ $handle ] ) ) {
1164          return false;
1165      }
1166  
1167      $path   = untrailingslashit( $path );
1168      $locale = determine_locale();
1169  
1170      // If a path was given and the handle file exists simply return it.
1171      $file_base       = 'default' === $domain ? $locale : $domain . '-' . $locale;
1172      $handle_filename = $file_base . '-' . $handle . '.json';
1173  
1174      if ( $path ) {
1175          $translations = load_script_translations( $path . '/' . $handle_filename, $handle, $domain );
1176  
1177          if ( $translations ) {
1178              return $translations;
1179          }
1180      }
1181  
1182      $src = $wp_scripts->registered[ $handle ]->src;
1183  
1184      if ( ! preg_match( '|^(https?:)?//|', $src ) && ! ( $wp_scripts->content_url && str_starts_with( $src, $wp_scripts->content_url ) ) ) {
1185          $src = $wp_scripts->base_url . $src;
1186      }
1187  
1188      $relative       = false;
1189      $languages_path = WP_LANG_DIR;
1190  
1191      $src_url     = wp_parse_url( $src );
1192      $content_url = wp_parse_url( content_url() );
1193      $plugins_url = wp_parse_url( plugins_url() );
1194      $site_url    = wp_parse_url( site_url() );
1195  
1196      // If the host is the same or it's a relative URL.
1197      if (
1198          ( ! isset( $content_url['path'] ) || str_starts_with( $src_url['path'], $content_url['path'] ) ) &&
1199          ( ! isset( $src_url['host'] ) || ! isset( $content_url['host'] ) || $src_url['host'] === $content_url['host'] )
1200      ) {
1201          // Make the src relative the specific plugin or theme.
1202          if ( isset( $content_url['path'] ) ) {
1203              $relative = substr( $src_url['path'], strlen( $content_url['path'] ) );
1204          } else {
1205              $relative = $src_url['path'];
1206          }
1207          $relative = trim( $relative, '/' );
1208          $relative = explode( '/', $relative );
1209  
1210          $languages_path = WP_LANG_DIR . '/plugins';
1211  
1212          $relative = array_slice( $relative, 2 ); // Remove plugins/<plugin name> or themes/<theme name>.
1213          $relative = implode( '/', $relative );
1214      } elseif (
1215          ( ! isset( $plugins_url['path'] ) || str_starts_with( $src_url['path'], $plugins_url['path'] ) ) &&
1216          ( ! isset( $src_url['host'] ) || ! isset( $plugins_url['host'] ) || $src_url['host'] === $plugins_url['host'] )
1217      ) {
1218          // Make the src relative the specific plugin.
1219          if ( isset( $plugins_url['path'] ) ) {
1220              $relative = substr( $src_url['path'], strlen( $plugins_url['path'] ) );
1221          } else {
1222              $relative = $src_url['path'];
1223          }
1224          $relative = trim( $relative, '/' );
1225          $relative = explode( '/', $relative );
1226  
1227          $languages_path = WP_LANG_DIR . '/plugins';
1228  
1229          $relative = array_slice( $relative, 1 ); // Remove <plugin name>.
1230          $relative = implode( '/', $relative );
1231      } elseif ( ! isset( $src_url['host'] ) || ! isset( $site_url['host'] ) || $src_url['host'] === $site_url['host'] ) {
1232          if ( ! isset( $site_url['path'] ) ) {
1233              $relative = trim( $src_url['path'], '/' );
1234          } elseif ( str_starts_with( $src_url['path'], trailingslashit( $site_url['path'] ) ) ) {
1235              // Make the src relative to the WP root.
1236              $relative = substr( $src_url['path'], strlen( $site_url['path'] ) );
1237              $relative = trim( $relative, '/' );
1238          }
1239      }
1240  
1241      /**
1242       * Filters the relative path of scripts used for finding translation files.
1243       *
1244       * @since 5.0.2
1245       *
1246       * @param string|false $relative The relative path of the script. False if it could not be determined.
1247       * @param string       $src      The full source URL of the script.
1248       */
1249      $relative = apply_filters( 'load_script_textdomain_relative_path', $relative, $src );
1250  
1251      // If the source is not from WP.
1252      if ( false === $relative ) {
1253          return load_script_translations( false, $handle, $domain );
1254      }
1255  
1256      // Translations are always based on the unminified filename.
1257      if ( str_ends_with( $relative, '.min.js' ) ) {
1258          $relative = substr( $relative, 0, -7 ) . '.js';
1259      }
1260  
1261      $md5_filename = $file_base . '-' . md5( $relative ) . '.json';
1262  
1263      if ( $path ) {
1264          $translations = load_script_translations( $path . '/' . $md5_filename, $handle, $domain );
1265  
1266          if ( $translations ) {
1267              return $translations;
1268          }
1269      }
1270  
1271      $translations = load_script_translations( $languages_path . '/' . $md5_filename, $handle, $domain );
1272  
1273      if ( $translations ) {
1274          return $translations;
1275      }
1276  
1277      return load_script_translations( false, $handle, $domain );
1278  }
1279  
1280  /**
1281   * Loads the translation data for the given script handle and text domain.
1282   *
1283   * @since 5.0.2
1284   *
1285   * @param string|false $file   Path to the translation file to load. False if there isn't one.
1286   * @param string       $handle Name of the script to register a translation domain to.
1287   * @param string       $domain The text domain.
1288   * @return string|false The JSON-encoded translated strings for the given script handle and text domain.
1289   *                      False if there are none.
1290   */
1291  function load_script_translations( $file, $handle, $domain ) {
1292      /**
1293       * Pre-filters script translations for the given file, script handle and text domain.
1294       *
1295       * Returning a non-null value allows to override the default logic, effectively short-circuiting the function.
1296       *
1297       * @since 5.0.2
1298       *
1299       * @param string|false|null $translations JSON-encoded translation data. Default null.
1300       * @param string|false      $file         Path to the translation file to load. False if there isn't one.
1301       * @param string            $handle       Name of the script to register a translation domain to.
1302       * @param string            $domain       The text domain.
1303       */
1304      $translations = apply_filters( 'pre_load_script_translations', null, $file, $handle, $domain );
1305  
1306      if ( null !== $translations ) {
1307          return $translations;
1308      }
1309  
1310      /**
1311       * Filters the file path for loading script translations for the given script handle and text domain.
1312       *
1313       * @since 5.0.2
1314       *
1315       * @param string|false $file   Path to the translation file to load. False if there isn't one.
1316       * @param string       $handle Name of the script to register a translation domain to.
1317       * @param string       $domain The text domain.
1318       */
1319      $file = apply_filters( 'load_script_translation_file', $file, $handle, $domain );
1320  
1321      if ( ! $file || ! is_readable( $file ) ) {
1322          return false;
1323      }
1324  
1325      $translations = file_get_contents( $file );
1326  
1327      /**
1328       * Filters script translations for the given file, script handle and text domain.
1329       *
1330       * @since 5.0.2
1331       *
1332       * @param string $translations JSON-encoded translation data.
1333       * @param string $file         Path to the translation file that was loaded.
1334       * @param string $handle       Name of the script to register a translation domain to.
1335       * @param string $domain       The text domain.
1336       */
1337      return apply_filters( 'load_script_translations', $translations, $file, $handle, $domain );
1338  }
1339  
1340  /**
1341   * Loads plugin and theme text domains just-in-time.
1342   *
1343   * When a textdomain is encountered for the first time, we try to load
1344   * the translation file from `wp-content/languages`, removing the need
1345   * to call load_plugin_textdomain() or load_theme_textdomain().
1346   *
1347   * @since 4.6.0
1348   * @access private
1349   *
1350   * @global MO[]                   $l10n_unloaded          An array of all text domains that have been unloaded again.
1351   * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
1352   *
1353   * @param string $domain Text domain. Unique identifier for retrieving translated strings.
1354   * @return bool True when the textdomain is successfully loaded, false otherwise.
1355   */
1356  function _load_textdomain_just_in_time( $domain ) {
1357      /** @var WP_Textdomain_Registry $wp_textdomain_registry */
1358      global $l10n_unloaded, $wp_textdomain_registry;
1359  
1360      $l10n_unloaded = (array) $l10n_unloaded;
1361  
1362      // Short-circuit if domain is 'default' which is reserved for core.
1363      if ( 'default' === $domain || isset( $l10n_unloaded[ $domain ] ) ) {
1364          return false;
1365      }
1366  
1367      if ( ! $wp_textdomain_registry->has( $domain ) ) {
1368          return false;
1369      }
1370  
1371      $locale = determine_locale();
1372      $path   = $wp_textdomain_registry->get( $domain, $locale );
1373      if ( ! $path ) {
1374          return false;
1375      }
1376      // Themes with their language directory outside of WP_LANG_DIR have a different file name.
1377      $template_directory   = trailingslashit( get_template_directory() );
1378      $stylesheet_directory = trailingslashit( get_stylesheet_directory() );
1379      if ( str_starts_with( $path, $template_directory ) || str_starts_with( $path, $stylesheet_directory ) ) {
1380          $mofile = "{$path}{$locale}.mo";
1381      } else {
1382          $mofile = "{$path}{$domain}-{$locale}.mo";
1383      }
1384  
1385      return load_textdomain( $domain, $mofile, $locale );
1386  }
1387  
1388  /**
1389   * Returns the Translations instance for a text domain.
1390   *
1391   * If there isn't one, returns empty Translations instance.
1392   *
1393   * @since 2.8.0
1394   *
1395   * @global MO[] $l10n An array of all currently loaded text domains.
1396   *
1397   * @param string $domain Text domain. Unique identifier for retrieving translated strings.
1398   * @return Translations|NOOP_Translations A Translations instance.
1399   */
1400  function get_translations_for_domain( $domain ) {
1401      global $l10n;
1402      if ( isset( $l10n[ $domain ] ) || ( _load_textdomain_just_in_time( $domain ) && isset( $l10n[ $domain ] ) ) ) {
1403          return $l10n[ $domain ];
1404      }
1405  
1406      static $noop_translations = null;
1407      if ( null === $noop_translations ) {
1408          $noop_translations = new NOOP_Translations();
1409      }
1410  
1411      $l10n[ $domain ] = &$noop_translations;
1412  
1413      return $noop_translations;
1414  }
1415  
1416  /**
1417   * Determines whether there are translations for the text domain.
1418   *
1419   * @since 3.0.0
1420   *
1421   * @global MO[] $l10n An array of all currently loaded text domains.
1422   *
1423   * @param string $domain Text domain. Unique identifier for retrieving translated strings.
1424   * @return bool Whether there are translations.
1425   */
1426  function is_textdomain_loaded( $domain ) {
1427      global $l10n;
1428      return isset( $l10n[ $domain ] ) && ! $l10n[ $domain ] instanceof NOOP_Translations;
1429  }
1430  
1431  /**
1432   * Translates role name.
1433   *
1434   * Since the role names are in the database and not in the source there
1435   * are dummy gettext calls to get them into the POT file and this function
1436   * properly translates them back.
1437   *
1438   * The before_last_bar() call is needed, because older installations keep the roles
1439   * using the old context format: 'Role name|User role' and just skipping the
1440   * content after the last bar is easier than fixing them in the DB. New installations
1441   * won't suffer from that problem.
1442   *
1443   * @since 2.8.0
1444   * @since 5.2.0 Added the `$domain` parameter.
1445   *
1446   * @param string $name   The role name.
1447   * @param string $domain Optional. Text domain. Unique identifier for retrieving translated strings.
1448   *                       Default 'default'.
1449   * @return string Translated role name on success, original name on failure.
1450   */
1451  function translate_user_role( $name, $domain = 'default' ) {
1452      return translate_with_gettext_context( before_last_bar( $name ), 'User role', $domain );
1453  }
1454  
1455  /**
1456   * Gets all available languages based on the presence of *.mo and *.l10n.php files in a given directory.
1457   *
1458   * The default directory is WP_LANG_DIR.
1459   *
1460   * @since 3.0.0
1461   * @since 4.7.0 The results are now filterable with the {@see 'get_available_languages'} filter.
1462   * @since 6.5.0 The initial file list is now cached and also takes into account *.l10n.php files.
1463   *
1464   * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
1465   *
1466   * @param string $dir A directory to search for language files.
1467   *                    Default WP_LANG_DIR.
1468   * @return string[] An array of language codes or an empty array if no languages are present.
1469   *                  Language codes are formed by stripping the file extension from the language file names.
1470   */
1471  function get_available_languages( $dir = null ) {
1472      global $wp_textdomain_registry;
1473  
1474      $languages = array();
1475  
1476      $path       = is_null( $dir ) ? WP_LANG_DIR : $dir;
1477      $lang_files = $wp_textdomain_registry->get_language_files_from_path( $path );
1478  
1479      if ( $lang_files ) {
1480          foreach ( $lang_files as $lang_file ) {
1481              $lang_file = basename( $lang_file, '.mo' );
1482              $lang_file = basename( $lang_file, '.l10n.php' );
1483  
1484              if ( ! str_starts_with( $lang_file, 'continents-cities' ) && ! str_starts_with( $lang_file, 'ms-' ) &&
1485                  ! str_starts_with( $lang_file, 'admin-' ) ) {
1486                  $languages[] = $lang_file;
1487              }
1488          }
1489      }
1490  
1491      /**
1492       * Filters the list of available language codes.
1493       *
1494       * @since 4.7.0
1495       *
1496       * @param string[] $languages An array of available language codes.
1497       * @param string   $dir       The directory where the language files were found.
1498       */
1499      return apply_filters( 'get_available_languages', array_unique( $languages ), $dir );
1500  }
1501  
1502  /**
1503   * Gets installed translations.
1504   *
1505   * Looks in the wp-content/languages directory for translations of
1506   * plugins or themes.
1507   *
1508   * @since 3.7.0
1509   *
1510   * @global WP_Textdomain_Registry $wp_textdomain_registry WordPress Textdomain Registry.
1511   *
1512   * @param string $type What to search for. Accepts 'plugins', 'themes', 'core'.
1513   * @return array Array of language data.
1514   */
1515  function wp_get_installed_translations( $type ) {
1516      global $wp_textdomain_registry;
1517  
1518      if ( 'themes' !== $type && 'plugins' !== $type && 'core' !== $type ) {
1519          return array();
1520      }
1521  
1522      $dir = 'core' === $type ? WP_LANG_DIR : WP_LANG_DIR . "/$type";
1523  
1524      if ( ! is_dir( $dir ) ) {
1525          return array();
1526      }
1527  
1528      $files = $wp_textdomain_registry->get_language_files_from_path( $dir );
1529      if ( ! $files ) {
1530          return array();
1531      }
1532  
1533      $language_data = array();
1534  
1535      foreach ( $files as $file ) {
1536          if ( ! preg_match( '/(?:(.+)-)?([a-z]{2,3}(?:_[A-Z]{2})?(?:_[a-z0-9]+)?)\.(?:mo|l10n\.php)/', basename( $file ), $match ) ) {
1537              continue;
1538          }
1539  
1540          list( , $textdomain, $language ) = $match;
1541          if ( '' === $textdomain ) {
1542              $textdomain = 'default';
1543          }
1544  
1545          if ( str_ends_with( $file, '.mo' ) ) {
1546              $pofile = substr_replace( $file, '.po', - strlen( '.mo' ) );
1547  
1548              if ( ! file_exists( $pofile ) ) {
1549                  continue;
1550              }
1551  
1552              $language_data[ $textdomain ][ $language ] = wp_get_pomo_file_data( $pofile );
1553          } else {
1554              $pofile = substr_replace( $file, '.po', - strlen( '.l10n.php' ) );
1555  
1556              // If both a PO and a PHP file exist, prefer the PO file.
1557              if ( file_exists( $pofile ) ) {
1558                  continue;
1559              }
1560  
1561              $language_data[ $textdomain ][ $language ] = wp_get_l10n_php_file_data( $file );
1562          }
1563      }
1564      return $language_data;
1565  }
1566  
1567  /**
1568   * Extracts headers from a PO file.
1569   *
1570   * @since 3.7.0
1571   *
1572   * @param string $po_file Path to PO file.
1573   * @return string[] Array of PO file header values keyed by header name.
1574   */
1575  function wp_get_pomo_file_data( $po_file ) {
1576      $headers = get_file_data(
1577          $po_file,
1578          array(
1579              'POT-Creation-Date'  => '"POT-Creation-Date',
1580              'PO-Revision-Date'   => '"PO-Revision-Date',
1581              'Project-Id-Version' => '"Project-Id-Version',
1582              'X-Generator'        => '"X-Generator',
1583          )
1584      );
1585      foreach ( $headers as $header => $value ) {
1586          // Remove possible contextual '\n' and closing double quote.
1587          $headers[ $header ] = preg_replace( '~(\\\n)?"$~', '', $value );
1588      }
1589      return $headers;
1590  }
1591  
1592  /**
1593   * Extracts headers from a PHP translation file.
1594   *
1595   * @since 6.6.0
1596   *
1597   * @param string $php_file Path to a `.l10n.php` file.
1598   * @return string[] Array of file header values keyed by header name.
1599   */
1600  function wp_get_l10n_php_file_data( $php_file ) {
1601      $data = (array) include $php_file;
1602  
1603      unset( $data['messages'] );
1604      $headers = array(
1605          'POT-Creation-Date'  => 'pot-creation-date',
1606          'PO-Revision-Date'   => 'po-revision-date',
1607          'Project-Id-Version' => 'project-id-version',
1608          'X-Generator'        => 'x-generator',
1609      );
1610  
1611      $result = array(
1612          'POT-Creation-Date'  => '',
1613          'PO-Revision-Date'   => '',
1614          'Project-Id-Version' => '',
1615          'X-Generator'        => '',
1616      );
1617  
1618      foreach ( $headers as $po_header => $php_header ) {
1619          if ( isset( $data[ $php_header ] ) ) {
1620              $result[ $po_header ] = $data[ $php_header ];
1621          }
1622      }
1623  
1624      return $result;
1625  }
1626  
1627  /**
1628   * Displays or returns a Language selector.
1629   *
1630   * @since 4.0.0
1631   * @since 4.3.0 Introduced the `echo` argument.
1632   * @since 4.7.0 Introduced the `show_option_site_default` argument.
1633   * @since 5.1.0 Introduced the `show_option_en_us` argument.
1634   * @since 5.9.0 Introduced the `explicit_option_en_us` argument.
1635   *
1636   * @see get_available_languages()
1637   * @see wp_get_available_translations()
1638   *
1639   * @param string|array $args {
1640   *     Optional. Array or string of arguments for outputting the language selector.
1641   *
1642   *     @type string   $id                           ID attribute of the select element. Default 'locale'.
1643   *     @type string   $name                         Name attribute of the select element. Default 'locale'.
1644   *     @type string[] $languages                    List of installed languages, contain only the locales.
1645   *                                                  Default empty array.
1646   *     @type array    $translations                 List of available translations. Default result of
1647   *                                                  wp_get_available_translations().
1648   *     @type string   $selected                     Language which should be selected. Default empty.
1649   *     @type bool|int $echo                         Whether to echo the generated markup. Accepts 0, 1, or their
1650   *                                                  boolean equivalents. Default 1.
1651   *     @type bool     $show_available_translations  Whether to show available translations. Default true.
1652   *     @type bool     $show_option_site_default     Whether to show an option to fall back to the site's locale. Default false.
1653   *     @type bool     $show_option_en_us            Whether to show an option for English (United States). Default true.
1654   *     @type bool     $explicit_option_en_us        Whether the English (United States) option uses an explicit value of en_US
1655   *                                                  instead of an empty value. Default false.
1656   * }
1657   * @return string HTML dropdown list of languages.
1658   */
1659  function wp_dropdown_languages( $args = array() ) {
1660  
1661      $parsed_args = wp_parse_args(
1662          $args,
1663          array(
1664              'id'                          => 'locale',
1665              'name'                        => 'locale',
1666              'languages'                   => array(),
1667              'translations'                => array(),
1668              'selected'                    => '',
1669              'echo'                        => 1,
1670              'show_available_translations' => true,
1671              'show_option_site_default'    => false,
1672              'show_option_en_us'           => true,
1673              'explicit_option_en_us'       => false,
1674          )
1675      );
1676  
1677      // Bail if no ID or no name.
1678      if ( ! $parsed_args['id'] || ! $parsed_args['name'] ) {
1679          return;
1680      }
1681  
1682      // English (United States) uses an empty string for the value attribute.
1683      if ( 'en_US' === $parsed_args['selected'] && ! $parsed_args['explicit_option_en_us'] ) {
1684          $parsed_args['selected'] = '';
1685      }
1686  
1687      $translations = $parsed_args['translations'];
1688      if ( empty( $translations ) ) {
1689          require_once  ABSPATH . 'wp-admin/includes/translation-install.php';
1690          $translations = wp_get_available_translations();
1691      }
1692  
1693      /*
1694       * $parsed_args['languages'] should only contain the locales. Find the locale in
1695       * $translations to get the native name. Fall back to locale.
1696       */
1697      $languages = array();
1698      foreach ( $parsed_args['languages'] as $locale ) {
1699          if ( isset( $translations[ $locale ] ) ) {
1700              $translation = $translations[ $locale ];
1701              $languages[] = array(
1702                  'language'    => $translation['language'],
1703                  'native_name' => $translation['native_name'],
1704                  'lang'        => current( $translation['iso'] ),
1705              );
1706  
1707              // Remove installed language from available translations.
1708              unset( $translations[ $locale ] );
1709          } else {
1710              $languages[] = array(
1711                  'language'    => $locale,
1712                  'native_name' => $locale,
1713                  'lang'        => '',
1714              );
1715          }
1716      }
1717  
1718      $translations_available = ( ! empty( $translations ) && $parsed_args['show_available_translations'] );
1719  
1720      // Holds the HTML markup.
1721      $structure = array();
1722  
1723      // List installed languages.
1724      if ( $translations_available ) {
1725          $structure[] = '<optgroup label="' . esc_attr_x( 'Installed', 'translations' ) . '">';
1726      }
1727  
1728      // Site default.
1729      if ( $parsed_args['show_option_site_default'] ) {
1730          $structure[] = sprintf(
1731              '<option value="site-default" data-installed="1"%s>%s</option>',
1732              selected( 'site-default', $parsed_args['selected'], false ),
1733              _x( 'Site Default', 'default site language' )
1734          );
1735      }
1736  
1737      if ( $parsed_args['show_option_en_us'] ) {
1738          $value       = ( $parsed_args['explicit_option_en_us'] ) ? 'en_US' : '';
1739          $structure[] = sprintf(
1740              '<option value="%s" lang="en" data-installed="1"%s>English (United States)</option>',
1741              esc_attr( $value ),
1742              selected( '', $parsed_args['selected'], false )
1743          );
1744      }
1745  
1746      // List installed languages.
1747      foreach ( $languages as $language ) {
1748          $structure[] = sprintf(
1749              '<option value="%s" lang="%s"%s data-installed="1">%s</option>',
1750              esc_attr( $language['language'] ),
1751              esc_attr( $language['lang'] ),
1752              selected( $language['language'], $parsed_args['selected'], false ),
1753              esc_html( $language['native_name'] )
1754          );
1755      }
1756      if ( $translations_available ) {
1757          $structure[] = '</optgroup>';
1758      }
1759  
1760      // List available translations.
1761      if ( $translations_available ) {
1762          $structure[] = '<optgroup label="' . esc_attr_x( 'Available', 'translations' ) . '">';
1763          foreach ( $translations as $translation ) {
1764              $structure[] = sprintf(
1765                  '<option value="%s" lang="%s"%s>%s</option>',
1766                  esc_attr( $translation['language'] ),
1767                  esc_attr( current( $translation['iso'] ) ),
1768                  selected( $translation['language'], $parsed_args['selected'], false ),
1769                  esc_html( $translation['native_name'] )
1770              );
1771          }
1772          $structure[] = '</optgroup>';
1773      }
1774  
1775      // Combine the output string.
1776      $output  = sprintf( '<select name="%s" id="%s">', esc_attr( $parsed_args['name'] ), esc_attr( $parsed_args['id'] ) );
1777      $output .= implode( "\n", $structure );
1778      $output .= '</select>';
1779  
1780      if ( $parsed_args['echo'] ) {
1781          echo $output;
1782      }
1783  
1784      return $output;
1785  }
1786  
1787  /**
1788   * Determines whether the current locale is right-to-left (RTL).
1789   *
1790   * For more information on this and similar theme functions, check out
1791   * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
1792   * Conditional Tags} article in the Theme Developer Handbook.
1793   *
1794   * @since 3.0.0
1795   *
1796   * @global WP_Locale $wp_locale WordPress date and time locale object.
1797   *
1798   * @return bool Whether locale is RTL.
1799   */
1800  function is_rtl() {
1801      global $wp_locale;
1802      if ( ! ( $wp_locale instanceof WP_Locale ) ) {
1803          return false;
1804      }
1805      return $wp_locale->is_rtl();
1806  }
1807  
1808  /**
1809   * Switches the translations according to the given locale.
1810   *
1811   * @since 4.7.0
1812   *
1813   * @global WP_Locale_Switcher $wp_locale_switcher WordPress locale switcher object.
1814   *
1815   * @param string $locale The locale.
1816   * @return bool True on success, false on failure.
1817   */
1818  function switch_to_locale( $locale ) {
1819      /* @var WP_Locale_Switcher $wp_locale_switcher */
1820      global $wp_locale_switcher;
1821  
1822      if ( ! $wp_locale_switcher ) {
1823          return false;
1824      }
1825  
1826      return $wp_locale_switcher->switch_to_locale( $locale );
1827  }
1828  
1829  /**
1830   * Switches the translations according to the given user's locale.
1831   *
1832   * @since 6.2.0
1833   *
1834   * @global WP_Locale_Switcher $wp_locale_switcher WordPress locale switcher object.
1835   *
1836   * @param int $user_id User ID.
1837   * @return bool True on success, false on failure.
1838   */
1839  function switch_to_user_locale( $user_id ) {
1840      /* @var WP_Locale_Switcher $wp_locale_switcher */
1841      global $wp_locale_switcher;
1842  
1843      if ( ! $wp_locale_switcher ) {
1844          return false;
1845      }
1846  
1847      return $wp_locale_switcher->switch_to_user_locale( $user_id );
1848  }
1849  
1850  /**
1851   * Restores the translations according to the previous locale.
1852   *
1853   * @since 4.7.0
1854   *
1855   * @global WP_Locale_Switcher $wp_locale_switcher WordPress locale switcher object.
1856   *
1857   * @return string|false Locale on success, false on error.
1858   */
1859  function restore_previous_locale() {
1860      /* @var WP_Locale_Switcher $wp_locale_switcher */
1861      global $wp_locale_switcher;
1862  
1863      if ( ! $wp_locale_switcher ) {
1864          return false;
1865      }
1866  
1867      return $wp_locale_switcher->restore_previous_locale();
1868  }
1869  
1870  /**
1871   * Restores the translations according to the original locale.
1872   *
1873   * @since 4.7.0
1874   *
1875   * @global WP_Locale_Switcher $wp_locale_switcher WordPress locale switcher object.
1876   *
1877   * @return string|false Locale on success, false on error.
1878   */
1879  function restore_current_locale() {
1880      /* @var WP_Locale_Switcher $wp_locale_switcher */
1881      global $wp_locale_switcher;
1882  
1883      if ( ! $wp_locale_switcher ) {
1884          return false;
1885      }
1886  
1887      return $wp_locale_switcher->restore_current_locale();
1888  }
1889  
1890  /**
1891   * Determines whether switch_to_locale() is in effect.
1892   *
1893   * @since 4.7.0
1894   *
1895   * @global WP_Locale_Switcher $wp_locale_switcher WordPress locale switcher object.
1896   *
1897   * @return bool True if the locale has been switched, false otherwise.
1898   */
1899  function is_locale_switched() {
1900      /* @var WP_Locale_Switcher $wp_locale_switcher */
1901      global $wp_locale_switcher;
1902  
1903      return $wp_locale_switcher->is_switched();
1904  }
1905  
1906  /**
1907   * Translates the provided settings value using its i18n schema.
1908   *
1909   * @since 5.9.0
1910   * @access private
1911   *
1912   * @param string|string[]|array[]|object $i18n_schema I18n schema for the setting.
1913   * @param string|string[]|array[]        $settings    Value for the settings.
1914   * @param string                         $textdomain  Textdomain to use with translations.
1915   *
1916   * @return string|string[]|array[] Translated settings.
1917   */
1918  function translate_settings_using_i18n_schema( $i18n_schema, $settings, $textdomain ) {
1919      if ( empty( $i18n_schema ) || empty( $settings ) || empty( $textdomain ) ) {
1920          return $settings;
1921      }
1922  
1923      if ( is_string( $i18n_schema ) && is_string( $settings ) ) {
1924          return translate_with_gettext_context( $settings, $i18n_schema, $textdomain );
1925      }
1926      if ( is_array( $i18n_schema ) && is_array( $settings ) ) {
1927          $translated_settings = array();
1928          foreach ( $settings as $value ) {
1929              $translated_settings[] = translate_settings_using_i18n_schema( $i18n_schema[0], $value, $textdomain );
1930          }
1931          return $translated_settings;
1932      }
1933      if ( is_object( $i18n_schema ) && is_array( $settings ) ) {
1934          $group_key           = '*';
1935          $translated_settings = array();
1936          foreach ( $settings as $key => $value ) {
1937              if ( isset( $i18n_schema->$key ) ) {
1938                  $translated_settings[ $key ] = translate_settings_using_i18n_schema( $i18n_schema->$key, $value, $textdomain );
1939              } elseif ( isset( $i18n_schema->$group_key ) ) {
1940                  $translated_settings[ $key ] = translate_settings_using_i18n_schema( $i18n_schema->$group_key, $value, $textdomain );
1941              } else {
1942                  $translated_settings[ $key ] = $value;
1943              }
1944          }
1945          return $translated_settings;
1946      }
1947      return $settings;
1948  }
1949  
1950  /**
1951   * Retrieves the list item separator based on the locale.
1952   *
1953   * @since 6.0.0
1954   *
1955   * @global WP_Locale $wp_locale WordPress date and time locale object.
1956   *
1957   * @return string Locale-specific list item separator.
1958   */
1959  function wp_get_list_item_separator() {
1960      global $wp_locale;
1961  
1962      if ( ! ( $wp_locale instanceof WP_Locale ) ) {
1963          // Default value of WP_Locale::get_list_item_separator().
1964          /* translators: Used between list items, there is a space after the comma. */
1965          return __( ', ' );
1966      }
1967  
1968      return $wp_locale->get_list_item_separator();
1969  }
1970  
1971  /**
1972   * Retrieves the word count type based on the locale.
1973   *
1974   * @since 6.2.0
1975   *
1976   * @global WP_Locale $wp_locale WordPress date and time locale object.
1977   *
1978   * @return string Locale-specific word count type. Possible values are `characters_excluding_spaces`,
1979   *                `characters_including_spaces`, or `words`. Defaults to `words`.
1980   */
1981  function wp_get_word_count_type() {
1982      global $wp_locale;
1983  
1984      if ( ! ( $wp_locale instanceof WP_Locale ) ) {
1985          // Default value of WP_Locale::get_word_count_type().
1986          return 'words';
1987      }
1988  
1989      return $wp_locale->get_word_count_type();
1990  }


Generated : Sat May 18 08:20:01 2024 Cross-referenced by PHPXref