{"version":3,"file":"scripts.380ca165bfb35d7c.js","mappings":"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","names":["sffjs","currentCulture","version","setCulture","languageCode","currentCultureId","updateCulture","registerCulture","culture","cultures","name","toUpperCase","fillGapsInCulture","getCultures","result","INVARIANT_CULTURE","key","push","CULTURE_TEMPLATE","d","D","t","T","M","Y","s","_M","_D","_r","_t","_c","_ct","_cr","_am","_pm","navigator","systemLanguage","language","Object","create","zeroPad","value","len","length","hasValue","numberCoalesce","value1","value2","isNaN","hasOwnProperty","f","F","g","G","m","y","LC","split","ensureFixedPoint","numberString","parts","exponent","Number","replace","numberToString","number","decimals","Math","abs","toString","radixIndex","indexOf","toFixed","numberOfIntegralDigits","point","groupedAppend","out","i","basicNumberFormatter","minIntegralDigits","minDecimalDigits","maxDecimalDigits","radixPoint","thousandSeparator","integralDigits","decimalDigits","numberOfDecimalDigits","substr","join","prototype","__Format","format","this","isFinite","standardFormatStringMatch","match","standardFormatStringMatch_UpperCase","precision","parseInt","coefficient","minDecimals","maxDecimals","exponentPrefix","exponentPrecision","round","customNumberFormatter","currentToken","numberIndex","formatIndex","endIndex","digits","forcedDigits","forcedDecimals","thousandsMultiplier","atDecimals","unused","tokens","tokenGroups","String","substring","max","Date","date","year","getFullYear","month","getMonth","dayOfMonth","getDate","dayOfWeek","getDay","hour","getHours","minute","getMinutes","second","getSeconds","fracSecond","getMilliseconds","tzOffset","getTimezoneOffset","tzOffsetAbs","char0","_d","_m","str","obj0","obj1","obj2","outerArgs","arguments","innerArgs","processFormatItem","pathOrIndex","align","formatString","args","paddingLength","index","padding","resolvePath","path","followingMembers","exec","formattables","msf"],"ignoreList":[],"sourceRoot":"webpack:///","sources":["src\\assets\\js\\sffjs\\stringformat.js","src\\assets\\js\\sffjs\\cultures\\stringformat.en.js","src\\assets\\js\\sffjs\\cultures\\stringformat.sv.js"],"sourcesContent":["/**\r\n * String.format for JavaScript 1.17.0\r\n * https://github.com/dmester/sffjs\r\n *  \r\n * Built: 2020-10-18T11:11:31.521Z\r\n *\r\n * Copyright (c) 2009-2020 Daniel Mester Pirttijärvi\r\n *\r\n * This software is provided 'as-is', without any express or implied\r\n * warranty.  In no event will the authors be held liable for any damages\r\n * arising from the use of this software.\r\n * \r\n * Permission is granted to anyone to use this software for any purpose,\r\n * including commercial applications, and to alter it and redistribute it\r\n * freely, subject to the following restrictions:\r\n * \r\n * 1. The origin of this software must not be misrepresented; you must not\r\n *    claim that you wrote the original software. If you use this software\r\n *    in a product, an acknowledgment in the product documentation would be\r\n *    appreciated but is not required.\r\n * \r\n * 2. Altered source versions must be plainly marked as such, and must not be\r\n *    misrepresented as being the original software.\r\n * \r\n * 3. This notice may not be removed or altered from any source distribution.\r\n * \r\n */\r\n\r\nvar sffjs = (function() {\r\n    \"use strict\";\r\n\r\n    // ***** Public Interface *****\r\n    var sffjs = {\r\n            /**\r\n             * The version of the library String.Format for JavaScript.\r\n             * @type string\r\n             */\r\n            version: \"1.17.0\",\r\n            \r\n            /**\r\n             * Sets the current culture, used for culture specific formatting.\r\n             * @param {string} languageCode The IETF language code of the culture, e.g. en-US or en.\r\n             */\r\n            setCulture: function (languageCode) {\r\n                currentCultureId = languageCode;\r\n                updateCulture();\r\n            },\r\n            \r\n            /**\r\n             * Registers an object containing information about a culture.\r\n             * @param {*} culture Culture object.\r\n             */\r\n            registerCulture: function (culture) {\r\n                cultures[culture.name[toUpperCase]()] = fillGapsInCulture(culture);\r\n                \r\n                // ...and reevaulate current culture\r\n                updateCulture();\r\n            },\r\n\r\n            /**\r\n             * Gets an array of all registered cultures.\r\n             */\r\n            getCultures: function () {\r\n                var result = [INVARIANT_CULTURE];\r\n                for (var key in cultures) {\r\n                    result.push(cultures[key]);\r\n                }\r\n                return result;\r\n            },\r\n        },\r\n        \r\n    // ***** Shortcuts *****\r\n        toUpperCase = \"toUpperCase\",\r\n   \r\n    // ***** Private Variables *****\r\n    \r\n        // This is the default values of a culture. Any missing format will default to the format in CULTURE_TEMPLATE.\r\n        // The invariant culture is generated from these default values.\r\n        CULTURE_TEMPLATE = {\r\n            name: \"\", // Empty on invariant culture\r\n            d: \"MM/dd/yyyy\",\r\n            D: \"dddd, dd MMMM yyyy\",\r\n            t: \"HH:mm\",\r\n            T: \"HH:mm:ss\",\r\n            M: \"MMMM dd\",\r\n            Y: \"yyyy MMMM\",\r\n            s: \"yyyy-MM-ddTHH:mm:ss\",\r\n            _M: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"],\r\n            _D: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\r\n            _r: \".\", // Radix point\r\n            _t: \",\", // Thounsands separator\r\n            _c: \"¤#,0.00\", // Currency format string\r\n            _ct: \",\", // Currency thounsands separator\r\n            _cr: \".\",  // Currency radix point\r\n            _am: \"AM\",\r\n            _pm: \"PM\"\r\n        },\r\n    \r\n        // Generate invariant culture\r\n        INVARIANT_CULTURE = fillGapsInCulture({}),\r\n    \r\n        // Holds the current culture object\r\n        currentCulture,\r\n    \r\n        // Holds the id of the current culture. The id is also included in the culture object, but the \r\n        // culture object might be replaced during runtime when a better matching culture is registered.\r\n        currentCultureId = typeof navigator != \"undefined\" && (navigator.systemLanguage || navigator.language) || \"\",\r\n    \r\n        // Holds all registered external cultures, i.e. not the invariant culture\r\n        cultures = Object.create(null);\r\n    \r\n    \r\n    // ***** Private Methods *****\r\n    \r\n    // General helpers\r\n    \r\n    /**\r\n     * Pads the specified value with zeroes to the left until it reaches the specified length.\r\n     * @param {*} value Value to zeropad. \r\n     * @param {number} len Minimum length of result.\r\n     * @returns {string}\r\n     */\r\n    function zeroPad(value, len) {\r\n        var s = \"\" + value;\r\n        while (s.length < len) s = \"0\" + s;\r\n        return s;\r\n    }\r\n\r\n    /**\r\n     * Returns `true` if `value` is not null or undefined.\r\n     * @param {*} value \r\n     */\r\n    function hasValue(value) {\r\n        return value != null;\r\n    }\r\n    \r\n    /**\r\n     * Returns the first of the two values that is not NaN.\r\n     */\r\n    function numberCoalesce(value1, value2) {\r\n        return isNaN(value1) ? value2 : value1;\r\n    }\r\n    \r\n    \r\n    // Culture functions\r\n    \r\n    /**\r\n     * This method will fill gaps in the specified culture with information from the invariant culture.\r\n     */\r\n    function fillGapsInCulture(culture) {\r\n        // Add missing formats from the culture template\r\n        for (var key in CULTURE_TEMPLATE) {\r\n            if (CULTURE_TEMPLATE.hasOwnProperty(key) && culture[key] == null) {\r\n                culture[key] = CULTURE_TEMPLATE[key];\r\n            }\r\n        }\r\n        \r\n        // Construct composite formats if they are not already defined\r\n        culture.f = culture.f || culture.D + \" \" + culture.t;\r\n        culture.F = culture.F || culture.D + \" \" + culture.T;\r\n        culture.g = culture.g || culture.d + \" \" + culture.t;\r\n        culture.G = culture.G || culture.d + \" \" + culture.T;\r\n        \r\n        // Add aliases\r\n        culture.m = culture.M;\r\n        culture.y = culture.Y;\r\n        \r\n        return culture;\r\n    }\r\n    \r\n    /**\r\n     * This method will update the currently selected culture object to reflect the currently set LCID (as far as possible).\r\n     */\r\n    function updateCulture() {\r\n        sffjs.LC = currentCulture = \r\n            currentCultureId && \r\n            (\r\n                cultures[currentCultureId[toUpperCase]()] || \r\n                cultures[currentCultureId.split(\"-\")[0][toUpperCase]()]\r\n            ) || INVARIANT_CULTURE;\r\n    }\r\n    \r\n    \r\n    // Maths\r\n    \r\n    function ensureFixedPoint(numberString) {\r\n        var parts = numberString.split(\"e\");\r\n        var result = parts[0];\r\n        \r\n        if (parts.length > 1) {\r\n            // Convert exponential to fixed-point number\r\n            var exponent = Number(parts[1]);\r\n            result = result.replace(\".\", \"\");\r\n            \r\n            if (exponent < 0) {\r\n                while (++exponent < 0) {\r\n                    result = \"0\" + result;\r\n                }\r\n                result = \"0.\" + result;\r\n            }\r\n            else {\r\n                while (exponent >= result.length) {\r\n                    result += \"0\";\r\n                }\r\n            }\r\n        }\r\n        \r\n        return result;\r\n    }\r\n    \r\n    /**\r\n     * Generates a string representation of the specified number with the specified number of digits.\r\n     * @param {number} number The value to be processed.\r\n     * @param {number} [decimals] The maximum number of decimals. If not specified, the value is not rounded.\r\n     * @returns {string} The rounded absolute value as a string.\r\n     */\r\n    function numberToString(number, decimals) {\r\n        var result = ensureFixedPoint(Math.abs(number).toString());\r\n        \r\n        var radixIndex = result.indexOf(\".\");\r\n        if (radixIndex > 0 && result.length - radixIndex - 1 > decimals) {\r\n            // Rounding required\r\n            \r\n            // Add 1 to string representation of the number to improve \r\n            // the chance that toFixed rounds correctly.\r\n            result = ensureFixedPoint(Number(result + \"1\").toFixed(decimals));\r\n            \r\n            // Trim excessive decimal zeroes\r\n            if (decimals > 0) {\r\n                result = result.replace(/\\.?0+$/, \"\");\r\n            }\r\n        }\r\n        \r\n        return result;\r\n    }\r\n    \r\n    /**\r\n     * Counts the number of integral digits in a number converted to a string by the JavaScript runtime.\r\n     * @param {string} numberString \r\n     * @returns {number}\r\n     */\r\n    function numberOfIntegralDigits(numberString) {\r\n        var point = numberString.indexOf(\".\");\r\n        return point < 0 ? numberString.length : point;\r\n    }\r\n    \r\n    /**\r\n     * Counts the number of decimal digits in a number converted to a string by the JavaScript runtime\r\n     * @param {string} numberString \r\n     * @returns {number}\r\n     */\r\n    function numberOfDecimalDigits(numberString) {\r\n        var point = numberString.indexOf(\".\");\r\n        return point < 0 ? 0 : numberString.length - point - 1;\r\n    }\r\n    \r\n    \r\n    // Formatting helpers\r\n    \r\n    /**\r\n     * This function resolves a path on the format `<membername>(.<membername>|[<index>])*`\r\n     * and evaluates the value.\r\n     * @param {string} path A series of path components separated by points. Each component is either an index in square brackets.\r\n     * @param {*} value An object on which the path is evaluated.\r\n     */\r\n    function resolvePath(path, value) {\r\n        // Parse and evaluate path\r\n        if (hasValue(value)) {\r\n            var followingMembers = /(\\.([a-zA-Z_$]\\w*)|\\[(\\d+)\\])/g,\r\n                match = /^[a-zA-Z_$]\\w*/.exec(path);\r\n                \r\n            value = value[match[0]];\r\n            \r\n            // Evaluate path until we reach the searched member or the value is undefined/null\r\n            while (hasValue(value) && (match = followingMembers.exec(path))) {\r\n                value = value[match[2] || Number(match[3])];\r\n            }\r\n        }\r\n        \r\n        return value;\r\n    }\r\n    \r\n    /**\r\n     * Writes a value to an array in groups of three digits.\r\n     * @param {string[]} out An array used as string builder to which the grouped output will be appended. The array\r\n     * may have to properties that affect the output:\r\n     * \r\n     * * `g`: the number of integral digits left to write.\r\n     * * `t`: the thousand separator.\r\n     *   \r\n     * If any of those properties are missing, the output is not grouped.\r\n     * @param {string} value The value that will be written to `out`.\r\n     */\r\n    function groupedAppend(out, value) {\r\n        for (var i = 0, length = value.length; i < length; i++) {\r\n            // Write number\r\n            out.push(value[i]);\r\n\r\n            // Begin a new group?\r\n            if (out.g > 1 && out.g-- % 3 == 1) {\r\n                out.push(out.t);\r\n            }\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * Process a single format item in a composite format string.\r\n     * @param {string} pathOrIndex The raw argument index or path component of the format item.\r\n     * @param {string} align The raw alignment component of the format item.\r\n     * @param {string} formatString The raw format string of the format item.\r\n     * @param {Array} args The arguments that were passed to String.format, where index 0 is the full composite format string.\r\n     * @returns {string} The formatted value as a string.\r\n     */\r\n    function processFormatItem(pathOrIndex, align, formatString, args) {        \r\n        var value, \r\n            index = parseInt(pathOrIndex, 10), \r\n            paddingLength, \r\n            padding = \"\";\r\n        \r\n        // Determine whether index or path mode was used\r\n        if (isNaN(index)) {\r\n            // Non-numerical index => treat as path\r\n            value = resolvePath(pathOrIndex, args[1]);\r\n        } else {\r\n            // Index was numerical => ensure index is within range\r\n            if (index > args.length - 2) {\r\n                // Throw exception if argument is not specified (however undefined and null values are fine!)\r\n                throw \"Missing argument\";\r\n            }\r\n            \r\n            value = args[index + 1];\r\n        }\r\n        \r\n        // If the object has a custom format method, use it,\r\n        // otherwise use toString to create a string\r\n        value = !hasValue(value) ? \"\" : value.__Format ? value.__Format(formatString) : \"\" + value;\r\n        \r\n        // Add padding (if necessary)\r\n        align = Number(align) || 0;\r\n        \r\n        paddingLength = Math.abs(align) - value.length;\r\n\r\n        while (paddingLength-- > 0) {\r\n            padding += \" \";\r\n        }\r\n        \r\n        // innerArgs[1] is the leading {'s\r\n        return (align < 0 ? value + padding : padding + value);\r\n    }\r\n    \r\n    /**\r\n     * Handles basic formatting used for standard numeric format strings.\r\n     * @param {number} number The number to format.\r\n     * @param {number} minIntegralDigits The minimum number of integral digits. The number is padded with leading\r\n     * zeroes if necessary.\r\n     * @param {number} minDecimalDigits The minimum number of decimal digits. The decimal part is padded with trailing\r\n     * zeroes if necessary.\r\n     * @param {number} maxDecimalDigits The maximum number of decimal digits. The number is rounded if necessary.\r\n     * @param {string} radixPoint The string that will be appended to the output as a radix point.\r\n     * @param {string} thousandSeparator The string that will be used as a thousand separator of the integral digits.\r\n     * @returns {string} The formatted value as a string.\r\n     */\r\n    function basicNumberFormatter(number, minIntegralDigits, minDecimalDigits, maxDecimalDigits, radixPoint, thousandSeparator) {\r\n        var integralDigits, decimalDigits, out = [];\r\n        out.t = thousandSeparator;\r\n        \r\n        // Minus sign\r\n        if (number < 0) {\r\n            out.push(\"-\");\r\n        }\r\n        \r\n        // Prepare number \r\n        number = numberToString(number, maxDecimalDigits);\r\n        \r\n        integralDigits = out.g = numberOfIntegralDigits(number);\r\n        decimalDigits = numberOfDecimalDigits(number);\r\n\r\n        // Pad integrals with zeroes to reach the minimum number of integral digits\r\n        minIntegralDigits -= integralDigits;\r\n        while (minIntegralDigits-- > 0) {\r\n            groupedAppend(out, \"0\");\r\n        }\r\n        \r\n        // Add integral digits\r\n        groupedAppend(out, number.substr(0, integralDigits));\r\n        \r\n        // Add decimal point and decimal digits\r\n        if (minDecimalDigits || decimalDigits) {\r\n            out.push(radixPoint);\r\n            \r\n            groupedAppend(out, number.substr(integralDigits + 1));\r\n\r\n            // Pad with zeroes\r\n            minDecimalDigits -= decimalDigits;\r\n            while (minDecimalDigits-- > 0) {\r\n                groupedAppend(out, \"0\");\r\n            }\r\n        }\r\n        \r\n        return out.join(\"\");\r\n    }\r\n    \r\n    /**\r\n     * Handles formatting of custom numeric format strings.\r\n     * @param {number} number The number to format.\r\n     * @param {string} format A string specifying the format of the output.\r\n     * @param {string} radixPoint The string that will be appended to the output as a radix point.\r\n     * @param {string} thousandSeparator The string that will be used as a thousand separator of the integral digits.\r\n     * @returns {string} The formatted value as a string.\r\n     */\r\n    function customNumberFormatter(number, format, radixPoint, thousandSeparator) {\r\n        var digits = 0,\r\n            forcedDigits = -1,\r\n            integralDigits = -1,\r\n            decimals = 0,\r\n            forcedDecimals = -1,\r\n            \r\n            thousandsMultiplier = 1,\r\n            \r\n            atDecimals = 0, // Bool\r\n            unused = 1, // Bool, True until a digit has been written to the output\r\n            \r\n            tokens = [],\r\n            tokenGroups = [ tokens ],\r\n            \r\n            currentToken,\r\n            numberIndex,\r\n            formatIndex,\r\n            endIndex,\r\n            \r\n            out = [];\r\n\r\n        // Tokenize format string.\r\n        // Constants are represented with String instances, while all other tokens are represented with\r\n        // string literals.\r\n        for (formatIndex = 0; formatIndex < format.length; formatIndex++) {\r\n            currentToken = format[formatIndex];\r\n            \r\n            // Check if we have reached a literal\r\n            if (currentToken == \"'\" || currentToken == '\"') {\r\n                \r\n                // Find end of literal\r\n                endIndex = format.indexOf(currentToken, formatIndex + 1);\r\n                \r\n                // String instances are used to represent constants\r\n                tokens.push(new String(\r\n                    format.substring(\r\n                        formatIndex + 1, \r\n                        endIndex < 0 ? undefined : endIndex // assume rest of string if matching quotation mark is missing\r\n                    )));\r\n                \r\n                // If there is no matching end quotation mark, let's assume the rest of the string is a literal.\r\n                // This is the way .NET handles things.\r\n                if (endIndex < 0) break;\r\n                \r\n                formatIndex = endIndex;\r\n                \r\n            // Check for single escaped character\r\n            } else if (currentToken == \"\\\\\") {\r\n                // String instances are used to represent constants\r\n                tokens.push(new String(format[++formatIndex]));\r\n                \r\n            } else if (currentToken == \";\") {\r\n            \r\n                // Short circuit tokenizer\r\n                if (number > 0 || // No need to parse any more groups if the number is positive since the first group is for positive numbers\r\n                    number < 0 && tokenGroups.length > 1) { // Dito for negative numbers which is specified in the second group\r\n                    break;\r\n                }\r\n                \r\n                // Begin a new token group\r\n                tokenGroups.push(tokens = []);\r\n                \r\n            } else {\r\n                tokens.push(currentToken);\r\n                \r\n            }\r\n        }\r\n\r\n        // Determine which token group to be used ( positive; negative; zero, where the two last ones are optional)\r\n        if (number < 0 && tokenGroups.length > 1) {\r\n            number *= -1;\r\n            format = tokenGroups[1];\r\n        } else {\r\n            format = tokenGroups[!number && tokenGroups.length > 2 ? 2 : 0];\r\n        }\r\n\r\n        // Analyse format string\r\n        // Count number of digits, decimals, forced digits and forced decimals.\r\n        for (formatIndex = 0; formatIndex < format.length; formatIndex++) {\r\n            currentToken = format[formatIndex];\r\n            \r\n            // Only handle digit placeholders and number multipliers during analysis phase\r\n            if (currentToken === \"0\" || currentToken === \"#\") {\r\n                decimals += atDecimals;\r\n\r\n                if (currentToken == \"0\") {\r\n                    // 0 is a forced digit\r\n                    if (atDecimals) {\r\n                        forcedDecimals = decimals;\r\n                    } else if (forcedDigits < 0) {\r\n                        forcedDigits = digits;\r\n                    }\r\n                }\r\n                \r\n                // If a comma specifier is specified before the last integral digit\r\n                // it indicates thousand grouping.\r\n                if (thousandsMultiplier != 1 && !atDecimals) {\r\n                    // Set thousand separator\r\n                    out.t = thousandSeparator;\r\n                    thousandsMultiplier = 1;\r\n                }\r\n\r\n                digits += !atDecimals;\r\n            }\r\n            \r\n            // End of integral part\r\n            else if (currentToken === \".\") {\r\n                atDecimals = 1;\r\n            }\r\n            \r\n            // Comma specifier used for both thousand grouping and scaling.\r\n            // It is only effective if specified before the explicit or implicit decimal point. \r\n            else if (currentToken === \",\" && !atDecimals && digits > 0) { \r\n                thousandsMultiplier *= 0.001;\r\n            }\r\n            \r\n            // Percent\r\n            else if (currentToken === \"%\") {\r\n                number *= 100;\r\n            }\r\n        }\r\n        forcedDigits = forcedDigits < 0 ? 1 : digits - forcedDigits;\r\n\r\n        // Negative value? Begin string with a dash\r\n        if (number < 0) {\r\n            out.push(\"-\");\r\n        }\r\n\r\n        // Round the number value to a specified number of decimals\r\n        number = numberToString(number * thousandsMultiplier, decimals);\r\n\r\n        // Get integral length\r\n        integralDigits = numberOfIntegralDigits(number);\r\n\r\n        // Set initial number cursor position\r\n        numberIndex = integralDigits - digits;\r\n\r\n        // Initialize thousand grouping\r\n        out.g = Math.max(integralDigits, forcedDigits);\r\n        \r\n        for (formatIndex = 0; formatIndex < format.length; formatIndex++) {\r\n            currentToken = format[formatIndex];\r\n        \r\n            // Digit placeholder\r\n            if (currentToken === \"#\" || currentToken === \"0\") {\r\n                if (numberIndex < integralDigits) {\r\n                    // In the integral part\r\n                    if (numberIndex >= 0) {\r\n                        if (unused) {\r\n                            groupedAppend(out, number.substr(0, numberIndex));\r\n                        }\r\n                        groupedAppend(out, number[numberIndex]);\r\n\r\n                        // Not yet inside the number number, force a zero?\r\n                    } else if (numberIndex >= integralDigits - forcedDigits) {\r\n                        groupedAppend(out, \"0\");\r\n                    }\r\n\r\n                    unused = 0;\r\n\r\n                } else if (forcedDecimals-- > 0 || numberIndex < number.length) {\r\n                    // In the fractional part\r\n                    groupedAppend(out, numberIndex >= number.length ? \"0\" : number[numberIndex]);\r\n                }\r\n\r\n                numberIndex++;\r\n\r\n            // Radix point character according to current culture.\r\n            } else if (currentToken === \".\") {\r\n                if (number.length > ++numberIndex || forcedDecimals > 0) {\r\n                    out.push(radixPoint);\r\n                }\r\n                \r\n            // Other characters are written as they are, except from commas\r\n            } else if (currentToken !== \",\") {\r\n                out.push(currentToken);\r\n            }\r\n        }\r\n        \r\n        return out.join(\"\");\r\n    }\r\n    \r\n    // ***** FORMATTERS\r\n    // ***** Number Formatting *****\r\n\r\n    /**\r\n     * Formats this number according the specified format string.\r\n     * @param {string} format The formatting string used to format this number.\r\n     * @returns {string}\r\n     */\r\n    Number.prototype.__Format = function(format) {\r\n        var number = Number(this),\r\n            radixPoint = currentCulture._r,\r\n            thousandSeparator = currentCulture._t;\r\n        \r\n        // If not finite, i.e. ±Intifity and NaN, return the default JavaScript string notation\r\n        if (!isFinite(number)) {\r\n            return \"\" + number;\r\n        }\r\n        \r\n        // Default formatting if no format string is specified\r\n        if (!format && format !== \"0\") {\r\n            format = \"G\";\r\n        }\r\n        \r\n        // EVALUATE STANDARD NUMERIC FORMAT STRING\r\n        // See reference at\r\n        // http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx\r\n        \r\n        var standardFormatStringMatch = format.match(/^([a-zA-Z])(\\d{0,2})$/);\r\n        if (standardFormatStringMatch)\r\n        {\r\n            var standardFormatStringMatch_UpperCase = standardFormatStringMatch[1][toUpperCase](),\r\n                precision = parseInt(standardFormatStringMatch[2], 10); // parseInt used to ensure empty string is aprsed to NaN\r\n            \r\n            // Standard numeric format string\r\n            switch (standardFormatStringMatch_UpperCase) {\r\n                case \"D\":\r\n                    // DECIMAL\r\n                    // Precision: number of digits\r\n                    \r\n                    // Note: the .NET implementation throws an exception if used with non-integral \r\n                    // data types. However, this implementation follows the JavaScript manner being\r\n                    // nice about arguments and thus rounds any floating point numbers to integers.\r\n                    \r\n                    return basicNumberFormatter(number, numberCoalesce(precision, 1), 0, 0);\r\n                \r\n                case \"F\":\r\n                    // FIXED-POINT\r\n                    // Precision: number of decimals\r\n                    \r\n                    thousandSeparator = \"\";\r\n                    // Fall through to N, which has the same format as F, except no thousand grouping\r\n                    \r\n                case \"N\":\r\n                    // NUMBER\r\n                    // Precision: number of decimals\r\n                    \r\n                    return basicNumberFormatter(number, 1, numberCoalesce(precision, 2), numberCoalesce(precision, 2), radixPoint, thousandSeparator);\r\n                \r\n                case \"G\":\r\n                    // GENERAL\r\n                    // Precision: number of significant digits\r\n                    \r\n                    // Fall through to E, whose implementation is shared with G\r\n                    \r\n                case \"E\":\r\n                    // EXPONENTIAL (SCIENTIFIC)\r\n                    // Precision: number of decimals\r\n                    \r\n                    // Note that we might have fell through from G above!\r\n                    \r\n                    // Determine coefficient and exponent for exponential notation\r\n                    var exponent = 0, coefficient = Math.abs(number);\r\n                    \r\n                    while (coefficient >= 10) {\r\n                        coefficient /= 10;\r\n                        exponent++;\r\n                    }\r\n                    \r\n                    while (coefficient > 0 && coefficient < 1) {\r\n                        coefficient *= 10;\r\n                        exponent--;\r\n                    }\r\n                    \r\n                    var exponentPrefix = standardFormatStringMatch[1],\r\n                        exponentPrecision = 3,\r\n                        minDecimals, maxDecimals;\r\n                    \r\n                    if (standardFormatStringMatch_UpperCase == \"G\") {\r\n                        // Default precision in .NET is dependent on the data type.\r\n                        // For double the default precision is 15.\r\n                        precision = precision || 15;\r\n                        \r\n                        // When (exponent <= -5) the exponential notation is always more compact.\r\n                        //   e.g. 0.0000123 vs 1.23E-05\r\n                        // When (exponent >= precision) the number cannot be represented \r\n                        //   with the right number of significant digits without using \r\n                        //   exponential notation.\r\n                        //   e.g. 123 (1.23E+02) cannot be represented using fixed-point \r\n                        //   notation with less than 3 significant digits.\r\n                        if (exponent > -5 && exponent < precision) {\r\n                            // Use fixed-point notation\r\n                            return basicNumberFormatter(number, 1, 0, precision - exponent - 1, radixPoint);\r\n                        }\r\n                    \r\n                        exponentPrefix = exponentPrefix == \"G\" ? \"E\" : \"e\";\r\n                        exponentPrecision = 2;\r\n                        \r\n                        // The precision of G is the number of significant digits\r\n                        minDecimals = 0;\r\n                        maxDecimals = precision - 1;\r\n                    } else {\r\n                        // The precision of E is the number of decimal digits\r\n                        minDecimals = maxDecimals = numberCoalesce(precision, 6);\r\n                    }\r\n                    \r\n                    // If the exponent is negative, then the minus is added when formatting the exponent as a number.\r\n                    // In the case of a positive exponent, we need to add the plus sign explicitly.\r\n                    if (exponent >= 0) {\r\n                        exponentPrefix += \"+\";\r\n                    }\r\n                    \r\n                    // Consider if the coefficient is positive or negative.\r\n                    // (the sign was lost when determining the coefficient)\r\n                    if (number < 0) {\r\n                        coefficient *= -1;\r\n                    }\r\n                    \r\n                    return (\r\n                        basicNumberFormatter(coefficient, 1, minDecimals, maxDecimals, radixPoint, thousandSeparator) + \r\n                        exponentPrefix + \r\n                        basicNumberFormatter(exponent, exponentPrecision, 0, 0)\r\n                        );\r\n                \r\n                case \"P\":\r\n                    // PERCENT\r\n                    // Precision: number of decimals\r\n                    \r\n                    return basicNumberFormatter(number * 100, 1, numberCoalesce(precision, 2), numberCoalesce(precision, 2), radixPoint, thousandSeparator) + \" %\";\r\n                \r\n                case \"X\":\r\n                    // HEXADECIMAL\r\n                    // Precision: number of digits\r\n                    \r\n                    // Note: the .NET implementation throws an exception if used with non-integral \r\n                    // data types. However, this implementation follows the JavaScript manner being\r\n                    // nice about arguments and thus rounds any floating point numbers to integers.\r\n                    \r\n                    var result = Math.round(number).toString(16);\r\n                    \r\n                    if (standardFormatStringMatch[1] == \"X\") {\r\n                        result = result[toUpperCase]();\r\n                    }\r\n                    \r\n                    // Add padding, remember precision might be NaN\r\n                    precision -= result.length;\r\n                    while (precision-- > 0) {\r\n                        result = \"0\" + result;\r\n                    }\r\n                    \r\n                    return result;\r\n                \r\n                case \"C\":\r\n                    // CURRENCY\r\n                    // Precision: ignored (number of decimals in the .NET implementation)\r\n                    \r\n                    // The currency format uses a custom format string specified by the culture.\r\n                    // Precision is not supported and probably won't be supported in the future.\r\n                    // Developers probably use explicit formatting of currencies anyway...\r\n                    format = currentCulture._c;\r\n                    radixPoint = currentCulture._cr;\r\n                    thousandSeparator = currentCulture._ct;\r\n                    break;\r\n                \r\n                case \"R\":\r\n                    // ROUND-TRIP\r\n                    // Precision: ignored\r\n                    \r\n                    // The result should be reparsable => just use Javascript default string representation.\r\n                    \r\n                    return \"\" + number;\r\n            }\r\n        }\r\n        \r\n        // EVALUATE CUSTOM NUMERIC FORMAT STRING\r\n        return customNumberFormatter(number, format, radixPoint, thousandSeparator);\r\n    };\r\n\r\n    // ***** Date Formatting *****\r\n\r\n    /**\r\n     * Formats this date according the specified format string.\r\n     * @param {string} format The formatting string used to format this date.\r\n     * @returns {string}\r\n     */\r\n    Date.prototype.__Format = function(format) {\r\n        var date        = this, \r\n            year        = date.getFullYear(),\r\n            month       = date.getMonth(),\r\n            dayOfMonth  = date.getDate(),\r\n            dayOfWeek   = date.getDay(),\r\n            hour        = date.getHours(),\r\n            minute      = date.getMinutes(),\r\n            second      = date.getSeconds(),\r\n            fracSecond  = date.getMilliseconds() / 1000,\r\n            tzOffset    = date.getTimezoneOffset(),\r\n            tzOffsetAbs = tzOffset < 0 ? -tzOffset : tzOffset;\r\n            \r\n        // If no format is specified, default to G format\r\n        format = format || \"G\";\r\n        \r\n        // Resolve standard date/time format strings\r\n        if (format.length == 1) {\r\n            format = currentCulture[format] || format;\r\n        }\r\n\r\n        // Note that a leading percent is trimmed below. This is not completely compatible with .NET Framework,\r\n        // which will treat a percent followed by more than a single character as two format tokens, e.g. \r\n        // %yy is interpreted as ['y' 'y'], whereas this implementation will interpret it as ['yy']. This does\r\n        // not seem to be a documented behavior and thus an acceptable deviation.\r\n        return format.replace(/^%/, \"\").replace(/(\\\\.|'[^']*'|\"[^\"]*\"|d{1,4}|M{1,4}|y+|HH?|hh?|mm?|ss?|[f]{1,7}|[F]{1,7}|z{1,3}|tt?)/g, \r\n            function (match) { \r\n                var char0 = match[0];\r\n\r\n                        // Day\r\n                return  match == \"dddd\" ? currentCulture._D[dayOfWeek] :\r\n                                             // Use three first characters from long day name if abbreviations are not specifed\r\n                        match == \"ddd\"  ? (currentCulture._d ? currentCulture._d[dayOfWeek] : currentCulture._D[dayOfWeek].substr(0, 3)) : \r\n                        char0 == \"d\"    ? zeroPad(dayOfMonth, match.length) :\r\n                        \r\n                        // Month\r\n                        match == \"MMMM\" ? currentCulture._M[month] :\r\n                                             // Use three first characters from long month name if abbreviations are not specifed\r\n                        match == \"MMM\"  ? (currentCulture._m ? currentCulture._m[month] : currentCulture._M[month].substr(0, 3)) :\r\n                        char0 == \"M\"    ? zeroPad(month + 1, match.length) :\r\n\r\n                        // Year\r\n                        match == \"yy\"   ? zeroPad(year % 100, 2) : \r\n                        match == \"y\"    ? year % 100 :\r\n                        char0 == \"y\"    ? zeroPad(year, match.length) :\r\n                        \r\n                        // Hour\r\n                        char0 == \"H\"    ? zeroPad(hour, match.length) :\r\n                        char0 == \"h\"    ? zeroPad(hour % 12 || 12, match.length) :\r\n                        \r\n                        // Minute\r\n                        char0 == \"m\"    ? zeroPad(minute, match.length) :\r\n                        \r\n                        // Second\r\n                        char0 == \"s\"    ? zeroPad(second, match.length) :\r\n\r\n                        // Fractional second (substr is to remove \"0.\")\r\n                        char0 == \"f\"    ? (fracSecond).toFixed(match.length).substr(2) :\r\n                        char0 == \"F\"    ? numberToString(fracSecond, match.length).substr(2) :\r\n                        \r\n                        // Timezone, \"z\" -> \"+2\", \"zz\" -> \"+02\", \"zzz\" -> \"+02:00\"\r\n                        char0 == \"z\"    ? (tzOffset < 0 ? \"-\" : \"+\") + // sign\r\n                                          (zeroPad(0 | (tzOffsetAbs / 60), match == \"z\" ? 1 : 2)) + // hours\r\n                                          (match == \"zzz\" ? \":\" + zeroPad(tzOffsetAbs % 60, 2) : \"\") : // minutes\r\n\r\n                        // AM/PM\r\n                        match == \"tt\"   ? (hour < 12 ? currentCulture._am : currentCulture._pm) : \r\n                        char0 == \"t\"    ? (hour < 12 ? currentCulture._am : currentCulture._pm)[0] :\r\n                        \r\n                        // String literal => strip quotation marks\r\n                        match.substr(1, match.length - 1 - (match[0] != \"\\\\\"));\r\n            });\r\n    };\r\n    \r\n    /**\r\n     * Formats a string according to a specified formatting string.\r\n     * @param {string} str The formatting string used to format the additional arguments.\r\n     * @param {...*} args\r\n     */\r\n    String.__Format = function(str, obj0, obj1, obj2) {\r\n        var outerArgs = arguments;\r\n        \r\n        return str.replace(/\\{((\\d+|[a-zA-Z_$]\\w*(?:\\.[a-zA-Z_$]\\w*|\\[\\d+\\])*)(?:\\,(-?\\d*))?(?:\\:([^\\}]*(?:(?:\\}\\})+[^\\}]+)*))?)\\}|(\\{\\{)|(\\}\\})/g, function () {\r\n            var innerArgs = arguments;\r\n            \r\n            // Handle escaped {\r\n            return innerArgs[5] ? \"{\" :\r\n            \r\n            // Handle escaped }\r\n                innerArgs[6] ? \"}\" :\r\n            \r\n            // Valid format item\r\n                processFormatItem(\r\n                    innerArgs[2], \r\n                    innerArgs[3], \r\n                    // Format string might contain escaped braces\r\n                    innerArgs[4] && innerArgs[4].replace(/\\}\\}/g, \"}\").replace(/\\{\\{/g, \"{\"), \r\n                    outerArgs);\r\n        });\r\n    };\r\n\r\n    // If a format method has not already been defined on the following objects, set __Format as format.\r\n    var formattables = [ Date.prototype, Number.prototype, String ];\r\n    for (var i = 0, length = formattables.length; i < length; i++) {\r\n        formattables[i].format = formattables[i].format || formattables[i].__Format;\r\n    }\r\n    \r\n    // Initiate culture\r\n    updateCulture();\r\n    \r\n    return sffjs;\r\n})(), \r\n\r\n// msf for backward compatibility\r\nmsf = sffjs;","// This culture information has been generated using the Mono class library\r\n// licensed under the terms of the MIT X11 license.\r\n// See: http://www.mono-project.com/FAQ:_Licensing\r\n\r\nsffjs.registerCulture({\r\n    name: \"en\",\r\n    d: \"M/d/yyyy\",\r\n    D: \"dddd, MMMM dd, yyyy\",\r\n    t: \"h:mm tt\",\r\n    T: \"h:mm:ss tt\",\r\n    M: \"MMMM dd\",\r\n    Y: \"MMMM, yyyy\",\r\n    _am: \"AM\",\r\n    _pm: \"PM\",\r\n    _r: \".\",\r\n    _cr: \".\",\r\n    _t: \",\",\r\n    _ct: \",\",\r\n    _c: \"\\u0027$\\u0027#,0.00\",\r\n    _d: [\"Sun\",\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"],\r\n    _D: [\"Sunday\",\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\"],\r\n    _m: [\"Jan\",\"Feb\",\"Mar\",\"Apr\",\"May\",\"Jun\",\"Jul\",\"Aug\",\"Sep\",\"Oct\",\"Nov\",\"Dec\",\"\"],\r\n    _M: [\"January\",\"February\",\"March\",\"April\",\"May\",\"June\",\"July\",\"August\",\"September\",\"October\",\"November\",\"December\",\"\"]\r\n});\r\n\r\n","\r\nsffjs.registerCulture({\r\n    name: \"sv\",\r\n    d: \"yyyy-MM-dd\",\r\n    D: \"'den 'd MMMM yyyy\",\r\n    M: \"d MMMM\",\r\n    Y: \"MMMM yyyy\",\r\n    _M: [\"januari\", \"februari\", \"mars\", \"april\", \"maj\", \"juni\", \"juli\", \"augusti\", \"september\", \"oktober\", \"november\", \"december\"],\r\n    _m: [\"jan\", \"feb\", \"mar\", \"apr\", \"maj\", \"jun\", \"jul\", \"aug\", \"sep\", \"okt\", \"nov\", \"dec\"],\r\n    _D: [\"söndag\", \"måndag\", \"tisdag\", \"onsdag\", \"torsdag\", \"fredag\", \"lördag\"],\r\n    _d: [\"sön\", \"mån\", \"tis\", \"ons\", \"tor\", \"fre\", \"lör\"],\r\n    _r: \",\",\r\n    _cr: \",\",\r\n    _t: \" \",\r\n    _ct: \".\",\r\n    _c: \"#,0.00 kr\"\r\n});\r\n"],"x_google_ignoreList":[]}