             )
 
 
-        getLocaleName: () ->
-            return @locale.name
-
-        translate: ( key, interpolation ) ->
-            @polyglot.t( key, interpolation )
-
-        date: ( type, date ) ->
-            moment = Moment( date )
-
-            return moment.format( @locale.formatting.datetime[ type ] )
-
-        money: ( currency, amount ) ->
-            # Choose the default currency if requested
-            #
-            if currency is 'default'
-                currency = @locale.formatting.money.default )
-
-            sign        = @locale.formatting.money[ currency ].sign
-            precision   = @locale.formatting.money[ currency ].precision
-            decimal     = @locale.formatting.number.decimalMarker
-            thousand    = @locale.formatting.number.thousandMarker
-
-            return accounting.formatMoney( amount, sign, precision, thousand, decimal )
-
-        number: ( number, precision ) ->
-            precision  ?= @locale.formatting.number.precision
-            decimal     = @locale.formatting.number.decimalMarker
-            thousand    = @locale.formatting.number.thousandMarker
-
-            return accounting.formatNumber( number, precision, thousand, decimal )
+        ###*
+        #   Produce the current locale definition's [BCP 47 language tag](https://tools.ietf.org/html/bcp47#section-2) string.
+        #
+        #   @method     getLocaleName
+        #
+        #   @return     {String}                                        The current [BCP 47 language tag](https://tools.ietf.org/html/bcp47#section-2) string.
+        ###
+
+        getLocaleName: () -> @locale.name
+
+
+        ###*
+        #   Produce the localized `date` representation formatted according to the specified `format` key.
+        #
+        #   @method     _date
+        #   @protected
+        #
+        #   @param      {String}        format                          A key into the `formatting.datetime` section of the current locale definition.
+        #   @param      {Any}           date                            The `Moment` compatible value to format.
+        #
+        #   @return     {String}                                        The localized `date` representation string.
+        ###
+
+
+        _date: ( type, date ) ->
+
+            return Moment( date ).format( @locale.formatting.datetime[ type ] )
+
+
+        ###*
+        #   Produce the localized `amount` representation according to the specified or `'default'` `currency`.
+        #
+        #   @method     _money
+        #   @protected
+        #
+        #   @param      {String}        currency                        A key into the `formatting.money` section of the current locale definition designating
+        #                                                               the specific currency to use or sinply the current locale definition's `'default'`
+        #                                                               currency.
+        #   @param      {Number}        amount                          The amount to format.
+        #
+        #   @return     {String}                                        The localized `amount` representation string.
+        ###
+
+        _money: ( currency, amount ) ->
+
+            formatting  = @locale.formatting
+            number      = formatting.number
+            money       = formatting.money
+            currency    = money[ if 'default' is currency then money.default else currency ]
+
+            return accounting.formatMoney(
+
+                amount
+                currency.sign
+                currency.precision
+                number.decimalMarker
+                number.thousandMarker
+            )
+
+
+        ###*
+        #   Produce the localized `number` representation with optional `precision`.
+        #
+        #   @method     _number
+        #   @protected
+        #
+        #   @param      {Number}        number                          The number to format
+        #   @param      {Number}        [precision]                     The optional number of decimals to include; defaults to the precision specified in the
+        #                                                               current locale definition.
+        #
+        #   @return     {String}                                        The localized `number` representation string.
+        ###
+
+        _number: ( number, precision ) ->
+
+            formatting  = @locale.formatting.number
+
+            return accounting.formatNumber(
+
+                number
+                precision ? formatting.precision
+                formatting.decimalMarker
+                formatting.thousandMarker
+            )
+
+
+        ###*
+        #   Produce the specified, possibly interpolated, entry from `@polyglot`'s `phrases` dictionary.
+        #
+        #   @method     _translate
+        #   @protected
+        #
+        #   @param      {String}        key                             The key designating the entry to use from the current locale definition's `phrases`
+        #                                                               dictionary.
+        #   @param      {Any}           [...args]                       A variable number of positional arguments to interpolate into that entry.
+        #   @param      {Object}        meta                            The Handlebars `options` argument to helpers.
+        #   @param      {Object}        meta.hash                       Any named parameters to interpolate instead if no positional arguments were given.
+        #
+        #   @return     {String}                                        The, possibly interpolated, entry from `@polyglot`'s `phrases` dictionary.
+        ###
+
+        _translate: ( key, args..., meta ) ->
+
+            return @polyglot.t( key, if args.length then args else meta.hash )
 
 
         ###*




    # We only need one translator
    #
    localeManager = new LocaleManager()
    return localeManager
)



            @initialized    = true
            @localeLocation = localeLocation if localeLocation?
            @polyglot       = new Polyglot()

            ##  Register the handlebars helper(s)
            ##
            date            = @_date.bind( @ )
            money           = @_money.bind( @ )
            number          = @_number.bind( @ )
            translate       = @_translate.bind( @ )

            runtime.registerHelper( '_date',                    date )
            runtime.registerHelper( 'D',                        date )

            runtime.registerHelper( '_money',                   money )
            runtime.registerHelper( 'M',                        money )

            runtime.registerHelper( '_number',                  number )
            runtime.registerHelper( 'N',                        number )

            runtime.registerHelper( '_translate',               translate   )
            runtime.registerHelper( 't',                        translate   )
            runtime.registerHelper( 'T', _.compose( capitalize, translate ) )

            return @setLocale( localeName )


        ###*
        #   Reset to the specified locale definition, reusing a previously cached one when available
        #
        #   @method     setLocale
        #
        #   @param      {String}        localeName                      A valid [BCP 47 language tag](https://tools.ietf.org/html/bcp47#section-2) string
        #                                                               designating a `.json` locale definition by the same name that is to be loaded;
        #
        #   @return     {Promise}                                       A promise to load the locale definition.
        ###

        setLocale: ( localeName ) ->

            unless @initialized

