##----------------------------------------------------------------------------
## Unicode Locale Identifier - ~/lib/Locale/Unicode.pm
## Version v0.3.11
## Copyright(c) 2025 DEGUEST Pte. Ltd.
## Author: Jacques Deguest <jack@deguest.jp>
## Created 2024/05/11
## Modified 2025/01/05
## All rights reserved
## 
## 
## This program is free software; you can redistribute  it  and/or  modify  it
## under the same terms as Perl itself.
##----------------------------------------------------------------------------
package Locale::Unicode;
BEGIN
{
    use v5.10.1;
    use strict;
    use warnings;
    use warnings::register;
    use vars qw(
        $ERROR $VERSION $DEBUG $FATAL_EXCEPTIONS
        $LOCALE_BCP47_RE $LOCALE_BCP47_NAMELESS_RE $LOCALE_RE $LOCALE_UNICODE_SUBTAG_RE
        $LOCALE_EXTENSIONS_RE $LOCALE_TRANSFORM_PARAMETERS_RE $GRANDFATHERED_IRREGULAR
        $GRANDFATHERED_REGULAR
        $TZ_DICT $TZ_NAME2ID
        $PROP_TO_SUB
        $EXPLICIT_BOOLEAN
    );
    use overload (
        '""'    => 'as_string',
        bool    => sub{1},
        fallback => 1,
    );
    use Scalar::Util ();
    use Want;
    # ""root" is treated as a special unicode_language_subtag"
    # <https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier>
    # NOTE: $LOCALE_BCP47_RE
    our $LOCALE_BCP47_RE = qr/
    (?:
        (?:
            # "root" is treated as a special Unicode language subtag in the LDML and required in the valid pattern
            (?<root>root)
            |
            (?<language>[a-z]{2})
            |
            (?<language3>[a-z]{3})
        )
        # "Up to three optional extended language subtags composed of three letters each, separated by hyphens"
        # "There is currently no extended language subtag registered in the Language Subtag Registry without an equivalent and preferred primary language subtag"
        (?:
            \-
            (?<extended>
                [a-z]{3}
                (?:\-[a-z]{3}){0,2}
            )
        )?
    )
    # ISO 15924 for scripts
    (?:
        -
        (?:
            (?<script>[A-Z][a-z]{3})
            |
            (?<script>[a-z]{4})
        )
    )?
    (?:
        (?:
            -
            (?<territory>
                (?<country_code>[A-Z]{2})
                |
                # BCP47, section 2.2.4.4: the UN Standard Country or Area Codes for Statistical Use
                # We are careful not to catch a following variant starting with a digit.
                (?<region>\d{3}(?!\d))
            )
        )?
        # "Optional variant subtags, separated by hyphens, each composed of five to eight letters, or of four characters starting with a digit"
        # ca-ES-valencia
        # country code can be skipped if the variant is limited to a country
        # be-tarask
        (?:
            -
            (?<variant>
                (?:
                    (?:[[:alnum:]]{5,8})
                    |
                    (?:\d[[:alnum:]]{3})
                )
                (?:
                    \-
                    (?:
                        (?:[[:alnum:]]{5,8})
                        |
                        (?:\d[[:alnum:]]{3})
                    )
                )*
            )
        )?
    )?
    /xi;
    # We need the same regular express as $LOCALE_BCP47_RE, but without named capturing group
    # so it does not interfere with matches from $LOCALE_BCP47_RE
    # NOTE: $LOCALE_BCP47_NAMELESS_RE
    our $LOCALE_BCP47_NAMELESS_RE = qr/
    (?:
        (?:
            # "root" is treated as a special Unicode language subtag in the LDML and required in the valid pattern
            (?:root)
            |
            (?:[a-z]{2})
            |
            (?:[a-z]{3})
        )
        # "Up to three optional extended language subtags composed of three letters each, separated by hyphens"
        # "There is currently no extended language subtag registered in the Language Subtag Registry without an equivalent and preferred primary language subtag"
        (?:
            \-
            (?:
                [a-z]{3}
                (?:\-[a-z]{3}){0,2}
            )
        )?
    )
    # ISO 15924 for scripts
    (?:
        -
        (?:
            (?:[A-Z][a-z]{3})
            |
            (?:[a-z]{4})
        )
    )?
    (?:
        (?:
            -
            (?:
                (?:[A-Z]{2})
                |
                # BCP47, section 2.2.4.4: the UN Standard Country or Area Codes for Statistical Use
                # We are careful not to catch a following variant starting with a digit.
                (?:\d{3}\d{3}(?!\d))
            )
        )?
        # "Optional variant subtags, separated by hyphens, each composed of five to eight letters, or of four characters starting with a digit"
        # ca-ES-valencia
        # country code can be skipped if the variant is limited to a country
        # be-tarask
        (?:
            -
            (?:
                (?:
                    (?:[[:alnum:]]{5,8})
                    |
                    (?:\d[[:alnum:]]{3})
                )
                (?:
                    \-
                    (?:
                        (?:[[:alnum:]]{5,8})
                        |
                        (?:\d[[:alnum:]]{3})
                    )
                )*
            )
        )?
    )?
    /xi;
    # NOTE: $LOCALE_UNICODE_SUBTAG_RE
    our $LOCALE_UNICODE_SUBTAG_RE = qr/
    (?<ext_unicode_subtag>
        (?:
            (?<ext_calendar>ca)
            |
            (?<ext_currency_format>cf)
            |
            (?<ext_collation>co)
            |
            (?<ext_currency>cu)
            |
            (?<ext_dict_break_exclusion>dx)
            |
            (?<ext_emoji>em)
            |
            (?<ext_first_day>fw)
            |
            (?<ext_hour_cycle>hc)
            |
            (?<ext_line_break>lb)
            |
            (?<ext_line_break_word>lw)
            |
            (?<ext_measurement>ms)
            |
            (?<ext_unit>mu)
            |
            (?<ext_number>nu)
            |
            (?<ext_region_override>rg)
            |
            (?<ext_subdivision>sd)
            |
            (?<ext_sentence_break_suppression>ss)
            |
            (?<ext_time_zone>tz)
            |
            (?<ext_variant>va)
            |
            (?<ext_unicode_unknown>
                [a-zA-Z0-9]{2,8}
            )
        )
        (?<ext_unicode_values>
            (?:\-
                # Collation or Transformation subtags, eventhough the latter should not be here
                (?!(?:ka|kb|kc|kf|kh|kk|kn|kr|ks|kv|vt|d0|h0|i0|k0|m0|s0|t0|x0|[a]0)[^[:alnum:]])
                [a-zA-Z0-9]{2,8}
            )*
        )
    )
    (?:
        \-
        (?:
            # Should not be here, but could be malformed
            (?<transform_options>
                (?:d0|h0|i0|k0|m0|s0|t0|x0|[a]0)
                (?:\-[a-zA-Z0-9]{2,8})*
            )
            |
            (?<collation_options>
                (?:ka|kb|kc|kf|kh|kk|kn|kr|ks|kv|vt)
                (?:\-[a-zA-Z0-9]{2,8})*
            )
        )
    )?
    /xi;
    # NOTE: $LOCALE_TRANSFORM_PARAMETERS_RE
    our $LOCALE_TRANSFORM_PARAMETERS_RE = qr/(?:d0|h0|i0|k0|m0|s0|t0|x0|[a]0)/i;
    # NOTE: $LOCALE_TRANSFORM_SUBTAG_RE
    our $LOCALE_TRANSFORM_SUBTAG_RE = qr/
    (?<ext_transform_locale>
        $LOCALE_BCP47_NAMELESS_RE
    )
    (?:
        \-
        (?<ext_transform_subtag>
            (?:
                (?<ext_destination>d0)
                |
                (?<ext_hybrid>h0)
                |
                (?<ext_input>i0)
                |
                (?<ext_keyboard>k0)
                |
                (?<ext_mechanism>m0)
                |
                (?<ext_source>s0)
                |
                (?<ext_translation>t0)
                |
                (?<ext_private_transform>x0)
                |
                (?<ext_transform_unknown>
                    [a-zA-Z0-9]{2,8}
                )
            )
            (?<ext_transform_values>
                (?:\-
                    # Transformation or Unicode collation subtags, eventhough the latter should not be here
                    (?!(?:ka|kb|kc|kf|kh|kk|kn|kr|ks|kv|vt|d0|h0|i0|k0|m0|s0|t0|x0|[a]0)[^[:alnum:]])
                    [a-zA-Z0-9]{2,8}
                )*
            )
        )
    )?
    (?:
        \-
        (?:
            (?<transform_options>
                (?:d0|h0|i0|k0|m0|s0|t0|x0|[a]0)
                (?:\-[a-zA-Z0-9]{2,8})*
            )
            |
            # Should not be here, but could be malformed
            (?<collation_options>
                (?:ka|kb|kc|kf|kh|kk|kn|kr|ks|kv|vt)
                (?:\-[a-zA-Z0-9]{2,8})*
            )
        )
    )?
    /xi;
    # NOTE: $LOCALE_EXTENSIONS_RE
    our $LOCALE_EXTENSIONS_RE = qr/
    (?:
        (?<ext_transform>
            t
            \-
            $LOCALE_TRANSFORM_SUBTAG_RE
        )
        |
        (?<ext_unicode>
            u
            \-
            $LOCALE_UNICODE_SUBTAG_RE
        )
        |
        (?<extension>
            (?<singleton>[a-wy-z])
            \-
            (?<subtag>
                [a-zA-Z0-9]{2,8}
                (?:\-[a-zA-Z0-9]{2,8})*
            )
        )
    )
    /xi;
    # NOTE: $GRANDFATHERED_IRREGULAR
    our $GRANDFATHERED_IRREGULAR = qr/
    (?:
        en-GB-oed
        |
        (?:i-
            (?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)
        )
        |
        (?:sgn-(?:BE-FR|BE-NL|CH-DE))
    )
    /xi;
    # NOTE: $GRANDFATHERED_REGULAR
    our $GRANDFATHERED_REGULAR = qr/
    (?:
        art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang
    )
    /xi;
    # Possible IETF BCP 47 language tags:
    # fr
    # fre
    # fr-Bret
    # fr-FR
    # fr-Bret-FR
    # See: <https://en.wikipedia.org/wiki/IETF_language_tag#Syntax_of_language_tags>
    #      <https://en.wikipedia.org/wiki/ISO_15924>
    #      Grandfathered subtags: <https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.8>
    # NOTE: $LOCALE_RE
    our $LOCALE_RE = qr/
    (?<locale_bcp47>
        (?:
            (?:
                x
                \-
                (?<privateuse>
                    [a-zA-Z0-9]{1,8}
                    (?:\-[a-zA-Z0-9]{1,8})*
                )
            )
            |
            (?<grandfathered>
                (?<grandfathered_irregular>$GRANDFATHERED_IRREGULAR)
                |
                (?<grandfathered_regular>$GRANDFATHERED_REGULAR)
            )
            |
            $LOCALE_BCP47_RE
        )
    )
    # BCP47, section 2.2.6:
    # "Optional extension subtags, separated by hyphens, each composed of a single character, with the exception of the letter x, and a hyphen followed by one or more subtags of two to eight characters each, separated by hyphens"
    (?:
        \-
        (?:
            (?:
                (?<locale_extensions>
                    $LOCALE_EXTENSIONS_RE
                    (?:
                        \-
                        $LOCALE_EXTENSIONS_RE
                    )*
                )?
                # "An optional private-use subtag, composed of the letter x and a hyphen followed by subtags of one to eight characters each, separated by hyphens"
                (?:
                    \-
                    (?<private_extension>
                        x
                        \-
                        (?<private_subtag>
                            [a-zA-Z0-9]{1,8}
                            (?:\-[a-zA-Z0-9]{1,8})*
                        )
                    )
                )*
            )
            |
            (?<private_extension>
                x
                \-
                (?<private_subtag>
                    [a-zA-Z0-9]{1,8}
                    (?:\-[a-zA-Z0-9]{1,8})*
                )
            )
        )
    )?
    /xi;
    our $PROP_TO_SUB = {};
    # False, by default
    our $EXPLICIT_BOOLEAN = 0;
    our $VERSION = 'v0.3.11';
};

use strict;
use warnings;

sub new
{
    my $this = shift( @_ );
    my $self = bless( {} => ( ref( $this ) || $this ) );
    my $locale = shift( @_ ) ||
        return( $self->error( "No locale was provided." ) );
    # u-dx
    $self->{break_exclusion}    = undef;
    # u-ca
    $self->{calendar}           = undef;
    # u-co
    $self->{collation}          = undef;
    # ISO3166 2-letters country code
    $self->{country_code}       = undef;
    # u-cf
    $self->{cu_format}          = undef;
    # u-cu
    $self->{currency}           = undef;
    # t-d0
    $self->{destination}        = undef;
    # u-em
    $self->{emoji}              = undef;
    $self->{extended}           = undef;
    $self->{fatal}              = ( $FATAL_EXCEPTIONS // 0 );
    # u-fw
    $self->{first_day}          = undef;
    $self->{grandfathered_irregular} = undef;
    $self->{grandfathered_regular}   = undef;
    # u-hc
    $self->{hour_cycle}         = undef;
    # t-h0
    $self->{hybrid}             = undef;
    # t-i0
    $self->{input}              = undef;
    $self->{language}           = undef;
    $self->{language3}          = undef;
    # u-lb
    $self->{line_break}         = undef;
    # u-lw
    $self->{line_break_word}    = undef;
    # u-ms
    $self->{measurement}        = undef;
    # u-nu
    $self->{number}             = undef;
    # Overlong country code (3-characters code) whereas it should be 2-characters code
    # For example: PAN -> PA
    # See the 'alias' method in Locale::Unicode::Data to convert those overlong territory to their 2-characters equivalent
    $self->{overlong}           = undef;
    # u-mu
    $self->{unit}               = undef;
    # t-m0
    $self->{mechanism}          = undef;
    # x-something
    $self->{private}            = undef;
    $self->{privateuse}         = undef;
    $self->{region}             = undef;
    # u-rg
    $self->{region_override}    = undef;
    # t-s0
    $self->{source}             = undef;
    $self->{script}             = undef;
    $self->{territory}          = undef;
    # t-t0
    $self->{translation}        = undef;
    # u-sd
    $self->{subdivision}        = undef;
    # t-x
    $self->{t_private}          = undef;
    # u-tz
    $self->{time_zone}          = undef;
    # u-va
    $self->{variant}            = undef;
    # A simple dictionary that stores the preferred boolean representation for each attribute
    # i.e. yes or true, no or false
    # literal or logic
    $self->{_bool_types} = {};
    my @args = @_;
    if( scalar( @args ) == 1 &&
        defined( $args[0] ) &&
        ref( $args[0] ) eq 'HASH' )
    {
        my $opts = shift( @args );
        # We need to set up early, so we can use it soon after
        $self->{fatal} = delete( $opts->{fatal} ) if( exists( $opts->{fatal} ) );
        @args = %$opts;
    }
    elsif( ( scalar( @args ) % 2 ) )
    {
        return( $self->error( sprintf( "Uneven number of parameters provided (%d). Should receive key => value pairs. Parameters provided are: %s", scalar( @args ), join( ', ', @args ) ) ) );
    }

    for( my $i = 0; $i < scalar( @args ); $i += 2 )
    {
        if( $args[$i] eq 'fatal' )
        {
            $self->{fatal} = $args[$i + 1];
            last;
        }
    }

    # If the locale provided contains any subtags, parse it
    if( index( $locale, '-' ) != -1 ||
        index( $locale, '_' ) != -1 )
    {
        $locale =~ tr/_/-/;
    }
    my $ref = $self->parse( $locale ) ||
        return( $self->pass_error );
    return( $self->error( "Invalid locale value \"${locale}\" provided." ) ) if( !scalar( keys( %$ref ) ) );
    $self->apply( $ref ) || return( $self->pass_error );

    # Then, if the user provided with an hash or hash reference of options, we apply them
    for( my $i = 0; $i < scalar( @args ); $i++ )
    {
        my $name = $args[ $i ];
        my $val  = $args[ ++$i ];
        my $meth = $self->can( $name );
        if( !defined( $meth ) )
        {
            return( $self->error( "Unknown method \"${meth}\" provided for locale \"${locale}\"." ) );
        }
        elsif( !defined( $meth->( $self, $val ) ) )
        {
            if( defined( $val ) && $self->error )
            {
                return( $self->pass_error );
            }
        }
    }
    return( $self );
}

sub apply
{
    my $self = shift( @_ );
    my $hash = $self->_get_args_as_hash( @_ );
    return( $self ) if( !scalar( keys( %$hash ) ) );
    foreach my $prop ( keys( %$hash ) )
    {
        next if( $prop eq 'transform_ext' || $prop eq 'unicode_ext' );
        my $code;
        unless( $code = $PROP_TO_SUB->{ $prop } )
        {
            $code = $self->can( $prop );
            if( !$code )
            {
                warn( "No method \"${prop}\" supported in ", ( ref( $self ) || $self ) ) if( warnings::enabled() );
                next;
            }
            $PROP_TO_SUB->{ $prop } = $code;
        }
        $code->( $self, $hash->{ $prop } );
    }
    return( $self );
}

sub as_string
{
    my $self = shift( @_ );
    return( $self->{_cache_value} ) if( $self->{_cache_value} && !CORE::length( $self->{_reset} // '' ) );
    my $unicodes =
    {
    ca  => 'calendar',
    cf  => 'cu_format',
    co  => 'collation',
    cu  => 'currency',
    dx  => 'break_exclusion',
    em  => 'emoji',
    fw  => 'first_day',
    hc  => 'hour_cycle',
    lb  => 'line_break',
    lw  => 'line_break_word',
    ms  => 'measurement',
    mu  => 'unit',
    nu  => 'number',
    rg  => 'region_override',
    sd  => 'subdivision',
    ss  => 'sentence_break',
    tz  => 'time_zone',
    va  => 'va',
    };
    my $collation =
    {
    ka  => 'colAlternate',
    kb  => { type => 'boolean', method => 'colBackwards' },
    kc  => { type => 'boolean', method => 'colCaseLevel' },
    kf  => 'colCaseFirst',
    kh  => { type => 'boolean', method => 'colHiraganaQuaternary' },
    kk  => { type => 'boolean', method => 'colNormalization' },
    kn  => { type => 'boolean', method => 'colNumeric' },
    kr  => 'colReorder',
    ks  => 'colStrength',
    kv  => 'colValue',
    vt  => 'colVariableTop',
    };
    my $transform =
    {
    d0  => 'destination',
    h0  => 'hybrid',
    i0  => 'input',
    k0  => 'keyboard',
    m0  => 'mechanism',
    s0  => 'source',
    t0  => 'translation',
    x0  => 't_private',
    };
    my $others =
    {
    x_  => 'private',
    };
    my $map =
    [
        unicode => { prefix => 'u', data => $unicodes },
        # und-u-ka-noignore
        collation => { prefix => 'u', data => $collation },
        transform => { prefix => 't', data => $transform },
    ];
    my $result = {};
    for( my $i = 0; $i < scalar( @$map ); $i += 2 )
    {
        my $type = $map->[$i];
        my $dict = $map->[$i + 1];
        my $prefix = $dict->{prefix};
        my $ref  = $dict->{data};
        foreach my $tag ( sort( keys( %$ref ) ) )
        {
            my $meth;
            my $def = {};
            if( ref( $ref->{ $tag } ) eq 'HASH' )
            {
                $def = $ref->{ $tag };
                $meth = $def->{method};
            }
            else
            {
                $meth = $ref->{ $tag };
            }
            my $code;
            unless( $code = $PROP_TO_SUB->{ $tag } )
            {
                $code = $self->can( $meth ) || die( "Unknown method '${meth}' for ${type} subtag '${tag}'" );
                $PROP_TO_SUB->{ $tag } = $code;
            }

            my $val = $code->( $self );
            next if( !defined( $val ) );
            $result->{ $prefix } = [] if( !exists( $result->{ $prefix } ) );
            if( exists( $def->{type} ) && $def->{type} eq 'boolean' )
            {
                # We are explicit about the true value, but it could be ignored and be implicit.
                # push( @{$result->{ $prefix }}, join( '-', $tag, ( $val ? 'true' : 'false' ) ) );
                push( @{$result->{ $prefix }}, ( $EXPLICIT_BOOLEAN ? join( '-', $tag, ( $val ? 'true' : 'false' ) ) : ( $val ? $tag : join( '-', $tag, 'false' ) ) ) );
            }
            else
            {
                push( @{$result->{ $prefix }}, join( '-', $tag, $val ) );
            }
        }
    }
    my @parts = ();

    push( @parts, $self->core );

    if( my $transform_locale = $self->transform_locale )
    {
        unshift( @{$result->{t}}, $transform_locale );
    }
    # There is no transformation locale and yet the user has set some transformation subtags.
    # We warn the user about it.
    elsif( exists( $result->{t} ) &&
           ref( $result->{t} ) eq 'ARRAY' &&
           scalar( @{$result->{t}} ) )
    {
        warn( "You are attempting at setting ", scalar( @{$result->{t}} ), " transform subtags without declaring a transformation locale." ) if( warnings::enabled() );
    }

    foreach my $pref ( qw( u t ) )
    {
        if( exists( $result->{ $pref } ) )
        {
            push( @parts, join( '-', $pref, join( '-', @{$result->{ $pref }} ) ) );
        }
    }
    if( my $private = $self->private )
    {
        push( @parts, "x-${private}" );
    }
    my $rv = join( '-', @parts );
    $self->{_cache_value} = $rv;
    CORE::delete( $self->{_reset} );
    return( $rv );
}

sub base
{
    my $self = shift( @_ );
    if( @_ )
    {
        my $base = shift( @_ );
        unless( Scalar::Util::blessed( $base ) &&
                $base->isa( 'Locale::Unicode' ) )
        {
            $base = Locale::Unicode->new( "$base" ) ||
                return( $self->pass_error );
        }
        # $base = $base->canonical;
        if( my $lang = $base->language_id )
        {
            $self->language_id( $lang );
        }
        else
        {
            $self->language_id( undef );
        }

        if( my $script = $base->script )
        {
            $self->script( $script );
        }
        else
        {
            $self->script( undef );
        }

        if( my $territory = $base->territory )
        {
            $self->territory( $territory ) ||
                return( $self->pass_error );
        }
        else
        {
            $self->territory( undef );
        }

        my $ref;
        if( ( $ref = $base->variants ) &&
            ref( $ref // '' ) eq 'ARRAY' &&
            scalar( @$ref ) )
        {
            local $" = '-';
            $self->variant( "@$ref" );
        }
        else
        {
            $self->variant( undef );
        }
    }
    return( $self->core );
}

# u-dx
sub break_exclusion { return( shift->reset(@_)->_set_get_prop( 'break_exclusion', @_ ) ); }

# u-ca
sub ca { return( shift->calendar( @_ ) ); }

sub calendar { return( shift->reset(@_)->_set_get_prop( 'calendar', @_ ) ); }

# NOTE: canonical -> specs <https://unicode.org/reports/tr35/tr35.html#Canonical_Unicode_Locale_Identifiers>
# <https://unicode.org/reports/tr35/tr35.html#LocaleId_Canonicalization>
# <https://unicode.org/reports/tr35/tr35.html#5.-canonicalizing-syntax>
sub canonical
{
    my $self = shift( @_ );
    local $EXPLICIT_BOOLEAN = 0;
    my $clone = Locale::Unicode->new( "$self" );
    if( my $privateuse = $clone->privateuse )
    {
        return( $clone );
    }
    elsif( my $grandfathered = $clone->grandfathered )
    {
        return( $clone );
    }

    if( my $variant = $self->variant )
    {
        # Make sure we have unique variants
        # "The sequence of variant subtags must not have any duplicates (eg, de-1996-fonipa-1996 is not syntactically well-formed)."
        # <https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier>
        my $uniq = sub
        {
            my %seen;
            grep( !$seen{ $_ }++, @_ );
        };
        my $variant2 = join( '-', $uniq->( sort( map( lc( $_ ), split( /-/, $variant ) ) ) ) );
        $clone->variant( $variant2 ) if( $variant2 ne $variant );
    }

    # We query the country_code method only, because territory includes both world region 
    # and country code, and world region is only digits that do not need to be in uppercase
    if( my $country_code = $self->country_code )
    {
        my $cc = uc( $country_code );
        $clone->country_code( $cc ) if( $cc ne $country_code );
    }

    if( my $script = $self->script )
    {
        my $script2 = ucfirst( lc( $script ) );
        $clone->script( $script2 ) if( $script2 ne $script );
    }

    my( $lang, $lang3 );
    if( ( $lang = $self->language ) ||
        ( $lang3 = $self->language3 ) )
    {
        # <https://unicode.org/reports/tr35/tr35.html#Unicode_Locale_Identifier_BCP_47_to_CLDR>
        # "the primary language subtag "und" is replaced with "root" if no script, region, or variant subtags are present."
        # Hmmm, I am really reluctant to do this, because other parts of the LDML indicates we should stick with dash and use 'und' and 'root' is not compliant with RFC standard that a language ID should be 2 to 3-characters
        # if( !$locale->script && 
        #     !$locale->territory &&
        #     !$locale->variant )
        # {
        #     $locale->language( 'root' );
        # }
        if( $lang )
        {
            my $lang_canon = lc( $lang );
            if( $lang_canon eq 'root' )
            {
                $clone->language3( 'und' );
            }
            elsif( $lang_canon ne $lang )
            {
                $clone->language( $lang_canon );
            }
        }
        elsif( $lang3 )
        {
            my $lang_canon = lc( $lang3 );
            $clone->language3( $lang_canon ) if( $lang_canon ne $lang3 );
        }
    }
    else
    {
        $clone->language( 'und' );
    }
    return( $clone );
}

# u-cf
sub cf { return( shift->cu_format( @_ ) ); }

sub clone
{
    my $self = shift( @_ );
    my $new = $self->new( "$self" ) || return( $self->pass_error );
    return( $new );
}

# u-co
sub co { return( shift->collation( @_ ) ); }

# u-ka
sub colAlternate { return( shift->reset(@_)->_set_get_prop({
    field => 'col_alternate',
    regexp => qr/[[:alnum:]][[:alnum:]\-]+/,
}, @_ ) ); }

# u-kb
sub colBackwards { return( shift->reset(@_)->_set_get_prop({
    field => 'col_backwards',
    type => 'boolean',
}, @_ ) ); }

# u-kc
sub colCaseLevel { return( shift->reset(@_)->_set_get_prop({
    field => 'col_case_level',
    type => 'boolean',
}, @_ ) ); }

# u-kf
sub colCaseFirst { return( shift->reset(@_)->_set_get_prop({
    field => 'col_case_first',
    # lower, upper, undef
    regexp => qr/[[:alnum:]]+/,
}, @_ ) ); }

# u-co
sub collation { return( shift->reset(@_)->_set_get_prop({
    field => 'collation',
    regexp => qr/[[:alnum:]]+/,
}, @_ ) ); }

# u-kh
sub colHiraganaQuaternary { return( shift->reset(@_)->_set_get_prop({
    field => 'col_hiragana_quaternary',
    type => 'boolean',
}, @_ ) ); }

sub colNormalisation { return( shift->colNormalization( @_ ) ); }

# u-kk
sub colNormalization { return( shift->reset(@_)->_set_get_prop({
    field => 'col_normalisation',
    type => 'boolean',
}, @_ ) ); }

# u-kn
sub colNumeric { return( shift->reset(@_)->_set_get_prop({
    field => 'col_numeric',
    type => 'boolean',
}, @_ ) ); }

# u-kr
sub colReorder { return( shift->reset(@_)->_set_get_prop({
    field => 'col_reorder',
    regexp => qr/[[:alnum:]][[:alnum:]\-]+/,
}, @_ ) ); }

# u-ks
sub colStrength { return( shift->reset(@_)->_set_get_prop({
    field => 'col_strength',
    regexp => qr/[[:alnum:]][[:alnum:]\-]+/,
}, @_ ) ); }

# u-kv
sub colValue { return( shift->reset(@_)->_set_get_prop({
    field => 'col_value',
    regexp => qr/[[:alnum:]]+/,
}, @_ ) ); }

# u-vt
sub colVariableTop { return( shift->reset(@_)->_set_get_prop({
    field => 'col_variable_top',
    regexp => qr/[[:alnum:]]+/,
}, @_ ) ); }

sub core
{
    my $self = shift( @_ );
    my @locale_parts = ();
    if( my $privateuse = $self->privateuse )
    {
        push( @locale_parts, 'x-' . $privateuse );
    }
    elsif( my $grandfathered = $self->grandfathered )
    {
        push( @locale_parts, $grandfathered );
    }
    else
    {
        if( my $lang = $self->language )
        {
            push( @locale_parts, $lang );
        }
        elsif( my $lang3 = $self->language3 )
        {
            push( @locale_parts, $lang3 );
        }
        # 'und' for 'undefined'
        else
        {
            push( @locale_parts, 'und' );
        }

        if( my $extended = $self->extended )
        {
            push( @locale_parts, $extended );
        }

        if( my $script = $self->script )
        {
            push( @locale_parts, $script );
        }

        if( my $cc = $self->country_code )
        {
            push( @locale_parts, $cc );
        }
        elsif( my $region = $self->region )
        {
            push( @locale_parts, $region );
        }

        if( my $variant = $self->variant )
        {
            push( @locale_parts, $variant );
        }
    }
    return( join( '-', @locale_parts ) );
}

sub country_code { return( shift->reset(@_)->_set_get_prop({
    field => 'country_code',
    on_update => sub
    {
        $_[0]->{region} = undef;
        $_[0]->{overlong} = undef;
    },
}, @_ ) ); }

# u-cf
sub cu_format { return( shift->reset(@_)->_set_get_prop( 'cu_format', @_ ) ); }

# u-cu
sub cu { return( shift->reset(@_)->_set_get_prop( 'currency', @_ ) ); }

# u-cu
sub currency { return( shift->reset(@_)->_set_get_prop( 'currency', @_ ) ); }

# t-d0
sub d0 { return( shift->reset(@_)->_set_get_prop( 'destination', @_ ) ); }

# t-d0
sub dest { return( shift->reset(@_)->_set_get_prop( 'destination', @_ ) ); }

# t-d0
sub destination { return( shift->reset(@_)->_set_get_prop( 'destination', @_ ) ); }

# u-dx
sub dx { return( shift->reset(@_)->_set_get_prop( 'break_exclusion', @_ ) ); }

# u-em
sub em { return( shift->reset(@_)->_set_get_prop( 'emoji', @_ ) ); }

# u-em
sub emoji { return( shift->reset(@_)->_set_get_prop( 'emoji', @_ ) ); }

sub error
{
    my $self = shift( @_ );
    if( @_ )
    {
        my $msg = join( '', map( ( ref( $_ ) eq 'CODE' ) ? $_->() : $_, @_ ) );
        $self->{error} = $ERROR = Locale::Unicode::Exception->new({
            skip_frames => 1,
            message => $msg,
        });
        if( $self->fatal )
        {
            die( $self->{error} );
        }
        else
        {
            warn( $msg ) if( warnings::enabled() );
            rreturn( Locale::Unicode::NullObject->new ) if( Want::want( 'OBJECT' ) );
            return;
        }
    }
    return( ref( $self ) ? $self->{error} : $ERROR );
}

sub extended { return( shift->reset(@_)->_set_get_prop( 'extended', @_ ) ); }

sub false { return( $Locale::Unicode::Boolean::false ); }

sub fatal { return( shift->_set_get_prop( 'fatal', @_ ) ); }

# u-fw
sub first_day { return( shift->reset(@_)->_set_get_prop( 'first_day', @_ ) ); }

# u-fw
sub fw { return( shift->reset(@_)->_set_get_prop( 'first_day', @_ ) ); }

sub grandfathered
{
    my $self = shift( @_ );
    if( @_ )
    {
        my $val = shift( @_ );
        $self->reset(1);
        if( !defined( $val ) )
        {
            $self->_set_get_prop( 'grandfathered_irregular', undef );
            $self->_set_get_prop( 'grandfathered_regular', undef );
        }
        elsif( $val =~ /^$GRANDFATHERED_IRREGULAR$/ )
        {
            $self->grandfathered_irregular( $val );
        }
        elsif( $val =~ /^$GRANDFATHERED_REGULAR$/ )
        {
            $self->grandfathered_regular( $val );
        }
        else
        {
            warn( "Value provided does not seem to be either a regular or irregular grandfathered language tag." ) if( warnings::enabled() );
        }
    }
    return( $self->_set_get_prop( 'grandfathered_irregular' ) || $self->_set_get_prop( 'grandfathered_regular' ) );
}

sub grandfathered_irregular { return( shift->reset(@_)->_set_get_prop( {
    field => 'grandfathered_irregular',
    on_update => sub
    {
        $_[0]->{language} = undef;
        $_[0]->{language3} = undef;
        $_[0]->{privateuse} = undef;
        $_[0]->{grandfathered_regular} = undef;
    },
}, @_ ) ); }

sub grandfathered_regular { return( shift->reset(@_)->_set_get_prop( {
    field => 'grandfathered_regular',
    on_update => sub
    {
        $_[0]->{language} = undef;
        $_[0]->{language3} = undef;
        $_[0]->{privateuse} = undef;
        $_[0]->{grandfathered_irregular} = undef;
    },
}, @_ ) ); }

# t-h0
sub h0 { return( shift->reset(@_)->_set_get_prop( 'hybrid', @_ ) ); }

# u-hc
sub hc { return( shift->reset(@_)->_set_get_prop( 'hour_cycle', @_ ) ); }

# u-hc
sub hour_cycle { return( shift->reset(@_)->_set_get_prop( 'hour_cycle', @_ ) ); }

# t-h0
sub hybrid { return( shift->reset(@_)->_set_get_prop( 'hybrid', @_ ) ); }

# t-i0
sub i0 { return( shift->reset(@_)->_set_get_prop( 'input', @_ ) ); }

# t-i0
sub input { return( shift->reset(@_)->_set_get_prop( 'input', @_ ) ); }

# t-k0
sub k0 { return( shift->reset(@_)->_set_get_prop( 'keyboard', @_ ) ); }

# u-ka
sub ka { return( shift->colAlternate( @_ ) ); }

# u-kb
sub kb { return( shift->colBackwards( @_ ) ); }

# u-kc
sub kc { return( shift->colCaseLevel( @_ ) ); }

# t-k0
sub keyboard { return( shift->reset(@_)->_set_get_prop( 'keyboard', @_ ) ); }

# u-kf
sub kf { return( shift->colCaseFirst( @_ ) ); }

# u-kh
sub kh { return( shift->colHiraganaQuaternary( @_ ) ); }

# u-kk
sub kk { return( shift->colNormalization( @_ ) ); }

# u-kn
sub kn { return( shift->colNumeric( @_ ) ); }

# u-kr
sub kr { return( shift->colReorder( @_ ) ); }

# u-ks
sub ks { return( shift->colStrength( @_ ) ); }

# u-kv
sub kv { return( shift->colValue( @_ ) ); }

sub lang { return( shift->reset(@_)->_set_get_prop( {
    field => 'language',
    on_update => sub
    {
        $_[0]->{language3} = undef;
        $_[0]->{grandfathered_irregular} = undef;
        $_[0]->{grandfathered_regular} = undef;
        $_[0]->{privateuse} = undef;
    },
}, @_ ) ); }

sub lang3 { return( shift->reset(@_)->_set_get_prop( {
    field => 'language3',
    on_update => sub
    {
        $_[0]->{language} = undef;
        $_[0]->{grandfathered_irregular} = undef;
        $_[0]->{grandfathered_regular} = undef;
        $_[0]->{privateuse} = undef;
    },
}, @_ ) ); }

sub language { return( shift->lang( @_ ) ); }

sub language_extended
{
    my $self = shift( @_ );
    my @parts = ();
    if( my $lang = $self->language )
    {
        push( @parts, $lang );
    }
    elsif( my $lang3 = $self->language3 )
    {
        push( @parts, $lang3 );
    }

    if( my $ext = $self->extended )
    {
        push( @parts, $ext );
    }
    return( join( '-', @parts ) );
}

sub language3 { return( shift->lang3( @_ ) ); }

sub language_id
{
    my $self = shift( @_ );
    if( @_ )
    {
        my $val = shift( @_ );
        if( !defined( $val ) )
        {
            $self->language( undef );
            $self->language3( undef );
        }
        elsif( length( $val ) == 3 )
        {
            $self->language3( $val );
        }
        # Should be a 2-characters language ID, but we are not going to enforce it.
        # This is the responsibility of the developer.
        else
        {
            $self->language( $val );
        }
    }
    return( $self->language || $self->language3 );
}

# u-lb
sub lb { return( shift->reset(@_)->_set_get_prop( 'line_break', @_ ) ); }

# u-lb
sub line_break { return( shift->reset(@_)->_set_get_prop( 'line_break', @_ ) ); }

# u-lw
sub line_break_word { return( shift->reset(@_)->_set_get_prop( 'line_break_word', @_ ) ); }

# NOTE: the term 'locale' is abusive, since a locale is the entire string, and the language is just this part
sub locale { return( shift->reset(@_)->_set_get_prop( 'language', @_ ) ); }

sub locale3 { return( shift->reset(@_)->_set_get_prop( 'language3', @_ ) ); }

# u-lw
sub lw { return( shift->reset(@_)->_set_get_prop( 'line_break_word', @_ ) ); }

# t-m0
sub m0 { return( shift->mechanism( @_ ) ); }

sub matches
{
    my $self = shift( @_ );
    my $lang = shift( @_ ) || return( $self->error( "No language was provided." ) );
    # Required by RFC for parsing
    $lang =~ tr/_/-/;
    # Special language 'root' becomes 'und' for 'undefined'
    # if( substr( lc( $lang ), 0, 5 ) eq 'root-' )
    # {
    #     substr( $lang, 0, 4, 'und' );
    # }
    if( $lang =~ /^$LOCALE_RE$/ )
    {
        my $re = {%+};
        return( $re );
    }
    # Returns false with empty string, but not undef. Undef is reserved for errors
    return( wantarray() ? () : '' );
}

# u-ms
sub measurement { return( shift->reset(@_)->_set_get_prop( 'measurement', @_ ) ); }

# t-m0
sub mechanism { return( shift->reset(@_)->_set_get_prop( 'mechanism', @_ ) ); }

sub merge
{
    my $self = shift( @_ );
    my @locales = @_;
    if( scalar( @_ ) != 1 )
    {
        return( $self->error( "I expected 1 locale, but instead received ", scalar( @locales ), " locales." ) );
    }
    my $other = shift( @locales );
    unless( Scalar::Util::blessed( $other ) &&
            $other->isa( 'Locale::Unicode' ) )
    {
        $other = Locale::Unicode->new( "$other" ) ||
            return( $self->pass_error( Locale::Unicode->error ) );
    }
    my @keys = grep{ exists( $PROP_TO_SUB->{ $_ } ) || $self->can( $_ ) } keys( %$self );
    foreach my $prop ( @keys )
    {
        next if( $prop eq 'variant' );
        if( exists( $other->{ $prop } ) &&
            defined( $other->{ $prop } ) )
        {
            $self->$prop( $other->{ $prop } );
        }
    }
    my $ref;
    if( ( $ref = $other->variants ) &&
        scalar( @$ref ) )
    {
        my $orig = $self->variants;
        if( scalar( @$orig ) )
        {
            # Make sure we have unique keys
            my $uniq = sub
            {
                my %seen;
                grep( !$seen{ $_ }++, @_ );
            };
            my @variants = $uniq->( @$orig, @$ref );
            $self->variant( join( '-', @variants ) );
        }
        else
        {
            my $var = $other->variant;
            $self->variant( $var );
        }
    }
    return( $self );
}

# u-ms
sub ms { return( shift->measurement( @_ ) ); }

# u-mu
sub mu { return( shift->unit( @_ ) ); }

# u-nu
sub nu { return( shift->number( @_ ) ); }

# u-nu
sub number { return( shift->reset(@_)->_set_get_prop( 'number', @_ ) ); }

sub overlong { return( shift->reset(@_)->_set_get_prop( {
    field => 'overlong',
    on_update => sub
    {
        $_[0]->{country_code} = $_[1];
        $_[0]->{region} = undef;
    },
}, @_ ) ); }

sub parse
{
    my $self = shift( @_ );
    my $this = shift( @_ ) || return( $self->error( "No language string was provided." ) );
    my $opts = $self->_get_args_as_hash( @_ );

    my $re = $self->matches( $this );
    return( $self->pass_error ) if( !defined( $opts ) );

    my $info = {};
    # Value provided failed to match the locale regular expression
    return( $info ) if( !$re );
    # "root" is treated as a special unicode_language_subtag
    # <https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier>
    if( exists( $re->{root} ) &&
        defined( $re->{root} ) &&
        length( $re->{root} ) )
    {
        $re->{language} = delete( $re->{root} )
    }
    foreach my $prop ( qw( language language3 extended script country_code region variant privateuse grandfathered_irregular grandfathered_regular overlong ) )
    {
        # the property provided as an option can be undef by design to remove the value
        if( exists( $opts->{ $prop } ) )
        {
            $info->{ $prop } = $opts->{ $prop };
        }
        elsif( exists( $re->{ $prop } ) &&
            defined( $re->{ $prop } ) &&
            length( $re->{ $prop } ) )
        {
            $info->{ $prop } = $re->{ $prop };
        }
    }

    if( exists( $re->{locale_bcp47} ) &&
        defined( $re->{locale_bcp47} ) &&
        length( $re->{locale_bcp47} ) )
    {
        my $offset = length( $re->{locale_bcp47} );
        $offset++ if( substr( $this, $offset, 1 ) eq '-' );
        substr( $this, 0, $offset, '' );
    }

    if( ( exists( $re->{ext_transform} ) &&
          defined( $re->{ext_transform} ) &&
          length( $re->{ext_transform} ) ) ||
        ( exists( $re->{transform_options} ) &&
          defined( $re->{transform_options} ) &&
          length( $re->{transform_options} ) ) )
    {
        my $t;
        if( exists( $re->{ext_transform} ) &&
            defined( $re->{ext_transform} ) )
        {
            my $t_locale = $self->new( $re->{ext_transform_locale} ) ||
                return( $self->pass_error );
            $info->{transform_locale} = $t_locale;
            $t = $re->{ext_transform};
            my $offset = length( "t-${t_locale}" );
            if( length( $re->{ext_transform} ) > $offset &&
                substr( $re->{ext_transform}, $offset, 1 ) eq '-' )
            {
                $offset++;
            }
            substr( $t, 0, $offset, '' );
        }
        elsif( exists( $re->{transform_options} ) &&
               defined( $re->{transform_options} ) )
        {
            $t = $re->{transform_options};
        }
        $info->{transform_ext} = [];
        my @parts = split( /\-?($LOCALE_TRANSFORM_PARAMETERS_RE)\-/, $t );
        # First array element is undef, because it is the beginning of the string.
        shift( @parts );
        for( my $i = 0; $i < scalar( @parts ); $i += 2 )
        {
            my $n = $parts[$i];
            my $v = $parts[$i + 1];
            if( exists( $info->{ $n } ) )
            {
                warn( "The Transform extension \"${n}\" was previously defined with \"", ( $info->{ $n } // 'undef' ), "\", overwriting it with \"", ( $v // 'undef' ), "\"" ) if( warnings::enabled() );
            }
            elsif( !$self->can( $n ) )
            {
                warn( "The Transform extension specified \"${n}\" is unsupported." ) if( warnings::enabled() );
            }
            $info->{ $n } = $v;
            push( @{$info->{transform_ext}}, $n );
        }
    }

    if( ( exists( $re->{ext_unicode} ) &&
          defined( $re->{ext_unicode} ) &&
          length( $re->{ext_unicode} ) ) ||
        ( exists( $re->{collation_options} ) &&
          defined( $re->{collation_options} ) &&
          length( $re->{collation_options} ) ) )
    {
        $info->{unicode_ext} = [];
        # ca, co, cf, cu, etc... or collation options such as: ka, kb, kc, etc.
        # my @parts = split( /\-([a-z]{2})\-/, '-' . ( $re->{ext_unicode_subtag} // $re->{collation_options} ) );
        substr( $re->{ext_unicode}, 0, 1, '' ) if( substr( $re->{ext_unicode}, 0, 2 ) eq 'u-' );
        my @parts = split( /\-([a-z]{2})\-/, ( $re->{ext_unicode} // ( '-' . $re->{collation_options} ) ) );
        shift( @parts );
        for( my $i = 0; $i < scalar( @parts ); $i += 2 )
        {
            my $n = $parts[$i];
            my $v = $parts[$i + 1];
            if( exists( $info->{ $n } ) )
            {
                warn( "The Unicode extension \"${n}\" was previously defined with \"", ( $info->{ $n } // 'undef' ), "\", overwriting it with \"", ( $v // 'undef' ), "\"" ) if( warnings::enabled() );
            }
            elsif( !$self->can( $n ) )
            {
                warn( "The Unicode extension specified \"${n}\" is unsupported." ) if( warnings::enabled() );
            }
            $info->{ $n } = $v;
            push( @{$info->{unicode_ext}}, $n );
        }
    }

    if( exists( $re->{extension} ) &&
        defined( $re->{extension} ) &&
        length( $re->{extension} ) )
    {
        my $tag = $re->{singleton};
        $info->{singleton} = 
        {
            $tag => {},
        };
        $info->{singleton}->{ $tag }->{subtags} = [];
        my @parts = split( /\-([a-zA-Z0-9]{2,8})\-/, $re->{subtag} );
        for( my $i = 0; $i < scalar( @parts ); $i += 2 )
        {
            my $n = $parts[$i];
            my $v = $parts[$i + 1];
            $info->{singleton}->{ $tag }->{ $n } = $v;
            push( @{$info->{singleton}->{ $tag }->{subtags}}, $n );
        }
    }

    if( exists( $re->{private_extension} ) &&
        defined( $re->{private_extension} ) &&
        length( $re->{private_extension} ) )
    {
        $info->{private} = $re->{private_subtag};
    }
    return( $info );
}

sub pass_error
{
    my $self = shift( @_ );
    my $pack = ref( $self ) || $self;
    my $opts = {};
    my( $err, $class, $code );
    no strict 'refs';
    if( scalar( @_ ) )
    {
        # Either an hash defining a new error and this will be passed along to error(); or
        # an hash with a single property: { class => 'Some::ExceptionClass' }
        if( scalar( @_ ) == 1 && ref( $_[0] ) eq 'HASH' )
        {
            $opts = $_[0];
        }
        else
        {
            if( scalar( @_ ) > 1 && ref( $_[-1] ) eq 'HASH' )
            {
                $opts = pop( @_ );
            }
            $err = $_[0];
        }
    }
    $err = $opts->{error} if( !defined( $err ) && CORE::exists( $opts->{error} ) && defined( $opts->{error} ) && CORE::length( $opts->{error} ) );
    # We set $class only if the hash provided is a one-element hash and not an error-defining hash
    $class = $opts->{class} if( CORE::exists( $opts->{class} ) && defined( $opts->{class} ) && CORE::length( $opts->{class} ) );
    $code  = $opts->{code} if( CORE::exists( $opts->{code} ) && defined( $opts->{code} ) && CORE::length( $opts->{code} ) );
    
    # called with no argument, most likely from the same class to pass on an error 
    # set up earlier by another method; or
    # with an hash containing just one argument class => 'Some::ExceptionClass'
    if( !defined( $err ) && ( !scalar( @_ ) || defined( $class ) ) )
    {
        # $error is a previous erro robject
        my $error = ref( $self ) ? $self->{error} : length( ${ $pack . '::ERROR' } ) ? ${ $pack . '::ERROR' } : undef;
        if( !defined( $error ) )
        {
            warn( "No error object provided and no previous error set either! It seems the previous method call returned a simple undef" );
        }
        else
        {
            $err = ( defined( $class ) ? bless( $error => $class ) : $error );
            $err->code( $code ) if( defined( $code ) );
        }
    }
    elsif( defined( $err ) && 
           Scalar::Util::blessed( $err ) && 
           ( scalar( @_ ) == 1 || 
             ( scalar( @_ ) == 2 && defined( $class ) ) 
           ) )
    {
        $self->{error} = ${ $pack . '::ERROR' } = ( defined( $class ) ? bless( $err => $class ) : $err );
        $self->{error}->code( $code ) if( defined( $code ) && $self->{error}->can( 'code' ) );
        
        if( $self->{fatal} || ( defined( ${"${class}\::FATAL_EXCEPTIONS"} ) && ${"${class}\::FATAL_EXCEPTIONS"} ) )
        {
            die( $self->{error} );
        }
    }
    # If the error provided is not an object, we call error to create one
    else
    {
        return( $self->error( @_ ) );
    }
    
    if( Want::want( 'OBJECT' ) )
    {
        rreturn( Locale::Unicode::NullObject->new );
    }
    return;
}

# x-something
sub private { return( shift->reset(@_)->_set_get_prop( 'private', @_ ) ); }

sub privateuse { return( shift->reset(@_)->_set_get_prop( {
    field => 'privateuse',
    on_update => sub
    {
        $_[0]->{language} = undef;
        $_[0]->{language3} = undef;
        $_[0]->{grandfathered_irregular} = undef;
        $_[0]->{grandfathered_regular} = undef;
    },
}, @_ ) ); }

sub region { return( shift->reset(@_)->_set_get_prop({
    field => 'region',
    on_update => sub{ $_[0]->{country_code} = undef; },
}, @_ ) ); }

# u-rg
sub region_override { return( shift->reset(@_)->_set_get_prop( 'region_override', @_ ) ); }

# u-rg
sub rg { return( shift->region_override( @_ ) ); }

sub reset
{
    my $self = shift( @_ );
    if( !CORE::length( $self->{_reset} // '' ) && scalar( @_ ) )
    {
        $self->{_reset} = scalar( @_ );
    }
    return( $self );
}

# t-s0
sub s0 { return( shift->source( @_ ) ); }

sub script { return( shift->reset(@_)->_set_get_prop( 'script', @_ ) ); }

# u-ss
sub sentence_break { return( shift->reset(@_)->_set_get_prop( 'sentence_break', @_ ) ); }

# u-kv
sub shiftedGroup { return( shift->colValue( @_ ) ); }

# t-s0
sub source { return( shift->reset(@_)->_set_get_prop( 'source', @_ ) ); }

# u-sd
sub sd { return( shift->subdivision( @_ ) ); }

# u-ss
sub ss { return( shift->sentence_break( @_ ) ); }

# u-sd
sub subdivision { return( shift->reset(@_)->_set_get_prop( 'subdivision', @_ ) ); }

# t-t0
sub t0 { return( shift->translation( @_ ) ); }

# t-x0
sub t_private { return( shift->reset(@_)->_set_get_prop( 't_private', @_ ) ); }

sub territory
{
    my $self = shift( @_ );
    if( @_ )
    {
        my $val = shift( @_ );
        if( defined( $val ) )
        {
            if( $val =~ /^([a-zA-Z]{2})$/ )
            {
                $self->country_code( uc( $1 ) );
            }
            elsif( $val =~ /^(\d{3})$/ )
            {
                $self->region( $1 );
            }
            else
            {
                return( $self->error( "Invalid value for territory. It must be either a 2-characters ISO3166 code or a 3-digits region code." ) );
            }
        }
        else
        {
            $self->country_code( undef );
            $self->region( undef );
        }
    }
    return( $self->country_code || $self->region );
}

# u-tz
sub time_zone { return( shift->reset(@_)->_set_get_prop( 'time_zone', @_ ) ); }

# u-tz
sub timezone { return( shift->reset(@_)->_set_get_prop( 'time_zone', @_ ) ); }

sub transform
{
    my $self = shift( @_ );
    if( @_ )
    {
        my $val = shift( @_ );
        if( defined( $val ) )
        {
            unless( Scalar::Util::blessed( $val ) && 
                    $val->isa( ref( $self ) || $self ) )
            {
                my $locale = $self->new( $val ) || return( $self->pass_error );
                my $core = $locale->core;
                $locale = $self->new( $core ) unless( $core eq $locale );
                $val = $locale;
            }
        }
        $self->transform_locale( $val );
    }
    return( $self );
}

# t-und-Latn
sub transform_locale { return( shift->reset(@_)->_set_get_prop({
    field => 'transform_locale',
    isa => 'Locale::Unicode',
}, @_ ) ); }

# t-t0
sub translation { return( shift->reset(@_)->_set_get_prop( 'translation', @_ ) ); }

sub true { return( $Locale::Unicode::Boolean::true ); }

# u-tz
sub tz { return( shift->time_zone( @_ ) ); }

# Returns an Olson IANA time zone name as a string for a given CLDR timezone ID
sub tz_id2name
{
    my $self = shift( @_ );
    my $id = shift( @_ ) || return( $self->error( "No CLDR timezone ID was provided." ) );
    my $def = $self->tz_info( $id ) || return( '' );
    if( !defined( $def->{tz} ) ||
        !length( $def->{tz} // '' ) )
    {
        return( $self->error( "No property 'tz' could be found in our database for CLDR timezone ID '$id'. It seems our database is corrupted." ) );
    }
    return( $def->{tz} );
}

# Returns an array object of Olson IANA time zones for a given CLDR timezone ID
sub tz_id2names
{
    my $self = shift( @_ );
    my $id = shift( @_ ) || return( $self->error( "No CLDR timezone ID was provided." ) );
    my $a = [];
    my $def = $self->tz_info( $id );
    if( !defined( $def ) )
    {
        return( $self->pass_error );
    }
    elsif( !$def )
    {
        return( $a );
    }
    push( @$a, @{$def->{alias}} ) if( exists( $def->{alias} ) && ( ref( $def->{alias} ) || '' ) eq 'ARRAY' );
    return( $a );
}

sub tz_info
{
    my $self = shift( @_ );
    my $id = shift( @_ ) || return( $self->error( "No CLDR timezone ID was provided." ) );
    $id = lc( $id );
    return( '' ) if( !exists( $TZ_DICT->{ $id } ) );
    my %ref = %{$TZ_DICT->{ $id }};
    return( \%ref );
}

# Returns a CLDR timezone ID for a given IANA Olson timezone name
sub tz_name2id
{
    my $self = shift( @_ );
    my $name = shift( @_ ) || return( $self->error( "No CLDR timezone ID was provided." ) );
    if( !exists( $TZ_NAME2ID->{ $name } ) ||
        !defined( $TZ_NAME2ID->{ $name } ) ||
        !length( $TZ_NAME2ID->{ $name } // '' ) )
    {
        return( '' );
    }
    return( $TZ_NAME2ID->{ $name } );
}

# u-mu
sub unit { return( shift->reset(@_)->_set_get_prop( 'unit', @_ ) ); }

# u-va
sub va { return( shift->reset(@_)->_set_get_prop( 'va', @_ ) ); }

# u-va
sub variant { return( shift->reset(@_)->_set_get_prop( 'variant', @_ ) ); }

sub variants
{
    my $self = shift( @_ );
    my $variants = [];
    if( my $variant = $self->variant )
    {
        $variants = [split( /-/, $variant )];
    }
    return( $variants );
}

# u-vt
sub vt { return( shift->colVariableTop( @_ ) ); }

# t-x0
sub x0 { return( shift->t_private( @_ ) ); }

sub _set_get_prop
{
    my $self = shift( @_ );
    my $field = shift( @_ ) ||
        return( $self->error( "No field was provided." ) );
    my( $re, $type, $isa, $on_update );
    if( ref( $field ) eq 'HASH' )
    {
        my $def = $field;
        $field = $def->{field} || die( "No 'field' property was provided in the field dictionary hash reference." );
        if( exists( $def->{regexp} ) &&
            defined( $def->{regexp} ) &&
            ref( $def->{regexp} ) eq 'Regexp' )
        {
            $re = $def->{regexp};
        }
        elsif( exists( $def->{type} ) &&
               defined( $def->{type} ) &&
               length( $def->{type} ) )
        {
            $type = $def->{type};
        }
        if( exists( $def->{isa} ) &&
            defined( $def->{isa} ) &&
            length( $def->{isa} ) )
        {
            $isa = $def->{isa};
        }
        if( exists( $def->{on_update} ) &&
            defined( $def->{on_update} ) &&
            ref( $def->{on_update} ) eq 'CODE' )
        {
            $on_update = $def->{on_update};
        }
    }
    if( @_ )
    {
        my $val = shift( @_ );
        if( defined( $val ) &&
            length( $val ) )
        {
            if( defined( $re ) &&
                $val !~ /^$re$/ )
            {
                return( $self->error( "Invalid value provided for \"${field}\": ${val}" ) );
            }
            elsif( defined( $type ) &&
                   $type eq 'boolean' )
            {
                $val = lc( $val );
                if( $val =~ /^(?:yes|no)$/i )
                {
                    $self->{_bool_types}->{ $field } = 'literal';
                    $val = ( $val eq 'yes' ? $self->true : $self->false );
                }
                elsif( $val =~ /^(?:true|false)$/i )
                {
                    $self->{_bool_types}->{ $field } = 'logic';
                    $val = ( $val eq 'true' ? $self->true : $self->false );
                }
                elsif( $val =~ /^(?:1|0)$/ )
                {
                    $self->{_bool_types}->{ $field } = 'logic';
                    $val = ( $val ? $self->true : $self->false );
                }
                else
                {
                    warn( "Unexpected value used as boolean for attribute \"${field}\": ${val}" ) if( warnings::enabled() );
                    $val = ( $val ? $self->true : $self->false );
                }
            }
            elsif( defined( $isa ) )
            {
                if( !Scalar::Util::blessed( $val ) ||
                    ( Scalar::Util::blessed( $val ) && !$val->isa( $isa ) ) )
                {
                    return( $self->error( "Value provided is not an ${isa} object." ) );
                }
            }

            if( defined( $on_update ) )
            {
                local $@;
                eval{ $on_update->( $self, $val ) };
                if( $@ )
                {
                    return( $self->error( "Error setting value \"${val}\" for \"{field}\": $@" ) );
                }
            }
        }
        $self->{ $field } = $val
    }
    # So chaining works
    rreturn( $self ) if( Want::want( 'OBJECT' ) );
    # Returns undef in scalar context and an empty list in list context
    return if( !defined( $self->{ $field } ) );
    return( $self->{ $field } );
}

sub _get_args_as_hash
{
    my $self = shift( @_ );
    my $ref = {};
    if( scalar( @_ ) == 1 &&
        defined( $_[0] ) &&
        ( ref( $_[0] ) || '' ) eq 'HASH' )
    {
        $ref = shift( @_ );
    }
    elsif( !( scalar( @_ ) % 2 ) )
    {
        $ref = { @_ };
    }
    else
    {
        die( "Uneven number of parameters provided." );
    }
    return( $ref );
}

{
    # NOTE: $TZ_DICT
    $TZ_DICT =
    {
        adalv => { desc => "Andorra", tz => "Europe/Andorra" },
        aedxb => { desc => "Dubai, United Arab Emirates", tz => "Asia/Dubai" },
        afkbl => { desc => "Kabul, Afghanistan", tz => "Asia/Kabul" },
        aganu => { desc => "Antigua", tz => "America/Antigua" },
        aiaxa => { desc => "Anguilla", tz => "America/Anguilla" },
        altia => { desc => "Tirane, Albania", tz => "Europe/Tirane" },
        amevn => { desc => "Yerevan, Armenia", tz => "Asia/Yerevan" },
        ancur => { desc => "Cura\xE7ao", tz => "America/Curacao" },
        aolad => { desc => "Luanda, Angola", tz => "Africa/Luanda" },
        aqams => {
            deprecated => 1,
            desc => "Amundsen-Scott Station, South Pole",
            preferred => "nzakl",
        },
        aqcas => { desc => "Casey Station, Bailey Peninsula", tz => "Antarctica/Casey" },
        aqdav => { desc => "Davis Station, Vestfold Hills", tz => "Antarctica/Davis" },
        aqddu => {
            desc => "Dumont d'Urville Station, Terre Ad\xE9lie",
            tz => "Antarctica/DumontDUrville",
        },
        aqmaw => { desc => "Mawson Station, Holme Bay", tz => "Antarctica/Mawson" },
        aqmcm => { desc => "McMurdo Station, Ross Island", tz => "Antarctica/McMurdo" },
        aqplm => { desc => "Palmer Station, Anvers Island", tz => "Antarctica/Palmer" },
        aqrot => {
            desc => "Rothera Station, Adelaide Island",
            tz => "Antarctica/Rothera",
        },
        aqsyw => {
            desc => "Syowa Station, East Ongul Island",
            tz => "Antarctica/Syowa",
        },
        aqtrl => { desc => "Troll Station, Queen Maud Land", tz => "Antarctica/Troll" },
        aqvos => { desc => "Vostok Station, Lake Vostok", tz => "Antarctica/Vostok" },
        arbue => {
            alias => [qw( America/Buenos_Aires America/Argentina/Buenos_Aires )],
            desc => "Buenos Aires, Argentina",
            tz => "America/Argentina/Buenos_Aires",
        },
        arcor => {
            alias => [qw( America/Cordoba America/Argentina/Cordoba America/Rosario )],
            desc => "C\xF3rdoba, Argentina",
            tz => "America/Argentina/Cordoba",
        },
        arctc => {
            alias => [qw(
                America/Catamarca America/Argentina/Catamarca
                America/Argentina/ComodRivadavia
            )],
            desc => "Catamarca, Argentina",
            tz => "America/Argentina/Catamarca",
        },
        arirj => { desc => "La Rioja, Argentina", tz => "America/Argentina/La_Rioja" },
        arjuj => {
            alias => [qw( America/Jujuy America/Argentina/Jujuy )],
            desc => "Jujuy, Argentina",
            tz => "America/Argentina/Jujuy",
        },
        arluq => { desc => "San Luis, Argentina", tz => "America/Argentina/San_Luis" },
        armdz => {
            alias => [qw( America/Mendoza America/Argentina/Mendoza )],
            desc => "Mendoza, Argentina",
            tz => "America/Argentina/Mendoza",
        },
        arrgl => {
            desc => "R\xEDo Gallegos, Argentina",
            tz => "America/Argentina/Rio_Gallegos",
        },
        arsla => { desc => "Salta, Argentina", tz => "America/Argentina/Salta" },
        artuc => { desc => "Tucum\xE1n, Argentina", tz => "America/Argentina/Tucuman" },
        aruaq => { desc => "San Juan, Argentina", tz => "America/Argentina/San_Juan" },
        arush => { desc => "Ushuaia, Argentina", tz => "America/Argentina/Ushuaia" },
        asppg => {
            alias => [qw( Pacific/Pago_Pago Pacific/Samoa US/Samoa )],
            desc => "Pago Pago, American Samoa",
            tz => "Pacific/Pago_Pago",
        },
        atvie => { desc => "Vienna, Austria", tz => "Europe/Vienna" },
        auadl => {
            alias => [qw( Australia/Adelaide Australia/South )],
            desc => "Adelaide, Australia",
            tz => "Australia/Adelaide",
        },
        aubhq => {
            alias => [qw( Australia/Broken_Hill Australia/Yancowinna )],
            desc => "Broken Hill, Australia",
            tz => "Australia/Broken_Hill",
        },
        aubne => {
            alias => [qw( Australia/Brisbane Australia/Queensland )],
            desc => "Brisbane, Australia",
            tz => "Australia/Brisbane",
        },
        audrw => {
            alias => [qw( Australia/Darwin Australia/North )],
            desc => "Darwin, Australia",
            tz => "Australia/Darwin",
        },
        aueuc => { desc => "Eucla, Australia", tz => "Australia/Eucla" },
        auhba => {
            alias => [qw( Australia/Hobart Australia/Tasmania Australia/Currie )],
            desc => "Hobart, Australia",
            tz => "Australia/Hobart",
        },
        aukns => { deprecated => 1, desc => "Currie, Australia", preferred => "auhba" },
        auldc => { desc => "Lindeman Island, Australia", tz => "Australia/Lindeman" },
        auldh => {
            alias => [qw( Australia/Lord_Howe Australia/LHI )],
            desc => "Lord Howe Island, Australia",
            tz => "Australia/Lord_Howe",
        },
        aumel => {
            alias => [qw( Australia/Melbourne Australia/Victoria )],
            desc => "Melbourne, Australia",
            tz => "Australia/Melbourne",
        },
        aumqi => {
            desc => "Macquarie Island Station, Macquarie Island",
            tz => "Antarctica/Macquarie",
        },
        auper => {
            alias => [qw( Australia/Perth Australia/West )],
            desc => "Perth, Australia",
            tz => "Australia/Perth",
        },
        ausyd => {
            alias => [qw(
                Australia/Sydney Australia/ACT Australia/Canberra
                Australia/NSW
            )],
            desc => "Sydney, Australia",
            tz => "Australia/Sydney",
        },
        awaua => { desc => "Aruba", tz => "America/Aruba" },
        azbak => { desc => "Baku, Azerbaijan", tz => "Asia/Baku" },
        basjj => { desc => "Sarajevo, Bosnia and Herzegovina", tz => "Europe/Sarajevo" },
        bbbgi => { desc => "Barbados", tz => "America/Barbados" },
        bddac => {
            alias => [qw( Asia/Dhaka Asia/Dacca )],
            desc => "Dhaka, Bangladesh",
            tz => "Asia/Dhaka",
        },
        bebru => { desc => "Brussels, Belgium", tz => "Europe/Brussels" },
        bfoua => { desc => "Ouagadougou, Burkina Faso", tz => "Africa/Ouagadougou" },
        bgsof => { desc => "Sofia, Bulgaria", tz => "Europe/Sofia" },
        bhbah => { desc => "Bahrain", tz => "Asia/Bahrain" },
        bibjm => { desc => "Bujumbura, Burundi", tz => "Africa/Bujumbura" },
        bjptn => { desc => "Porto-Novo, Benin", tz => "Africa/Porto-Novo" },
        bmbda => { desc => "Bermuda", tz => "Atlantic/Bermuda" },
        bnbwn => { desc => "Brunei", tz => "Asia/Brunei" },
        bolpb => { desc => "La Paz, Bolivia", tz => "America/La_Paz" },
        bqkra => {
            desc => "Bonaire, Sint Estatius and Saba",
            tz => "America/Kralendijk",
        },
        braux => { desc => "Aragua\xEDna, Brazil", tz => "America/Araguaina" },
        brbel => { desc => "Bel\xE9m, Brazil", tz => "America/Belem" },
        brbvb => { desc => "Boa Vista, Brazil", tz => "America/Boa_Vista" },
        brcgb => { desc => "Cuiab\xE1, Brazil", tz => "America/Cuiaba" },
        brcgr => { desc => "Campo Grande, Brazil", tz => "America/Campo_Grande" },
        brern => { desc => "Eirunep\xE9, Brazil", tz => "America/Eirunepe" },
        brfen => {
            alias => [qw( America/Noronha Brazil/DeNoronha )],
            desc => "Fernando de Noronha, Brazil",
            tz => "America/Noronha",
        },
        brfor => { desc => "Fortaleza, Brazil", tz => "America/Fortaleza" },
        brmao => {
            alias => [qw( America/Manaus Brazil/West )],
            desc => "Manaus, Brazil",
            tz => "America/Manaus",
        },
        brmcz => { desc => "Macei\xF3, Brazil", tz => "America/Maceio" },
        brpvh => { desc => "Porto Velho, Brazil", tz => "America/Porto_Velho" },
        brrbr => {
            alias => [qw( America/Rio_Branco America/Porto_Acre Brazil/Acre )],
            desc => "Rio Branco, Brazil",
            tz => "America/Rio_Branco",
        },
        brrec => { desc => "Recife, Brazil", tz => "America/Recife" },
        brsao => {
            alias => [qw( America/Sao_Paulo Brazil/East )],
            desc => "S\xE3o Paulo, Brazil",
            tz => "America/Sao_Paulo",
        },
        brssa => { desc => "Bahia, Brazil", tz => "America/Bahia" },
        brstm => { desc => "Santar\xE9m, Brazil", tz => "America/Santarem" },
        bsnas => { desc => "Nassau, Bahamas", tz => "America/Nassau" },
        btthi => {
            alias => [qw( Asia/Thimphu Asia/Thimbu )],
            desc => "Thimphu, Bhutan",
            tz => "Asia/Thimphu",
        },
        bwgbe => { desc => "Gaborone, Botswana", tz => "Africa/Gaborone" },
        bymsq => { desc => "Minsk, Belarus", tz => "Europe/Minsk" },
        bzbze => { desc => "Belize", tz => "America/Belize" },
        cacfq => { desc => "Creston, Canada", tz => "America/Creston" },
        caedm => {
            alias => [qw( America/Edmonton Canada/Mountain America/Yellowknife )],
            desc => "Edmonton, Canada",
            tz => "America/Edmonton",
        },
        caffs => { deprecated => 1, desc => "Rainy River, Canada", preferred => "cawnp" },
        cafne => { desc => "Fort Nelson, Canada", tz => "America/Fort_Nelson" },
        caglb => { desc => "Glace Bay, Canada", tz => "America/Glace_Bay" },
        cagoo => { desc => "Goose Bay, Canada", tz => "America/Goose_Bay" },
        cahal => {
            alias => [qw( America/Halifax Canada/Atlantic )],
            desc => "Halifax, Canada",
            tz => "America/Halifax",
        },
        caiql => {
            alias => [qw( America/Iqaluit America/Pangnirtung )],
            desc => "Iqaluit, Canada",
            tz => "America/Iqaluit",
        },
        camon => { desc => "Moncton, Canada", tz => "America/Moncton" },
        camtr => { deprecated => 1, desc => "Montreal, Canada", preferred => "cator" },
        canpg => { deprecated => 1, desc => "Nipigon, Canada", preferred => "cator" },
        capnt => { deprecated => 1, desc => "Pangnirtung, Canada", preferred => "caiql" },
        careb => { desc => "Resolute, Canada", tz => "America/Resolute" },
        careg => {
            alias => [qw( America/Regina Canada/East-Saskatchewan Canada/Saskatchewan )],
            desc => "Regina, Canada",
            tz => "America/Regina",
        },
        casjf => {
            alias => [qw( America/St_Johns Canada/Newfoundland )],
            desc => "St. John's, Canada",
            tz => "America/St_Johns",
        },
        cathu => { deprecated => 1, desc => "Thunder Bay, Canada", preferred => "cator" },
        cator => {
            alias => [qw(
                America/Toronto America/Montreal Canada/Eastern
                America/Nipigon America/Thunder_Bay
            )],
            desc => "Toronto, Canada",
            tz => "America/Toronto",
        },
        cavan => {
            alias => [qw( America/Vancouver Canada/Pacific )],
            desc => "Vancouver, Canada",
            tz => "America/Vancouver",
        },
        cawnp => {
            alias => [qw( America/Winnipeg Canada/Central America/Rainy_River )],
            desc => "Winnipeg, Canada",
            tz => "America/Winnipeg",
        },
        caybx => { desc => "Blanc-Sablon, Canada", tz => "America/Blanc-Sablon" },
        caycb => { desc => "Cambridge Bay, Canada", tz => "America/Cambridge_Bay" },
        cayda => { desc => "Dawson, Canada", tz => "America/Dawson" },
        caydq => { desc => "Dawson Creek, Canada", tz => "America/Dawson_Creek" },
        cayek => { desc => "Rankin Inlet, Canada", tz => "America/Rankin_Inlet" },
        cayev => { desc => "Inuvik, Canada", tz => "America/Inuvik" },
        cayxy => {
            alias => [qw( America/Whitehorse Canada/Yukon )],
            desc => "Whitehorse, Canada",
            tz => "America/Whitehorse",
        },
        cayyn => { desc => "Swift Current, Canada", tz => "America/Swift_Current" },
        cayzf => { deprecated => 1, desc => "Yellowknife, Canada", preferred => "caedm" },
        cayzs => {
            alias => [qw( America/Coral_Harbour America/Atikokan )],
            desc => "Atikokan, Canada",
            tz => "America/Atikokan",
        },
        cccck => { desc => "Cocos (Keeling) Islands", tz => "Indian/Cocos" },
        cdfbm => {
            desc => "Lubumbashi, Democratic Republic of the Congo",
            tz => "Africa/Lubumbashi",
        },
        cdfih => {
            desc => "Kinshasa, Democratic Republic of the Congo",
            tz => "Africa/Kinshasa",
        },
        cfbgf => { desc => "Bangui, Central African Republic", tz => "Africa/Bangui" },
        cgbzv => {
            desc => "Brazzaville, Republic of the Congo",
            tz => "Africa/Brazzaville",
        },
        chzrh => { desc => "Zurich, Switzerland", tz => "Europe/Zurich" },
        ciabj => { desc => "Abidjan, C\xF4te d'Ivoire", tz => "Africa/Abidjan" },
        ckrar => { desc => "Rarotonga, Cook Islands", tz => "Pacific/Rarotonga" },
        clipc => {
            alias => [qw( Pacific/Easter Chile/EasterIsland )],
            desc => "Easter Island, Chile",
            tz => "Pacific/Easter",
        },
        clpuq => { desc => "Punta Arenas, Chile", tz => "America/Punta_Arenas" },
        clscl => {
            alias => [qw( America/Santiago Chile/Continental )],
            desc => "Santiago, Chile",
            tz => "America/Santiago",
        },
        cmdla => { desc => "Douala, Cameroon", tz => "Africa/Douala" },
        cnckg => { deprecated => 1, desc => "Chongqing, China", preferred => "cnsha" },
        cnhrb => { deprecated => 1, desc => "Harbin, China", preferred => "cnsha" },
        cnkhg => { deprecated => 1, desc => "Kashgar, China", preferred => "cnurc" },
        cnsha => {
            alias => [qw( Asia/Shanghai Asia/Chongqing Asia/Chungking Asia/Harbin PRC )],
            desc => "Shanghai, China",
            tz => "Asia/Shanghai",
        },
        cnurc => {
            alias => [qw( Asia/Urumqi Asia/Kashgar )],
            desc => "\xDCr\xFCmqi, China",
            tz => "Asia/Urumqi",
        },
        cobog => { desc => "Bogot\xE1, Colombia", tz => "America/Bogota" },
        crsjo => { desc => "Costa Rica", tz => "America/Costa_Rica" },
        cst6cdt => {
            desc => "POSIX style time zone for US Central Time",
            tz => "CST6CDT",
        },
        cuhav => {
            alias => [qw( America/Havana Cuba )],
            desc => "Havana, Cuba",
            tz => "America/Havana",
        },
        cvrai => { desc => "Cape Verde", tz => "Atlantic/Cape_Verde" },
        cxxch => { desc => "Christmas Island", tz => "Indian/Christmas" },
        cyfmg => { desc => "Famagusta, Cyprus", tz => "Asia/Famagusta" },
        cynic => {
            alias => [qw( Asia/Nicosia Europe/Nicosia )],
            desc => "Nicosia, Cyprus",
            tz => "Asia/Nicosia",
        },
        czprg => { desc => "Prague, Czech Republic", tz => "Europe/Prague" },
        deber => { desc => "Berlin, Germany", tz => "Europe/Berlin" },
        debsngn => { desc => "Busingen, Germany", tz => "Europe/Busingen" },
        deprecated => 1,
        djjib => { desc => "Djibouti", tz => "Africa/Djibouti" },
        dkcph => { desc => "Copenhagen, Denmark", tz => "Europe/Copenhagen" },
        dmdom => { desc => "Dominica", tz => "America/Dominica" },
        dosdq => {
            desc => "Santo Domingo, Dominican Republic",
            tz => "America/Santo_Domingo",
        },
        dzalg => { desc => "Algiers, Algeria", tz => "Africa/Algiers" },
        ecgps => { desc => "Gal\xE1pagos Islands, Ecuador", tz => "Pacific/Galapagos" },
        ecgye => { desc => "Guayaquil, Ecuador", tz => "America/Guayaquil" },
        eetll => { desc => "Tallinn, Estonia", tz => "Europe/Tallinn" },
        egcai => {
            alias => [qw( Africa/Cairo Egypt )],
            desc => "Cairo, Egypt",
            tz => "Africa/Cairo",
        },
        eheai => { desc => "El Aai\xFAn, Western Sahara", tz => "Africa/El_Aaiun" },
        erasm => {
            alias => [qw( Africa/Asmera Africa/Asmara )],
            desc => "Asmara, Eritrea",
            tz => "Africa/Asmara",
        },
        esceu => { desc => "Ceuta, Spain", tz => "Africa/Ceuta" },
        eslpa => { desc => "Canary Islands, Spain", tz => "Atlantic/Canary" },
        esmad => { desc => "Madrid, Spain", tz => "Europe/Madrid" },
        est5edt => {
            desc => "POSIX style time zone for US Eastern Time",
            tz => "EST5EDT",
        },
        etadd => { desc => "Addis Ababa, Ethiopia", tz => "Africa/Addis_Ababa" },
        fihel => { desc => "Helsinki, Finland", tz => "Europe/Helsinki" },
        fimhq => { desc => "Mariehamn, \xC5land, Finland", tz => "Europe/Mariehamn" },
        fjsuv => { desc => "Fiji", tz => "Pacific/Fiji" },
        fkpsy => { desc => "Stanley, Falkland Islands", tz => "Atlantic/Stanley" },
        fmksa => { desc => "Kosrae, Micronesia", tz => "Pacific/Kosrae" },
        fmpni => {
            alias => [qw( Pacific/Ponape Pacific/Pohnpei )],
            desc => "Pohnpei, Micronesia",
            tz => "Pacific/Pohnpei",
        },
        fmtkk => {
            alias => [qw( Pacific/Truk Pacific/Chuuk Pacific/Yap )],
            desc => "Chuuk, Micronesia",
            tz => "Pacific/Chuuk",
        },
        fotho => {
            alias => [qw( Atlantic/Faeroe Atlantic/Faroe )],
            desc => "Faroe Islands",
            tz => "Atlantic/Faroe",
        },
        frpar => { desc => "Paris, France", tz => "Europe/Paris" },
        galbv => { desc => "Libreville, Gabon", tz => "Africa/Libreville" },
        gaza => {
            deprecated => 1,
            desc => "Gaza Strip, Palestinian Territories",
            preferred => "gazastrp",
        },
        gazastrp => { desc => "Gaza Strip, Palestinian Territories", tz => "Asia/Gaza" },
        gblon => {
            alias => [qw( Europe/London Europe/Belfast GB GB-Eire )],
            desc => "London, United Kingdom",
            tz => "Europe/London",
        },
        gdgnd => { desc => "Grenada", tz => "America/Grenada" },
        getbs => { desc => "Tbilisi, Georgia", tz => "Asia/Tbilisi" },
        gfcay => { desc => "Cayenne, French Guiana", tz => "America/Cayenne" },
        gggci => { desc => "Guernsey", tz => "Europe/Guernsey" },
        ghacc => { desc => "Accra, Ghana", tz => "Africa/Accra" },
        gigib => { desc => "Gibraltar", tz => "Europe/Gibraltar" },
        gldkshvn => { desc => "Danmarkshavn, Greenland", tz => "America/Danmarkshavn" },
        glgoh => {
            alias => [qw( America/Godthab America/Nuuk )],
            desc => "Nuuk (Godth\xE5b), Greenland",
            tz => "America/Nuuk",
        },
        globy => {
            desc => "Ittoqqortoormiit (Scoresbysund), Greenland",
            tz => "America/Scoresbysund",
        },
        glthu => { desc => "Qaanaaq (Thule), Greenland", tz => "America/Thule" },
        gmbjl => { desc => "Banjul, Gambia", tz => "Africa/Banjul" },
        gmt => {
            alias => [qw(
                Etc/GMT Etc/GMT+0 Etc/GMT-0 Etc/GMT0 Etc/Greenwich GMT
                GMT+0 GMT-0 GMT0 Greenwich
            )],
            desc => "Greenwich Mean Time",
            tz => "Etc/GMT",
        },
        gncky => { desc => "Conakry, Guinea", tz => "Africa/Conakry" },
        gpbbr => { desc => "Guadeloupe", tz => "America/Guadeloupe" },
        gpmsb => { desc => "Marigot, Saint Martin", tz => "America/Marigot" },
        gpsbh => { desc => "Saint Barth\xE9lemy", tz => "America/St_Barthelemy" },
        gqssg => { desc => "Malabo, Equatorial Guinea", tz => "Africa/Malabo" },
        grath => { desc => "Athens, Greece", tz => "Europe/Athens" },
        gsgrv => {
            desc => "South Georgia and the South Sandwich Islands",
            tz => "Atlantic/South_Georgia",
        },
        gtgua => { desc => "Guatemala", tz => "America/Guatemala" },
        gugum => { desc => "Guam", tz => "Pacific/Guam" },
        gwoxb => { desc => "Bissau, Guinea-Bissau", tz => "Africa/Bissau" },
        gygeo => { desc => "Guyana", tz => "America/Guyana" },
        hebron => { desc => "West Bank, Palestinian Territories", tz => "Asia/Hebron" },
        hkhkg => {
            alias => [qw( Asia/Hong_Kong Hongkong )],
            desc => "Hong Kong SAR China",
            tz => "Asia/Hong_Kong",
        },
        hntgu => { desc => "Tegucigalpa, Honduras", tz => "America/Tegucigalpa" },
        hrzag => { desc => "Zagreb, Croatia", tz => "Europe/Zagreb" },
        htpap => { desc => "Port-au-Prince, Haiti", tz => "America/Port-au-Prince" },
        hubud => { desc => "Budapest, Hungary", tz => "Europe/Budapest" },
        iddjj => { desc => "Jayapura, Indonesia", tz => "Asia/Jayapura" },
        idjkt => { desc => "Jakarta, Indonesia", tz => "Asia/Jakarta" },
        idmak => {
            alias => [qw( Asia/Makassar Asia/Ujung_Pandang )],
            desc => "Makassar, Indonesia",
            tz => "Asia/Makassar",
        },
        idpnk => { desc => "Pontianak, Indonesia", tz => "Asia/Pontianak" },
        iedub => {
            alias => [qw( Europe/Dublin Eire )],
            desc => "Dublin, Ireland",
            tz => "Europe/Dublin",
        },
        imdgs => { desc => "Isle of Man", tz => "Europe/Isle_of_Man" },
        inccu => {
            alias => [qw( Asia/Calcutta Asia/Kolkata )],
            desc => "Kolkata, India",
            tz => "Asia/Kolkata",
        },
        iodga => { desc => "Chagos Archipelago", tz => "Indian/Chagos" },
        iqbgw => { desc => "Baghdad, Iraq", tz => "Asia/Baghdad" },
        irthr => {
            alias => [qw( Asia/Tehran Iran )],
            desc => "Tehran, Iran",
            tz => "Asia/Tehran",
        },
        isrey => {
            alias => [qw( Atlantic/Reykjavik Iceland )],
            desc => "Reykjavik, Iceland",
            tz => "Atlantic/Reykjavik",
        },
        itrom => { desc => "Rome, Italy", tz => "Europe/Rome" },
        jeruslm => {
            alias => [qw( Asia/Jerusalem Asia/Tel_Aviv Israel )],
            desc => "Jerusalem",
            tz => "Asia/Jerusalem",
        },
        jesth => { desc => "Jersey", tz => "Europe/Jersey" },
        jmkin => {
            alias => [qw( America/Jamaica Jamaica )],
            desc => "Jamaica",
            tz => "America/Jamaica",
        },
        joamm => { desc => "Amman, Jordan", tz => "Asia/Amman" },
        jptyo => {
            alias => [qw( Asia/Tokyo Japan )],
            desc => "Tokyo, Japan",
            tz => "Asia/Tokyo",
        },
        kenbo => { desc => "Nairobi, Kenya", tz => "Africa/Nairobi" },
        kgfru => { desc => "Bishkek, Kyrgyzstan", tz => "Asia/Bishkek" },
        khpnh => { desc => "Phnom Penh, Cambodia", tz => "Asia/Phnom_Penh" },
        kicxi => { desc => "Kiritimati, Kiribati", tz => "Pacific/Kiritimati" },
        kipho => {
            alias => [qw( Pacific/Enderbury Pacific/Kanton )],
            desc => "Enderbury Island, Kiribati",
            tz => "Pacific/Kanton",
        },
        kitrw => { desc => "Tarawa, Kiribati", tz => "Pacific/Tarawa" },
        kmyva => { desc => "Comoros", tz => "Indian/Comoro" },
        knbas => { desc => "Saint Kitts", tz => "America/St_Kitts" },
        kpfnj => { desc => "Pyongyang, North Korea", tz => "Asia/Pyongyang" },
        krsel => {
            alias => [qw( Asia/Seoul ROK )],
            desc => "Seoul, South Korea",
            tz => "Asia/Seoul",
        },
        kwkwi => { desc => "Kuwait", tz => "Asia/Kuwait" },
        kygec => { desc => "Cayman Islands", tz => "America/Cayman" },
        kzaau => { desc => "Aqtau, Kazakhstan", tz => "Asia/Aqtau" },
        kzakx => { desc => "Aqtobe, Kazakhstan", tz => "Asia/Aqtobe" },
        kzala => { desc => "Almaty, Kazakhstan", tz => "Asia/Almaty" },
        kzguw => { desc => "Atyrau (Guryev), Kazakhstan", tz => "Asia/Atyrau" },
        kzksn => { desc => "Qostanay (Kostanay), Kazakhstan", tz => "Asia/Qostanay" },
        kzkzo => { desc => "Kyzylorda, Kazakhstan", tz => "Asia/Qyzylorda" },
        kzura => { desc => "Oral, Kazakhstan", tz => "Asia/Oral" },
        lavte => { desc => "Vientiane, Laos", tz => "Asia/Vientiane" },
        lbbey => { desc => "Beirut, Lebanon", tz => "Asia/Beirut" },
        lccas => { desc => "Saint Lucia", tz => "America/St_Lucia" },
        livdz => { desc => "Vaduz, Liechtenstein", tz => "Europe/Vaduz" },
        lkcmb => { desc => "Colombo, Sri Lanka", tz => "Asia/Colombo" },
        lrmlw => { desc => "Monrovia, Liberia", tz => "Africa/Monrovia" },
        lsmsu => { desc => "Maseru, Lesotho", tz => "Africa/Maseru" },
        ltvno => { desc => "Vilnius, Lithuania", tz => "Europe/Vilnius" },
        lulux => { desc => "Luxembourg", tz => "Europe/Luxembourg" },
        lvrix => { desc => "Riga, Latvia", tz => "Europe/Riga" },
        lytip => {
            alias => [qw( Africa/Tripoli Libya )],
            desc => "Tripoli, Libya",
            tz => "Africa/Tripoli",
        },
        macas => { desc => "Casablanca, Morocco", tz => "Africa/Casablanca" },
        mcmon => { desc => "Monaco", tz => "Europe/Monaco" },
        mdkiv => {
            alias => [qw( Europe/Chisinau Europe/Tiraspol )],
            desc => "Chi\x{15F}in\x{103}u, Moldova",
            tz => "Europe/Chisinau",
        },
        metgd => { desc => "Podgorica, Montenegro", tz => "Europe/Podgorica" },
        mgtnr => { desc => "Antananarivo, Madagascar", tz => "Indian/Antananarivo" },
        mhkwa => {
            alias => [qw( Pacific/Kwajalein Kwajalein )],
            desc => "Kwajalein, Marshall Islands",
            tz => "Pacific/Kwajalein",
        },
        mhmaj => { desc => "Majuro, Marshall Islands", tz => "Pacific/Majuro" },
        mkskp => { desc => "Skopje, Macedonia", tz => "Europe/Skopje" },
        mlbko => {
            alias => [qw( Africa/Bamako Africa/Timbuktu )],
            desc => "Bamako, Mali",
            tz => "Africa/Bamako",
        },
        mmrgn => {
            alias => [qw( Asia/Rangoon Asia/Yangon )],
            desc => "Yangon (Rangoon), Burma",
            tz => "Asia/Yangon",
        },
        mncoq => { desc => "Choibalsan, Mongolia", tz => "Asia/Choibalsan" },
        mnhvd => { desc => "Khovd (Hovd), Mongolia", tz => "Asia/Hovd" },
        mnuln => {
            alias => [qw( Asia/Ulaanbaatar Asia/Ulan_Bator )],
            desc => "Ulaanbaatar (Ulan Bator), Mongolia",
            tz => "Asia/Ulaanbaatar",
        },
        momfm => {
            alias => [qw( Asia/Macau Asia/Macao )],
            desc => "Macau SAR China",
            tz => "Asia/Macau",
        },
        mpspn => { desc => "Saipan, Northern Mariana Islands", tz => "Pacific/Saipan" },
        mqfdf => { desc => "Martinique", tz => "America/Martinique" },
        mrnkc => { desc => "Nouakchott, Mauritania", tz => "Africa/Nouakchott" },
        msmni => { desc => "Montserrat", tz => "America/Montserrat" },
        mst7mdt => {
            desc => "POSIX style time zone for US Mountain Time",
            tz => "MST7MDT",
        },
        mtmla => { desc => "Malta", tz => "Europe/Malta" },
        muplu => { desc => "Mauritius", tz => "Indian/Mauritius" },
        mvmle => { desc => "Maldives", tz => "Indian/Maldives" },
        mwblz => { desc => "Blantyre, Malawi", tz => "Africa/Blantyre" },
        mxchi => { desc => "Chihuahua, Mexico", tz => "America/Chihuahua" },
        mxcjs => { desc => "Ciudad Ju\xE1rez, Mexico", tz => "America/Ciudad_Juarez" },
        mxcun => { desc => "Canc\xFAn, Mexico", tz => "America/Cancun" },
        mxhmo => { desc => "Hermosillo, Mexico", tz => "America/Hermosillo" },
        mxmam => { desc => "Matamoros, Mexico", tz => "America/Matamoros" },
        mxmex => {
            alias => [qw( America/Mexico_City Mexico/General )],
            desc => "Mexico City, Mexico",
            tz => "America/Mexico_City",
        },
        mxmid => { desc => "M\xE9rida, Mexico", tz => "America/Merida" },
        mxmty => { desc => "Monterrey, Mexico", tz => "America/Monterrey" },
        mxmzt => {
            alias => [qw( America/Mazatlan Mexico/BajaSur )],
            desc => "Mazatl\xE1n, Mexico",
            tz => "America/Mazatlan",
        },
        mxoji => { desc => "Ojinaga, Mexico", tz => "America/Ojinaga" },
        mxpvr => {
            desc => "Bah\xEDa de Banderas, Mexico",
            tz => "America/Bahia_Banderas",
        },
        mxstis => {
            deprecated => 1,
            desc => "Santa Isabel (Baja California), Mexico",
            preferred => "mxtij",
        },
        mxtij => {
            alias => [qw(
                America/Tijuana America/Ensenada Mexico/BajaNorte
                America/Santa_Isabel
            )],
            desc => "Tijuana, Mexico",
            tz => "America/Tijuana",
        },
        mykch => { desc => "Kuching, Malaysia", tz => "Asia/Kuching" },
        mykul => { desc => "Kuala Lumpur, Malaysia", tz => "Asia/Kuala_Lumpur" },
        mzmpm => { desc => "Maputo, Mozambique", tz => "Africa/Maputo" },
        nawdh => { desc => "Windhoek, Namibia", tz => "Africa/Windhoek" },
        ncnou => { desc => "Noumea, New Caledonia", tz => "Pacific/Noumea" },
        nenim => { desc => "Niamey, Niger", tz => "Africa/Niamey" },
        nfnlk => { desc => "Norfolk Island", tz => "Pacific/Norfolk" },
        nglos => { desc => "Lagos, Nigeria", tz => "Africa/Lagos" },
        nimga => { desc => "Managua, Nicaragua", tz => "America/Managua" },
        nlams => { desc => "Amsterdam, Netherlands", tz => "Europe/Amsterdam" },
        noosl => { desc => "Oslo, Norway", tz => "Europe/Oslo" },
        npktm => {
            alias => [qw( Asia/Katmandu Asia/Kathmandu )],
            desc => "Kathmandu, Nepal",
            tz => "Asia/Kathmandu",
        },
        nrinu => { desc => "Nauru", tz => "Pacific/Nauru" },
        nuiue => { desc => "Niue", tz => "Pacific/Niue" },
        nzakl => {
            alias => [qw( Pacific/Auckland Antarctica/South_Pole NZ )],
            desc => "Auckland, New Zealand",
            tz => "Pacific/Auckland",
        },
        nzcht => {
            alias => [qw( Pacific/Chatham NZ-CHAT )],
            desc => "Chatham Islands, New Zealand",
            tz => "Pacific/Chatham",
        },
        ommct => { desc => "Muscat, Oman", tz => "Asia/Muscat" },
        papty => { desc => "Panama", tz => "America/Panama" },
        pelim => { desc => "Lima, Peru", tz => "America/Lima" },
        pfgmr => {
            desc => "Gambiera Islands, French Polynesia",
            tz => "Pacific/Gambier",
        },
        pfnhv => {
            desc => "Marquesas Islands, French Polynesia",
            tz => "Pacific/Marquesas",
        },
        pfppt => { desc => "Tahiti, French Polynesia", tz => "Pacific/Tahiti" },
        pgpom => {
            desc => "Port Moresby, Papua New Guinea",
            tz => "Pacific/Port_Moresby",
        },
        pgraw => {
            desc => "Bougainville, Papua New Guinea",
            tz => "Pacific/Bougainville",
        },
        phmnl => { desc => "Manila, Philippines", tz => "Asia/Manila" },
        pkkhi => { desc => "Karachi, Pakistan", tz => "Asia/Karachi" },
        plwaw => {
            alias => [qw( Europe/Warsaw Poland )],
            desc => "Warsaw, Poland",
            tz => "Europe/Warsaw",
        },
        pmmqc => { desc => "Saint Pierre and Miquelon", tz => "America/Miquelon" },
        pnpcn => { desc => "Pitcairn Islands", tz => "Pacific/Pitcairn" },
        prsju => { desc => "Puerto Rico", tz => "America/Puerto_Rico" },
        pst8pdt => {
            desc => "POSIX style time zone for US Pacific Time",
            tz => "PST8PDT",
        },
        ptfnc => { desc => "Madeira, Portugal", tz => "Atlantic/Madeira" },
        ptlis => {
            alias => [qw( Europe/Lisbon Portugal )],
            desc => "Lisbon, Portugal",
            tz => "Europe/Lisbon",
        },
        ptpdl => { desc => "Azores, Portugal", tz => "Atlantic/Azores" },
        pwror => { desc => "Palau", tz => "Pacific/Palau" },
        pyasu => { desc => "Asunci\xF3n, Paraguay", tz => "America/Asuncion" },
        qadoh => { desc => "Qatar", tz => "Asia/Qatar" },
        rereu => { desc => "R\xE9union", tz => "Indian/Reunion" },
        robuh => { desc => "Bucharest, Romania", tz => "Europe/Bucharest" },
        rsbeg => { desc => "Belgrade, Serbia", tz => "Europe/Belgrade" },
        ruasf => { desc => "Astrakhan, Russia", tz => "Europe/Astrakhan" },
        rubax => { desc => "Barnaul, Russia", tz => "Asia/Barnaul" },
        ruchita => { desc => "Chita Zabaykalsky, Russia", tz => "Asia/Chita" },
        rudyr => { desc => "Anadyr, Russia", tz => "Asia/Anadyr" },
        rugdx => { desc => "Magadan, Russia", tz => "Asia/Magadan" },
        ruikt => { desc => "Irkutsk, Russia", tz => "Asia/Irkutsk" },
        rukgd => { desc => "Kaliningrad, Russia", tz => "Europe/Kaliningrad" },
        rukhndg => { desc => "Khandyga Tomponsky, Russia", tz => "Asia/Khandyga" },
        rukra => { desc => "Krasnoyarsk, Russia", tz => "Asia/Krasnoyarsk" },
        rukuf => { desc => "Samara, Russia", tz => "Europe/Samara" },
        rukvx => { desc => "Kirov, Russia", tz => "Europe/Kirov" },
        rumow => {
            alias => [qw( Europe/Moscow W-SU )],
            desc => "Moscow, Russia",
            tz => "Europe/Moscow",
        },
        runoz => { desc => "Novokuznetsk, Russia", tz => "Asia/Novokuznetsk" },
        ruoms => { desc => "Omsk, Russia", tz => "Asia/Omsk" },
        ruovb => { desc => "Novosibirsk, Russia", tz => "Asia/Novosibirsk" },
        rupkc => { desc => "Kamchatka Peninsula, Russia", tz => "Asia/Kamchatka" },
        rurtw => { desc => "Saratov, Russia", tz => "Europe/Saratov" },
        rusred => { desc => "Srednekolymsk, Russia", tz => "Asia/Srednekolymsk" },
        rutof => { desc => "Tomsk, Russia", tz => "Asia/Tomsk" },
        ruuly => { desc => "Ulyanovsk, Russia", tz => "Europe/Ulyanovsk" },
        ruunera => { desc => "Ust-Nera Oymyakonsky, Russia", tz => "Asia/Ust-Nera" },
        ruuus => { desc => "Sakhalin, Russia", tz => "Asia/Sakhalin" },
        ruvog => { desc => "Volgograd, Russia", tz => "Europe/Volgograd" },
        ruvvo => { desc => "Vladivostok, Russia", tz => "Asia/Vladivostok" },
        ruyek => { desc => "Yekaterinburg, Russia", tz => "Asia/Yekaterinburg" },
        ruyks => { desc => "Yakutsk, Russia", tz => "Asia/Yakutsk" },
        rwkgl => { desc => "Kigali, Rwanda", tz => "Africa/Kigali" },
        saruh => { desc => "Riyadh, Saudi Arabia", tz => "Asia/Riyadh" },
        sbhir => { desc => "Guadalcanal, Solomon Islands", tz => "Pacific/Guadalcanal" },
        scmaw => { desc => "Mah\xE9, Seychelles", tz => "Indian/Mahe" },
        sdkrt => { desc => "Khartoum, Sudan", tz => "Africa/Khartoum" },
        sesto => { desc => "Stockholm, Sweden", tz => "Europe/Stockholm" },
        sgsin => {
            alias => [qw( Asia/Singapore Singapore )],
            desc => "Singapore",
            tz => "Asia/Singapore",
        },
        shshn => { desc => "Saint Helena", tz => "Atlantic/St_Helena" },
        silju => { desc => "Ljubljana, Slovenia", tz => "Europe/Ljubljana" },
        sjlyr => {
            alias => [qw( Arctic/Longyearbyen Atlantic/Jan_Mayen )],
            desc => "Longyearbyen, Svalbard",
            tz => "Arctic/Longyearbyen",
        },
        skbts => { desc => "Bratislava, Slovakia", tz => "Europe/Bratislava" },
        slfna => { desc => "Freetown, Sierra Leone", tz => "Africa/Freetown" },
        smsai => { desc => "San Marino", tz => "Europe/San_Marino" },
        sndkr => { desc => "Dakar, Senegal", tz => "Africa/Dakar" },
        somgq => { desc => "Mogadishu, Somalia", tz => "Africa/Mogadishu" },
        srpbm => { desc => "Paramaribo, Suriname", tz => "America/Paramaribo" },
        ssjub => { desc => "Juba, South Sudan", tz => "Africa/Juba" },
        sttms => {
            desc => "S\xE3o Tom\xE9, S\xE3o Tom\xE9 and Pr\xEDncipe",
            tz => "Africa/Sao_Tome",
        },
        svsal => { desc => "El Salvador", tz => "America/El_Salvador" },
        sxphi => { desc => "Sint Maarten", tz => "America/Lower_Princes" },
        sydam => { desc => "Damascus, Syria", tz => "Asia/Damascus" },
        szqmn => { desc => "Mbabane, Swaziland", tz => "Africa/Mbabane" },
        tcgdt => {
            desc => "Grand Turk, Turks and Caicos Islands",
            tz => "America/Grand_Turk",
        },
        tdndj => { desc => "N'Djamena, Chad", tz => "Africa/Ndjamena" },
        tfpfr => {
            desc => "Kerguelen Islands, French Southern Territories",
            tz => "Indian/Kerguelen",
        },
        tglfw => { desc => "Lom\xE9, Togo", tz => "Africa/Lome" },
        thbkk => { desc => "Bangkok, Thailand", tz => "Asia/Bangkok" },
        tjdyu => { desc => "Dushanbe, Tajikistan", tz => "Asia/Dushanbe" },
        tkfko => { desc => "Fakaofo, Tokelau", tz => "Pacific/Fakaofo" },
        tldil => { desc => "Dili, East Timor", tz => "Asia/Dili" },
        tmasb => {
            alias => [qw( Asia/Ashgabat Asia/Ashkhabad )],
            desc => "Ashgabat, Turkmenistan",
            tz => "Asia/Ashgabat",
        },
        tntun => { desc => "Tunis, Tunisia", tz => "Africa/Tunis" },
        totbu => { desc => "Tongatapu, Tonga", tz => "Pacific/Tongatapu" },
        trist => {
            alias => [qw( Europe/Istanbul Asia/Istanbul Turkey )],
            desc => "Istanbul, T\xFCrkiye",
            tz => "Europe/Istanbul",
        },
        ttpos => {
            desc => "Port of Spain, Trinidad and Tobago",
            tz => "America/Port_of_Spain",
        },
        tvfun => { desc => "Funafuti, Tuvalu", tz => "Pacific/Funafuti" },
        twtpe => {
            alias => [qw( Asia/Taipei ROC )],
            desc => "Taipei, Taiwan",
            tz => "Asia/Taipei",
        },
        tzdar => { desc => "Dar es Salaam, Tanzania", tz => "Africa/Dar_es_Salaam" },
        uaiev => {
            alias => [qw( Europe/Kiev Europe/Kyiv Europe/Zaporozhye Europe/Uzhgorod )],
            desc => "Kyiv, Ukraine",
            tz => "Europe/Kyiv",
        },
        uaozh => {
            deprecated => 1,
            desc => "Zaporizhia (Zaporozhye), Ukraine",
            preferred => "uaiev",
        },
        uasip => { desc => "Simferopol, Ukraine", tz => "Europe/Simferopol" },
        uauzh => {
            deprecated => 1,
            desc => "Uzhhorod (Uzhgorod), Ukraine",
            preferred => "uaiev",
        },
        ugkla => { desc => "Kampala, Uganda", tz => "Africa/Kampala" },
        umawk => {
            desc => "Wake Island, U.S. Minor Outlying Islands",
            tz => "Pacific/Wake",
        },
        umjon => {
            deprecated => 1,
            desc => "Johnston Atoll, U.S. Minor Outlying Islands",
            preferred => "ushnl",
        },
        ummdy => {
            desc => "Midway Islands, U.S. Minor Outlying Islands",
            tz => "Pacific/Midway",
        },
        unk => { desc => "Unknown time zone", tz => "Etc/Unknown" },
        usadk => {
            alias => [qw( America/Adak America/Atka US/Aleutian )],
            desc => "Adak (Alaska), United States",
            tz => "America/Adak",
        },
        usaeg => {
            desc => "Marengo (Indiana), United States",
            tz => "America/Indiana/Marengo",
        },
        usanc => {
            alias => [qw( America/Anchorage US/Alaska )],
            desc => "Anchorage, United States",
            tz => "America/Anchorage",
        },
        usboi => { desc => "Boise (Idaho), United States", tz => "America/Boise" },
        uschi => {
            alias => [qw( America/Chicago US/Central )],
            desc => "Chicago, United States",
            tz => "America/Chicago",
        },
        usden => {
            alias => [qw( America/Denver America/Shiprock Navajo US/Mountain )],
            desc => "Denver, United States",
            tz => "America/Denver",
        },
        usdet => {
            alias => [qw( America/Detroit US/Michigan )],
            desc => "Detroit, United States",
            tz => "America/Detroit",
        },
        ushnl => {
            alias => [qw( Pacific/Honolulu US/Hawaii Pacific/Johnston )],
            desc => "Honolulu, United States",
            tz => "Pacific/Honolulu",
        },
        usind => {
            alias => [qw(
                America/Indianapolis America/Fort_Wayne
                America/Indiana/Indianapolis US/East-Indiana
            )],
            desc => "Indianapolis, United States",
            tz => "America/Indiana/Indianapolis",
        },
        usinvev => {
            desc => "Vevay (Indiana), United States",
            tz => "America/Indiana/Vevay",
        },
        usjnu => { desc => "Juneau (Alaska), United States", tz => "America/Juneau" },
        usknx => {
            alias => [qw( America/Indiana/Knox America/Knox_IN US/Indiana-Starke )],
            desc => "Knox (Indiana), United States",
            tz => "America/Indiana/Knox",
        },
        uslax => {
            alias => [qw( America/Los_Angeles US/Pacific US/Pacific-New )],
            desc => "Los Angeles, United States",
            tz => "America/Los_Angeles",
        },
        uslui => {
            alias => [qw( America/Louisville America/Kentucky/Louisville )],
            desc => "Louisville (Kentucky), United States",
            tz => "America/Kentucky/Louisville",
        },
        usmnm => {
            desc => "Menominee (Michigan), United States",
            tz => "America/Menominee",
        },
        usmoc => {
            desc => "Monticello (Kentucky), United States",
            tz => "America/Kentucky/Monticello",
        },
        usmtm => {
            desc => "Metlakatla (Alaska), United States",
            tz => "America/Metlakatla",
        },
        usnavajo => {
            deprecated => 1,
            desc => "Shiprock (Navajo), United States",
            preferred => "usden",
        },
        usndcnt => {
            desc => "Center (North Dakota), United States",
            tz => "America/North_Dakota/Center",
        },
        usndnsl => {
            desc => "New Salem (North Dakota), United States",
            tz => "America/North_Dakota/New_Salem",
        },
        usnyc => {
            alias => [qw( America/New_York US/Eastern )],
            desc => "New York, United States",
            tz => "America/New_York",
        },
        usoea => {
            desc => "Vincennes (Indiana), United States",
            tz => "America/Indiana/Vincennes",
        },
        usome => { desc => "Nome (Alaska), United States", tz => "America/Nome" },
        usphx => {
            alias => [qw( America/Phoenix US/Arizona )],
            desc => "Phoenix, United States",
            tz => "America/Phoenix",
        },
        ussit => { desc => "Sitka (Alaska), United States", tz => "America/Sitka" },
        ustel => {
            desc => "Tell City (Indiana), United States",
            tz => "America/Indiana/Tell_City",
        },
        uswlz => {
            desc => "Winamac (Indiana), United States",
            tz => "America/Indiana/Winamac",
        },
        uswsq => {
            desc => "Petersburg (Indiana), United States",
            tz => "America/Indiana/Petersburg",
        },
        usxul => {
            desc => "Beulah (North Dakota), United States",
            tz => "America/North_Dakota/Beulah",
        },
        usyak => { desc => "Yakutat (Alaska), United States", tz => "America/Yakutat" },
        utc => {
            alias => [qw(
                Etc/UTC Etc/UCT Etc/Universal Etc/Zulu UCT UTC Universal
                Zulu
            )],
            desc => "UTC (Coordinated Universal Time)",
            tz => "Etc/UTC",
        },
        utce01 => { desc => "1 hour ahead of UTC", tz => "Etc/GMT-1" },
        utce02 => { desc => "2 hours ahead of UTC", tz => "Etc/GMT-2" },
        utce03 => { desc => "3 hours ahead of UTC", tz => "Etc/GMT-3" },
        utce04 => { desc => "4 hours ahead of UTC", tz => "Etc/GMT-4" },
        utce05 => { desc => "5 hours ahead of UTC", tz => "Etc/GMT-5" },
        utce06 => { desc => "6 hours ahead of UTC", tz => "Etc/GMT-6" },
        utce07 => { desc => "7 hours ahead of UTC", tz => "Etc/GMT-7" },
        utce08 => { desc => "8 hours ahead of UTC", tz => "Etc/GMT-8" },
        utce09 => { desc => "9 hours ahead of UTC", tz => "Etc/GMT-9" },
        utce10 => { desc => "10 hours ahead of UTC", tz => "Etc/GMT-10" },
        utce11 => { desc => "11 hours ahead of UTC", tz => "Etc/GMT-11" },
        utce12 => { desc => "12 hours ahead of UTC", tz => "Etc/GMT-12" },
        utce13 => { desc => "13 hours ahead of UTC", tz => "Etc/GMT-13" },
        utce14 => { desc => "14 hours ahead of UTC", tz => "Etc/GMT-14" },
        utcw01 => { desc => "1 hour behind UTC", tz => "Etc/GMT+1" },
        utcw02 => { desc => "2 hours behind UTC", tz => "Etc/GMT+2" },
        utcw03 => { desc => "3 hours behind UTC", tz => "Etc/GMT+3" },
        utcw04 => { desc => "4 hours behind UTC", tz => "Etc/GMT+4" },
        utcw05 => {
            alias => [qw( Etc/GMT+5 EST )],
            desc => "5 hours behind UTC",
            tz => "Etc/GMT+5",
        },
        utcw06 => { desc => "6 hours behind UTC", tz => "Etc/GMT+6" },
        utcw07 => {
            alias => [qw( Etc/GMT+7 MST )],
            desc => "7 hours behind UTC",
            tz => "Etc/GMT+7",
        },
        utcw08 => { desc => "8 hours behind UTC", tz => "Etc/GMT+8" },
        utcw09 => { desc => "9 hours behind UTC", tz => "Etc/GMT+9" },
        utcw10 => {
            alias => [qw( Etc/GMT+10 HST )],
            desc => "10 hours behind UTC",
            tz => "Etc/GMT+10",
        },
        utcw11 => { desc => "11 hours behind UTC", tz => "Etc/GMT+11" },
        utcw12 => { desc => "12 hours behind UTC", tz => "Etc/GMT+12" },
        uymvd => { desc => "Montevideo, Uruguay", tz => "America/Montevideo" },
        uzskd => { desc => "Samarkand, Uzbekistan", tz => "Asia/Samarkand" },
        uztas => { desc => "Tashkent, Uzbekistan", tz => "Asia/Tashkent" },
        vavat => { desc => "Vatican City", tz => "Europe/Vatican" },
        vcsvd => {
            desc => "Saint Vincent, Saint Vincent and the Grenadines",
            tz => "America/St_Vincent",
        },
        veccs => { desc => "Caracas, Venezuela", tz => "America/Caracas" },
        vgtov => { desc => "Tortola, British Virgin Islands", tz => "America/Tortola" },
        vistt => {
            alias => [qw( America/St_Thomas America/Virgin )],
            desc => "Saint Thomas, U.S. Virgin Islands",
            tz => "America/St_Thomas",
        },
        vnsgn => {
            alias => [qw( Asia/Saigon Asia/Ho_Chi_Minh )],
            desc => "Ho Chi Minh City, Vietnam",
            tz => "Asia/Ho_Chi_Minh",
        },
        vuvli => { desc => "Efate, Vanuatu", tz => "Pacific/Efate" },
        wfmau => { desc => "Wallis Islands, Wallis and Futuna", tz => "Pacific/Wallis" },
        wsapw => { desc => "Apia, Samoa", tz => "Pacific/Apia" },
        yeade => { desc => "Aden, Yemen", tz => "Asia/Aden" },
        ytmam => { desc => "Mayotte", tz => "Indian/Mayotte" },
        zajnb => { desc => "Johannesburg, South Africa", tz => "Africa/Johannesburg" },
        zmlun => { desc => "Lusaka, Zambia", tz => "Africa/Lusaka" },
        zwhre => { desc => "Harare, Zimbabwe", tz => "Africa/Harare" },
    };

    # NOTE: $TZ_NAME2ID
    # This BCP47 timezone database is different from the Olson IANA database in that it keeps old record for reliability and consistency.
    # See <https://github.com/unicode-org/cldr/blob/main/common/bcp47/timezone.xml>
    # <https://www.iana.org/time-zones>
    # <ftp://ftp.iana.org/tz/releases/>
    $TZ_NAME2ID =
    {
        "Africa/Abidjan" => "ciabj",
        "Africa/Accra" => "ghacc",
        "Africa/Addis_Ababa" => "etadd",
        "Africa/Algiers" => "dzalg",
        "Africa/Asmara" => "erasm",
        "Africa/Asmera" => "erasm",
        "Africa/Bamako" => "mlbko",
        "Africa/Bangui" => "cfbgf",
        "Africa/Banjul" => "gmbjl",
        "Africa/Bissau" => "gwoxb",
        "Africa/Blantyre" => "mwblz",
        "Africa/Brazzaville" => "cgbzv",
        "Africa/Bujumbura" => "bibjm",
        "Africa/Cairo" => "egcai",
        "Africa/Casablanca" => "macas",
        "Africa/Ceuta" => "esceu",
        "Africa/Conakry" => "gncky",
        "Africa/Dakar" => "sndkr",
        "Africa/Dar_es_Salaam" => "tzdar",
        "Africa/Djibouti" => "djjib",
        "Africa/Douala" => "cmdla",
        "Africa/El_Aaiun" => "eheai",
        "Africa/Freetown" => "slfna",
        "Africa/Gaborone" => "bwgbe",
        "Africa/Harare" => "zwhre",
        "Africa/Johannesburg" => "zajnb",
        "Africa/Juba" => "ssjub",
        "Africa/Kampala" => "ugkla",
        "Africa/Khartoum" => "sdkrt",
        "Africa/Kigali" => "rwkgl",
        "Africa/Kinshasa" => "cdfih",
        "Africa/Lagos" => "nglos",
        "Africa/Libreville" => "galbv",
        "Africa/Lome" => "tglfw",
        "Africa/Luanda" => "aolad",
        "Africa/Lubumbashi" => "cdfbm",
        "Africa/Lusaka" => "zmlun",
        "Africa/Malabo" => "gqssg",
        "Africa/Maputo" => "mzmpm",
        "Africa/Maseru" => "lsmsu",
        "Africa/Mbabane" => "szqmn",
        "Africa/Mogadishu" => "somgq",
        "Africa/Monrovia" => "lrmlw",
        "Africa/Nairobi" => "kenbo",
        "Africa/Ndjamena" => "tdndj",
        "Africa/Niamey" => "nenim",
        "Africa/Nouakchott" => "mrnkc",
        "Africa/Ouagadougou" => "bfoua",
        "Africa/Porto-Novo" => "bjptn",
        "Africa/Sao_Tome" => "sttms",
        "Africa/Timbuktu" => "mlbko",
        "Africa/Tripoli" => "lytip",
        "Africa/Tunis" => "tntun",
        "Africa/Windhoek" => "nawdh",
        "America/Adak" => "usadk",
        "America/Anchorage" => "usanc",
        "America/Anguilla" => "aiaxa",
        "America/Antigua" => "aganu",
        "America/Araguaina" => "braux",
        "America/Argentina/Buenos_Aires" => "arbue",
        "America/Argentina/Catamarca" => "arctc",
        "America/Argentina/ComodRivadavia" => "arctc",
        "America/Argentina/Cordoba" => "arcor",
        "America/Argentina/Jujuy" => "arjuj",
        "America/Argentina/La_Rioja" => "arirj",
        "America/Argentina/Mendoza" => "armdz",
        "America/Argentina/Rio_Gallegos" => "arrgl",
        "America/Argentina/Salta" => "arsla",
        "America/Argentina/San_Juan" => "aruaq",
        "America/Argentina/San_Luis" => "arluq",
        "America/Argentina/Tucuman" => "artuc",
        "America/Argentina/Ushuaia" => "arush",
        "America/Aruba" => "awaua",
        "America/Asuncion" => "pyasu",
        "America/Atikokan" => "cayzs",
        "America/Atka" => "usadk",
        "America/Bahia" => "brssa",
        "America/Bahia_Banderas" => "mxpvr",
        "America/Barbados" => "bbbgi",
        "America/Belem" => "brbel",
        "America/Belize" => "bzbze",
        "America/Blanc-Sablon" => "caybx",
        "America/Boa_Vista" => "brbvb",
        "America/Bogota" => "cobog",
        "America/Boise" => "usboi",
        "America/Buenos_Aires" => "arbue",
        "America/Cambridge_Bay" => "caycb",
        "America/Campo_Grande" => "brcgr",
        "America/Cancun" => "mxcun",
        "America/Caracas" => "veccs",
        "America/Catamarca" => "arctc",
        "America/Cayenne" => "gfcay",
        "America/Cayman" => "kygec",
        "America/Chicago" => "uschi",
        "America/Chihuahua" => "mxchi",
        "America/Ciudad_Juarez" => "mxcjs",
        "America/Coral_Harbour" => "cayzs",
        "America/Cordoba" => "arcor",
        "America/Costa_Rica" => "crsjo",
        "America/Creston" => "cacfq",
        "America/Cuiaba" => "brcgb",
        "America/Curacao" => "ancur",
        "America/Danmarkshavn" => "gldkshvn",
        "America/Dawson" => "cayda",
        "America/Dawson_Creek" => "caydq",
        "America/Denver" => "usden",
        "America/Detroit" => "usdet",
        "America/Dominica" => "dmdom",
        "America/Edmonton" => "caedm",
        "America/Eirunepe" => "brern",
        "America/El_Salvador" => "svsal",
        "America/Ensenada" => "mxtij",
        "America/Fort_Nelson" => "cafne",
        "America/Fort_Wayne" => "usind",
        "America/Fortaleza" => "brfor",
        "America/Glace_Bay" => "caglb",
        "America/Godthab" => "glgoh",
        "America/Goose_Bay" => "cagoo",
        "America/Grand_Turk" => "tcgdt",
        "America/Grenada" => "gdgnd",
        "America/Guadeloupe" => "gpbbr",
        "America/Guatemala" => "gtgua",
        "America/Guayaquil" => "ecgye",
        "America/Guyana" => "gygeo",
        "America/Halifax" => "cahal",
        "America/Havana" => "cuhav",
        "America/Hermosillo" => "mxhmo",
        "America/Indiana/Indianapolis" => "usind",
        "America/Indiana/Knox" => "usknx",
        "America/Indiana/Marengo" => "usaeg",
        "America/Indiana/Petersburg" => "uswsq",
        "America/Indiana/Tell_City" => "ustel",
        "America/Indiana/Vevay" => "usinvev",
        "America/Indiana/Vincennes" => "usoea",
        "America/Indiana/Winamac" => "uswlz",
        "America/Indianapolis" => "usind",
        "America/Inuvik" => "cayev",
        "America/Iqaluit" => "caiql",
        "America/Jamaica" => "jmkin",
        "America/Jujuy" => "arjuj",
        "America/Juneau" => "usjnu",
        "America/Kentucky/Louisville" => "uslui",
        "America/Kentucky/Monticello" => "usmoc",
        "America/Knox_IN" => "usknx",
        "America/Kralendijk" => "bqkra",
        "America/La_Paz" => "bolpb",
        "America/Lima" => "pelim",
        "America/Los_Angeles" => "uslax",
        "America/Louisville" => "uslui",
        "America/Lower_Princes" => "sxphi",
        "America/Maceio" => "brmcz",
        "America/Managua" => "nimga",
        "America/Manaus" => "brmao",
        "America/Marigot" => "gpmsb",
        "America/Martinique" => "mqfdf",
        "America/Matamoros" => "mxmam",
        "America/Mazatlan" => "mxmzt",
        "America/Mendoza" => "armdz",
        "America/Menominee" => "usmnm",
        "America/Merida" => "mxmid",
        "America/Metlakatla" => "usmtm",
        "America/Mexico_City" => "mxmex",
        "America/Miquelon" => "pmmqc",
        "America/Moncton" => "camon",
        "America/Monterrey" => "mxmty",
        "America/Montevideo" => "uymvd",
        "America/Montreal" => "cator",
        "America/Montserrat" => "msmni",
        "America/Nassau" => "bsnas",
        "America/New_York" => "usnyc",
        "America/Nipigon" => "cator",
        "America/Nome" => "usome",
        "America/Noronha" => "brfen",
        "America/North_Dakota/Beulah" => "usxul",
        "America/North_Dakota/Center" => "usndcnt",
        "America/North_Dakota/New_Salem" => "usndnsl",
        "America/Nuuk" => "glgoh",
        "America/Ojinaga" => "mxoji",
        "America/Panama" => "papty",
        "America/Pangnirtung" => "caiql",
        "America/Paramaribo" => "srpbm",
        "America/Phoenix" => "usphx",
        "America/Port-au-Prince" => "htpap",
        "America/Port_of_Spain" => "ttpos",
        "America/Porto_Acre" => "brrbr",
        "America/Porto_Velho" => "brpvh",
        "America/Puerto_Rico" => "prsju",
        "America/Punta_Arenas" => "clpuq",
        "America/Rainy_River" => "cawnp",
        "America/Rankin_Inlet" => "cayek",
        "America/Recife" => "brrec",
        "America/Regina" => "careg",
        "America/Resolute" => "careb",
        "America/Rio_Branco" => "brrbr",
        "America/Rosario" => "arcor",
        "America/Santa_Isabel" => "mxtij",
        "America/Santarem" => "brstm",
        "America/Santiago" => "clscl",
        "America/Santo_Domingo" => "dosdq",
        "America/Sao_Paulo" => "brsao",
        "America/Scoresbysund" => "globy",
        "America/Shiprock" => "usden",
        "America/Sitka" => "ussit",
        "America/St_Barthelemy" => "gpsbh",
        "America/St_Johns" => "casjf",
        "America/St_Kitts" => "knbas",
        "America/St_Lucia" => "lccas",
        "America/St_Thomas" => "vistt",
        "America/St_Vincent" => "vcsvd",
        "America/Swift_Current" => "cayyn",
        "America/Tegucigalpa" => "hntgu",
        "America/Thule" => "glthu",
        "America/Thunder_Bay" => "cator",
        "America/Tijuana" => "mxtij",
        "America/Toronto" => "cator",
        "America/Tortola" => "vgtov",
        "America/Vancouver" => "cavan",
        "America/Virgin" => "vistt",
        "America/Whitehorse" => "cayxy",
        "America/Winnipeg" => "cawnp",
        "America/Yakutat" => "usyak",
        "America/Yellowknife" => "caedm",
        "Antarctica/Casey" => "aqcas",
        "Antarctica/Davis" => "aqdav",
        "Antarctica/DumontDUrville" => "aqddu",
        "Antarctica/Macquarie" => "aumqi",
        "Antarctica/Mawson" => "aqmaw",
        "Antarctica/McMurdo" => "aqmcm",
        "Antarctica/Palmer" => "aqplm",
        "Antarctica/Rothera" => "aqrot",
        "Antarctica/South_Pole" => "nzakl",
        "Antarctica/Syowa" => "aqsyw",
        "Antarctica/Troll" => "aqtrl",
        "Antarctica/Vostok" => "aqvos",
        "Arctic/Longyearbyen" => "sjlyr",
        "Asia/Aden" => "yeade",
        "Asia/Almaty" => "kzala",
        "Asia/Amman" => "joamm",
        "Asia/Anadyr" => "rudyr",
        "Asia/Aqtau" => "kzaau",
        "Asia/Aqtobe" => "kzakx",
        "Asia/Ashgabat" => "tmasb",
        "Asia/Ashkhabad" => "tmasb",
        "Asia/Atyrau" => "kzguw",
        "Asia/Baghdad" => "iqbgw",
        "Asia/Bahrain" => "bhbah",
        "Asia/Baku" => "azbak",
        "Asia/Bangkok" => "thbkk",
        "Asia/Barnaul" => "rubax",
        "Asia/Beirut" => "lbbey",
        "Asia/Bishkek" => "kgfru",
        "Asia/Brunei" => "bnbwn",
        "Asia/Calcutta" => "inccu",
        "Asia/Chita" => "ruchita",
        "Asia/Choibalsan" => "mncoq",
        "Asia/Chongqing" => "cnsha",
        "Asia/Chungking" => "cnsha",
        "Asia/Colombo" => "lkcmb",
        "Asia/Dacca" => "bddac",
        "Asia/Damascus" => "sydam",
        "Asia/Dhaka" => "bddac",
        "Asia/Dili" => "tldil",
        "Asia/Dubai" => "aedxb",
        "Asia/Dushanbe" => "tjdyu",
        "Asia/Famagusta" => "cyfmg",
        "Asia/Gaza" => "gazastrp",
        "Asia/Harbin" => "cnsha",
        "Asia/Hebron" => "hebron",
        "Asia/Ho_Chi_Minh" => "vnsgn",
        "Asia/Hong_Kong" => "hkhkg",
        "Asia/Hovd" => "mnhvd",
        "Asia/Irkutsk" => "ruikt",
        "Asia/Istanbul" => "trist",
        "Asia/Jakarta" => "idjkt",
        "Asia/Jayapura" => "iddjj",
        "Asia/Jerusalem" => "jeruslm",
        "Asia/Kabul" => "afkbl",
        "Asia/Kamchatka" => "rupkc",
        "Asia/Karachi" => "pkkhi",
        "Asia/Kashgar" => "cnurc",
        "Asia/Kathmandu" => "npktm",
        "Asia/Katmandu" => "npktm",
        "Asia/Khandyga" => "rukhndg",
        "Asia/Kolkata" => "inccu",
        "Asia/Krasnoyarsk" => "rukra",
        "Asia/Kuala_Lumpur" => "mykul",
        "Asia/Kuching" => "mykch",
        "Asia/Kuwait" => "kwkwi",
        "Asia/Macao" => "momfm",
        "Asia/Macau" => "momfm",
        "Asia/Magadan" => "rugdx",
        "Asia/Makassar" => "idmak",
        "Asia/Manila" => "phmnl",
        "Asia/Muscat" => "ommct",
        "Asia/Nicosia" => "cynic",
        "Asia/Novokuznetsk" => "runoz",
        "Asia/Novosibirsk" => "ruovb",
        "Asia/Omsk" => "ruoms",
        "Asia/Oral" => "kzura",
        "Asia/Phnom_Penh" => "khpnh",
        "Asia/Pontianak" => "idpnk",
        "Asia/Pyongyang" => "kpfnj",
        "Asia/Qatar" => "qadoh",
        "Asia/Qostanay" => "kzksn",
        "Asia/Qyzylorda" => "kzkzo",
        "Asia/Rangoon" => "mmrgn",
        "Asia/Riyadh" => "saruh",
        "Asia/Saigon" => "vnsgn",
        "Asia/Sakhalin" => "ruuus",
        "Asia/Samarkand" => "uzskd",
        "Asia/Seoul" => "krsel",
        "Asia/Shanghai" => "cnsha",
        "Asia/Singapore" => "sgsin",
        "Asia/Srednekolymsk" => "rusred",
        "Asia/Taipei" => "twtpe",
        "Asia/Tashkent" => "uztas",
        "Asia/Tbilisi" => "getbs",
        "Asia/Tehran" => "irthr",
        "Asia/Tel_Aviv" => "jeruslm",
        "Asia/Thimbu" => "btthi",
        "Asia/Thimphu" => "btthi",
        "Asia/Tokyo" => "jptyo",
        "Asia/Tomsk" => "rutof",
        "Asia/Ujung_Pandang" => "idmak",
        "Asia/Ulaanbaatar" => "mnuln",
        "Asia/Ulan_Bator" => "mnuln",
        "Asia/Urumqi" => "cnurc",
        "Asia/Ust-Nera" => "ruunera",
        "Asia/Vientiane" => "lavte",
        "Asia/Vladivostok" => "ruvvo",
        "Asia/Yakutsk" => "ruyks",
        "Asia/Yangon" => "mmrgn",
        "Asia/Yekaterinburg" => "ruyek",
        "Asia/Yerevan" => "amevn",
        "Atlantic/Azores" => "ptpdl",
        "Atlantic/Bermuda" => "bmbda",
        "Atlantic/Canary" => "eslpa",
        "Atlantic/Cape_Verde" => "cvrai",
        "Atlantic/Faeroe" => "fotho",
        "Atlantic/Faroe" => "fotho",
        "Atlantic/Jan_Mayen" => "sjlyr",
        "Atlantic/Madeira" => "ptfnc",
        "Atlantic/Reykjavik" => "isrey",
        "Atlantic/South_Georgia" => "gsgrv",
        "Atlantic/St_Helena" => "shshn",
        "Atlantic/Stanley" => "fkpsy",
        "Australia/ACT" => "ausyd",
        "Australia/Adelaide" => "auadl",
        "Australia/Brisbane" => "aubne",
        "Australia/Broken_Hill" => "aubhq",
        "Australia/Canberra" => "ausyd",
        "Australia/Currie" => "auhba",
        "Australia/Darwin" => "audrw",
        "Australia/Eucla" => "aueuc",
        "Australia/Hobart" => "auhba",
        "Australia/LHI" => "auldh",
        "Australia/Lindeman" => "auldc",
        "Australia/Lord_Howe" => "auldh",
        "Australia/Melbourne" => "aumel",
        "Australia/North" => "audrw",
        "Australia/NSW" => "ausyd",
        "Australia/Perth" => "auper",
        "Australia/Queensland" => "aubne",
        "Australia/South" => "auadl",
        "Australia/Sydney" => "ausyd",
        "Australia/Tasmania" => "auhba",
        "Australia/Victoria" => "aumel",
        "Australia/West" => "auper",
        "Australia/Yancowinna" => "aubhq",
        "Brazil/Acre" => "brrbr",
        "Brazil/DeNoronha" => "brfen",
        "Brazil/East" => "brsao",
        "Brazil/West" => "brmao",
        "Canada/Atlantic" => "cahal",
        "Canada/Central" => "cawnp",
        "Canada/East-Saskatchewan" => "careg",
        "Canada/Eastern" => "cator",
        "Canada/Mountain" => "caedm",
        "Canada/Newfoundland" => "casjf",
        "Canada/Pacific" => "cavan",
        "Canada/Saskatchewan" => "careg",
        "Canada/Yukon" => "cayxy",
        "Chile/Continental" => "clscl",
        "Chile/EasterIsland" => "clipc",
        CST6CDT => "cst6cdt",
        Cuba => "cuhav",
        Egypt => "egcai",
        Eire => "iedub",
        EST => "utcw05",
        EST5EDT => "est5edt",
        "Etc/GMT" => "gmt",
        "Etc/GMT+0" => "gmt",
        "Etc/GMT+1" => "utcw01",
        "Etc/GMT+10" => "utcw10",
        "Etc/GMT+11" => "utcw11",
        "Etc/GMT+12" => "utcw12",
        "Etc/GMT+2" => "utcw02",
        "Etc/GMT+3" => "utcw03",
        "Etc/GMT+4" => "utcw04",
        "Etc/GMT+5" => "utcw05",
        "Etc/GMT+6" => "utcw06",
        "Etc/GMT+7" => "utcw07",
        "Etc/GMT+8" => "utcw08",
        "Etc/GMT+9" => "utcw09",
        "Etc/GMT-0" => "gmt",
        "Etc/GMT-1" => "utce01",
        "Etc/GMT-10" => "utce10",
        "Etc/GMT-11" => "utce11",
        "Etc/GMT-12" => "utce12",
        "Etc/GMT-13" => "utce13",
        "Etc/GMT-14" => "utce14",
        "Etc/GMT-2" => "utce02",
        "Etc/GMT-3" => "utce03",
        "Etc/GMT-4" => "utce04",
        "Etc/GMT-5" => "utce05",
        "Etc/GMT-6" => "utce06",
        "Etc/GMT-7" => "utce07",
        "Etc/GMT-8" => "utce08",
        "Etc/GMT-9" => "utce09",
        "Etc/GMT0" => "gmt",
        "Etc/Greenwich" => "gmt",
        "Etc/UCT" => "utc",
        "Etc/Universal" => "utc",
        "Etc/Unknown" => "unk",
        "Etc/UTC" => "utc",
        "Etc/Zulu" => "utc",
        "Europe/Amsterdam" => "nlams",
        "Europe/Andorra" => "adalv",
        "Europe/Astrakhan" => "ruasf",
        "Europe/Athens" => "grath",
        "Europe/Belfast" => "gblon",
        "Europe/Belgrade" => "rsbeg",
        "Europe/Berlin" => "deber",
        "Europe/Bratislava" => "skbts",
        "Europe/Brussels" => "bebru",
        "Europe/Bucharest" => "robuh",
        "Europe/Budapest" => "hubud",
        "Europe/Busingen" => "debsngn",
        "Europe/Chisinau" => "mdkiv",
        "Europe/Copenhagen" => "dkcph",
        "Europe/Dublin" => "iedub",
        "Europe/Gibraltar" => "gigib",
        "Europe/Guernsey" => "gggci",
        "Europe/Helsinki" => "fihel",
        "Europe/Isle_of_Man" => "imdgs",
        "Europe/Istanbul" => "trist",
        "Europe/Jersey" => "jesth",
        "Europe/Kaliningrad" => "rukgd",
        "Europe/Kiev" => "uaiev",
        "Europe/Kirov" => "rukvx",
        "Europe/Kyiv" => "uaiev",
        "Europe/Lisbon" => "ptlis",
        "Europe/Ljubljana" => "silju",
        "Europe/London" => "gblon",
        "Europe/Luxembourg" => "lulux",
        "Europe/Madrid" => "esmad",
        "Europe/Malta" => "mtmla",
        "Europe/Mariehamn" => "fimhq",
        "Europe/Minsk" => "bymsq",
        "Europe/Monaco" => "mcmon",
        "Europe/Moscow" => "rumow",
        "Europe/Nicosia" => "cynic",
        "Europe/Oslo" => "noosl",
        "Europe/Paris" => "frpar",
        "Europe/Podgorica" => "metgd",
        "Europe/Prague" => "czprg",
        "Europe/Riga" => "lvrix",
        "Europe/Rome" => "itrom",
        "Europe/Samara" => "rukuf",
        "Europe/San_Marino" => "smsai",
        "Europe/Sarajevo" => "basjj",
        "Europe/Saratov" => "rurtw",
        "Europe/Simferopol" => "uasip",
        "Europe/Skopje" => "mkskp",
        "Europe/Sofia" => "bgsof",
        "Europe/Stockholm" => "sesto",
        "Europe/Tallinn" => "eetll",
        "Europe/Tirane" => "altia",
        "Europe/Tiraspol" => "mdkiv",
        "Europe/Ulyanovsk" => "ruuly",
        "Europe/Uzhgorod" => "uaiev",
        "Europe/Vaduz" => "livdz",
        "Europe/Vatican" => "vavat",
        "Europe/Vienna" => "atvie",
        "Europe/Vilnius" => "ltvno",
        "Europe/Volgograd" => "ruvog",
        "Europe/Warsaw" => "plwaw",
        "Europe/Zagreb" => "hrzag",
        "Europe/Zaporozhye" => "uaiev",
        "Europe/Zurich" => "chzrh",
        GB => "gblon",
        "GB-Eire" => "gblon",
        GMT => "gmt",
        "GMT+0" => "gmt",
        "GMT-0" => "gmt",
        GMT0 => "gmt",
        Greenwich => "gmt",
        Hongkong => "hkhkg",
        HST => "utcw10",
        Iceland => "isrey",
        "Indian/Antananarivo" => "mgtnr",
        "Indian/Chagos" => "iodga",
        "Indian/Christmas" => "cxxch",
        "Indian/Cocos" => "cccck",
        "Indian/Comoro" => "kmyva",
        "Indian/Kerguelen" => "tfpfr",
        "Indian/Mahe" => "scmaw",
        "Indian/Maldives" => "mvmle",
        "Indian/Mauritius" => "muplu",
        "Indian/Mayotte" => "ytmam",
        "Indian/Reunion" => "rereu",
        Iran => "irthr",
        Israel => "jeruslm",
        Jamaica => "jmkin",
        Japan => "jptyo",
        Kwajalein => "mhkwa",
        Libya => "lytip",
        "Mexico/BajaNorte" => "mxtij",
        "Mexico/BajaSur" => "mxmzt",
        "Mexico/General" => "mxmex",
        MST => "utcw07",
        MST7MDT => "mst7mdt",
        Navajo => "usden",
        NZ => "nzakl",
        "NZ-CHAT" => "nzcht",
        "Pacific/Apia" => "wsapw",
        "Pacific/Auckland" => "nzakl",
        "Pacific/Bougainville" => "pgraw",
        "Pacific/Chatham" => "nzcht",
        "Pacific/Chuuk" => "fmtkk",
        "Pacific/Easter" => "clipc",
        "Pacific/Efate" => "vuvli",
        "Pacific/Enderbury" => "kipho",
        "Pacific/Fakaofo" => "tkfko",
        "Pacific/Fiji" => "fjsuv",
        "Pacific/Funafuti" => "tvfun",
        "Pacific/Galapagos" => "ecgps",
        "Pacific/Gambier" => "pfgmr",
        "Pacific/Guadalcanal" => "sbhir",
        "Pacific/Guam" => "gugum",
        "Pacific/Honolulu" => "ushnl",
        "Pacific/Johnston" => "ushnl",
        "Pacific/Kanton" => "kipho",
        "Pacific/Kiritimati" => "kicxi",
        "Pacific/Kosrae" => "fmksa",
        "Pacific/Kwajalein" => "mhkwa",
        "Pacific/Majuro" => "mhmaj",
        "Pacific/Marquesas" => "pfnhv",
        "Pacific/Midway" => "ummdy",
        "Pacific/Nauru" => "nrinu",
        "Pacific/Niue" => "nuiue",
        "Pacific/Norfolk" => "nfnlk",
        "Pacific/Noumea" => "ncnou",
        "Pacific/Pago_Pago" => "asppg",
        "Pacific/Palau" => "pwror",
        "Pacific/Pitcairn" => "pnpcn",
        "Pacific/Pohnpei" => "fmpni",
        "Pacific/Ponape" => "fmpni",
        "Pacific/Port_Moresby" => "pgpom",
        "Pacific/Rarotonga" => "ckrar",
        "Pacific/Saipan" => "mpspn",
        "Pacific/Samoa" => "asppg",
        "Pacific/Tahiti" => "pfppt",
        "Pacific/Tarawa" => "kitrw",
        "Pacific/Tongatapu" => "totbu",
        "Pacific/Truk" => "fmtkk",
        "Pacific/Wake" => "umawk",
        "Pacific/Wallis" => "wfmau",
        "Pacific/Yap" => "fmtkk",
        Poland => "plwaw",
        Portugal => "ptlis",
        PRC => "cnsha",
        PST8PDT => "pst8pdt",
        ROC => "twtpe",
        ROK => "krsel",
        Singapore => "sgsin",
        Turkey => "trist",
        UCT => "utc",
        Universal => "utc",
        "US/Alaska" => "usanc",
        "US/Aleutian" => "usadk",
        "US/Arizona" => "usphx",
        "US/Central" => "uschi",
        "US/East-Indiana" => "usind",
        "US/Eastern" => "usnyc",
        "US/Hawaii" => "ushnl",
        "US/Indiana-Starke" => "usknx",
        "US/Michigan" => "usdet",
        "US/Mountain" => "usden",
        "US/Pacific" => "uslax",
        "US/Pacific-New" => "uslax",
        "US/Samoa" => "asppg",
        UTC => "utc",
        "W-SU" => "rumow",
        Zulu => "utc",
    };
};

sub FREEZE
{
    my $self = CORE::shift( @_ );
    my $serialiser = CORE::shift( @_ ) // '';
    my $class = CORE::ref( $self );
    my %hash  = %$self;
    # Return an array reference rather than a list so this works with Sereal and CBOR
    # On or before Sereal version 4.023, Sereal did not support multiple values returned
    CORE::return( [$class, \%hash] ) if( $serialiser eq 'Sereal' && Sereal::Encoder->VERSION <= version->parse( '4.023' ) );
    # But Storable want a list with the first element being the serialised element
    CORE::return( $class, \%hash );
}

sub STORABLE_freeze { return( shift->FREEZE( @_ ) ); }

sub STORABLE_thaw { return( shift->THAW( @_ ) ); }

# NOTE: CBOR will call the THAW method with the stored classname as first argument, the constant string CBOR as second argument, and all values returned by FREEZE as remaining arguments.
# NOTE: Storable calls it with a blessed object it created followed with $cloning and any other arguments initially provided by STORABLE_freeze
sub THAW
{
    my( $self, undef, @args ) = @_;
    my $ref = ( CORE::scalar( @args ) == 1 && CORE::ref( $args[0] ) eq 'ARRAY' ) ? CORE::shift( @args ) : \@args;
    my $class = ( CORE::defined( $ref ) && CORE::ref( $ref ) eq 'ARRAY' && CORE::scalar( @$ref ) > 1 ) ? CORE::shift( @$ref ) : ( CORE::ref( $self ) || $self );
    my $hash = CORE::ref( $ref ) eq 'ARRAY' ? CORE::shift( @$ref ) : {};
    my $new;
    # Storable pattern requires to modify the object it created rather than returning a new one
    if( CORE::ref( $self ) )
    {
        foreach( CORE::keys( %$hash ) )
        {
            $self->{ $_ } = CORE::delete( $hash->{ $_ } );
        }
        $new = $self;
    }
    else
    {
        $new = CORE::bless( $hash => $class );
    }
    CORE::return( $new );
}

sub TO_JSON { return( shift->as_string ); }

# NOTE: Locale::Unicode::Boolean class
package Locale::Unicode::Boolean;
BEGIN
{
    use strict;
    use warnings;
    use vars qw( $VERSION $true $false );
    use overload
      "0+"     => sub{ ${$_[0]} },
      "++"     => sub{ $_[0] = ${$_[0]} + 1 },
      "--"     => sub{ $_[0] = ${$_[0]} - 1 },
      fallback => 1;
    $true  = do{ bless( \( my $dummy = 1 ) => 'Locale::Unicode::Boolean' ) };
    $false = do{ bless( \( my $dummy = 0 ) => 'Locale::Unicode::Boolean' ) };
    our $VERSION = 'v0.1.0';
};
use strict;
use warnings;

sub new
{
    my $this = shift( @_ );
    my $self = bless( \( my $dummy = ( $_[0] ? 1 : 0 ) ) => ( ref( $this ) || $this ) );
}

sub clone
{
    my $self = shift( @_ );
    unless( ref( $self ) )
    {
        die( "clone() must be called with an object." );
    }
    my $copy = $$self;
    my $new = bless( \$copy => ref( $self ) );
    return( $new );
}

sub false() { $false }

sub is_bool($) { UNIVERSAL::isa( $_[0], 'Locale::Unicode::Boolean' ) }

sub is_true($) { $_[0] && UNIVERSAL::isa( $_[0], 'Locale::Unicode::Boolean' ) }

sub is_false($) { !$_[0] && UNIVERSAL::isa( $_[0], 'Locale::Unicode::Boolean' ) }

sub true() { $true  }

sub FREEZE
{
    my $self = CORE::shift( @_ );
    my $serialiser = CORE::shift( @_ ) // '';
    my $class = CORE::ref( $self );
    # Return an array reference rather than a list so this works with Sereal and CBOR
    # On or before Sereal version 4.023, Sereal did not support multiple values returned
    CORE::return( [$class, $$self] ) if( $serialiser eq 'Sereal' && Sereal::Encoder->VERSION <= version->parse( '4.023' ) );
    # But Storable want a list with the first element being the serialised element
    CORE::return( $$self );
}

sub STORABLE_freeze { CORE::return( CORE::shift->FREEZE( @_ ) ); }

sub STORABLE_thaw { CORE::return( CORE::shift->THAW( @_ ) ); }

# NOTE: CBOR will call the THAW method with the stored classname as first argument, the constant string CBOR as second argument, and all values returned by FREEZE as remaining arguments.
# NOTE: Storable calls it with a blessed object it created followed with $cloning and any other arguments initially provided by STORABLE_freeze
sub THAW
{
    my( $self, undef, @args ) = @_;
    my( $class, $str );
    if( CORE::scalar( @args ) == 1 && CORE::ref( $args[0] ) eq 'ARRAY' )
    {
        ( $class, $str ) = @{$args[0]};
    }
    else
    {
        $class = CORE::ref( $self ) || $self;
        $str = CORE::shift( @args );
    }
    # Storable pattern requires to modify the object it created rather than returning a new one
    if( CORE::ref( $self ) )
    {
        $$self = $str;
        CORE::return( $self );
    }
    else
    {
        CORE::return( $class->new( $str ) );
    }
}

sub TO_JSON
{
    # JSON does not check that the value is a proper true or false. It stupidly assumes this is a string
    # The only way to make it understand is to return a scalar ref of 1 or 0
    # return( $_[0] ? 'true' : 'false' );
    return( $_[0] ? \1 : \0 );
}

# NOTE: Locale::Unicode::Exception class
package Locale::Unicode::Exception;
BEGIN
{
    use strict;
    use warnings;
    use vars qw( $VERSION );
    use overload (
        '""'    => 'as_string',
        bool    => sub{ $_[0] },
        fallback => 1,
    );
    our $VERSION = 'v0.1.0';
};
use strict;
use warnings;
use overloading;

sub new
{
    my $this = shift( @_ );
    my $self = bless( {} => ( ref( $this ) || $this ) );
    my @info = caller;
    @$self{ qw( package file line ) } = @info[0..2];
    my $args = {};
    if( scalar( @_ ) == 1 )
    {
        if( ( ref( $_[0] ) || '' ) eq 'HASH' )
        {
            $args = shift( @_ );
            if( $args->{skip_frames} )
            {
                @info = caller( int( $args->{skip_frames} ) );
                @$self{ qw( package file line ) } = @info[0..2];
            }
            $args->{message} ||= '';
            foreach my $k ( qw( package file line message code type retry_after ) )
            {
                $self->{ $k } = $args->{ $k } if( CORE::exists( $args->{ $k } ) );
            }
        }
        elsif( ref( $_[0] ) && $_[0]->isa( 'Locale::Unicode::Exception' ) )
        {
            my $o = $args->{object} = shift( @_ );
            $self->{message} = $o->message;
            $self->{code} = $o->code;
            $self->{type} = $o->type;
            $self->{retry_after} = $o->retry_after;
        }
        else
        {
            die( "Unknown argument provided: '", overload::StrVal( $_[0] ), "'" );
        }
    }
    else
    {
        $args->{message} = join( '', map( ref( $_ ) eq 'CODE' ? $_->() : $_, @_ ) );
    }
    return( $self );
}

# This is important as stringification is called by die, so as per the manual page, we need to end with new line
# And will add the stack trace
sub as_string
{
    no overloading;
    my $self = shift( @_ );
    return( $self->{_cache_value} ) if( $self->{_cache_value} && !CORE::length( $self->{_reset} // '' ) );
    my $str = $self->message;
    $str = "$str";
    $str =~ s/\r?\n$//g;
    $str .= sprintf( " within package %s at line %d in file %s", ( $self->{package} // 'undef' ), ( $self->{line} // 'undef' ), ( $self->{file} // 'undef' ) );
    $self->{_cache_value} = $str;
    CORE::delete( $self->{_reset} );
    return( $str );
}

sub code { return( shift->reset(@_)->_set_get_prop( 'code', @_ ) ); }

sub file { return( shift->reset(@_)->_set_get_prop( 'file', @_ ) ); }

sub line { return( shift->reset(@_)->_set_get_prop( 'line', @_ ) ); }

sub message { return( shift->reset(@_)->_set_get_prop( 'message', @_ ) ); }

sub package { return( shift->reset(@_)->_set_get_prop( 'package', @_ ) ); }

# From perlfunc docmentation on "die":
# "If LIST was empty or made an empty string, and $@ contains an
# object reference that has a "PROPAGATE" method, that method will
# be called with additional file and line number parameters. The
# return value replaces the value in $@; i.e., as if "$@ = eval {
# $@->PROPAGATE(__FILE__, __LINE__) };" were called."
sub PROPAGATE
{
    my( $self, $file, $line ) = @_;
    if( defined( $file ) && defined( $line ) )
    {
        my $clone = $self->clone;
        $clone->file( $file );
        $clone->line( $line );
        return( $clone );
    }
    return( $self );
}

sub reset
{
    my $self = shift( @_ );
    if( !CORE::length( $self->{_reset} // '' ) && scalar( @_ ) )
    {
        $self->{_reset} = scalar( @_ );
    }
    return( $self );
}

sub rethrow 
{
    my $self = shift( @_ );
    return if( !ref( $self ) );
    die( $self );
}

sub retry_after { return( shift->_set_get_prop( 'retry_after', @_ ) ); }

sub throw
{
    my $self = shift( @_ );
    my $e;
    if( @_ )
    {
        my $msg  = shift( @_ );
        $e = $self->new({
            skip_frames => 1,
            message => $msg,
        });
    }
    else
    {
        $e = $self;
    }
    die( $e );
}

sub type { return( shift->reset(@_)->_set_get_prop( 'type', @_ ) ); }

sub _set_get_prop
{
    my $self = shift( @_ );
    my $prop = shift( @_ ) || die( "No object property was provided." );
    $self->{ $prop } = shift( @_ ) if( @_ );
    return( $self->{ $prop } );
}

sub FREEZE
{
    my $self = CORE::shift( @_ );
    my $serialiser = CORE::shift( @_ ) // '';
    my $class = CORE::ref( $self );
    my %hash  = %$self;
    # Return an array reference rather than a list so this works with Sereal and CBOR
    # On or before Sereal version 4.023, Sereal did not support multiple values returned
    CORE::return( [$class, \%hash] ) if( $serialiser eq 'Sereal' && Sereal::Encoder->VERSION <= version->parse( '4.023' ) );
    # But Storable want a list with the first element being the serialised element
    CORE::return( $class, \%hash );
}

sub STORABLE_freeze { return( shift->FREEZE( @_ ) ); }

sub STORABLE_thaw { return( shift->THAW( @_ ) ); }

# NOTE: CBOR will call the THAW method with the stored classname as first argument, the constant string CBOR as second argument, and all values returned by FREEZE as remaining arguments.
# NOTE: Storable calls it with a blessed object it created followed with $cloning and any other arguments initially provided by STORABLE_freeze
sub THAW
{
    my( $self, undef, @args ) = @_;
    my $ref = ( CORE::scalar( @args ) == 1 && CORE::ref( $args[0] ) eq 'ARRAY' ) ? CORE::shift( @args ) : \@args;
    my $class = ( CORE::defined( $ref ) && CORE::ref( $ref ) eq 'ARRAY' && CORE::scalar( @$ref ) > 1 ) ? CORE::shift( @$ref ) : ( CORE::ref( $self ) || $self );
    my $hash = CORE::ref( $ref ) eq 'ARRAY' ? CORE::shift( @$ref ) : {};
    my $new;
    # Storable pattern requires to modify the object it created rather than returning a new one
    if( CORE::ref( $self ) )
    {
        foreach( CORE::keys( %$hash ) )
        {
            $self->{ $_ } = CORE::delete( $hash->{ $_ } );
        }
        $new = $self;
    }
    else
    {
        $new = CORE::bless( $hash => $class );
    }
    CORE::return( $new );
}

sub TO_JSON { return( shift->as_string ); }

{
    # NOTE: Locale::Unicode::NullObject class
    package
        Locale::Unicode::NullObject;
    BEGIN
    {
        use strict;
        use warnings;
        use overload (
            '""'    => sub{ '' },
            fallback => 1,
        );
        use Want;
    };
    use strict;
    use warnings;

    sub new
    {
        my $this = shift( @_ );
        my $ref = @_ ? { @_ } : {};
        return( bless( $ref => ( ref( $this ) || $this ) ) );
    }

    sub AUTOLOAD
    {
        my( $method ) = our $AUTOLOAD =~ /([^:]+)$/;
        my $self = shift( @_ );
        if( Want::want( 'OBJECT' ) )
        {
            rreturn( $self );
        }
        # Otherwise, we return undef; Empty return returns undef in scalar context and empty list in list context
        return;
    };
}

1;
# NOTE: POD
__END__

=encoding utf-8

=head1 NAME

Locale::Unicode - Unicode Locale Identifier compliant with BCP47 and CLDR

=head1 SYNOPSIS

    use Locale::Unicode;
    my $locale = Locale::Unicode->new( 'ja-Kana-t-it' ) ||
        die( Locale::Unicode->error );
    say $locale; # ja-Kana-t-it

    # Some undefined locale in Cyrillic script
    my $locale = Locale::Unicode->new( 'und-Cyrl' );
    $locale->transform( 'und-latn' );
    $locale->mechanism( 'ungegn-2007' );
    say $locale; # und-Cyrl-t-und-latn-m0-ungegn-2007
    # A locale in Cyrillic, transformed from Latin, according to a UNGEGN specification dated 2007.

    # Enabling fatal exceptions
    use v5.34;
    use experimental 'try';
    no warnings 'experimental';
    try
    {
        my $locale = Locale::Unicode->new( 'x', fatal => 1 );
        # More code
    }
    catch( $e )
    {
        say "Oops: ", $e->message;
    }

Or, you could set the global variable C<$FATAL_EXCEPTIONS> instead:

    use v5.34;
    use experimental 'try';
    no warnings 'experimental';
    local $Locale::Unicode::FATAL_EXCEPTIONS = 1;
    try
    {
        my $locale = Locale::Unicode->new( 'x' );
        # More code
    }
    catch( $e )
    {
        say "Oops: ", $e->message;
    }

This API detects when methods are called in object context and return the current object:

    $locale->translation( 'my-software' )->tz( 'jptyo' )->ca( 'japanese' )

In Scalar or in list context, the value returned is the last value set.

    $locale->translation( 'my-software' ); # my-software
    $locale->translation( 'other-software' ); # other-software

=head1 VERSION

    v0.3.11

=head1 DESCRIPTION

This module implements the L<Unicode LDML (Locale Data Markup Language) extensions|https://unicode.org/reports/tr35/#u_Extension>

It does not enforce the standard, and is merely an API to construct, access and modify locales. It is your responsibility to set the right values.

The only requirement is to provide a proper L<language|https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier>, which is a 2 or 3-characters code, or a L<privateuse or other grandfathered language tags|https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.8>

For your convenience, summary of key elements of the standard can be found in this documentation.

It is lightweight and fast with no dependency outside of L<Scalar::Util> and L<Want>. It requires perl C<v5.10.1> minimum to operate.

The object stringifies, and once its string value is computed, it is cached and re-used until it is changed. Thus repetitive call to L<as_string|/as_string> or to stringification does not incur any speed penalty by recomputing what has not changed.

See the L<LDML specifications|https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier> fore more information of what composes a Unicode language identifier.

=head1 CONSTRUCTOR

=head2 new

    # Sets the language 'en'
    my $locale = Locale::Unicode->new( 'en' );
    # Sets the language 'en' with territory 'GB'
    my $locale = Locale::Unicode->new( 'en-GB' );
    # Sets the language 'en' with script 'Latn' and territory 'AU'
    my $locale = Locale::Unicode->new( 'en-Latn-AU' );
    my $locale = Locale::Unicode->new( 'he-IL-u-ca-hebrew-tz-jeruslm' );
    my $locale = Locale::Unicode->new( 'ja-Kana-t-it' );
    my $locale = Locale::Unicode->new( 'und-Latn-t-und-cyrl' );
    my $locale = Locale::Unicode->new( 'und-Cyrl-t-und-latn-m0-ungegn-2007' );
    my $locale = Locale::Unicode->new( 'de-u-co-phonebk-ka-shifted' );
    # Machine translated from German to Japanese using an undefined vendor
    my $locale = Locale::Unicode->new( 'ja-t-de-t0-und' );
    $locale->script( 'Kana' );
    $locale->country_code( 'JP' );
    # Now: ja-Kana-JP-t-de-t0-und

This takes a C<locale> as compliant with the BCP47 standard upgraded by the L<LDML specifications|https://unicode.org/reports/tr35>, and an optional hash or hash reference of options and this returns a new object.

The C<locale> provided is parsed and its components can be accessed and modified using all the methods of this class API.

If an hash or hash reference of options are provided, it will be used to set or modify the components from the C<locale> provided.

If an error occurs, an L<exception object|Locale::Unicode::Exception> is set and C<undef> is returned in scalar context, or an empty list in list context. The L<exception object|Locale::Unicode::Exception> can then be retrieved using L<error|/error>, such as:

    my $locale = Locale::Unicode->new( $somthing_bad ) ||
        die( Locale::Unicode->error );

=head1 METHODS

All the methods below are context sensitive.

If they are called in an object context, they will return the current C<Locale::Unicode> object for chaining, otherwise, they will return the current value. And if that value is C<undef>, it will return C<undef> in scalar context, but an empty list in list context.

Also, if an error occurs, it will set an L<exception object|Locale::Unicode::Exception> and returns C<undef> in scalar context, or an empty list in list context.

=head2 apply

    my $hash_reference = Locale::Unicode->parse( 'ja-Kana-t-it' );
    $locale->apply( $hash_reference );

Provided with an hash reference of key-value pairs, and this will set each corresponding method with the associated value.

If a property provided has no corresponding method, it emits a warning if L<warnings are enabled|warnings/"warnings::enabled()">

It returns the current object upon success, or sets an L<error object|Module::Generic::Exception> upon error and returns C<undef> in scalar context, or an empty list in list context.

=head2 as_string

Returns the Locale object as a string, based on its latest attributes set.

The string value returned is computed only once and further call to C<as_string> returns a cached value unless changes were made to the Locale attributes.

Boolean values are expressed as C<true> for tue values and C<false> for false values. However, if a value is true for a given C<locale> component, it is not explicitly stated by default, since the C<LDML> specifications indicate, it is true implicitly. If, however, you want the true boolean value to be displayed nevertheless, make sure to set the global variable C<$EXPLICIT_BOOLEAN> to a true value.

For example:

    my $locale = Locale::Unicode->new( 'ko-Kore-KR', {
        # You can also use 1 or 'yes' as per the specifications
        colNumeric => 'true',
        colCaseFirst => 'upper'
    });
    say $locale; # ko-Kore-KR-u-kf-upper-kn

    local $EXPLICIT_BOOLEAN = 1;
    my $locale = Locale::Unicode->new( 'ko-Kore-KR', {
        # You can also use 1 or 'yes' as per the specifications
        colNumeric => 'true',
        colCaseFirst => 'upper'
    });
    say $locale; # ko-Kore-KR-u-kf-upper-kn-true

=head2 base

    my $locale = Locale::Unicode->new( 'en-US' );
    say $locale->base; # en-US

    my $locale = Locale::Unicode->new( 'en-Latn-US-posix-t-de-AT-t0-und-x0-medical' );
    say $locale->base; # en-Latn-US-posix
    $locale->base( 'ja-JP' );
    say $locale->base; # ja-JP
    say $locale; ja-JP-t-de-AT-t0-und-x0-medical

This method sets or gets the L<base part|https://datatracker.ietf.org/doc/html/rfc6067#section-2.1> of the C<locale>

The C<base> part is composed of the L<language_id|/language_id>, an optional L<script|/script>, an optional L<territory|/territory> and zero or more L<variants|/variant>

If a value is provided, it will replace the current C<locale> object C<base>

If an improper C<base> value is provided, it will set an L<error object|Locale::Unicode::Exception> and return C<undef> in scalar context and an empty list in list context.

It returns the current base as a string.

=head2 break_exclusion

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->break_exclusion( 'hani-hira-kata' );
    # Now: ja-dx-hani-hira-kata

This is a Unicode Dictionary Break Exclusion Identifier that specifies scripts to be excluded from dictionary-based text break (for words and lines).

Sets or gets the Unicode extension C<dx>

See also L<dx|/dx>

=head2 ca

This is an alias for L</calendar>

=head2 calendar

    my $locale = Locale::Unicode->new( 'th' );
    $locale->calendar( 'buddhist' );
    # or:
    # $locale->ca( 'buddhist' );
    # Now: th-u-ca-buddhist
    # which is the Thai with Buddist calendar

Sets or gets the Unicode extension C<ca>, which is a L<calendar identifier|https://unicode.org/reports/tr35/#UnicodeCalendarIdentifier>.

See the section on L</"BCP47 EXTENSIONS"> for the proper values.

=head2 canonical

This returns a L<clone|/clone> of the current object, formatted as per the L<Unicode locale canonical specifications|https://unicode.org/reports/tr35/tr35.html#Canonical_Unicode_Locale_Identifiers>.

This means that:

=over 4

=item * C<variant>

Variants are sorted and made in lower case.

    my $locale = Locale::Unicode->new( 'en-Scouse-fonipA' );
    say $locale->canonical; # en-fonipa-scouse

Any duplicates are removed as L<per the LDML specifications|https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier>.

    my $locale = Locale::Unicode->new( 'de-1996-fonipa-1996' );
    say $locale->canonical; # de-1996-fonipa    

=item * C<territory>

Territory is made in upper case

    my $locale = Locale::Unicode->new( 'en-us' );
    say $locale->canonical; # en-US

    # Spanish as spoken in South America
    my $locale = Locale::Unicode->new( 'es-005' );
    say $locale->canonical; # es-005

=item * C<script>

Script is formatted in title case.

    my $locale = Locale::Unicode->new( 'ja-kana-jp' );
    say $locale->canonical; # ja-Kana-JP

=item * C<language>

The language code is made in lower case.

The special C<language> code C<root> is replaced by C<und>

=back

See the L<LDML specifications|https://unicode.org/reports/tr35/tr35.html#5.-canonicalizing-syntax> for more information.

See also the method L<Locale::Unicode::Data/normalise>

=head2 cf

This is an alias for L</cu_format>

=head2 clone

Clones the current object and returns the newly instantiated copy.

If an error occurs, this sets an L<exception object|Locale::Unicode::Exception> and returns C<undef> in scalar context, and an empty list in list context.

=head2 co

    my $locale = Locale::Unicode->new( 'de' );
    $locale->collation( 'phonebk' );
    $locale->ka( 'shifted' );
    # Now: de-u-co-phonebk-ka-shifted

This is a Unicode collation identifier that specifies a type of collation (sort order).

This is an alias for L</collation>

=head2 colAlternate

    my $locale = Locale::Unicode->new( 'de' );
    $locale->collation( 'phonebk' );
    $locale->ka( 'shifted' );
    # Now: de-u-co-phonebk-ka-shifted

    $locale->collation( 'noignore' );
    # or similarly:
    $locale->collation( 'non-ignorable' );

Sets alternate handling for variable weights.

Sets or gets the Unicode extension C<ka>

See L</"Collation Options"> for more information.

=head2 colBackwards

    $locale->colBackwards(1); # true
    # Now: kb-true
    $locale->colBackwards(0); # false
    # Now: kb-false

Sets collation boolean value for backward collation weight.

Sets or gets the Unicode extension C<kb>

See L</"Collation Options"> for more information.

=head2 colCaseFirst

    $locale->colCaseFirst( undef ); # false (default)
    $locale->colCaseFirst( 'upper' );
    $locale->colCaseFirst( 'lower' );

Sets or gets the Unicode extension C<kf>

See L</"Collation Options"> for more information.

=head2 colCaseLevel

    $locale->colCaseLevel(1); # true
    # Now: kc-true
    $locale->colCaseLevel(0); # false
    # Now: kc-false

Sets collation boolean value for case level.

Sets or gets the Unicode extension C<kc>

See L</"Collation Options"> for more information.

=head2 colHiraganaQuaternary

    $locale->colHiraganaQuaternary(1); # true
    # Now: kh-true
    $locale->colHiraganaQuaternary(0); # false
    # Now: kh-false

Sets collation parameter key for special Hiragana handling.

Sets or gets the Unicode extension C<kh>

See L</"Collation Options"> for more information.

=head2 collation

    my $locale = Locale::Unicode->new( 'fr' );
    $locale->collation( 'emoji' );
    # Now: fr-u-co-emoji

    my $locale = Locale::Unicode->new( 'de' );
    $locale->collation( 'phonebk' );
    # Now: de-u-co-phonebk
    # which is: German using Phonebook sorting

Sets or gets the Unicode extension C<co>

This specifies a type of collation (sort order).

See L</"Unicode extensions"> for possible values and more information on standard.

See also L</"Collation Options"> for more on collation options.

=head2 colNormalisation

This is an alias for L<colNormalization|/colNormalization>

=head2 colNormalization

    $locale->colNormalization(1); # true
    # Now: kk-true
    $locale->colNormalization(0); # false
    # Now: kk-false

Sets collation parameter key for normalisation.

Sets or gets the Unicode extension C<kk>

See L</"Collation Options"> for more information.

=head2 colNumeric

    $locale->colNumeric(1); # true
    # Now: kn-true
    $locale->colNumeric(0); # false
    # Now: kn-false

Sets collation parameter key for numeric handling.

Sets or gets the Unicode extension C<kn>

See L</"Collation Options"> for more information.

=head2 colReorder

    my $locale = Locale::Unicode->new( 'en' );
    $locale->colReorder( 'latn-digit' );
    # Now: en-u-kr-latn-digit
    # Reorder digits after Latin characters.

    my $locale = Locale::Unicode->new( 'en' );
    $locale->colReorder( 'arab-cyrl-others-symbol' );
    # Now: en-u-kr-arab-cyrl-others-symbol
    # Reorder Arabic characters first, then Cyrillic, and put
    # symbols at the end—after all other characters.

Sets collation reorder codes.

Sets or gets the Unicode extension C<kr>

See L</"Collation Options"> for more information.

=head2 shiftedGroup

This is an alias for L</colValue>

=head2 colStrength

    $locale->colStrength( 'level1' );
    # Now: ks-level1
    # or, equivalent:
    $locale->colStrength( 'primary' );

    $locale->colStrength( 'level2' );
    # or, equivalent:
    $locale->colStrength( 'secondary' );

    $locale->colStrength( 'level3' );
    # or, equivalent:
    $locale->colStrength( 'tertiary' );

    $locale->colStrength( 'level4' );
    # or, equivalent:
    $locale->colStrength( 'quaternary' );
    $locale->colStrength( 'quarternary' );

    $locale->colStrength( 'identic' );
    $locale->colStrength( 'identic' );
    $locale->colStrength( 'identical' );

Sets the collation parameter key for collation strength used for comparison.

Sets or gets the Unicode extension C<ks>

See L</"Collation Options"> for more information.

=head2 colValue

    $locale->colValue( 'currency' );
    $locale->colValue( 'punct' );
    $locale->colValue( 'space' );
    $locale->colValue( 'symbol' );

Sets the collation value for the last reordering group to be affected by L<ka-shifted|/colAlternate>.

Sets or gets the Unicode extension C<kv>

See L</"Collation Options"> for more information.

=head2 colVariableTop

Sets the string value for the variable top.

Sets or gets the Unicode extension C<vt>

See L</"Collation Options"> for more information.

=head2 core

    my $locale = Locale::Unicode->new( 'ja-Kana-JP-t-de-AT-t0-und-u-ca-japanese-tz-jptyo' );
    say $locale->core; # ja-Kana-JP
    my $locale = Locale::Unicode->new( 'es-001-valencia-t-und-latn-m0-ungegn-2007' );
    say $locale->core; # es-001-valencia

This is a read-only method.

It returns the core part of the C<locale>, which is composed of a 2 to 3-characters code, some optional C<script> and C<country> or C<region> code, and some option C<variant> ID.

=head2 country_code

    my $locale = Locale::Unicode->new( 'en' );
    $locale->country_code( 'US' );
    # Now: en-US
    $locale->country_code( 'GB' );
    # Now: en-GB

Sets or gets the country code part of the C<locale>.

A country code should be an ISO 3166 2-letters code, but keep in mind that the C<LDML> (Locale Data Markup Language) accepts old data to ensure stability.

Note that when you set a country code, it will automatically unset any L<region|/region> code.

    my $locale = Locale::Unicode->new( 'en-001' );
    say $locale->region; # 001
    $locale->country_code( 'US' );
    say $locale->region; # undef
    say $locale; # en-US

You can use L</territory> alternatively.

=head2 cu

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->cu( 'jpy' );
    # Now: ja-u-cu-jpy
    # which is the Japanese Yens

This is a Unicode currency identifier that specifies a type of currency (ISO 4217 code.

This is an alias for L</currency>

=head2 cu_format

    # Using minus sign symbol for negative numbers
    $locale->cf( 'standard' );
    # Using parentheses for negative numbers
    $locale->cf( 'account' );

This is a currency format identifier such as C<standard> or C<account>

Sets or gets the Unicode extension C<cf>

See the section on L</"BCP47 EXTENSIONS"> for the proper values.

=head2 currency

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->currency( 'jpy' );
    # or
    # $locale->cu( 'jpy' );
    # Now: ja-u-cu-jpy
    # which is the Japanese yens

Sets or gets the Unicode extension C<cu>

This specifies a type of ISO4217 currency code.

=head2 d0

This is an alias for L</destination>

=head2 dest

This is an alias for L</destination>

=head2 destination

Sets or gets the Transformation extension C<d0> for destination.

See the section on L</"Transform extensions"> for more information.

=head2 dx

This is an alias for L</break_exclusion>

=head2 em

This is an alias for L</emoji>

=head2 emoji

This is a Unicode Emoji Presentation Style Identifier that specifies a request for the preferred emoji presentation style.

Sets or gets the Unicode extension C<em>.

=head2 error

Used as a mutator, this sets and L<exception object|Locale::Unicode::Exception> and returns an C<Locale::Unicode::NullObject> in object context (such as when chaining), or C<undef> in scalar context, or an empty list in list context.

The C<Locale::Unicode::NullObject> class prevents the perl error of C<Can't call method "%s" on an undefined value> (see L<perldiag>). Upon the last method chained, C<undef> is returned in scalar context or an empty list in list context.

For example:

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->translation( 'my-software' )->transform_locale( $bad_value )->tz( 'jptyo' ) ||
        die( $locale->error );

In this example, C<jptyo> will never be set, because C<transform_locale> triggered an exception that returned an C<Locale::Unicode::NullObject> object catching all further method calls, but eventually we get the error and die.

=head2 extended

    # Chinese, Mandarin, Simplified script, as used in China
    my $locale = Locale::Unicode->new( 'zh-cmn-Hans-CN' );
    say $locale->extended; # cmn

    # Mandarin Chinese, Simplified script, as used in China
    my $locale = Locale::Unicode->new( 'cmn-Hans-CN' );
    say $locale->extended; # undef
    say $locale->script; # Hans

    # Chinese, Cantonese, as used in Hong Kong SAR
    my $locale = Locale::Unicode->new( 'zh-yue-HK' );
    say $locale->extended; # yue

Sets or gets the C<extended> C<language> subtags. As per the standard, a language ID may be followed by up to 3 C<extended> C<language> subtag. However, the L<standard states|https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.2>: "Although the ABNF production 'extlang' permits up to three extended language tags in the language tag, extended language subtags MUST NOT include another extended language subtag in their 'Prefix'. That is, the second and third extended language subtag positions in a language tag are permanently reserved and tags that include those subtags in that position are, and will always remain, invalid."

The regular expression in L<Locale::Unicode> supports the C<extended> language subtag inherited by Unicode from C<BCP47>, although L<it is not strictly supported by the standard|https://unicode.org/reports/tr35/tr35.html#BCP_47_Conformance>. This is done in order to ensure maximum portability and flexibility.

=head2 false

This is read-only and returns a L<Locale::Unicode::Boolean> object representing a false value.

=head2 fatal

    $locale->fatal(1); # Enable fatal exceptions
    $locale->fatal(0); # Disable fatal exceptions
    my $bool = $locale->fatal;

Sets or get the boolean value, whether to die upon exception, or not. If set to true, then instead of setting an L<exception object|Locale::Unicode::Exception>, this module will die with an L<exception object|Locale::Unicode::Exception>. You can catch the exception object then after using C<try>. For example:

    use v.5.34; # to be able to use try-catch blocks in perl
    use experimental 'try';
    no warnings 'experimental';
    try
    {
        my $locale = Locale::Unicode->new( 'x', fatal => 1 );
    }
    catch( $e )
    {
        say "Error occurred: ", $e->message;
        # Error occurred: Invalid locale value "x" provided.
    }

=head2 first_day

This is a Unicode First Day Identifier that specifies the preferred first day of the week for calendar display.

Sets or gets the Unicode extension C<fw>.

Its values are C<sun>, C<mon>, etc... C<sat>

=head2 fw

This is an alias for L</first_day>

=head2 grandfathered

    # auto-detect and sets an irregular grandfathered language tag
    $locale->grandfathered( 'i-klingon' );
    # sets a regular grandfathered language tag
    $locale->grandfathered( 'zh-hakka' );

Sets or gets a L<regular|/grandfathered_regular> or L<irregular|/grandfathered_irregular> L<grandfathered language tags|https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.8>

Those language tags are old-style language tags, that, although they remain valid for most of them, their format has morphed, and most of them have been superseded.

This is a convenient method that takes a language tag, and based on its value, this will call the method L<regular|/grandfathered_regular> or L<irregular|/grandfathered_irregular>

If you set a grandfathered language tag, this will automatically unset the L<language|/language>, L<language3|/language3> or L<privateuse|/privateuse> tag value.

The regular expression in L<Locale::Unicode> supports the C<grandfathered> language subtag inherited by Unicode from C<BCP47>, although L<it is not strictly supported by the standard|https://unicode.org/reports/tr35/tr35.html#BCP_47_Conformance>. This is done in order to ensure maximum portability and flexibility.

=head2 grandfathered_irregular

    $locale->grandfathered_irregular( 'en-GB-oed' );
    $locale->grandfathered_irregular( 'i-ami' );
    $locale->grandfathered_irregular( 'i-bnn' );
    $locale->grandfathered_irregular( 'i-default' );
    $locale->grandfathered_irregular( 'i-enochian' );
    $locale->grandfathered_irregular( 'i-hak' );
    $locale->grandfathered_irregular( 'i-klingon' );
    $locale->grandfathered_irregular( 'i-lux' );
    $locale->grandfathered_irregular( 'i-mingo' );
    $locale->grandfathered_irregular( 'i-navajo' );
    $locale->grandfathered_irregular( 'i-pwn' );
    $locale->grandfathered_irregular( 'i-tao' );
    $locale->grandfathered_irregular( 'i-tay' );
    $locale->grandfathered_irregular( 'i-tsu' );
    $locale->grandfathered_irregular( 'sgn-BE-FR' );
    $locale->grandfathered_irregular( 'sgn-BE-NL' );
    $locale->grandfathered_irregular( 'sgn-CH-DE' );

Sets or gets an L<irregular grandfathered language tag|https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.8>.

Setting a value, including C<undef>, will unset the L<language|/language>, L<language3|/language3>, L<privateuse|/privateuse> or L<grandfathered_regular|/grandfathered_regular> tag value.

The regular expression in L<Locale::Unicode> supports the C<grandfathered> language subtag inherited by Unicode from C<BCP47>, although L<it is not strictly supported by the standard|https://unicode.org/reports/tr35/tr35.html#BCP_47_Conformance>. This is done in order to ensure maximum portability and flexibility.

=head2 grandfathered_regular

    $locale->grandfathered_regular( 'art-lojban' );
    $locale->grandfathered_regular( 'cel-gaulish' );
    $locale->grandfathered_regular( 'no-bok' );
    $locale->grandfathered_regular( 'no-nyn' );
    $locale->grandfathered_regular( 'zh-guoyu' );
    $locale->grandfathered_regular( 'zh-hakka' );
    $locale->grandfathered_regular( 'zh-min' );
    $locale->grandfathered_regular( 'zh-min-nan' );
    $locale->grandfathered_regular( 'zh-xiang' );

Sets or gets a L<regular grandfathered language tag|https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.8>.

Setting a value, including C<undef>, will unset the L<language|/language>, L<language3|/language3>, L<privateuse|/privateuse> or L<grandfathered_irregular|/grandfathered_irregular> tag value.

The regular expression in L<Locale::Unicode> supports the C<grandfathered> language subtag inherited by Unicode from C<BCP47>, although L<it is not strictly supported by the standard|https://unicode.org/reports/tr35/tr35.html#BCP_47_Conformance>. This is done in order to ensure maximum portability and flexibility.

=head2 h0

This is an alias for L</hybrid>

=head2 hc

This is an alias for L</hour_cycle>

=head2 hour_cycle

This is a Unicode Hour Cycle Identifier that specifies the preferred time cycle.

Sets or gets the Unicode extension C<hc>.

=head2 hybrid

    my $locale = Locale::Unicode->new( 'ru' );
    $locale->transform( 'en' );
    $locale->hybrid(1); # true
    # or
    # $locale->hybrid( 'hybrid' );
    # or
    # $locale->h0( 'hybrid' );
    # Now: ru-t-en-h0-hybrid
    # Hybrid Cyrillic - Runglish

    my $locale = Locale::Unicode->new( 'en' );
    $locale->transform( 'zh-hant' );
    $locale->hybrid( 'hybrid' );
    # Now: en-t-zh-hant-h0-hybrid
    # which is Hybrid Latin - Chinglish

Those are Hybrid Locale Identifiers indicating that the C<t> value is a language that is mixed into the main language tag to form a hybrid.

Sets or gets the Transformation extension C<h0>.

See the section on L</"Transform extensions"> for more information.

=head2 i0

This is an alias for L</input>

=head2 k0

This is an alias for L</keyboard>

=head2 input

    my $locale = Locale::Unicode->new( 'zh' );
    $locale->input( 'pinyin' );
    # Now: zh-t-i0-pinyin

This is an Input Method Engine transformation.

Sets or gets the Transformation extension C<i0>.

See the section on L</"Transform extensions"> for more information.

=head2 ka

This is an alias for L</colAlternate>

=head2 kb

This is an alias for L</colBackwards>

=head2 kc

This is an alias for L</colCaseLevel>

=head2 keyboard

    my $locale = Locale::Unicode->new( 'en' );
    $locale->keyboard( 'dvorak' );
    # Now: en-t-k0-dvorak

This is a keyboard transformation, such as used by client-side virtual keyboards.

Sets or gets the Transformation extension C<k0>.

See the section on L</"Transform extensions"> for more information.

=head2 kf

This is an alias for L</colCaseFirst>

=head2 kh

This is an alias for L</colHiraganaQuaternary>

=head2 kk

This is an alias for L</colNormalization>

=head2 kn

This is an alias for L</colNumeric>

=head2 kr

This is an alias for L</colReorder>

=head2 ks

This is an alias for L</colStrength>

=head2 kv

This is an alias for L</colValue>

=head2 lang

    # current value: fr-FR
    $obj->lang( 'de' );
    # Now: de-FR

Sets or gets the C<language> part of this C<locale> object.

Note that when you set a 2-letters C<language> code, it automatically will unset any 3-characters C<language> code you would have previously set.

For example:

    $obj->lang( 'ja' );
    # locale is now set with language code 'ja'
    $obj->lang3( 'jpn' );
    # locale is now set with 3-characters language code 'jpn'
    say $obj->lang; # undef

See also L</language>

Note that you can alternatively use the method L<locale|/locale>, although strictly speaking a C<locale> is the whole string, while the C<language> is a component of it.

If you use the L<special locale root|https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier>, it will be accessible via the method L<language|/language>, although normally this is for 2-characters C<language>

    my $locale = Locale::Unicode->new( 'root' );
    say $locale; # root
    say $locale->language; # root
    say $locale->canonical; # und

    my $locale = Locale::Unicode->new( 'root-t-de-t0-ja-x0-medical' );
    say $locale; # root-t-de-t0-und-x0-medical
    say $locale->language; # root
    say $locale->canonical; # und-t-de-t0-ja-x0-medical
    say $locale->canonical->language; # und

=head2 lang3

    my $locale = Locale::Unicode->new( 'ja' );
    say $locale; # ja
    $locale->language3( 'jpn' );
    say $locale->language; # undef
    $locale->script( 'Kana' );
    # Now: jpn-Kana

Sets or gets the L<3-letter ISO 639-2 code|https://www.loc.gov/standards/iso639-2/php/code_list.php/>. Keep in mind, however, that to ensure stability, the C<LDML> (Locale Data Markup Language) also uses old data.

If you set the 3-characters C<language> code, it will replace any previously set 2-characters C<language> code.

=head2 language

This is an alias for L<lang|/lang>

=head2 language3

This is an alias for L<lang3|/lang3>

=head2 language_extended

    my $locale = Locale::Unicode->new( 'zh-cmn-TW' );
    say $locale->language; # zh
    say $locale->language3; # undef
    say $locale->language_id; # zh
    say $locale->extended; # cmn
    say $locale->language_extended; # zh-cmn
    say $locale->country_code; # TW

    my $locale = Locale::Unicode->new( 'ja-JP' );
    say $locale->language; # ja
    say $locale->extended; # undef
    say $locale->language_extended; # ja

    # Okinawan spoken in Japan Southern islands
    my $locale = Locale::Unicode->new( 'ryu-JP' );
    say $locale->language; # undef
    say $locale->language3; # ryu
    say $locale->language_id; # ryu
    say $locale->language_extended; # ryu

Read-only. This method returns the extended form of the language subtag, which means the 2 to 3-characters language ID and an optional extended language subtag.

Extended language subtag serves to provide more granularity to a locale, complementing the primary language subtag.

For example:

=over 4

=item * zh-cmn-Hans-CN (Chinese, Mandarin, Simplified script, as used in China)

=item * zh-yue-HK (Chinese, Cantonese, as used in Hong Kong SAR)

=back

However, with Unicode C<LDML>, this is deprecated, and, for example, C<zh-cmn-TW> would be normalised to just C<zh-TW>. See L<Locale::Unicode::Data/normalise> for more information.

=head2 language_id

    $locale->language_id( 'ja' );
    $locale->language_id( 'ryu' );
    $locale->language_id( 'und' );
    # Unset the language ID
    $locale->language_id( undef );
    my $str = $locale->language_id;

Sets or gets a language ID.

In mutator mode, if the language ID provided is 3-characters long, then L<language3|/language3> will be called to set it, otherwise L<language|/language> will be called.

In accessor mode, it returns the language ID whether it is a 2-characters ID accessible via L<language|/language>, or a 3-characters ID accessible via L<language3|/language3>

=head2 lb

This is an alias for L</line_break>

=head2 line_break

This is a Unicode Line Break Style Identifier that specifies a preferred line break style corresponding to the CSS level 3 line-break option.

Sets or gets the Unicode extension C<lb>.

=head2 line_break_word

This is a Unicode Line Break Word Identifier that specifies a preferred line break word handling behavior corresponding to the CSS level 3 word-break option

Sets or gets the Unicode extension C<lw>.

=head2 locale

This is an alias for L<lang|/lang>

=head2 locale3

This is an alias for L<lang3|/lang3>

=head2 lw

This is an alias for L</line_break_word>

=head2 m0

This is an alias for L</mechanism>

=head2 measurement

This is a Unicode Measurement System Identifier that specifies a preferred measurement system.

Sets or gets the Unicode extension C<ms>.

=head2 mechanism

    my $locale = Locale::Unicode->new( 'und-Latn' );
    $locale->transform( 'ru' );
    $locale->mechanism( 'ungegn-2007' );
    # Now: und-Latn-t-ru-m0-ungegn-2007
    # representing a transformation from United Nations Group of Experts on 
    # Geographical Names in 2007

This is a transformation mechanism referencing an authority or rules for a type of transformation.

Sets or gets the Transformation extension C<m0>.

See the section on L</"Transform extensions"> for more information.

=head2 merge

    my $locale1 = Locale::Unicode->new( 'ja-JP' );
    my $locale2 = Locale::Unicode->new( 'ja-Kana-hepburn-heploc' );
    say $locale1->merge( $locale2 ); # ja-Kana-JP-hepburn-heploc

Provided with another L<Locale::Unicode> object, or a C<locale> string, and this will merge all of that object property with the current object used to call this method.

Since a C<locale> can have multiple C<variant>s, merging two C<locale> object, will merge the C<variant>s, while avoiding duplicates, like so:

    my $locale1 = Locale::Unicode->new( 'ja-Kana-posix-hepburn' );
    my $locale2 = Locale::Unicode->new( 'ja-JP-hepburn-heploc' );
    say $locale1->merge( $locale2 ); # ja-Kana-JP-posix-hepburn-heploc

Note that it will not sort the variants. For that you want to use the L<canonical|/canonical> method.

See also the method L<Locale::Unicode::Data/normalise>

It returns the current object.

=head2 ms

This is an alias for L</measurement>

=head2 mu

This is an alias for L</unit>

=head2 nu

This is an alias for L</number>

=head2 number

This is a Unicode Number System Identifier that specifies a type of number system.

Sets or gets the Unicode extension C<nu>.

=head2 overlong

    my $locale = Locale::Unicode->new( 'en-US' );
    say $locale->overlong; # undef
    say $locale->country_code; # US
    say $locale->territory; # US
    # Changing to overlong USA
    $locale->overlong( 'USA' );
    say $locale->overlong; # USA
    say $locale->country_code; # undef
    say $locale->territory; # undef

But doing the following will not yield what you expect, because the C<overlong> C<territory> would be confused by an L<extended|/extended> language subtag.

    # Italian at Vatican City
    my $locale = Locale::Unicode->new( 'it-VAT' );
    say $locale->overlong; # undef
    say $locale->extended; # VAT

    # Spanish as spoken at Panama
    my $locale = Locale::Unicode->new( 'es-PAN-valencia' );
    say $locale->overlong; # undef
    say $locale->extended; # PAN

Thus, you cannot expect to have the value for L<overlong|/overlong> set. However, you can set it yourself directly by passing a value to method C<overlong>

Sets or gets an overlong country code.

You can normalise those C<overlong> country code to their normal equivalent by using L<Locale::Unicode::Data/normalise>

=head2 private

    my $locale = Locale::Unicode->new( 'ja-JP' );
    $locale->private( 'something-else' );
    # Now: ja-JP-x-something-else

This serves to set or get the value for a private subtag.

=head2 privateuse

    $locale->privateuse( 'x-abc' );
    my $str = $locale->privateuse;

Sets or gets the L<privateuse|https://www.rfc-editor.org/rfc/rfc5646.html> language tag.

Note that this use is deprecated. See the L<LDML specifications|https://unicode.org/reports/tr35/tr35.html#BCP_47_Language_Tag_Conversion>

The regular expression in L<Locale::Unicode> supports the C<privateuse> language subtag inherited by Unicode from C<BCP47>, although L<it is not strictly supported by the standard|https://unicode.org/reports/tr35/tr35.html#BCP_47_Conformance>. This is done in order to ensure maximum portability and flexibility.

=head2 region

    # current value: fr-FR
    $locale->region( '150' );
    # Now: fr-150

Sets or gets the C<region> part of a Unicode locale.

This is a world region represented by a 3-digits code.

Note that when you set a region code, it will automatically unset any L<country code|/country_code> code.

    my $locale = Locale::Unicode->new( 'en-US' );
    say $locale->country_code; # US
    $locale->region( '001' );
    say $locale->country_code; # undef
    say $locale; # en-001

Also, be careful that since the region code a padded with leading zeroes, not to turn them inadvertently into integer so that C<001> would not become C<1>. This is particularly true if you store it in a SQL database, where the L<DBI> driver might treat it as a number. You would then have to use L<bind_param|DBI/bind_param>

Below are the known region codes:

=over 4

=item * 001

World

=item * 002

Africa

=item * 003

North America

=item * 005

South America

=item * 009

Oceania

=item * 011

Western Africa

=item * 013

Central America

=item * 014

Eastern Africa

=item * 015

Northern Africa

=item * 017

Middle Africa

=item * 018

Southern Africa

=item * 019

Americas

=item * 021

Northern America

=item * 029

Caribbean

=item * 030

Eastern Asia

=item * 034

Southern Asia

=item * 035

Southeast Asia

=item * 039

Southern Europe

=item * 053

Australasia

=item * 054

Melanesia

=item * 057

Micronesian Region

=item * 061

Polynesia

=item * 142

Asia

=item * 143

Central Asia

=item * 145

Western Asia

=item * 150

Europe

=item * 151

Eastern Europe

=item * 154

Northern Europe

=item * 155

Western Europe

=item * 202

Sub-Saharan Africa

=item * 419

Latin America

=back

=head2 region_override

    my $locale = Locale::Unicode->new( 'en-GB' );
    $locale->region_override( 'uszzzz' );
    # Now: en-GB-u-rg-uszzzz
    # which is a locale for British English but with region-specific defaults set to US.

This is a Unicode Region Override that specifies an alternate C<country code> or C<region> to use for obtaining certain region-specific default values.

Sets or gets the Unicode extension C<rg>.

=head2 reset

When provided with any argument, this will reset the cached value computed by L</as_string>

=head2 rg

This is an alias for L</region_override>

=head2 s0

This is an alias for L</source>

=head2 script

    # current value: zh-Hans
    $locale->script( 'Hant' );
    # Now: zh-Hant

Sets or gets the C<script> part of the C<locale> identifier.

=head2 sd

This is an alias for L</subdivision>

=head2 sentence_break

This is a Unicode Sentence Break Suppressions Identifier that specifies a set of data to be used for suppressing certain sentence breaks.

Sets or gets the Unicode extension C<ss>.

=head2 source

This is a transformation source for non-languages or scripts, such as fullwidth-halfwidth conversion.

Sets or gets the Transformation extension C<s0>.

See the section on L</"Transform extensions"> for more information.

=head2 ss

This is an alias for L</sentence_break>

=head2 subdivision

    my $locale = Locale::Unicode->new( 'gsw' );
    $locale->subdivision( 'chzh' );
    # or
    # $locale->sd( 'chzh' );
    # Now: gsw-u-sd-chzh

    my $locale = Locale::Unicode->new( 'en-US' );
    $locale->sd( 'usca' );
    # Now: en-US-u-sd-usca

This is a Unicode Subdivision Identifier that specifies a regional subdivision used for C<locale>. This is typically the States in the U.S., or prefectures in France or Japan, or provinces in Canada.

Sets or gets the Unicode extension C<sd>.

Be careful of the rule in the standard. For example, C<en-CA-u-sd-gbsct> would be invalid because C<gb> in C<gbsct> does not match the region subtag C<CA>

=head2 t0

This is an alias for L</translation>

=head2 t_private

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->transform( 'und' );
    $locale->t_private( 'medical' );
    # Now: ja-t-de-t0-und-x0-medical

This is a private transformation subtag.

Sets or gets the Transformation private subtag C<x0>.

=head2 territory

    my $locale = Locale::Unicode->new( 'en' );
    # Sets the country code to 'US'
    $locale->territory( 'US' );
    # Now: en-US
    $locale->territory( 'GB' );
    # Now: en-GB
    # Sets the region to 150
    $locale->territory( 150 );

Sets or gets the country code or the region code part of the C<locale>.

A country code should be an ISO 3166 2-letters code, but keep in mind that the C<LDML> (Locale Data Markup Language) accepts old data to ensure stability.

A world C<region> is represented by a 3-digits code.

In mutator mode, depending on the value, this method C<territory> will set one or the other.

In accessor mode, this will return the country code, if any, or the region code.

See also L<country_code|/country_code> and L<region|/region>

=head2 time_zone

This is a Unicode Timezone Identifier that specifies a time zone.

Sets or gets the Unicode extension C<tz>.

=head2 timezone

This is an alias for L</time_zone>

=head2 transform

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->transform( 'it' );
    # Now: ja-t-it
    # which is Japanese, transformed from Italian

    my $locale = Locale::Unicode->new( 'ja-Kana' );
    $locale->transform( 'it' );
    # Now: ja-Kana-t-it
    # which is Japanese Katakana, transformed from Italian

    # 'und' is undefined and is perfectly valid
    my $locale = Locale::Unicode->new( 'und-Latn' );
    $locale->transform( 'und-cyrl' );
    # Now: und-Latn-t-und-cyrl
    # which is Latin script, transformed from the Cyrillic script

Sets or gets the Transformation extension C<t>.

This takes either a string representing a C<locale> or an L<Locale::Unicode> object.

If a string is provided, it will be converted to an L<Locale::Unicode> object.

The resulting value is passed to L<transform_locale|/transform_locale>

This method is convenient since you do not have to concern yourself whether the value you provide is an object, or not.

It returns the current object for chaining.

=head2 transform_locale

    my $locale = Locale::Unicode->new( 'ja' );
    my $locale2 = Locale::Unicode->new( 'it' );
    $locale->transform_locale( $locale2 );
    # Now: ja-t-it
    my $object = $locale->transform_locale;

Sets or gets a L<Locale::Unicode> object used to indicate the original locale subject to transformation.

This will trigger an L<exception|Locale::Unicode::Exception> if a value, other than C<Locale::Unicode> or an inheriting class object, is set.

See the section on L</"Transform extensions"> for more information.

=head2 translation

    my $locale = Locale::Unicode->new( 'ja' );
    $locale->transform( 'de' );
    $locale->translation( 'und' );
    # Now: ja-t-de-t0-und
    # Japanese translated from Germany by an undefined vendor

This is used to indicate content that has been machine translated, or a request for a particular type of machine translation of content.

Sets or gets the Transformation extension C<t0>.

See the section on L</"Transform extensions"> for more information.

=head2 true

This is read-only and returns a L<Locale::Unicode::Boolean> object representing a true value.

=head2 tz

This is an alias for L</time_zone>

=head2 unit

This is a Measurement Unit Preference Override that specifies an override for measurement unit preference.

Sets or gets the Unicode extension C<mu>.

=head2 va

This is an alias for L</variant>

=head2 variant

This is a Unicode Variant Identifier that specifies a special variant used for locales.

Sets or gets the Unicode extension C<va>.

=head2 variants

This returns the C<variant> part of the C<locale> as an array reference of C<variant> subtags.

It will always return an array reference whether any C<variant> is set or not.

    my $locale = Locale::Unicode->new( 'en-fonipa-scouse' );
    my $ref = $locale->variants; # ['fonipa', 'scouse']

You could reliably do something like:

    if( scalar( @{$locale->variants} ) > 1 )
    {
        # Do something
    }

Note that the proper canonical format of a C<locale> has the variants sorted in alphabetical order.

=head2 vt

This is an alias for L</colVariableTop>

=head2 x0

This is an alias for L</t_private>

=head1 CLASS FUNCTIONS

=head2 matches

Provided with a BCP47 C<locale>, and this returns an hash reference of its components if it matches the BCP47 regular expression, which can be accessed as global class variable C<$LOCALE_RE>.

If nothing matches, it returns an empty string in scalar context, or an empty list in list context.

If an error occurs, its sets an L<error object|Module::Generic::Exception> and returns C<undef> in scalar context, or an empty list in list context.

=head2 parse

    my $hash_ref = Locale::Unicode->parse( 'ja-Kana-t-it' );
    # Transcription in Japanese Katakana of an Italian word:
    # {
    #     ext_transform => "t-it",
    #     ext_transform_subtag => "it",
    #     language => "ja",
    #     script => "Kana",
    # }
    my $hash_ref = Locale::Unicode->parse( 'he-IL-u-ca-hebrew-tz-jeruslm' );
    # Represents Hebrew as spoken in Israel, using the traditional Hebrew calendar, 
    # and in the "Asia/Jerusalem" time zone
    # {
    #     country_code => "IL",
    #     ext_unicode => "u-ca-hebrew-tz-jeruslm",
    #     ext_unicode_subtag => "ca-hebrew-tz-jeruslm",
    #     language => "he",
    # }

Provided with a BCP47 C<locale>, and an optional hash reference like the one returned by L<matches|/matches>, and this will return an hash reference with detailed broken down of the C<locale> embedded information, as per the Unicode BCP47 standard.

=head2 tz_id2name

Provided with a CLDR timezone ID, such as C<jptyo> for C<Asia/Tokyo>, and this returns the IANA Olson name equivalent, which, in this case, would be C<Asia/Tokyo>

If an error occurs, its sets an L<error object|Module::Generic::Exception> and returns C<undef> in scalar context, or an empty list in list context.

=head2 tz_id2names

    my $ref = Locale::Unicode->tz_id2names( 'unknown' );
    # yields an empty array object
    my $ref = Locale::Unicode->tz_id2names( 'jptyo' );
    # Asia/Tokyo

Provided with a CLDR timezone ID, such as C<ausyd>, which stands primarily for C<Australia/Sydney>, and this returns an L<array object|Module::Generic::Array> of IANA Olson timezone names, which, in this case, would yield: C<['Australia/Sydney', 'Australia/ACT', 'Australia/Canberra', 'Australia/NSW']>

The order is set by L<BCP47 timezone data|https://github.com/unicode-org/cldr/blob/main/common/bcp47/timezone.xml>

If an error occurs, its sets an L<error object|Module::Generic::Exception> and returns C<undef> in scalar context, or an empty list in list context.

=head2 tz_info

    my $def = Locale::Unicode->tz_id2names( 'jptyo' );
    # yields the following hash reference:
    # {
    #     alias => [qw( Asia/Tokyo Japan )],
    #     desc => "Tokyo, Japan",
    #     tz => "Asia/Tokyo",
    # }
    my $def = Locale::Unicode->tz_id2names( 'unknown' );
    # yields an empty string (not undef)

Provided with a CLDR timezone ID, such as C<jptyo> and this returns an hash reference representing the dictionary entry for that ID.

If no information exists for the given timezone ID, an empty string is returned. C<undef> is returned only for errors.

If an error occurs, its sets an L<error object|Module::Generic::Exception> and returns C<undef> in scalar context, or an empty list in list context.

=head2 tz_name2id

    my $id = Locale::Unicode->tz_name2id( 'Asia/Tokyo' );
    # jptyo
    my $id = Locale::Unicode->tz_name2id( 'Australia/Canberra' );
    # ausyd

Provided with an IANA Olson timezone name, such as C<Asia/Tokyo> and this returns its CLDR equivalent, which, in this case, would be C<jptyo>

If none exists, an empty string is returned.

If an error occurs, its sets an L<error object|Module::Generic::Exception> and returns C<undef> in scalar context, or an empty list in list context.

=head1 OVERLOADING

Any object from this class is overloaded and stringifies to its C<locale> representation.

For example:

    my $locale = Locale::Unicode->new('ja-Kana-t-it' );
    say $locale; # ja-Kana-t-it
    $locale->transform( 'de' );
    say $locale; # ja-Kana-t-de

In boolean context, it always returns true by merely returning the current object instead of falling back on stringifying the object.

Any other overloading is performed using L<fallback methods|overload/"fallback">.

=head1 BCP47 EXTENSIONS

=head2 Unicode extensions

Example:

=over 4

=item * C<gsw-u-sd-chzh>

=back

Known L<BCP47 language extensions|https://unicode.org/reports/tr35/#u_Extension> as defined in L<RFC6067|https://datatracker.ietf.org/doc/html/rfc6067> are as follows:

=over 4

=item * C<ca>

A L<Unicode calendar identifier|https://unicode.org/reports/tr35/#UnicodeCalendarIdentifier> that specifies a type of calendar used for formatting and parsing, such as date/time symbols and patterns; it also selects supplemental calendarData used for calendrical calculations. The value can affect the computation of the first day of the week.

For example:

=over 8

=item * C<ja-u-ca-japanese>

Japanese Imperial calendar

=item * C<th-u-ca-buddhist>

Thai with Buddist calendar

=back

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/calendar.xml> are:

=over 8

=item * C<buddhist>

Thai Buddhist calendar

=item * C<chinese>

Traditional Chinese calendar

=item * C<coptic>

Coptic calendar

=item * C<dangi>

Traditional Korean calendar

=item * C<ethioaa>

Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E)

=item * C<ethiopic>

Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.)

=item * C<gregory>

Gregorian calendar

=item * C<hebrew>

Traditional Hebrew calendar

=item * C<indian>

Indian calendar

=item * C<islamic>

Hijri calendar

=item * C<islamic-civil>

Hijri calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - civil epoch)

=item * C<islamic-rgsa>

Hijri calendar, Saudi Arabia sighting

=item * C<islamic-tbla>

Hijri calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - astronomical epoch)

=item * C<islamic-umalqura>

Hijri calendar, Umm al-Qura

=item * C<islamicc>

Civil (algorithmic) Arabic calendar

=item * C<iso8601>

ISO calendar (Gregorian calendar using the ISO 8601 calendar week rules)

=item * C<japanese>

Japanese Imperial calendar

=item * C<persian>

Persian calendar

=item * C<roc>

Republic of China calendar

=back

=item * C<cf>

A L<Unicode currency format identifier|https://unicode.org/reports/tr35/#UnicodeCurrencyFormatIdentifier>

Typical values are:

=over 8

=item * C<standard>

Default value. Negative numbers use the minusSign symbol.

=item * C<account>

Negative numbers use parentheses or equivalent.

=back

=item * C<co>

A L<Unicode collation identifier|https://unicode.org/reports/tr35/#UnicodeCollationIdentifier> that specifies a type of collation (sort order).

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/collation.xml> are:

=over 8

=item * C<big5han>

Pinyin ordering for Latin, big5 charset ordering for CJK characters (used in Chinese)

=item * C<compat>

A previous version of the ordering, for compatibility

=item * C<dict>

Dictionary style ordering (such as in Sinhala)

=item * C<direct>

Binary code point order (used in Hindi)

=item * C<ducet>

The default Unicode collation element table order

=item * C<emoji>

Recommended ordering for emoji characters

=item * C<eor>

European ordering rules

=item * C<gb2312>

Pinyin ordering for Latin, gb2312han charset ordering for CJK characters (used in Chinese)

=item * C<phonebk>

Phonebook style ordering (such as in German)

=item * C<phonetic>

Phonetic ordering (sorting based on pronunciation)

=item * C<pinyin>

Pinyin ordering for Latin and for CJK characters (used in Chinese)

=item * C<reformed>

Reformed ordering (such as in Swedish)

=item * C<search>

Special collation type for string search

=item * C<searchjl>

Special collation type for Korean initial consonant search

=item * C<standard>

Default ordering for each language

=item * C<stroke>

Pinyin ordering for Latin, stroke order for CJK characters (used in Chinese)

=item * C<trad>

Traditional style ordering (such as in Spanish)

=item * C<unihan>

Pinyin ordering for Latin, Unihan radical-stroke ordering for CJK characters (used in Chinese)

=item * C<zhuyin>

Pinyin ordering for Latin, zhuyin order for Bopomofo and CJK characters (used in Chinese)

=back

For example: C<de-u-co-phonebk-ka-shifted> (German using Phonebook sorting, ignore punct.)

=item * C<cu>

A L<Unicode Currency Identifier|https://unicode.org/reports/tr35/#UnicodeCurrencyIdentifier> that specifies a type of currency (L<ISO 4217 code|https://github.com/unicode-org/cldr/blob/main/common/bcp47/currency.xml>) consisting of 3 ASCII letters that are or have been valid in ISO 4217, plus certain additional codes that are or have been in common use.

For example: C<ja-u-cu-jpy> (Japanese yens)

=item * C<dx>

A L<Unicode Dictionary Break Exclusion Identifier|https://unicode.org/reports/tr35/#UnicodeDictionaryBreakExclusionIdentifier> specifies scripts to be excluded from dictionary-based text break (for words and lines).

A proper value is one or more Unicode script subtags separated by hyphen. Their order is not important, but canonical order is alphabetical, such as C<dx-hani-thai>

For example:

=over 8

=item * C<dx-hani-hira-kata>

=item * C<dx-thai-hani>

=back

=item * C<em>

A L<Unicode Emoji Presentation Style Identifier|https://unicode.org/reports/tr35/#UnicodeEmojiPresentationStyleIdentifier> specifies a request for the preferred emoji presentation style.

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/variant.xml> are:

=over 8

=item * C<emoji>

Use an emoji presentation for emoji characters if possible.

=item * C<text>

Use a text presentation for emoji characters if possible.

=item * C<default>

Use the default presentation for emoji characters as specified in L<UTR #51|https://www.unicode.org/reports/tr51/#Presentation_Style>

=back

=item * C<fw>

A L<Unicode First Day Identifier|https://unicode.org/reports/tr35/#UnicodeFirstDayIdentifier> defines the preferred first day of the week for calendar display.

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/calendar.xml> are:

=over 8

=item * C<sun>

Sunday

=item * C<mon>

Monday

=item * C<tue>

Tuesday

=item * C<wed>

Wednesday

=item * C<thu>

Thursday

=item * C<fri>

Friday

=item * C<sat>

Saturday

=back

=item * C<hc>

A L<Unicode Hour Cycle Identifier|https://unicode.org/reports/tr35/#UnicodeHourCycleIdentifier> defines the preferred time cycle.

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/calendar.xml> are:

=over 8

=item * C<h12>

Hour system using 1–12; corresponds to C<h> in patterns

=item * C<h23>

Hour system using 0–23; corresponds to C<H> in patterns

=item * C<h11>

Hour system using 0–11; corresponds to C<K> in patterns

=item * C<h24>

Hour system using 1–24; corresponds to C<k> in pattern

=back

=item * C<lb>

A L<Unicode Line Break Style Identifier|https://unicode.org/reports/tr35/#UnicodeLineBreakStyleIdentifier> defines a preferred line break style corresponding to the L<CSS level 3 line-break option|https://drafts.csswg.org/css-text/#line-break-property>.

Possible L<values|https://github.com/unicode-org/cldr/blob/10ed3348d56be1c9fdadeb0a793a9b909eac3151/common/bcp47/segmentation.xml#L16> are:

=over 8

=item * C<strict>

CSS level 3 line-break=strict, e.g. treat CJ as NS

=item * C<normal>

CSS level 3 line-break=normal, e.g. treat CJ as ID, break before hyphens for ja,zh

=item * C<loose>

CSS lev 3 line-break=loose

=back

=item * C<lw>

A L<Unicode Line Break Word Identifier|https://unicode.org/reports/tr35/#UnicodeLineBreakWordIdentifier> defines preferred line break word handling behavior corresponding to the L<CSS level 3 word-break option|https://drafts.csswg.org/css-text/#word-break-property>.

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/segmentation.xml> are:

=over 8

=item * C<normal>

CSS level 3 word-break=normal, normal script/language behavior for midword breaks

=item * C<breakall>

CSS level 3 word-break=break-all, allow midword breaks unless forbidden by lb setting

=item * C<keepall>

CSS level 3 word-break=keep-all, prohibit midword breaks except for dictionary breaks

=item * C<phrase>

Prioritise keeping natural phrases (of multiple words) together when breaking, used in short text like title and headline

=back

=item * C<ms>

A L<Unicode Measurement System Identifier|https://unicode.org/reports/tr35/#UnicodeMeasurementSystemIdentifier> defines a preferred measurement system. Specifying "ms" in a C<locale> identifier overrides the default value specified by supplemental measurement system data for the region

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/measure.xml> are:

=over 8

=item * C<metric>

Metric System

=item * C<ussystem>

US System of measurement: feet, pints, etc.; pints are 16oz

=item * C<uksystem>

UK System of measurement: feet, pints, etc.; pints are 20oz

=back

=item * C<mu>

A L<Measurement Unit Preference Override|https://unicode.org/reports/tr35/#MeasurementUnitPreferenceOverride> defines an override for measurement unit preference.

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/measure.xml> are:

=over 8

=item * C<celsius>

Celsius as temperature unit

=item * C<kelvin>

Kelvin as temperature unit

=item * C<fahrenhe>

Fahrenheit as temperature unit

=back

=item * C<nu>

A L<Unicode Number System Identifier|https://unicode.org/reports/tr35/#UnicodeNumberSystemIdentifier> defines a type of number system.

For example: C<ar-u-nu-native> (Arabic with native digits such as "٠١٢٣٤"), or C<ar-u-nu-latn> (Arabic with Western digits such as "01234")

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/number.xml> are:

=over 8

=item * C<4-letters Unicode script subtag>

=item * C<arabext>

Extended Arabic-Indic digits ("arab" means the base Arabic-Indic digits)

=item * C<armnlow>

Armenian lowercase numerals

=item * C<finance>

Financial numerals

=item * C<fullwide>

Full width digits

=item * C<greklow>

Greek lower case numerals

=item * C<hanidays>

Han-character day-of-month numbering for lunar/other traditional calendars

=item * C<hanidec>

Positional decimal system using Chinese number ideographs as digits

=item * C<hansfin>

Simplified Chinese financial numerals

=item * C<hantfin>

Traditional Chinese financial numerals

=item * C<jpanfin>

Japanese financial numerals

=item * C<jpanyear>

Japanese first-year Gannen numbering for Japanese calendar

=item * C<lanatham>

Tai Tham Tham (ecclesiastical) digits

=item * C<mathbold>

Mathematical bold digits

=item * C<mathdbl>

Mathematical double-struck digits

=item * C<mathmono>

Mathematical monospace digits

=item * C<mathsanb>

Mathematical sans-serif bold digits

=item * C<mathsans>

Mathematical sans-serif digits

=item * C<mymrepka>

Myanmar Eastern Pwo Karen digits

=item * C<mymrpao>

Myanmar Pao digits

=item * C<mymrshan>

Myanmar Shan digits

=item * C<mymrtlng>

Myanmar Tai Laing digits

=item * C<native>

Native digits

=item * C<outlined>

Legacy computing outlined digits

=item * C<roman>

Roman numerals

=item * C<romanlow>

Roman lowercase numerals

=item * C<segment>

Legacy computing segmented digits

=item * C<tamldec>

Modern Tamil decimal digits

=item * C<traditio>

Traditional numerals

=back

=item * C<rg>

A L<Region Override|https://unicode.org/reports/tr35/#RegionOverride> specifies an alternate region to use for obtaining certain region-specific default values

For example: C<en-GB-u-rg-uszzzz> representing a C<locale> for British English but with region-specific defaults set to US.

=item * C<sd>

A L<Unicode Subdivision Identifier|https://unicode.org/reports/tr35/#UnicodeSubdivisionIdentifier> defines a L<regional subdivision|https://unicode.org/reports/tr35/#Unicode_Subdivision_Codes> used for locales.

They are called various names, such as a state in the United States, or a prefecture in Japan or France, or a province in Canada.

For example:

=over 8

=item * C<en-u-sd-uszzzz>

Subdivision codes for unknown values are the region code plus C<zzzz>, such as here with C<uszzzz> for an unknown subdivision of the US.

=item * C<en-US-u-sd-usca>

English as used in California, USA

=back

C<en-CA-u-sd-gbsct> would be invalid because C<gb> in C<gbsct> does not match the region subtag C<CA>

=item * C<ss>

A L<Unicode Sentence Break Suppressions Identifier|https://unicode.org/reports/tr35/#UnicodeSentenceBreakSuppressionsIdentifier> defines a set of data to be used for suppressing certain sentence breaks

Possible L<values|https://github.com/unicode-org/cldr/blob/10ed3348d56be1c9fdadeb0a793a9b909eac3151/common/bcp47/segmentation.xml#L29> are:

=over 8

=item * C<none> (default)

Do not use sentence break suppressions data

=item * C<standard>

Use sentence break suppressions data of type C<standard>

=back

=item * C<tz>

A L<Unicode Timezone Identifier|https://unicode.org/reports/tr35/#UnicodeTimezoneIdentifier> defines a timezone.

To access those values, check the class functions L</tz_id2name>, L<tz_id2names>, L</tz_info> and L</tz_name2id>

Possible L<values|https://github.com/unicode-org/cldr/blob/main/common/bcp47/timezone.xml> are:

=over 8

=item * C<adalv>

Name: Andorra

Time zone: C<Europe/Andorra>

=item * C<aedxb>

Name: Dubai, United Arab Emirates

Time zone: C<Asia/Dubai>

=item * C<afkbl>

Name: Kabul, Afghanistan

Time zone: C<Asia/Kabul>

=item * C<aganu>

Name: Antigua

Time zone: C<America/Antigua>

=item * C<aiaxa>

Name: Anguilla

Time zone: C<America/Anguilla>

=item * C<altia>

Name: Tirane, Albania

Time zone: C<Europe/Tirane>

=item * C<amevn>

Name: Yerevan, Armenia

Time zone: C<Asia/Yerevan>

=item * C<ancur>

Name: Curaçao

Time zone: C<America/Curacao>

=item * C<aolad>

Name: Luanda, Angola

Time zone: C<Africa/Luanda>

=item * C<aqams>

Amundsen-Scott Station, South Pole

Deprecated. See instead C<nzakl>

=item * C<aqcas>

Name: Casey Station, Bailey Peninsula

Time zone: C<Antarctica/Casey>

=item * C<aqdav>

Name: Davis Station, Vestfold Hills

Time zone: C<Antarctica/Davis>

=item * C<aqddu>

Name: Dumont d'Urville Station, Terre Adélie

Time zone: C<Antarctica/DumontDUrville>

=item * C<aqmaw>

Name: Mawson Station, Holme Bay

Time zone: C<Antarctica/Mawson>

=item * C<aqmcm>

Name: McMurdo Station, Ross Island

Time zone: C<Antarctica/McMurdo>

=item * C<aqplm>

Name: Palmer Station, Anvers Island

Time zone: C<Antarctica/Palmer>

=item * C<aqrot>

Name: Rothera Station, Adelaide Island

Time zone: C<Antarctica/Rothera>

=item * C<aqsyw>

Name: Syowa Station, East Ongul Island

Time zone: C<Antarctica/Syowa>

=item * C<aqtrl>

Name: Troll Station, Queen Maud Land

Time zone: C<Antarctica/Troll>

=item * C<aqvos>

Name: Vostok Station, Lake Vostok

Time zone: C<Antarctica/Vostok>

=item * C<arbue>

Name: Buenos Aires, Argentina

Time zone: C<America/Buenos_Aires>, C<America/Argentina/Buenos_Aires>

=item * C<arcor>

Name: Córdoba, Argentina

Time zone: C<America/Cordoba>, C<America/Argentina/Cordoba>, C<America/Rosario>

=item * C<arctc>

Name: Catamarca, Argentina

Time zone: C<America/Catamarca>, C<America/Argentina/Catamarca>, C<America/Argentina/ComodRivadavia>

=item * C<arirj>

Name: La Rioja, Argentina

Time zone: C<America/Argentina/La_Rioja>

=item * C<arjuj>

Name: Jujuy, Argentina

Time zone: C<America/Jujuy>, C<America/Argentina/Jujuy>

=item * C<arluq>

Name: San Luis, Argentina

Time zone: C<America/Argentina/San_Luis>

=item * C<armdz>

Name: Mendoza, Argentina

Time zone: C<America/Mendoza>, C<America/Argentina/Mendoza>

=item * C<arrgl>

Name: Río Gallegos, Argentina

Time zone: C<America/Argentina/Rio_Gallegos>

=item * C<arsla>

Name: Salta, Argentina

Time zone: C<America/Argentina/Salta>

=item * C<artuc>

Name: Tucumán, Argentina

Time zone: C<America/Argentina/Tucuman>

=item * C<aruaq>

Name: San Juan, Argentina

Time zone: C<America/Argentina/San_Juan>

=item * C<arush>

Name: Ushuaia, Argentina

Time zone: C<America/Argentina/Ushuaia>

=item * C<asppg>

Name: Pago Pago, American Samoa

Time zone: C<Pacific/Pago_Pago>, C<Pacific/Samoa>, C<US/Samoa>

=item * C<atvie>

Name: Vienna, Austria

Time zone: C<Europe/Vienna>

=item * C<auadl>

Name: Adelaide, Australia

Time zone: C<Australia/Adelaide>, C<Australia/South>

=item * C<aubhq>

Name: Broken Hill, Australia

Time zone: C<Australia/Broken_Hill>, C<Australia/Yancowinna>

=item * C<aubne>

Name: Brisbane, Australia

Time zone: C<Australia/Brisbane>, C<Australia/Queensland>

=item * C<audrw>

Name: Darwin, Australia

Time zone: C<Australia/Darwin>, C<Australia/North>

=item * C<aueuc>

Name: Eucla, Australia

Time zone: C<Australia/Eucla>

=item * C<auhba>

Name: Hobart, Australia

Time zone: C<Australia/Hobart>, C<Australia/Tasmania>, C<Australia/Currie>

=item * C<aukns>

Currie, Australia

Deprecated. See instead C<auhba>

=item * C<auldc>

Name: Lindeman Island, Australia

Time zone: C<Australia/Lindeman>

=item * C<auldh>

Name: Lord Howe Island, Australia

Time zone: C<Australia/Lord_Howe>, C<Australia/LHI>

=item * C<aumel>

Name: Melbourne, Australia

Time zone: C<Australia/Melbourne>, C<Australia/Victoria>

=item * C<aumqi>

Name: Macquarie Island Station, Macquarie Island

Time zone: C<Antarctica/Macquarie>

=item * C<auper>

Name: Perth, Australia

Time zone: C<Australia/Perth>, C<Australia/West>

=item * C<ausyd>

Name: Sydney, Australia

Time zone: C<Australia/Sydney>, C<Australia/ACT>, C<Australia/Canberra>, C<Australia/NSW>

=item * C<awaua>

Name: Aruba

Time zone: C<America/Aruba>

=item * C<azbak>

Name: Baku, Azerbaijan

Time zone: C<Asia/Baku>

=item * C<basjj>

Name: Sarajevo, Bosnia and Herzegovina

Time zone: C<Europe/Sarajevo>

=item * C<bbbgi>

Name: Barbados

Time zone: C<America/Barbados>

=item * C<bddac>

Name: Dhaka, Bangladesh

Time zone: C<Asia/Dhaka>, C<Asia/Dacca>

=item * C<bebru>

Name: Brussels, Belgium

Time zone: C<Europe/Brussels>

=item * C<bfoua>

Name: Ouagadougou, Burkina Faso

Time zone: C<Africa/Ouagadougou>

=item * C<bgsof>

Name: Sofia, Bulgaria

Time zone: C<Europe/Sofia>

=item * C<bhbah>

Name: Bahrain

Time zone: C<Asia/Bahrain>

=item * C<bibjm>

Name: Bujumbura, Burundi

Time zone: C<Africa/Bujumbura>

=item * C<bjptn>

Name: Porto-Novo, Benin

Time zone: C<Africa/Porto-Novo>

=item * C<bmbda>

Name: Bermuda

Time zone: C<Atlantic/Bermuda>

=item * C<bnbwn>

Name: Brunei

Time zone: C<Asia/Brunei>

=item * C<bolpb>

Name: La Paz, Bolivia

Time zone: C<America/La_Paz>

=item * C<bqkra>

Name: Bonaire, Sint Estatius and Saba

Time zone: C<America/Kralendijk>

=item * C<braux>

Name: Araguaína, Brazil

Time zone: C<America/Araguaina>

=item * C<brbel>

Name: Belém, Brazil

Time zone: C<America/Belem>

=item * C<brbvb>

Name: Boa Vista, Brazil

Time zone: C<America/Boa_Vista>

=item * C<brcgb>

Name: Cuiabá, Brazil

Time zone: C<America/Cuiaba>

=item * C<brcgr>

Name: Campo Grande, Brazil

Time zone: C<America/Campo_Grande>

=item * C<brern>

Name: Eirunepé, Brazil

Time zone: C<America/Eirunepe>

=item * C<brfen>

Name: Fernando de Noronha, Brazil

Time zone: C<America/Noronha>, C<Brazil/DeNoronha>

=item * C<brfor>

Name: Fortaleza, Brazil

Time zone: C<America/Fortaleza>

=item * C<brmao>

Name: Manaus, Brazil

Time zone: C<America/Manaus>, C<Brazil/West>

=item * C<brmcz>

Name: Maceió, Brazil

Time zone: C<America/Maceio>

=item * C<brpvh>

Name: Porto Velho, Brazil

Time zone: C<America/Porto_Velho>

=item * C<brrbr>

Name: Rio Branco, Brazil

Time zone: C<America/Rio_Branco>, C<America/Porto_Acre>, C<Brazil/Acre>

=item * C<brrec>

Name: Recife, Brazil

Time zone: C<America/Recife>

=item * C<brsao>

Name: São Paulo, Brazil

Time zone: C<America/Sao_Paulo>, C<Brazil/East>

=item * C<brssa>

Name: Bahia, Brazil

Time zone: C<America/Bahia>

=item * C<brstm>

Name: Santarém, Brazil

Time zone: C<America/Santarem>

=item * C<bsnas>

Name: Nassau, Bahamas

Time zone: C<America/Nassau>

=item * C<btthi>

Name: Thimphu, Bhutan

Time zone: C<Asia/Thimphu>, C<Asia/Thimbu>

=item * C<bwgbe>

Name: Gaborone, Botswana

Time zone: C<Africa/Gaborone>

=item * C<bymsq>

Name: Minsk, Belarus

Time zone: C<Europe/Minsk>

=item * C<bzbze>

Name: Belize

Time zone: C<America/Belize>

=item * C<cacfq>

Name: Creston, Canada

Time zone: C<America/Creston>

=item * C<caedm>

Name: Edmonton, Canada

Time zone: C<America/Edmonton>, C<Canada/Mountain>, C<America/Yellowknife>

=item * C<caffs>

Rainy River, Canada

Deprecated. See instead C<cawnp>

=item * C<cafne>

Name: Fort Nelson, Canada

Time zone: C<America/Fort_Nelson>

=item * C<caglb>

Name: Glace Bay, Canada

Time zone: C<America/Glace_Bay>

=item * C<cagoo>

Name: Goose Bay, Canada

Time zone: C<America/Goose_Bay>

=item * C<cahal>

Name: Halifax, Canada

Time zone: C<America/Halifax>, C<Canada/Atlantic>

=item * C<caiql>

Name: Iqaluit, Canada

Time zone: C<America/Iqaluit>, C<America/Pangnirtung>

=item * C<camon>

Name: Moncton, Canada

Time zone: C<America/Moncton>

=item * C<camtr>

Montreal, Canada

Deprecated. See instead C<cator>

=item * C<capnt>

Pangnirtung, Canada

Deprecated. See instead C<caiql>

=item * C<careb>

Name: Resolute, Canada

Time zone: C<America/Resolute>

=item * C<careg>

Name: Regina, Canada

Time zone: C<America/Regina>, C<Canada/East-Saskatchewan>, C<Canada/Saskatchewan>

=item * C<casjf>

Name: St. John's, Canada

Time zone: C<America/St_Johns>, C<Canada/Newfoundland>

=item * C<canpg>

Nipigon, Canada

Deprecated. See instead C<cator>

=item * C<cathu>

Thunder Bay, Canada

Deprecated. See instead C<cator>

=item * C<cator>

Name: Toronto, Canada

Time zone: C<America/Toronto>, C<America/Montreal>, C<Canada/Eastern>, C<America/Nipigon>, C<America/Thunder_Bay>

=item * C<cavan>

Name: Vancouver, Canada

Time zone: C<America/Vancouver>, C<Canada/Pacific>

=item * C<cawnp>

Name: Winnipeg, Canada

Time zone: C<America/Winnipeg>, C<Canada/Central>, C<America/Rainy_River>

=item * C<caybx>

Name: Blanc-Sablon, Canada

Time zone: C<America/Blanc-Sablon>

=item * C<caycb>

Name: Cambridge Bay, Canada

Time zone: C<America/Cambridge_Bay>

=item * C<cayda>

Name: Dawson, Canada

Time zone: C<America/Dawson>

=item * C<caydq>

Name: Dawson Creek, Canada

Time zone: C<America/Dawson_Creek>

=item * C<cayek>

Name: Rankin Inlet, Canada

Time zone: C<America/Rankin_Inlet>

=item * C<cayev>

Name: Inuvik, Canada

Time zone: C<America/Inuvik>

=item * C<cayxy>

Name: Whitehorse, Canada

Time zone: C<America/Whitehorse>, C<Canada/Yukon>

=item * C<cayyn>

Name: Swift Current, Canada

Time zone: C<America/Swift_Current>

=item * C<cayzf>

Yellowknife, Canada

Deprecated. See instead C<caedm>

=item * C<cayzs>

Name: Atikokan, Canada

Time zone: C<America/Coral_Harbour>, C<America/Atikokan>

=item * C<cccck>

Name: Cocos (Keeling) Islands

Time zone: C<Indian/Cocos>

=item * C<cdfbm>

Name: Lubumbashi, Democratic Republic of the Congo

Time zone: C<Africa/Lubumbashi>

=item * C<cdfih>

Name: Kinshasa, Democratic Republic of the Congo

Time zone: C<Africa/Kinshasa>

=item * C<cfbgf>

Name: Bangui, Central African Republic

Time zone: C<Africa/Bangui>

=item * C<cgbzv>

Name: Brazzaville, Republic of the Congo

Time zone: C<Africa/Brazzaville>

=item * C<chzrh>

Name: Zurich, Switzerland

Time zone: C<Europe/Zurich>

=item * C<ciabj>

Name: Abidjan, Côte d'Ivoire

Time zone: C<Africa/Abidjan>

=item * C<ckrar>

Name: Rarotonga, Cook Islands

Time zone: C<Pacific/Rarotonga>

=item * C<clipc>

Name: Easter Island, Chile

Time zone: C<Pacific/Easter>, C<Chile/EasterIsland>

=item * C<clpuq>

Name: Punta Arenas, Chile

Time zone: C<America/Punta_Arenas>

=item * C<clscl>

Name: Santiago, Chile

Time zone: C<America/Santiago>, C<Chile/Continental>

=item * C<cmdla>

Name: Douala, Cameroon

Time zone: C<Africa/Douala>

=item * C<cnckg>

Chongqing, China

Deprecated. See instead C<cnsha>

=item * C<cnhrb>

Harbin, China

Deprecated. See instead C<cnsha>

=item * C<cnkhg>

Kashgar, China

Deprecated. See instead C<cnurc>

=item * C<cnsha>

Name: Shanghai, China

Time zone: C<Asia/Shanghai>, C<Asia/Chongqing>, C<Asia/Chungking>, C<Asia/Harbin>, C<PRC>

=item * C<cnurc>

Name: Ürümqi, China

Time zone: C<Asia/Urumqi>, C<Asia/Kashgar>

=item * C<cobog>

Name: Bogotá, Colombia

Time zone: C<America/Bogota>

=item * C<crsjo>

Name: Costa Rica

Time zone: C<America/Costa_Rica>

=item * C<cst6cdt>

Name: POSIX style time zone for US Central Time

Time zone: C<CST6CDT>

=item * C<cuhav>

Name: Havana, Cuba

Time zone: C<America/Havana>, C<Cuba>

=item * C<cvrai>

Name: Cape Verde

Time zone: C<Atlantic/Cape_Verde>

=item * C<cxxch>

Name: Christmas Island

Time zone: C<Indian/Christmas>

=item * C<cyfmg>

Name: Famagusta, Cyprus

Time zone: C<Asia/Famagusta>

=item * C<cynic>

Name: Nicosia, Cyprus

Time zone: C<Asia/Nicosia>, C<Europe/Nicosia>

=item * C<czprg>

Name: Prague, Czech Republic

Time zone: C<Europe/Prague>

=item * C<deber>

Name: Berlin, Germany

Time zone: C<Europe/Berlin>

=item * C<debsngn>

Name: Busingen, Germany

Time zone: C<Europe/Busingen>

=item * C<djjib>

Name: Djibouti

Time zone: C<Africa/Djibouti>

=item * C<dkcph>

Name: Copenhagen, Denmark

Time zone: C<Europe/Copenhagen>

=item * C<dmdom>

Name: Dominica

Time zone: C<America/Dominica>

=item * C<dosdq>

Name: Santo Domingo, Dominican Republic

Time zone: C<America/Santo_Domingo>

=item * C<dzalg>

Name: Algiers, Algeria

Time zone: C<Africa/Algiers>

=item * C<ecgps>

Name: Galápagos Islands, Ecuador

Time zone: C<Pacific/Galapagos>

=item * C<ecgye>

Name: Guayaquil, Ecuador

Time zone: C<America/Guayaquil>

=item * C<eetll>

Name: Tallinn, Estonia

Time zone: C<Europe/Tallinn>

=item * C<egcai>

Name: Cairo, Egypt

Time zone: C<Africa/Cairo>, C<Egypt>

=item * C<eheai>

Name: El Aaiún, Western Sahara

Time zone: C<Africa/El_Aaiun>

=item * C<erasm>

Name: Asmara, Eritrea

Time zone: C<Africa/Asmera>, C<Africa/Asmara>

=item * C<esceu>

Name: Ceuta, Spain

Time zone: C<Africa/Ceuta>

=item * C<eslpa>

Name: Canary Islands, Spain

Time zone: C<Atlantic/Canary>

=item * C<esmad>

Name: Madrid, Spain

Time zone: C<Europe/Madrid>

=item * C<est5edt>

Name: POSIX style time zone for US Eastern Time

Time zone: C<EST5EDT>

=item * C<etadd>

Name: Addis Ababa, Ethiopia

Time zone: C<Africa/Addis_Ababa>

=item * C<fihel>

Name: Helsinki, Finland

Time zone: C<Europe/Helsinki>

=item * C<fimhq>

Name: Mariehamn, Åland, Finland

Time zone: C<Europe/Mariehamn>

=item * C<fjsuv>

Name: Fiji

Time zone: C<Pacific/Fiji>

=item * C<fkpsy>

Name: Stanley, Falkland Islands

Time zone: C<Atlantic/Stanley>

=item * C<fmksa>

Name: Kosrae, Micronesia

Time zone: C<Pacific/Kosrae>

=item * C<fmpni>

Name: Pohnpei, Micronesia

Time zone: C<Pacific/Ponape>, C<Pacific/Pohnpei>

=item * C<fmtkk>

Name: Chuuk, Micronesia

Time zone: C<Pacific/Truk>, C<Pacific/Chuuk>, C<Pacific/Yap>

=item * C<fotho>

Name: Faroe Islands

Time zone: C<Atlantic/Faeroe>, C<Atlantic/Faroe>

=item * C<frpar>

Name: Paris, France

Time zone: C<Europe/Paris>

=item * C<galbv>

Name: Libreville, Gabon

Time zone: C<Africa/Libreville>

=item * C<gaza>

Gaza Strip, Palestinian Territories

Deprecated. See instead C<gazastrp>

=item * C<gazastrp>

Name: Gaza Strip, Palestinian Territories

Time zone: C<Asia/Gaza>

=item * C<gblon>

Name: London, United Kingdom

Time zone: C<Europe/London>, C<Europe/Belfast>, C<GB>, C<GB-Eire>

=item * C<gdgnd>

Name: Grenada

Time zone: C<America/Grenada>

=item * C<getbs>

Name: Tbilisi, Georgia

Time zone: C<Asia/Tbilisi>

=item * C<gfcay>

Name: Cayenne, French Guiana

Time zone: C<America/Cayenne>

=item * C<gggci>

Name: Guernsey

Time zone: C<Europe/Guernsey>

=item * C<ghacc>

Name: Accra, Ghana

Time zone: C<Africa/Accra>

=item * C<gigib>

Name: Gibraltar

Time zone: C<Europe/Gibraltar>

=item * C<gldkshvn>

Name: Danmarkshavn, Greenland

Time zone: C<America/Danmarkshavn>

=item * C<glgoh>

Name: Nuuk (Godthåb), Greenland

Time zone: C<America/Godthab>, C<America/Nuuk>

=item * C<globy>

Name: Ittoqqortoormiit (Scoresbysund), Greenland

Time zone: C<America/Scoresbysund>

=item * C<glthu>

Name: Qaanaaq (Thule), Greenland

Time zone: C<America/Thule>

=item * C<gmbjl>

Name: Banjul, Gambia

Time zone: C<Africa/Banjul>

=item * C<gmt>

Name: Greenwich Mean Time

Time zone: C<Etc/GMT>, C<Etc/GMT+0>, C<Etc/GMT-0>, C<Etc/GMT0>, C<Etc/Greenwich>, C<GMT>, C<GMT+0>, C<GMT-0>, C<GMT0>, C<Greenwich>

=item * C<gncky>

Name: Conakry, Guinea

Time zone: C<Africa/Conakry>

=item * C<gpbbr>

Name: Guadeloupe

Time zone: C<America/Guadeloupe>

=item * C<gpmsb>

Name: Marigot, Saint Martin

Time zone: C<America/Marigot>

=item * C<gpsbh>

Name: Saint Barthélemy

Time zone: C<America/St_Barthelemy>

=item * C<gqssg>

Name: Malabo, Equatorial Guinea

Time zone: C<Africa/Malabo>

=item * C<grath>

Name: Athens, Greece

Time zone: C<Europe/Athens>

=item * C<gsgrv>

Name: South Georgia and the South Sandwich Islands

Time zone: C<Atlantic/South_Georgia>

=item * C<gtgua>

Name: Guatemala

Time zone: C<America/Guatemala>

=item * C<gugum>

Name: Guam

Time zone: C<Pacific/Guam>

=item * C<gwoxb>

Name: Bissau, Guinea-Bissau

Time zone: C<Africa/Bissau>

=item * C<gygeo>

Name: Guyana

Time zone: C<America/Guyana>

=item * C<hebron>

Name: West Bank, Palestinian Territories

Time zone: C<Asia/Hebron>

=item * C<hkhkg>

Name: Hong Kong SAR China

Time zone: C<Asia/Hong_Kong>, C<Hongkong>

=item * C<hntgu>

Name: Tegucigalpa, Honduras

Time zone: C<America/Tegucigalpa>

=item * C<hrzag>

Name: Zagreb, Croatia

Time zone: C<Europe/Zagreb>

=item * C<htpap>

Name: Port-au-Prince, Haiti

Time zone: C<America/Port-au-Prince>

=item * C<hubud>

Name: Budapest, Hungary

Time zone: C<Europe/Budapest>

=item * C<iddjj>

Name: Jayapura, Indonesia

Time zone: C<Asia/Jayapura>

=item * C<idjkt>

Name: Jakarta, Indonesia

Time zone: C<Asia/Jakarta>

=item * C<idmak>

Name: Makassar, Indonesia

Time zone: C<Asia/Makassar>, C<Asia/Ujung_Pandang>

=item * C<idpnk>

Name: Pontianak, Indonesia

Time zone: C<Asia/Pontianak>

=item * C<iedub>

Name: Dublin, Ireland

Time zone: C<Europe/Dublin>, C<Eire>

=item * C<imdgs>

Name: Isle of Man

Time zone: C<Europe/Isle_of_Man>

=item * C<inccu>

Name: Kolkata, India

Time zone: C<Asia/Calcutta>, C<Asia/Kolkata>

=item * C<iodga>

Name: Chagos Archipelago

Time zone: C<Indian/Chagos>

=item * C<iqbgw>

Name: Baghdad, Iraq

Time zone: C<Asia/Baghdad>

=item * C<irthr>

Name: Tehran, Iran

Time zone: C<Asia/Tehran>, C<Iran>

=item * C<isrey>

Name: Reykjavik, Iceland

Time zone: C<Atlantic/Reykjavik>, C<Iceland>

=item * C<itrom>

Name: Rome, Italy

Time zone: C<Europe/Rome>

=item * C<jeruslm>

Name: Jerusalem

Time zone: C<Asia/Jerusalem>, C<Asia/Tel_Aviv>, C<Israel>

=item * C<jesth>

Name: Jersey

Time zone: C<Europe/Jersey>

=item * C<jmkin>

Name: Jamaica

Time zone: C<America/Jamaica>, C<Jamaica>

=item * C<joamm>

Name: Amman, Jordan

Time zone: C<Asia/Amman>

=item * C<jptyo>

Name: Tokyo, Japan

Time zone: C<Asia/Tokyo>, C<Japan>

=item * C<kenbo>

Name: Nairobi, Kenya

Time zone: C<Africa/Nairobi>

=item * C<kgfru>

Name: Bishkek, Kyrgyzstan

Time zone: C<Asia/Bishkek>

=item * C<khpnh>

Name: Phnom Penh, Cambodia

Time zone: C<Asia/Phnom_Penh>

=item * C<kicxi>

Name: Kiritimati, Kiribati

Time zone: C<Pacific/Kiritimati>

=item * C<kipho>

Name: Enderbury Island, Kiribati

Time zone: C<Pacific/Enderbury>, C<Pacific/Kanton>

=item * C<kitrw>

Name: Tarawa, Kiribati

Time zone: C<Pacific/Tarawa>

=item * C<kmyva>

Name: Comoros

Time zone: C<Indian/Comoro>

=item * C<knbas>

Name: Saint Kitts

Time zone: C<America/St_Kitts>

=item * C<kpfnj>

Name: Pyongyang, North Korea

Time zone: C<Asia/Pyongyang>

=item * C<krsel>

Name: Seoul, South Korea

Time zone: C<Asia/Seoul>, C<ROK>

=item * C<kwkwi>

Name: Kuwait

Time zone: C<Asia/Kuwait>

=item * C<kygec>

Name: Cayman Islands

Time zone: C<America/Cayman>

=item * C<kzaau>

Name: Aqtau, Kazakhstan

Time zone: C<Asia/Aqtau>

=item * C<kzakx>

Name: Aqtobe, Kazakhstan

Time zone: C<Asia/Aqtobe>

=item * C<kzala>

Name: Almaty, Kazakhstan

Time zone: C<Asia/Almaty>

=item * C<kzguw>

Name: Atyrau (Guryev), Kazakhstan

Time zone: C<Asia/Atyrau>

=item * C<kzksn>

Name: Qostanay (Kostanay), Kazakhstan

Time zone: C<Asia/Qostanay>

=item * C<kzkzo>

Name: Kyzylorda, Kazakhstan

Time zone: C<Asia/Qyzylorda>

=item * C<kzura>

Name: Oral, Kazakhstan

Time zone: C<Asia/Oral>

=item * C<lavte>

Name: Vientiane, Laos

Time zone: C<Asia/Vientiane>

=item * C<lbbey>

Name: Beirut, Lebanon

Time zone: C<Asia/Beirut>

=item * C<lccas>

Name: Saint Lucia

Time zone: C<America/St_Lucia>

=item * C<livdz>

Name: Vaduz, Liechtenstein

Time zone: C<Europe/Vaduz>

=item * C<lkcmb>

Name: Colombo, Sri Lanka

Time zone: C<Asia/Colombo>

=item * C<lrmlw>

Name: Monrovia, Liberia

Time zone: C<Africa/Monrovia>

=item * C<lsmsu>

Name: Maseru, Lesotho

Time zone: C<Africa/Maseru>

=item * C<ltvno>

Name: Vilnius, Lithuania

Time zone: C<Europe/Vilnius>

=item * C<lulux>

Name: Luxembourg

Time zone: C<Europe/Luxembourg>

=item * C<lvrix>

Name: Riga, Latvia

Time zone: C<Europe/Riga>

=item * C<lytip>

Name: Tripoli, Libya

Time zone: C<Africa/Tripoli>, C<Libya>

=item * C<macas>

Name: Casablanca, Morocco

Time zone: C<Africa/Casablanca>

=item * C<mcmon>

Name: Monaco

Time zone: C<Europe/Monaco>

=item * C<mdkiv>

Name: Chişinău, Moldova

Time zone: C<Europe/Chisinau>, C<Europe/Tiraspol>

=item * C<metgd>

Name: Podgorica, Montenegro

Time zone: C<Europe/Podgorica>

=item * C<mgtnr>

Name: Antananarivo, Madagascar

Time zone: C<Indian/Antananarivo>

=item * C<mhkwa>

Name: Kwajalein, Marshall Islands

Time zone: C<Pacific/Kwajalein>, C<Kwajalein>

=item * C<mhmaj>

Name: Majuro, Marshall Islands

Time zone: C<Pacific/Majuro>

=item * C<mkskp>

Name: Skopje, Macedonia

Time zone: C<Europe/Skopje>

=item * C<mlbko>

Name: Bamako, Mali

Time zone: C<Africa/Bamako>, C<Africa/Timbuktu>

=item * C<mmrgn>

Name: Yangon (Rangoon), Burma

Time zone: C<Asia/Rangoon>, C<Asia/Yangon>

=item * C<mncoq>

Name: Choibalsan, Mongolia

Time zone: C<Asia/Choibalsan>

=item * C<mnhvd>

Name: Khovd (Hovd), Mongolia

Time zone: C<Asia/Hovd>

=item * C<mnuln>

Name: Ulaanbaatar (Ulan Bator), Mongolia

Time zone: C<Asia/Ulaanbaatar>, C<Asia/Ulan_Bator>

=item * C<momfm>

Name: Macau SAR China

Time zone: C<Asia/Macau>, C<Asia/Macao>

=item * C<mpspn>

Name: Saipan, Northern Mariana Islands

Time zone: C<Pacific/Saipan>

=item * C<mqfdf>

Name: Martinique

Time zone: C<America/Martinique>

=item * C<mrnkc>

Name: Nouakchott, Mauritania

Time zone: C<Africa/Nouakchott>

=item * C<msmni>

Name: Montserrat

Time zone: C<America/Montserrat>

=item * C<mst7mdt>

Name: POSIX style time zone for US Mountain Time

Time zone: C<MST7MDT>

=item * C<mtmla>

Name: Malta

Time zone: C<Europe/Malta>

=item * C<muplu>

Name: Mauritius

Time zone: C<Indian/Mauritius>

=item * C<mvmle>

Name: Maldives

Time zone: C<Indian/Maldives>

=item * C<mwblz>

Name: Blantyre, Malawi

Time zone: C<Africa/Blantyre>

=item * C<mxchi>

Name: Chihuahua, Mexico

Time zone: C<America/Chihuahua>

=item * C<mxcun>

Name: Cancún, Mexico

Time zone: C<America/Cancun>

=item * C<mxcjs>

Name: Ciudad Juárez, Mexico

Time zone: C<America/Ciudad_Juarez>

=item * C<mxhmo>

Name: Hermosillo, Mexico

Time zone: C<America/Hermosillo>

=item * C<mxmam>

Name: Matamoros, Mexico

Time zone: C<America/Matamoros>

=item * C<mxmex>

Name: Mexico City, Mexico

Time zone: C<America/Mexico_City>, C<Mexico/General>

=item * C<mxmid>

Name: Mérida, Mexico

Time zone: C<America/Merida>

=item * C<mxmty>

Name: Monterrey, Mexico

Time zone: C<America/Monterrey>

=item * C<mxmzt>

Name: Mazatlán, Mexico

Time zone: C<America/Mazatlan>, C<Mexico/BajaSur>

=item * C<mxoji>

Name: Ojinaga, Mexico

Time zone: C<America/Ojinaga>

=item * C<mxpvr>

Name: Bahía de Banderas, Mexico

Time zone: C<America/Bahia_Banderas>

=item * C<mxstis>

Santa Isabel (Baja California), Mexico

Deprecated. See instead C<mxtij>

=item * C<mxtij>

Name: Tijuana, Mexico

Time zone: C<America/Tijuana>, C<America/Ensenada>, C<Mexico/BajaNorte>, C<America/Santa_Isabel>

=item * C<mykch>

Name: Kuching, Malaysia

Time zone: C<Asia/Kuching>

=item * C<mykul>

Name: Kuala Lumpur, Malaysia

Time zone: C<Asia/Kuala_Lumpur>

=item * C<mzmpm>

Name: Maputo, Mozambique

Time zone: C<Africa/Maputo>

=item * C<nawdh>

Name: Windhoek, Namibia

Time zone: C<Africa/Windhoek>

=item * C<ncnou>

Name: Noumea, New Caledonia

Time zone: C<Pacific/Noumea>

=item * C<nenim>

Name: Niamey, Niger

Time zone: C<Africa/Niamey>

=item * C<nfnlk>

Name: Norfolk Island

Time zone: C<Pacific/Norfolk>

=item * C<nglos>

Name: Lagos, Nigeria

Time zone: C<Africa/Lagos>

=item * C<nimga>

Name: Managua, Nicaragua

Time zone: C<America/Managua>

=item * C<nlams>

Name: Amsterdam, Netherlands

Time zone: C<Europe/Amsterdam>

=item * C<noosl>

Name: Oslo, Norway

Time zone: C<Europe/Oslo>

=item * C<npktm>

Name: Kathmandu, Nepal

Time zone: C<Asia/Katmandu>, C<Asia/Kathmandu>

=item * C<nrinu>

Name: Nauru

Time zone: C<Pacific/Nauru>

=item * C<nuiue>

Name: Niue

Time zone: C<Pacific/Niue>

=item * C<nzakl>

Name: Auckland, New Zealand

Time zone: C<Pacific/Auckland>, C<Antarctica/South_Pole>, C<NZ>

=item * C<nzcht>

Name: Chatham Islands, New Zealand

Time zone: C<Pacific/Chatham>, C<NZ-CHAT>

=item * C<ommct>

Name: Muscat, Oman

Time zone: C<Asia/Muscat>

=item * C<papty>

Name: Panama

Time zone: C<America/Panama>

=item * C<pelim>

Name: Lima, Peru

Time zone: C<America/Lima>

=item * C<pfgmr>

Name: Gambiera Islands, French Polynesia

Time zone: C<Pacific/Gambier>

=item * C<pfnhv>

Name: Marquesas Islands, French Polynesia

Time zone: C<Pacific/Marquesas>

=item * C<pfppt>

Name: Tahiti, French Polynesia

Time zone: C<Pacific/Tahiti>

=item * C<pgpom>

Name: Port Moresby, Papua New Guinea

Time zone: C<Pacific/Port_Moresby>

=item * C<pgraw>

Name: Bougainville, Papua New Guinea

Time zone: C<Pacific/Bougainville>

=item * C<phmnl>

Name: Manila, Philippines

Time zone: C<Asia/Manila>

=item * C<pkkhi>

Name: Karachi, Pakistan

Time zone: C<Asia/Karachi>

=item * C<plwaw>

Name: Warsaw, Poland

Time zone: C<Europe/Warsaw>, C<Poland>

=item * C<pmmqc>

Name: Saint Pierre and Miquelon

Time zone: C<America/Miquelon>

=item * C<pnpcn>

Name: Pitcairn Islands

Time zone: C<Pacific/Pitcairn>

=item * C<prsju>

Name: Puerto Rico

Time zone: C<America/Puerto_Rico>

=item * C<pst8pdt>

Name: POSIX style time zone for US Pacific Time

Time zone: C<PST8PDT>

=item * C<ptfnc>

Name: Madeira, Portugal

Time zone: C<Atlantic/Madeira>

=item * C<ptlis>

Name: Lisbon, Portugal

Time zone: C<Europe/Lisbon>, C<Portugal>

=item * C<ptpdl>

Name: Azores, Portugal

Time zone: C<Atlantic/Azores>

=item * C<pwror>

Name: Palau

Time zone: C<Pacific/Palau>

=item * C<pyasu>

Name: Asunción, Paraguay

Time zone: C<America/Asuncion>

=item * C<qadoh>

Name: Qatar

Time zone: C<Asia/Qatar>

=item * C<rereu>

Name: Réunion

Time zone: C<Indian/Reunion>

=item * C<robuh>

Name: Bucharest, Romania

Time zone: C<Europe/Bucharest>

=item * C<rsbeg>

Name: Belgrade, Serbia

Time zone: C<Europe/Belgrade>

=item * C<ruasf>

Name: Astrakhan, Russia

Time zone: C<Europe/Astrakhan>

=item * C<rubax>

Name: Barnaul, Russia

Time zone: C<Asia/Barnaul>

=item * C<ruchita>

Name: Chita Zabaykalsky, Russia

Time zone: C<Asia/Chita>

=item * C<rudyr>

Name: Anadyr, Russia

Time zone: C<Asia/Anadyr>

=item * C<rugdx>

Name: Magadan, Russia

Time zone: C<Asia/Magadan>

=item * C<ruikt>

Name: Irkutsk, Russia

Time zone: C<Asia/Irkutsk>

=item * C<rukgd>

Name: Kaliningrad, Russia

Time zone: C<Europe/Kaliningrad>

=item * C<rukhndg>

Name: Khandyga Tomponsky, Russia

Time zone: C<Asia/Khandyga>

=item * C<rukra>

Name: Krasnoyarsk, Russia

Time zone: C<Asia/Krasnoyarsk>

=item * C<rukuf>

Name: Samara, Russia

Time zone: C<Europe/Samara>

=item * C<rukvx>

Name: Kirov, Russia

Time zone: C<Europe/Kirov>

=item * C<rumow>

Name: Moscow, Russia

Time zone: C<Europe/Moscow>, C<W-SU>

=item * C<runoz>

Name: Novokuznetsk, Russia

Time zone: C<Asia/Novokuznetsk>

=item * C<ruoms>

Name: Omsk, Russia

Time zone: C<Asia/Omsk>

=item * C<ruovb>

Name: Novosibirsk, Russia

Time zone: C<Asia/Novosibirsk>

=item * C<rupkc>

Name: Kamchatka Peninsula, Russia

Time zone: C<Asia/Kamchatka>

=item * C<rurtw>

Name: Saratov, Russia

Time zone: C<Europe/Saratov>

=item * C<rusred>

Name: Srednekolymsk, Russia

Time zone: C<Asia/Srednekolymsk>

=item * C<rutof>

Name: Tomsk, Russia

Time zone: C<Asia/Tomsk>

=item * C<ruuly>

Name: Ulyanovsk, Russia

Time zone: C<Europe/Ulyanovsk>

=item * C<ruunera>

Name: Ust-Nera Oymyakonsky, Russia

Time zone: C<Asia/Ust-Nera>

=item * C<ruuus>

Name: Sakhalin, Russia

Time zone: C<Asia/Sakhalin>

=item * C<ruvog>

Name: Volgograd, Russia

Time zone: C<Europe/Volgograd>

=item * C<ruvvo>

Name: Vladivostok, Russia

Time zone: C<Asia/Vladivostok>

=item * C<ruyek>

Name: Yekaterinburg, Russia

Time zone: C<Asia/Yekaterinburg>

=item * C<ruyks>

Name: Yakutsk, Russia

Time zone: C<Asia/Yakutsk>

=item * C<rwkgl>

Name: Kigali, Rwanda

Time zone: C<Africa/Kigali>

=item * C<saruh>

Name: Riyadh, Saudi Arabia

Time zone: C<Asia/Riyadh>

=item * C<sbhir>

Name: Guadalcanal, Solomon Islands

Time zone: C<Pacific/Guadalcanal>

=item * C<scmaw>

Name: Mahé, Seychelles

Time zone: C<Indian/Mahe>

=item * C<sdkrt>

Name: Khartoum, Sudan

Time zone: C<Africa/Khartoum>

=item * C<sesto>

Name: Stockholm, Sweden

Time zone: C<Europe/Stockholm>

=item * C<sgsin>

Name: Singapore

Time zone: C<Asia/Singapore>, C<Singapore>

=item * C<shshn>

Name: Saint Helena

Time zone: C<Atlantic/St_Helena>

=item * C<silju>

Name: Ljubljana, Slovenia

Time zone: C<Europe/Ljubljana>

=item * C<sjlyr>

Name: Longyearbyen, Svalbard

Time zone: C<Arctic/Longyearbyen>, C<Atlantic/Jan_Mayen>

=item * C<skbts>

Name: Bratislava, Slovakia

Time zone: C<Europe/Bratislava>

=item * C<slfna>

Name: Freetown, Sierra Leone

Time zone: C<Africa/Freetown>

=item * C<smsai>

Name: San Marino

Time zone: C<Europe/San_Marino>

=item * C<sndkr>

Name: Dakar, Senegal

Time zone: C<Africa/Dakar>

=item * C<somgq>

Name: Mogadishu, Somalia

Time zone: C<Africa/Mogadishu>

=item * C<srpbm>

Name: Paramaribo, Suriname

Time zone: C<America/Paramaribo>

=item * C<ssjub>

Name: Juba, South Sudan

Time zone: C<Africa/Juba>

=item * C<sttms>

Name: São Tomé, São Tomé and Príncipe

Time zone: C<Africa/Sao_Tome>

=item * C<svsal>

Name: El Salvador

Time zone: C<America/El_Salvador>

=item * C<sxphi>

Name: Sint Maarten

Time zone: C<America/Lower_Princes>

=item * C<sydam>

Name: Damascus, Syria

Time zone: C<Asia/Damascus>

=item * C<szqmn>

Name: Mbabane, Swaziland

Time zone: C<Africa/Mbabane>

=item * C<tcgdt>

Name: Grand Turk, Turks and Caicos Islands

Time zone: C<America/Grand_Turk>

=item * C<tdndj>

Name: N'Djamena, Chad

Time zone: C<Africa/Ndjamena>

=item * C<tfpfr>

Name: Kerguelen Islands, French Southern Territories

Time zone: C<Indian/Kerguelen>

=item * C<tglfw>

Name: Lomé, Togo

Time zone: C<Africa/Lome>

=item * C<thbkk>

Name: Bangkok, Thailand

Time zone: C<Asia/Bangkok>

=item * C<tjdyu>

Name: Dushanbe, Tajikistan

Time zone: C<Asia/Dushanbe>

=item * C<tkfko>

Name: Fakaofo, Tokelau

Time zone: C<Pacific/Fakaofo>

=item * C<tldil>

Name: Dili, East Timor

Time zone: C<Asia/Dili>

=item * C<tmasb>

Name: Ashgabat, Turkmenistan

Time zone: C<Asia/Ashgabat>, C<Asia/Ashkhabad>

=item * C<tntun>

Name: Tunis, Tunisia

Time zone: C<Africa/Tunis>

=item * C<totbu>

Name: Tongatapu, Tonga

Time zone: C<Pacific/Tongatapu>

=item * C<trist>

Name: Istanbul, Türkiye

Time zone: C<Europe/Istanbul>, C<Asia/Istanbul>, C<Turkey>

=item * C<ttpos>

Name: Port of Spain, Trinidad and Tobago

Time zone: C<America/Port_of_Spain>

=item * C<tvfun>

Name: Funafuti, Tuvalu

Time zone: C<Pacific/Funafuti>

=item * C<twtpe>

Name: Taipei, Taiwan

Time zone: C<Asia/Taipei>, C<ROC>

=item * C<tzdar>

Name: Dar es Salaam, Tanzania

Time zone: C<Africa/Dar_es_Salaam>

=item * C<uaiev>

Name: Kyiv, Ukraine

Time zone: C<Europe/Kiev>, C<Europe/Kyiv>, C<Europe/Zaporozhye>, C<Europe/Uzhgorod>

=item * C<uaozh>

Zaporizhia (Zaporozhye), Ukraine

Deprecated. See instead C<uaiev>

=item * C<uasip>

Name: Simferopol, Ukraine

Time zone: C<Europe/Simferopol>

=item * C<uauzh>

Uzhhorod (Uzhgorod), Ukraine

Deprecated. See instead C<uaiev>

=item * C<ugkla>

Name: Kampala, Uganda

Time zone: C<Africa/Kampala>

=item * C<umawk>

Name: Wake Island, U.S. Minor Outlying Islands

Time zone: C<Pacific/Wake>

=item * C<umjon>

Johnston Atoll, U.S. Minor Outlying Islands

Deprecated. See instead C<ushnl>

=item * C<ummdy>

Name: Midway Islands, U.S. Minor Outlying Islands

Time zone: C<Pacific/Midway>

=item * C<unk>

Name: Unknown time zone

Time zone: C<Etc/Unknown>

=item * C<usadk>

Name: Adak (Alaska), United States

Time zone: C<America/Adak>, C<America/Atka>, C<US/Aleutian>

=item * C<usaeg>

Name: Marengo (Indiana), United States

Time zone: C<America/Indiana/Marengo>

=item * C<usanc>

Name: Anchorage, United States

Time zone: C<America/Anchorage>, C<US/Alaska>

=item * C<usboi>

Name: Boise (Idaho), United States

Time zone: C<America/Boise>

=item * C<uschi>

Name: Chicago, United States

Time zone: C<America/Chicago>, C<US/Central>

=item * C<usden>

Name: Denver, United States

Time zone: C<America/Denver>, C<America/Shiprock>, C<Navajo>, C<US/Mountain>

=item * C<usdet>

Name: Detroit, United States

Time zone: C<America/Detroit>, C<US/Michigan>

=item * C<ushnl>

Name: Honolulu, United States

Time zone: C<Pacific/Honolulu>, C<US/Hawaii>, C<Pacific/Johnston>

=item * C<usind>

Name: Indianapolis, United States

Time zone: C<America/Indianapolis>, C<America/Fort_Wayne>, C<America/Indiana/Indianapolis>, C<US/East-Indiana>

=item * C<usinvev>

Name: Vevay (Indiana), United States

Time zone: C<America/Indiana/Vevay>

=item * C<usjnu>

Name: Juneau (Alaska), United States

Time zone: C<America/Juneau>

=item * C<usknx>

Name: Knox (Indiana), United States

Time zone: C<America/Indiana/Knox>, C<America/Knox_IN>, C<US/Indiana-Starke>

=item * C<uslax>

Name: Los Angeles, United States

Time zone: C<America/Los_Angeles>, C<US/Pacific>, C<US/Pacific-New>

=item * C<uslui>

Name: Louisville (Kentucky), United States

Time zone: C<America/Louisville>, C<America/Kentucky/Louisville>

=item * C<usmnm>

Name: Menominee (Michigan), United States

Time zone: C<America/Menominee>

=item * C<usmtm>

Name: Metlakatla (Alaska), United States

Time zone: C<America/Metlakatla>

=item * C<usmoc>

Name: Monticello (Kentucky), United States

Time zone: C<America/Kentucky/Monticello>

=item * C<usnavajo>

Shiprock (Navajo), United States

Deprecated. See instead C<usden>

=item * C<usndcnt>

Name: Center (North Dakota), United States

Time zone: C<America/North_Dakota/Center>

=item * C<usndnsl>

Name: New Salem (North Dakota), United States

Time zone: C<America/North_Dakota/New_Salem>

=item * C<usnyc>

Name: New York, United States

Time zone: C<America/New_York>, C<US/Eastern>

=item * C<usoea>

Name: Vincennes (Indiana), United States

Time zone: C<America/Indiana/Vincennes>

=item * C<usome>

Name: Nome (Alaska), United States

Time zone: C<America/Nome>

=item * C<usphx>

Name: Phoenix, United States

Time zone: C<America/Phoenix>, C<US/Arizona>

=item * C<ussit>

Name: Sitka (Alaska), United States

Time zone: C<America/Sitka>

=item * C<ustel>

Name: Tell City (Indiana), United States

Time zone: C<America/Indiana/Tell_City>

=item * C<uswlz>

Name: Winamac (Indiana), United States

Time zone: C<America/Indiana/Winamac>

=item * C<uswsq>

Name: Petersburg (Indiana), United States

Time zone: C<America/Indiana/Petersburg>

=item * C<usxul>

Name: Beulah (North Dakota), United States

Time zone: C<America/North_Dakota/Beulah>

=item * C<usyak>

Name: Yakutat (Alaska), United States

Time zone: C<America/Yakutat>

=item * C<utc>

Name: UTC (Coordinated Universal Time)

Time zone: C<Etc/UTC>, C<Etc/UCT>, C<Etc/Universal>, C<Etc/Zulu>, C<UCT>, C<UTC>, C<Universal>, C<Zulu>

=item * C<utce01>

Name: 1 hour ahead of UTC

Time zone: C<Etc/GMT-1>

=item * C<utce02>

Name: 2 hours ahead of UTC

Time zone: C<Etc/GMT-2>

=item * C<utce03>

Name: 3 hours ahead of UTC

Time zone: C<Etc/GMT-3>

=item * C<utce04>

Name: 4 hours ahead of UTC

Time zone: C<Etc/GMT-4>

=item * C<utce05>

Name: 5 hours ahead of UTC

Time zone: C<Etc/GMT-5>

=item * C<utce06>

Name: 6 hours ahead of UTC

Time zone: C<Etc/GMT-6>

=item * C<utce07>

Name: 7 hours ahead of UTC

Time zone: C<Etc/GMT-7>

=item * C<utce08>

Name: 8 hours ahead of UTC

Time zone: C<Etc/GMT-8>

=item * C<utce09>

Name: 9 hours ahead of UTC

Time zone: C<Etc/GMT-9>

=item * C<utce10>

Name: 10 hours ahead of UTC

Time zone: C<Etc/GMT-10>

=item * C<utce11>

Name: 11 hours ahead of UTC

Time zone: C<Etc/GMT-11>

=item * C<utce12>

Name: 12 hours ahead of UTC

Time zone: C<Etc/GMT-12>

=item * C<utce13>

Name: 13 hours ahead of UTC

Time zone: C<Etc/GMT-13>

=item * C<utce14>

Name: 14 hours ahead of UTC

Time zone: C<Etc/GMT-14>

=item * C<utcw01>

Name: 1 hour behind UTC

Time zone: C<Etc/GMT+1>

=item * C<utcw02>

Name: 2 hours behind UTC

Time zone: C<Etc/GMT+2>

=item * C<utcw03>

Name: 3 hours behind UTC

Time zone: C<Etc/GMT+3>

=item * C<utcw04>

Name: 4 hours behind UTC

Time zone: C<Etc/GMT+4>

=item * C<utcw05>

Name: 5 hours behind UTC

Time zone: C<Etc/GMT+5>, C<EST>

=item * C<utcw06>

Name: 6 hours behind UTC

Time zone: C<Etc/GMT+6>

=item * C<utcw07>

Name: 7 hours behind UTC

Time zone: C<Etc/GMT+7>, C<MST>

=item * C<utcw08>

Name: 8 hours behind UTC

Time zone: C<Etc/GMT+8>

=item * C<utcw09>

Name: 9 hours behind UTC

Time zone: C<Etc/GMT+9>

=item * C<utcw10>

Name: 10 hours behind UTC

Time zone: C<Etc/GMT+10>, C<HST>

=item * C<utcw11>

Name: 11 hours behind UTC

Time zone: C<Etc/GMT+11>

=item * C<utcw12>

Name: 12 hours behind UTC

Time zone: C<Etc/GMT+12>

=item * C<uymvd>

Name: Montevideo, Uruguay

Time zone: C<America/Montevideo>

=item * C<uzskd>

Name: Samarkand, Uzbekistan

Time zone: C<Asia/Samarkand>

=item * C<uztas>

Name: Tashkent, Uzbekistan

Time zone: C<Asia/Tashkent>

=item * C<vavat>

Name: Vatican City

Time zone: C<Europe/Vatican>

=item * C<vcsvd>

Name: Saint Vincent, Saint Vincent and the Grenadines

Time zone: C<America/St_Vincent>

=item * C<veccs>

Name: Caracas, Venezuela

Time zone: C<America/Caracas>

=item * C<vgtov>

Name: Tortola, British Virgin Islands

Time zone: C<America/Tortola>

=item * C<vistt>

Name: Saint Thomas, U.S. Virgin Islands

Time zone: C<America/St_Thomas>, C<America/Virgin>

=item * C<vnsgn>

Name: Ho Chi Minh City, Vietnam

Time zone: C<Asia/Saigon>, C<Asia/Ho_Chi_Minh>

=item * C<vuvli>

Name: Efate, Vanuatu

Time zone: C<Pacific/Efate>

=item * C<wfmau>

Name: Wallis Islands, Wallis and Futuna

Time zone: C<Pacific/Wallis>

=item * C<wsapw>

Name: Apia, Samoa

Time zone: C<Pacific/Apia>

=item * C<yeade>

Name: Aden, Yemen

Time zone: C<Asia/Aden>

=item * C<ytmam>

Name: Mayotte

Time zone: C<Indian/Mayotte>

=item * C<zajnb>

Name: Johannesburg, South Africa

Time zone: C<Africa/Johannesburg>

=item * C<zmlun>

Name: Lusaka, Zambia

Time zone: C<Africa/Lusaka>

=item * C<zwhre>

Name: Harare, Zimbabwe

Time zone: C<Africa/Harare>

=back

See the L<standard documentation|https://unicode.org/reports/tr35/#Time_Zone_Identifiers> for more information.

=item * C<va>

A L<Unicode Variant Identifier|https://unicode.org/reports/tr35/#UnicodeVariantIdentifier> defines a special variant used for locales.

=back

=head2 Transform extensions

This is used for transliterations, transcriptions, translations, etc, as per L<RFC6497|https://datatracker.ietf.org/doc/html/rfc6497>

For example:

=over 4

=item * C<ja-t-it>

The content is Japanese, transformed from Italian.

=item * C<ja-Kana-t-it>

The content is Japanese Katakana, transformed from Italian.

=item * C<und-Latn-t-und-cyrl>

The content is in the Latin script, transformed from the Cyrillic script.

=item * C<und-Cyrl-t-und-latn-m0-ungegn-2007>

The content is in Cyrillic, transformed from Latin, according to a UNGEGN specification dated 2007.

The date is of format C<YYYYMMDD> all without space, and the month and day information should be provided only when necessary for clarification, as per the L<RFC6497, section 2.5(c)|https://datatracker.ietf.org/doc/html/rfc6497#section-2.5>

=item * C<und-Cyrl-t-und-latn-m0-ungegn>

Same, but without year.

=back

The complete list of valid subtags is as follows. They are all two to eight alphanumeric characters.

=over 4

=item * C<d0>

Transform destination: for non-languages/scripts, such as fullwidth-halfwidth conversion

See also C<s0>

Possible L<values|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform-destination.xml> are:

=over 8

=item * C<accents>

Map base + punctuation, etc to accented characters

=item * C<ascii>

Map as many characters to the closest ASCII character as possible

=item * C<casefold>

Apply Unicode case folding

=item * C<charname>

Map each character to its Unicode name

=item * C<digit>

Convert to digit form of accent

=item * C<fcc>

Map string to the FCC format; L<http://unicode.org/notes/tn5>

=item * C<fcd>

Map string to the FCD format; L<http://unicode.org/notes/tn5>

=item * C<fwidth>

Map characters to their fullwidth equivalents

=item * C<hex>

Map characters to a hex equivalents, eg C<a> to C<\u0061>; for hex variants see L<transform.xml|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform.xml>

=item * C<hwidth>

Map characters to their halfwidth equivalents

=item * C<lower>

Apply Unicode full lowercase mapping

=item * C<morse>

Map Unicode to Morse Code encoding

=item * C<nfc>

Map string to the Unicode NFC format

=item * C<nfd>

Map string to the Unicode NFD format

=item * C<nfkc>

Map string to the Unicode NFKC format

=item * C<nfkd>

Map string to the Unicode NFKD format

=item * C<npinyin>

Map pinyin written with tones to the numeric form

=item * C<null>

Make no change in the string

=item * C<publish>

Map to preferred forms for publishing, such as C<, >, C<—>

=item * C<remove>

Remove every character in the string

=item * C<title>

Apply Unicode full titlecase mapping

=item * C<upper>

Apply Unicode full uppercase mapping

=item * C<zawgyi>

Map Unicode to Zawgyi Myanmar encoding

=back

=item * C<h0>

Hybrid Locale Identifiers: C<h0> with the value C<hybrid> indicates that the C<-t-> value is a language that is mixed into the main language tag to form a hybrid.

For L<example|https://unicode.org/reports/tr35/#Hybrid_Locale>:

=over 8

=item * C<hi-t-en-h0-hybrid>

Hybrid Deva - Hinglish

Hindi-English hybrid where the script is Devanagari*

=item * C<hi-Latn-t-en-h0-hybrid>

Hybrid Latin - Hinglish

Hindi-English hybrid where the script is Latin*

=item * C<ru-t-en-h0-hybrid>

Hybrid Cyrillic - Runglish

Russian with an admixture of American English

=item * C<ru-t-en-gb-h0-hybrid>

Hybrid Cyrillic - Runglish

Russian with an admixture of British English

=item * C<en-t-zh-h0-hybrid>

Hybrid Latin - Chinglish

American English with an admixture of Chinese (Simplified Mandarin Chinese)

=item * C<en-t-zh-hant-h0-hybrid>

Hybrid Latin - Chinglish

American English with an admixture of Chinese (Traditional Mandarin Chinese)

=back

=item * C<i0>

Input Method Engine transform: used to indicate an input method transformation, such as one used by a client-side input method. The first subfield in a sequence would typically be a C<platform> or vendor designation.

For example: C<zh-t-i0-pinyin>

Possible L<values|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform_ime.xml> are:

=over 8

=item * C<handwrit>

Handwriting input: used when the only information known (or requested) is that the text was (or is to be) converted using an handwriting input.

=item * C<pinyin>

Pinyin input: for simplified Chinese characters. See also L<http://en.wikipedia.org/wiki/Pinyin_method>.

=item * C<und>

The choice of input method is not specified. Used when the only information known (or requested) is that the text was (or is to be) converted using an input method engine

=item * C<wubi>

Wubi input: for simplified Chinese characters. For background information, see L<http://en.wikipedia.org/wiki/Wubi_method>

=back

=item * C<k0>

Keyboard transform: used to indicate a keyboard transformation, such as one used by a client-side virtual keyboard. The first subfield in a sequence would typically be a C<platform> designation, representing the platform that the keyboard is intended for.

For example: C<en-t-k0-dvorak>

Possible L<values|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform_keyboard.xml> are:

=over 8

=item * C<101key>

101 key layout.

=item * C<102key>

102 key layout.

=item * C<600dpi>

Keyboard for a 600 dpi device.

=item * C<768dpi>

Keyboard for a 768 dpi device.

=item * C<android>

Android keyboard.

=item * C<azerty>

A AZERTY-based keyboard or one that approximates AZERTY in a different script.

=item * C<chromeos>

ChromeOS keyboard.

=item * C<colemak>

Colemak keyboard layout. The Colemak keyboard is an alternative to the QWERTY and dvorak keyboards. http://colemak.com/.

=item * C<dvorak>

Dvorak keyboard layout. See also L<http://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard>.

=item * C<dvorakl>

Dvorak left-handed keyboard layout. See also L<http://en.wikipedia.org/wiki/File:KB_Dvorak_Left.svg>.

=item * C<dvorakr>

Dvorak right-handed keyboard layout. See also L<http://en.wikipedia.org/wiki/File:KB_Dvorak_Right.svg>.

=item * C<el220>

Greek 220 keyboard. See also L<http://www.microsoft.com/resources/msdn/goglobal/keyboards/kbdhela2.html>.

=item * C<el319>

Greek 319 keyboard. See also L<ftp://ftp.software.ibm.com/software/globalization/keyboards/KBD319.pdf>.

=item * C<extended>

A keyboard that has been enhanced with a large number of extra characters.

=item * C<googlevk>

Google virtual keyboard.

=item * C<isiri>

Persian ISIRI keyboard. Based on ISIRI 2901:1994 standard. See also L<http://behdad.org/download/Publications/persiancomputing/a007.pdf>.

=item * C<legacy>

A keyboard that has been replaced with a newer standard but is kept for legacy purposes.

=item * C<lt1205>

Lithuanian standard keyboard, based on the LST 1205:1992 standard. See also L<http://www.kada.lt/litwin/>.

=item * C<lt1582>

Lithuanian standard keyboard, based on the LST 1582:2000 standard. See also L<http://www.kada.lt/litwin/>.

=item * C<nutaaq>

Inuktitut Nutaaq keyboard. See also L<http://www.pirurvik.ca/en/webfm_send/15>.

=item * C<osx>

Mac OSX keyboard.

=item * C<patta>

Thai Pattachote keyboard. This is a less frequently used layout in Thai (Kedmanee layout is more popular). See also L<http://www.nectec.or.th/it-standards/keyboard_layout/thai-key.htm>.

=item * C<qwerty>

QWERTY-based keyboard or one that approximates QWERTY in a different script.

=item * C<qwertz>

QWERTZ-based keyboard or one that approximates QWERTZ in a different script.

=item * C<ta99>

Tamil 99 keyboard. See also L<http://www.tamilvu.org/Tamilnet99/annex1.htm>.

=item * C<und>

The vender for the keyboard is not specified. Used when the only information known (or requested) is that the text was (or is to be) converted using an keyboard.

=item * C<var>

A keyboard layout with small variations from the default.

=item * C<viqr>

Vietnamese VIQR layout, based on L<http://tools.ietf.org/html/rfc1456>.

=item * C<windows>

Windows keyboard.

=back

=item * C<m0>

Transform extension mechanism: to reference an authority or rules for a type of transformation.

For example: C<und-Latn-t-ru-m0-ungegn-2007>

Possible L<values|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform.xml> are:

=over 8

=item * C<aethiopi>

Encylopedia Aethiopica Transliteration

=item * C<alaloc>

American Library Association-Library of Congress

=item * C<betamets>

Beta Maṣāḥǝft Transliteration

=item * C<bgn>

US Board on Geographic Names

=item * C<buckwalt>

Buckwalter Arabic transliteration system

=item * C<c11>

for hex transforms, using the C11 syntax: \u0061\U0001F4D6

=item * C<css>

for hex transforms, using the CSS syntax: \61 \01F4D6, spacing where necessary

=item * C<din>

Deutsches Institut für Normung

=item * C<es3842>

Ethiopian Standards Agency ES 3842:2014 Ethiopic-Latin Transliteration

=item * C<ewts>

Extended Wylie Transliteration Scheme

=item * C<gost>

Euro-Asian Council for Standardization, Metrology and Certification

=item * C<gurage>

Gurage Legacy to Modern Transliteration

=item * C<gutgarts>

Yaros Gutgarts Ethiopic-Cyrillic Transliteration

=item * C<iast>

International Alphabet of Sanskrit Transliteration

=item * C<iesjes>

IES/JES Amharic Transliteration

=item * C<iso>

International Organization for Standardization

=item * C<java>

for hex transforms, using the Java syntax: \u0061\uD83D\uDCD6

=item * C<lambdin>

Thomas Oden Lambdin Ethiopic-Latin Transliteration

=item * C<mcst>

Korean Ministry of Culture, Sports and Tourism

=item * C<mns>

Mongolian National Standard

=item * C<percent>

for hex transforms, using the percent syntax: %61%F0%9F%93%96

=item * C<perl>

for hex transforms, using the perl syntax: \x{61}\x{1F4D6}

=item * C<plain>

for hex transforms, with no surrounding syntax, spacing where necessary: 0061 1F4D6

=item * C<prprname>

transform variant for proper names

=item * C<satts>

Standard Arabic Technical Transliteration System (SATTS)

=item * C<sera>

System for Ethiopic Representation in ASCII

=item * C<tekieali>

Tekie Alibekit Blin-Latin Transliteration

=item * C<ungegn>

United Nations Group of Experts on Geographical Names

=item * C<unicode>

to hex with the Unicode syntax: U+0061 U+1F4D6, spacing where necessary

=item * C<xaleget>

Eritrean Ministry of Education Blin-Latin Transliteration

=item * C<xml>

for hex transforms, using the xml syntax: &#x61;&#x1F4D6;

=item * C<xml10>

for hex transforms, using the xml decimal syntax: &#97;&#128214;

=back

=item * C<s0>

Transform source: for non-languages/scripts, such as fullwidth-halfwidth conversion

See also C<d0>

Possible L<values|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform-destination.xml> are:

=over 8

=item * C<accents>

Accented characters to map base + punctuation, etc

=item * C<ascii>

Map from ASCII to the target, perhaps using different conventions

=item * C<hex>

Map characters from hex equivalents, trying all variants, eg C<U+0061> to C<a>; for hex variants see L<transform.xml|https://github.com/unicode-org/cldr/blob/maint/maint-41/common/bcp47/transform.xml>

=item * C<morse>

Map Morse Code to Unicode encoding

=item * C<npinyin>

Map the numeric form of pinyin to the tone format

=item * C<publish>

Map publishing characters, such as C<, >, C<—>, to from vanilla characters

=item * C<zawgyi>

Map Zawgyi Myanmar encoding to Unicode

=back

=item * C<t0>

Machine Translation: used to indicate content that has been machine translated, or a request for a particular type of machine translation of content. The first subfield in a sequence would typically be a C<platform> or vendor designation.

For example: C<ja-t-de-t0-und>

=item * C<x0>

Private Use.

For example: C<ja-t-de-t0-und-x0-medical>

=back

=head2 Collation Options

L<Parametric settings|https://unicode.org/reports/tr35/tr35-collation.html#Setting_Options> can be specified in language tags or in rule syntax (in the form [keyword value] ). For example, C<-ks-level2> or [strength 2] will only compare strings based on their primary and secondary weights.

The options description below is taken from the LDML standard, and reflect how the algorithm works when implemented by web browser, or other runtime environment. This module does not do any of those algorithms. The documentation is only here for your benefit and convenience.

See the L<standard documentation|https://unicode.org/reports/tr35/tr35-collation.html> and the L<DUCET (Default Unicode Collation Element Table)|https://www.unicode.org/reports/tr10/#Default_Unicode_Collation_Element_Table> for more information.

=over 4

=item * C<ka> or C<colAlternate>

Sets alternate handling for variable weights.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L34> are optional and can be:

=over 8

=item * C<noignore> or C<non-ignorable>

Default value.

=item * C<shifted>

=back

=item * C<kb> or C<colBackwards>

Sets collation parameter key for backward collation weight.

Sets alternate handling for variable weights.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L39> are optional and can be: C<true> or C<yes>, C<false> (default) or C<no>

=item * C<kc> or C<colCaseLevel>

Sets collation parameter key for case level.

Specifies a boolean. If C<on>, a level consisting only of case characteristics will be inserted in front of tertiary level, as a "Level 2.5". To ignore accents but take case into account, set strength to C<primary> and case level to C<on>.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L44> are optional and can be: C<true> or C<yes>, C<false> (default) or C<no>

=item * C<kf> or C<colCaseFirst>

Sets collation parameter key for ordering by case.

If set to C<upper>, causes upper case to sort before lower case. If set to C<lower>, causes lower case to sort before upper case.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L49> are: C<upper>, C<lower>, C<false> (default) or C<no>

=item * C<kh> or C<colHiraganaQuaternary>

Sets collation parameter key for special Hiragana handling.

This is deprecated by the LDML standard.

Specifies a boolean. Controls special treatment of Hiragana code points on quaternary level. If turned on, Hiragana codepoints will get lower values than all the other non-variable code points in shifted.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L55> are optional and can be: C<true> (default) or C<yes>, C<false> or C<no>

=item * C<kk> or C<colNormalization>

Sets collation parameter key for normalisation.

Specifies a boolean. If on, then the normal L<UCA|https://www.unicode.org/reports/tr41/#UTS10> algorithm is used.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L60> are optional and can be: C<true> (default) or C<yes>, C<false> or C<no>

=item * C<kn> or C<colNumeric>

Sets collation parameter key for numeric handling.

Specifies a boolean. If set to on, any sequence of Decimal Digits is sorted at a primary level with its numeric value.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L65> are optional and can be: C<true> or C<yes>, C<false> (default) or C<no>

=item * C<kr> or C<colReorder>

Sets collation reorder codes.

Specifies a reordering of scripts or other significant blocks of characters such as symbols, punctuation, and digits.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L70> are: C<currency>, C<digit>, C<punct>, C<space>, C<symbol>, or any BCP47 script ID.

Also possible: C<others> where all codes not explicitly mentioned should be ordered. The script code Zzzz (Unknown Script) is a synonym for others.

For example:

=over 8

=item * C<en-u-kr-latn-digit>

Reorder digits after Latin characters.

=item * C<en-u-kr-arab-cyrl-others-symbol>

Reorder Arabic characters first, then Cyrillic, and put symbols at the end—after all other characters.

=item * C<en-u-kr-others>

Remove any locale-specific reordering, and use DUCET order for reordering blocks.

=back

=item * C<ks> or C<colStrength>

Sets the collation parameter key for collation strength used for comparison.

Possible L<values|https://github.com/unicode-org/cldr/blob/5ae2965c8afed18f89f54195db72205aa5b6fc3a/common/bcp47/collation.xml#L79> are:

=over 8

=item * C<level1> or C<primary>

=item * C<level2> or C<secondary>

=item * C<level3> (default) or C<tertiary>

=item * C<level4> or C<quaternary> or C<quarternary>

=item * C<identic> or C<identical>

=back

=item * C<kv>

Sets the collation parameter key for C<maxVariable>, the last reordering group to be affected by C<ka-shifted>.

Possible values are:

=over 8

=item * C<currency>

Spaces, punctuation and all symbols are affected by ka-shifted.

=item * C<punct>

Spaces and punctuation are affected by ka-shifted (CLDR default).

=item * C<space>

Only spaces are affected by ka-shifted.

=item * C<symbol>

Spaces, punctuation and symbols except for currency symbols are affected by ka-shifted (UCA default).

=back

=item * C<vt>

Sets the parameter key for the variable top.

B<This is deprecated by the LDML standard.>

=back

=head1 EXCEPTIONS

This module does not die upon errors, unless you have set L<fatal|/fatal> to a true value. Instead it sets an L<error object|Locale::Unicode::Exception> that can be retrieved.

When an error occurred, an L<error object|Locale::Unicode::Exception> will be set and the method will return C<undef> in scalar context and an empty list in list context.

Otherwise, the only occasions when this module will die is when there is an internal design error, which would be my fault.

=head1 SERIALISATION

C<Locale::Unicode> supports L<Storable::Improved>, L<Storable>, L<Sereal> and L<CBOR|CBOR::XS> serialisation, by implementing the methods C<FREEZE>, C<THAW>, C<STORABLE_freeze>, C<STORABLE_thaw>

For serialisation with L<Sereal>, make sure to instantiate the L<Sereal encoder|Sereal::Encoder> with the C<freeze_callbacks> option set to true, otherwise, C<Sereal> will not use the C<FREEZE> and C<THAW> methods.

See L<Sereal::Encoder/"FREEZE/THAW CALLBACK MECHANISM"> for more information.

For L<CBOR|CBOR::XS>, it is recommended to use the option C<allow_sharing> to enable the reuse of references, such as:

    my $cbor = CBOR::XS->new->allow_sharing;

Also, if you use the option C<allow_tags> with L<JSON>, then all of those modules will work too, since this option enables support for the C<FREEZE> and C<THAW> methods.

=head1 AUTHOR

Jacques Deguest E<lt>F<jack@deguest.jp>E<gt>

=head1 SEE ALSO

L<https://github.com/unicode-org/cldr/tree/main/common/bcp47>, L<https://en.wikipedia.org/wiki/IETF_language_tag>

L<https://www.rfc-editor.org/info/bcp47>

L<Unicode Locale Data Markup Language|https://unicode.org/reports/tr35/>

L<BCP47|https://www.rfc-editor.org/rfc/bcp/bcp47.txt>

L<RFC6067 on the Unicode extensions|https://datatracker.ietf.org/doc/html/rfc6067>

L<RFC6497 on the transformation extension|https://datatracker.ietf.org/doc/html/rfc6497>

L<RFC5646|https://www.rfc-editor.org/rfc/rfc5646.html>

See L<HTML::Object::Locale> for an implementation of Web API class L<Intl.Locale|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale>

L<Unicode::Collate>, L<Unicode::Collate::Locale>, L<Unicode::Unihan>

L<Locale::Unicode::Data> for the entire C<CLDR> data accessible as a SQLite database.

=head1 COPYRIGHT & LICENSE

Copyright(c) 2024 DEGUEST Pte. Ltd.

All rights reserved

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

=cut