|
7
|
1 /*!
|
|
|
2 * Globalize
|
|
|
3 *
|
|
|
4 * http://github.com/jquery/globalize
|
|
|
5 *
|
|
|
6 * Copyright Software Freedom Conservancy, Inc.
|
|
|
7 * Dual licensed under the MIT or GPL Version 2 licenses.
|
|
|
8 * http://jquery.org/license
|
|
|
9 */
|
|
|
10
|
|
|
11 (function( window, undefined ) {
|
|
|
12
|
|
|
13 var Globalize,
|
|
|
14 // private variables
|
|
|
15 regexHex,
|
|
|
16 regexInfinity,
|
|
|
17 regexParseFloat,
|
|
|
18 regexTrim,
|
|
|
19 // private JavaScript utility functions
|
|
|
20 arrayIndexOf,
|
|
|
21 endsWith,
|
|
|
22 extend,
|
|
|
23 isArray,
|
|
|
24 isFunction,
|
|
|
25 isObject,
|
|
|
26 startsWith,
|
|
|
27 trim,
|
|
|
28 truncate,
|
|
|
29 zeroPad,
|
|
|
30 // private Globalization utility functions
|
|
|
31 appendPreOrPostMatch,
|
|
|
32 expandFormat,
|
|
|
33 formatDate,
|
|
|
34 formatNumber,
|
|
|
35 getTokenRegExp,
|
|
|
36 getEra,
|
|
|
37 getEraYear,
|
|
|
38 parseExact,
|
|
|
39 parseNegativePattern;
|
|
|
40
|
|
|
41 // Global variable (Globalize) or CommonJS module (globalize)
|
|
|
42 Globalize = function( cultureSelector ) {
|
|
|
43 return new Globalize.prototype.init( cultureSelector );
|
|
|
44 };
|
|
|
45
|
|
|
46 if ( typeof require !== "undefined" &&
|
|
|
47 typeof exports !== "undefined" &&
|
|
|
48 typeof module !== "undefined" ) {
|
|
|
49 // Assume CommonJS
|
|
|
50 module.exports = Globalize;
|
|
|
51 } else {
|
|
|
52 // Export as global variable
|
|
|
53 window.Globalize = Globalize;
|
|
|
54 }
|
|
|
55
|
|
|
56 Globalize.cultures = {};
|
|
|
57
|
|
|
58 Globalize.prototype = {
|
|
|
59 constructor: Globalize,
|
|
|
60 init: function( cultureSelector ) {
|
|
|
61 this.cultures = Globalize.cultures;
|
|
|
62 this.cultureSelector = cultureSelector;
|
|
|
63
|
|
|
64 return this;
|
|
|
65 }
|
|
|
66 };
|
|
|
67 Globalize.prototype.init.prototype = Globalize.prototype;
|
|
|
68
|
|
|
69 // 1. When defining a culture, all fields are required except the ones stated as optional.
|
|
|
70 // 2. Each culture should have a ".calendars" object with at least one calendar named "standard"
|
|
|
71 // which serves as the default calendar in use by that culture.
|
|
|
72 // 3. Each culture should have a ".calendar" object which is the current calendar being used,
|
|
|
73 // it may be dynamically changed at any time to one of the calendars in ".calendars".
|
|
|
74 Globalize.cultures[ "default" ] = {
|
|
|
75 // A unique name for the culture in the form <language code>-<country/region code>
|
|
|
76 name: "en",
|
|
|
77 // the name of the culture in the english language
|
|
|
78 englishName: "English",
|
|
|
79 // the name of the culture in its own language
|
|
|
80 nativeName: "English",
|
|
|
81 // whether the culture uses right-to-left text
|
|
|
82 isRTL: false,
|
|
|
83 // "language" is used for so-called "specific" cultures.
|
|
|
84 // For example, the culture "es-CL" means "Spanish, in Chili".
|
|
|
85 // It represents the Spanish-speaking culture as it is in Chili,
|
|
|
86 // which might have different formatting rules or even translations
|
|
|
87 // than Spanish in Spain. A "neutral" culture is one that is not
|
|
|
88 // specific to a region. For example, the culture "es" is the generic
|
|
|
89 // Spanish culture, which may be a more generalized version of the language
|
|
|
90 // that may or may not be what a specific culture expects.
|
|
|
91 // For a specific culture like "es-CL", the "language" field refers to the
|
|
|
92 // neutral, generic culture information for the language it is using.
|
|
|
93 // This is not always a simple matter of the string before the dash.
|
|
|
94 // For example, the "zh-Hans" culture is netural (Simplified Chinese).
|
|
|
95 // And the "zh-SG" culture is Simplified Chinese in Singapore, whose lanugage
|
|
|
96 // field is "zh-CHS", not "zh".
|
|
|
97 // This field should be used to navigate from a specific culture to it's
|
|
|
98 // more general, neutral culture. If a culture is already as general as it
|
|
|
99 // can get, the language may refer to itself.
|
|
|
100 language: "en",
|
|
|
101 // numberFormat defines general number formatting rules, like the digits in
|
|
|
102 // each grouping, the group separator, and how negative numbers are displayed.
|
|
|
103 numberFormat: {
|
|
|
104 // [negativePattern]
|
|
|
105 // Note, numberFormat.pattern has no "positivePattern" unlike percent and currency,
|
|
|
106 // but is still defined as an array for consistency with them.
|
|
|
107 // negativePattern: one of "(n)|-n|- n|n-|n -"
|
|
|
108 pattern: [ "-n" ],
|
|
|
109 // number of decimal places normally shown
|
|
|
110 decimals: 2,
|
|
|
111 // string that separates number groups, as in 1,000,000
|
|
|
112 ",": ",",
|
|
|
113 // string that separates a number from the fractional portion, as in 1.99
|
|
|
114 ".": ".",
|
|
|
115 // array of numbers indicating the size of each number group.
|
|
|
116 // TODO: more detailed description and example
|
|
|
117 groupSizes: [ 3 ],
|
|
|
118 // symbol used for positive numbers
|
|
|
119 "+": "+",
|
|
|
120 // symbol used for negative numbers
|
|
|
121 "-": "-",
|
|
|
122 // symbol used for NaN (Not-A-Number)
|
|
|
123 "NaN": "NaN",
|
|
|
124 // symbol used for Negative Infinity
|
|
|
125 negativeInfinity: "-Infinity",
|
|
|
126 // symbol used for Positive Infinity
|
|
|
127 positiveInfinity: "Infinity",
|
|
|
128 percent: {
|
|
|
129 // [negativePattern, positivePattern]
|
|
|
130 // negativePattern: one of "-n %|-n%|-%n|%-n|%n-|n-%|n%-|-% n|n %-|% n-|% -n|n- %"
|
|
|
131 // positivePattern: one of "n %|n%|%n|% n"
|
|
|
132 pattern: [ "-n %", "n %" ],
|
|
|
133 // number of decimal places normally shown
|
|
|
134 decimals: 2,
|
|
|
135 // array of numbers indicating the size of each number group.
|
|
|
136 // TODO: more detailed description and example
|
|
|
137 groupSizes: [ 3 ],
|
|
|
138 // string that separates number groups, as in 1,000,000
|
|
|
139 ",": ",",
|
|
|
140 // string that separates a number from the fractional portion, as in 1.99
|
|
|
141 ".": ".",
|
|
|
142 // symbol used to represent a percentage
|
|
|
143 symbol: "%"
|
|
|
144 },
|
|
|
145 currency: {
|
|
|
146 // [negativePattern, positivePattern]
|
|
|
147 // negativePattern: one of "($n)|-$n|$-n|$n-|(n$)|-n$|n-$|n$-|-n $|-$ n|n $-|$ n-|$ -n|n- $|($ n)|(n $)"
|
|
|
148 // positivePattern: one of "$n|n$|$ n|n $"
|
|
|
149 pattern: [ "($n)", "$n" ],
|
|
|
150 // number of decimal places normally shown
|
|
|
151 decimals: 2,
|
|
|
152 // array of numbers indicating the size of each number group.
|
|
|
153 // TODO: more detailed description and example
|
|
|
154 groupSizes: [ 3 ],
|
|
|
155 // string that separates number groups, as in 1,000,000
|
|
|
156 ",": ",",
|
|
|
157 // string that separates a number from the fractional portion, as in 1.99
|
|
|
158 ".": ".",
|
|
|
159 // symbol used to represent currency
|
|
|
160 symbol: "$"
|
|
|
161 }
|
|
|
162 },
|
|
|
163 // calendars defines all the possible calendars used by this culture.
|
|
|
164 // There should be at least one defined with name "standard", and is the default
|
|
|
165 // calendar used by the culture.
|
|
|
166 // A calendar contains information about how dates are formatted, information about
|
|
|
167 // the calendar's eras, a standard set of the date formats,
|
|
|
168 // translations for day and month names, and if the calendar is not based on the Gregorian
|
|
|
169 // calendar, conversion functions to and from the Gregorian calendar.
|
|
|
170 calendars: {
|
|
|
171 standard: {
|
|
|
172 // name that identifies the type of calendar this is
|
|
|
173 name: "Gregorian_USEnglish",
|
|
|
174 // separator of parts of a date (e.g. "/" in 11/05/1955)
|
|
|
175 "/": "/",
|
|
|
176 // separator of parts of a time (e.g. ":" in 05:44 PM)
|
|
|
177 ":": ":",
|
|
|
178 // the first day of the week (0 = Sunday, 1 = Monday, etc)
|
|
|
179 firstDay: 0,
|
|
|
180 days: {
|
|
|
181 // full day names
|
|
|
182 names: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
|
|
|
183 // abbreviated day names
|
|
|
184 namesAbbr: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ],
|
|
|
185 // shortest day names
|
|
|
186 namesShort: [ "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" ]
|
|
|
187 },
|
|
|
188 months: {
|
|
|
189 // full month names (13 months for lunar calendards -- 13th month should be "" if not lunar)
|
|
|
190 names: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", "" ],
|
|
|
191 // abbreviated month names
|
|
|
192 namesAbbr: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "" ]
|
|
|
193 },
|
|
|
194 // AM and PM designators in one of these forms:
|
|
|
195 // The usual view, and the upper and lower case versions
|
|
|
196 // [ standard, lowercase, uppercase ]
|
|
|
197 // The culture does not use AM or PM (likely all standard date formats use 24 hour time)
|
|
|
198 // null
|
|
|
199 AM: [ "AM", "am", "AM" ],
|
|
|
200 PM: [ "PM", "pm", "PM" ],
|
|
|
201 eras: [
|
|
|
202 // eras in reverse chronological order.
|
|
|
203 // name: the name of the era in this culture (e.g. A.D., C.E.)
|
|
|
204 // start: when the era starts in ticks (gregorian, gmt), null if it is the earliest supported era.
|
|
|
205 // offset: offset in years from gregorian calendar
|
|
|
206 {
|
|
|
207 "name": "A.D.",
|
|
|
208 "start": null,
|
|
|
209 "offset": 0
|
|
|
210 }
|
|
|
211 ],
|
|
|
212 // when a two digit year is given, it will never be parsed as a four digit
|
|
|
213 // year greater than this year (in the appropriate era for the culture)
|
|
|
214 // Set it as a full year (e.g. 2029) or use an offset format starting from
|
|
|
215 // the current year: "+19" would correspond to 2029 if the current year 2010.
|
|
|
216 twoDigitYearMax: 2029,
|
|
|
217 // set of predefined date and time patterns used by the culture
|
|
|
218 // these represent the format someone in this culture would expect
|
|
|
219 // to see given the portions of the date that are shown.
|
|
|
220 patterns: {
|
|
|
221 // short date pattern
|
|
|
222 d: "M/d/yyyy",
|
|
|
223 // long date pattern
|
|
|
224 D: "dddd, MMMM dd, yyyy",
|
|
|
225 // short time pattern
|
|
|
226 t: "h:mm tt",
|
|
|
227 // long time pattern
|
|
|
228 T: "h:mm:ss tt",
|
|
|
229 // long date, short time pattern
|
|
|
230 f: "dddd, MMMM dd, yyyy h:mm tt",
|
|
|
231 // long date, long time pattern
|
|
|
232 F: "dddd, MMMM dd, yyyy h:mm:ss tt",
|
|
|
233 // month/day pattern
|
|
|
234 M: "MMMM dd",
|
|
|
235 // month/year pattern
|
|
|
236 Y: "yyyy MMMM",
|
|
|
237 // S is a sortable format that does not vary by culture
|
|
|
238 S: "yyyy\u0027-\u0027MM\u0027-\u0027dd\u0027T\u0027HH\u0027:\u0027mm\u0027:\u0027ss"
|
|
|
239 }
|
|
|
240 // optional fields for each calendar:
|
|
|
241 /*
|
|
|
242 monthsGenitive:
|
|
|
243 Same as months but used when the day preceeds the month.
|
|
|
244 Omit if the culture has no genitive distinction in month names.
|
|
|
245 For an explaination of genitive months, see http://blogs.msdn.com/michkap/archive/2004/12/25/332259.aspx
|
|
|
246 convert:
|
|
|
247 Allows for the support of non-gregorian based calendars. This convert object is used to
|
|
|
248 to convert a date to and from a gregorian calendar date to handle parsing and formatting.
|
|
|
249 The two functions:
|
|
|
250 fromGregorian( date )
|
|
|
251 Given the date as a parameter, return an array with parts [ year, month, day ]
|
|
|
252 corresponding to the non-gregorian based year, month, and day for the calendar.
|
|
|
253 toGregorian( year, month, day )
|
|
|
254 Given the non-gregorian year, month, and day, return a new Date() object
|
|
|
255 set to the corresponding date in the gregorian calendar.
|
|
|
256 */
|
|
|
257 }
|
|
|
258 },
|
|
|
259 // For localized strings
|
|
|
260 messages: {}
|
|
|
261 };
|
|
|
262
|
|
|
263 Globalize.cultures[ "default" ].calendar = Globalize.cultures[ "default" ].calendars.standard;
|
|
|
264
|
|
|
265 Globalize.cultures.en = Globalize.cultures[ "default" ];
|
|
|
266
|
|
|
267 Globalize.cultureSelector = "en";
|
|
|
268
|
|
|
269 //
|
|
|
270 // private variables
|
|
|
271 //
|
|
|
272
|
|
|
273 regexHex = /^0x[a-f0-9]+$/i;
|
|
|
274 regexInfinity = /^[+\-]?infinity$/i;
|
|
|
275 regexParseFloat = /^[+\-]?\d*\.?\d*(e[+\-]?\d+)?$/;
|
|
|
276 regexTrim = /^\s+|\s+$/g;
|
|
|
277
|
|
|
278 //
|
|
|
279 // private JavaScript utility functions
|
|
|
280 //
|
|
|
281
|
|
|
282 arrayIndexOf = function( array, item ) {
|
|
|
283 if ( array.indexOf ) {
|
|
|
284 return array.indexOf( item );
|
|
|
285 }
|
|
|
286 for ( var i = 0, length = array.length; i < length; i++ ) {
|
|
|
287 if ( array[i] === item ) {
|
|
|
288 return i;
|
|
|
289 }
|
|
|
290 }
|
|
|
291 return -1;
|
|
|
292 };
|
|
|
293
|
|
|
294 endsWith = function( value, pattern ) {
|
|
|
295 return value.substr( value.length - pattern.length ) === pattern;
|
|
|
296 };
|
|
|
297
|
|
|
298 extend = function() {
|
|
|
299 var options, name, src, copy, copyIsArray, clone,
|
|
|
300 target = arguments[0] || {},
|
|
|
301 i = 1,
|
|
|
302 length = arguments.length,
|
|
|
303 deep = false;
|
|
|
304
|
|
|
305 // Handle a deep copy situation
|
|
|
306 if ( typeof target === "boolean" ) {
|
|
|
307 deep = target;
|
|
|
308 target = arguments[1] || {};
|
|
|
309 // skip the boolean and the target
|
|
|
310 i = 2;
|
|
|
311 }
|
|
|
312
|
|
|
313 // Handle case when target is a string or something (possible in deep copy)
|
|
|
314 if ( typeof target !== "object" && !isFunction(target) ) {
|
|
|
315 target = {};
|
|
|
316 }
|
|
|
317
|
|
|
318 for ( ; i < length; i++ ) {
|
|
|
319 // Only deal with non-null/undefined values
|
|
|
320 if ( (options = arguments[ i ]) != null ) {
|
|
|
321 // Extend the base object
|
|
|
322 for ( name in options ) {
|
|
|
323 src = target[ name ];
|
|
|
324 copy = options[ name ];
|
|
|
325
|
|
|
326 // Prevent never-ending loop
|
|
|
327 if ( target === copy ) {
|
|
|
328 continue;
|
|
|
329 }
|
|
|
330
|
|
|
331 // Recurse if we're merging plain objects or arrays
|
|
|
332 if ( deep && copy && ( isObject(copy) || (copyIsArray = isArray(copy)) ) ) {
|
|
|
333 if ( copyIsArray ) {
|
|
|
334 copyIsArray = false;
|
|
|
335 clone = src && isArray(src) ? src : [];
|
|
|
336
|
|
|
337 } else {
|
|
|
338 clone = src && isObject(src) ? src : {};
|
|
|
339 }
|
|
|
340
|
|
|
341 // Never move original objects, clone them
|
|
|
342 target[ name ] = extend( deep, clone, copy );
|
|
|
343
|
|
|
344 // Don't bring in undefined values
|
|
|
345 } else if ( copy !== undefined ) {
|
|
|
346 target[ name ] = copy;
|
|
|
347 }
|
|
|
348 }
|
|
|
349 }
|
|
|
350 }
|
|
|
351
|
|
|
352 // Return the modified object
|
|
|
353 return target;
|
|
|
354 };
|
|
|
355
|
|
|
356 isArray = Array.isArray || function( obj ) {
|
|
|
357 return Object.prototype.toString.call( obj ) === "[object Array]";
|
|
|
358 };
|
|
|
359
|
|
|
360 isFunction = function( obj ) {
|
|
|
361 return Object.prototype.toString.call( obj ) === "[object Function]";
|
|
|
362 };
|
|
|
363
|
|
|
364 isObject = function( obj ) {
|
|
|
365 return Object.prototype.toString.call( obj ) === "[object Object]";
|
|
|
366 };
|
|
|
367
|
|
|
368 startsWith = function( value, pattern ) {
|
|
|
369 return value.indexOf( pattern ) === 0;
|
|
|
370 };
|
|
|
371
|
|
|
372 trim = function( value ) {
|
|
|
373 return ( value + "" ).replace( regexTrim, "" );
|
|
|
374 };
|
|
|
375
|
|
|
376 truncate = function( value ) {
|
|
|
377 if ( isNaN( value ) ) {
|
|
|
378 return NaN;
|
|
|
379 }
|
|
|
380 return Math[ value < 0 ? "ceil" : "floor" ]( value );
|
|
|
381 };
|
|
|
382
|
|
|
383 zeroPad = function( str, count, left ) {
|
|
|
384 var l;
|
|
|
385 for ( l = str.length; l < count; l += 1 ) {
|
|
|
386 str = ( left ? ("0" + str) : (str + "0") );
|
|
|
387 }
|
|
|
388 return str;
|
|
|
389 };
|
|
|
390
|
|
|
391 //
|
|
|
392 // private Globalization utility functions
|
|
|
393 //
|
|
|
394
|
|
|
395 appendPreOrPostMatch = function( preMatch, strings ) {
|
|
|
396 // appends pre- and post- token match strings while removing escaped characters.
|
|
|
397 // Returns a single quote count which is used to determine if the token occurs
|
|
|
398 // in a string literal.
|
|
|
399 var quoteCount = 0,
|
|
|
400 escaped = false;
|
|
|
401 for ( var i = 0, il = preMatch.length; i < il; i++ ) {
|
|
|
402 var c = preMatch.charAt( i );
|
|
|
403 switch ( c ) {
|
|
|
404 case "\'":
|
|
|
405 if ( escaped ) {
|
|
|
406 strings.push( "\'" );
|
|
|
407 }
|
|
|
408 else {
|
|
|
409 quoteCount++;
|
|
|
410 }
|
|
|
411 escaped = false;
|
|
|
412 break;
|
|
|
413 case "\\":
|
|
|
414 if ( escaped ) {
|
|
|
415 strings.push( "\\" );
|
|
|
416 }
|
|
|
417 escaped = !escaped;
|
|
|
418 break;
|
|
|
419 default:
|
|
|
420 strings.push( c );
|
|
|
421 escaped = false;
|
|
|
422 break;
|
|
|
423 }
|
|
|
424 }
|
|
|
425 return quoteCount;
|
|
|
426 };
|
|
|
427
|
|
|
428 expandFormat = function( cal, format ) {
|
|
|
429 // expands unspecified or single character date formats into the full pattern.
|
|
|
430 format = format || "F";
|
|
|
431 var pattern,
|
|
|
432 patterns = cal.patterns,
|
|
|
433 len = format.length;
|
|
|
434 if ( len === 1 ) {
|
|
|
435 pattern = patterns[ format ];
|
|
|
436 if ( !pattern ) {
|
|
|
437 throw "Invalid date format string \'" + format + "\'.";
|
|
|
438 }
|
|
|
439 format = pattern;
|
|
|
440 }
|
|
|
441 else if ( len === 2 && format.charAt(0) === "%" ) {
|
|
|
442 // %X escape format -- intended as a custom format string that is only one character, not a built-in format.
|
|
|
443 format = format.charAt( 1 );
|
|
|
444 }
|
|
|
445 return format;
|
|
|
446 };
|
|
|
447
|
|
|
448 formatDate = function( value, format, culture ) {
|
|
|
449 var cal = culture.calendar,
|
|
|
450 convert = cal.convert,
|
|
|
451 ret;
|
|
|
452
|
|
|
453 if ( !format || !format.length || format === "i" ) {
|
|
|
454 if ( culture && culture.name.length ) {
|
|
|
455 if ( convert ) {
|
|
|
456 // non-gregorian calendar, so we cannot use built-in toLocaleString()
|
|
|
457 ret = formatDate( value, cal.patterns.F, culture );
|
|
|
458 }
|
|
|
459 else {
|
|
|
460 var eraDate = new Date( value.getTime() ),
|
|
|
461 era = getEra( value, cal.eras );
|
|
|
462 eraDate.setFullYear( getEraYear(value, cal, era) );
|
|
|
463 ret = eraDate.toLocaleString();
|
|
|
464 }
|
|
|
465 }
|
|
|
466 else {
|
|
|
467 ret = value.toString();
|
|
|
468 }
|
|
|
469 return ret;
|
|
|
470 }
|
|
|
471
|
|
|
472 var eras = cal.eras,
|
|
|
473 sortable = format === "s";
|
|
|
474 format = expandFormat( cal, format );
|
|
|
475
|
|
|
476 // Start with an empty string
|
|
|
477 ret = [];
|
|
|
478 var hour,
|
|
|
479 zeros = [ "0", "00", "000" ],
|
|
|
480 foundDay,
|
|
|
481 checkedDay,
|
|
|
482 dayPartRegExp = /([^d]|^)(d|dd)([^d]|$)/g,
|
|
|
483 quoteCount = 0,
|
|
|
484 tokenRegExp = getTokenRegExp(),
|
|
|
485 converted;
|
|
|
486
|
|
|
487 function padZeros( num, c ) {
|
|
|
488 var r, s = num + "";
|
|
|
489 if ( c > 1 && s.length < c ) {
|
|
|
490 r = ( zeros[c - 2] + s);
|
|
|
491 return r.substr( r.length - c, c );
|
|
|
492 }
|
|
|
493 else {
|
|
|
494 r = s;
|
|
|
495 }
|
|
|
496 return r;
|
|
|
497 }
|
|
|
498
|
|
|
499 function hasDay() {
|
|
|
500 if ( foundDay || checkedDay ) {
|
|
|
501 return foundDay;
|
|
|
502 }
|
|
|
503 foundDay = dayPartRegExp.test( format );
|
|
|
504 checkedDay = true;
|
|
|
505 return foundDay;
|
|
|
506 }
|
|
|
507
|
|
|
508 function getPart( date, part ) {
|
|
|
509 if ( converted ) {
|
|
|
510 return converted[ part ];
|
|
|
511 }
|
|
|
512 switch ( part ) {
|
|
|
513 case 0:
|
|
|
514 return date.getFullYear();
|
|
|
515 case 1:
|
|
|
516 return date.getMonth();
|
|
|
517 case 2:
|
|
|
518 return date.getDate();
|
|
|
519 default:
|
|
|
520 throw "Invalid part value " + part;
|
|
|
521 }
|
|
|
522 }
|
|
|
523
|
|
|
524 if ( !sortable && convert ) {
|
|
|
525 converted = convert.fromGregorian( value );
|
|
|
526 }
|
|
|
527
|
|
|
528 for ( ; ; ) {
|
|
|
529 // Save the current index
|
|
|
530 var index = tokenRegExp.lastIndex,
|
|
|
531 // Look for the next pattern
|
|
|
532 ar = tokenRegExp.exec( format );
|
|
|
533
|
|
|
534 // Append the text before the pattern (or the end of the string if not found)
|
|
|
535 var preMatch = format.slice( index, ar ? ar.index : format.length );
|
|
|
536 quoteCount += appendPreOrPostMatch( preMatch, ret );
|
|
|
537
|
|
|
538 if ( !ar ) {
|
|
|
539 break;
|
|
|
540 }
|
|
|
541
|
|
|
542 // do not replace any matches that occur inside a string literal.
|
|
|
543 if ( quoteCount % 2 ) {
|
|
|
544 ret.push( ar[0] );
|
|
|
545 continue;
|
|
|
546 }
|
|
|
547
|
|
|
548 var current = ar[ 0 ],
|
|
|
549 clength = current.length;
|
|
|
550
|
|
|
551 switch ( current ) {
|
|
|
552 case "ddd":
|
|
|
553 //Day of the week, as a three-letter abbreviation
|
|
|
554 case "dddd":
|
|
|
555 // Day of the week, using the full name
|
|
|
556 var names = ( clength === 3 ) ? cal.days.namesAbbr : cal.days.names;
|
|
|
557 ret.push( names[value.getDay()] );
|
|
|
558 break;
|
|
|
559 case "d":
|
|
|
560 // Day of month, without leading zero for single-digit days
|
|
|
561 case "dd":
|
|
|
562 // Day of month, with leading zero for single-digit days
|
|
|
563 foundDay = true;
|
|
|
564 ret.push(
|
|
|
565 padZeros( getPart(value, 2), clength )
|
|
|
566 );
|
|
|
567 break;
|
|
|
568 case "MMM":
|
|
|
569 // Month, as a three-letter abbreviation
|
|
|
570 case "MMMM":
|
|
|
571 // Month, using the full name
|
|
|
572 var part = getPart( value, 1 );
|
|
|
573 ret.push(
|
|
|
574 ( cal.monthsGenitive && hasDay() ) ?
|
|
|
575 ( cal.monthsGenitive[ clength === 3 ? "namesAbbr" : "names" ][ part ] ) :
|
|
|
576 ( cal.months[ clength === 3 ? "namesAbbr" : "names" ][ part ] )
|
|
|
577 );
|
|
|
578 break;
|
|
|
579 case "M":
|
|
|
580 // Month, as digits, with no leading zero for single-digit months
|
|
|
581 case "MM":
|
|
|
582 // Month, as digits, with leading zero for single-digit months
|
|
|
583 ret.push(
|
|
|
584 padZeros( getPart(value, 1) + 1, clength )
|
|
|
585 );
|
|
|
586 break;
|
|
|
587 case "y":
|
|
|
588 // Year, as two digits, but with no leading zero for years less than 10
|
|
|
589 case "yy":
|
|
|
590 // Year, as two digits, with leading zero for years less than 10
|
|
|
591 case "yyyy":
|
|
|
592 // Year represented by four full digits
|
|
|
593 part = converted ? converted[ 0 ] : getEraYear( value, cal, getEra(value, eras), sortable );
|
|
|
594 if ( clength < 4 ) {
|
|
|
595 part = part % 100;
|
|
|
596 }
|
|
|
597 ret.push(
|
|
|
598 padZeros( part, clength )
|
|
|
599 );
|
|
|
600 break;
|
|
|
601 case "h":
|
|
|
602 // Hours with no leading zero for single-digit hours, using 12-hour clock
|
|
|
603 case "hh":
|
|
|
604 // Hours with leading zero for single-digit hours, using 12-hour clock
|
|
|
605 hour = value.getHours() % 12;
|
|
|
606 if ( hour === 0 ) hour = 12;
|
|
|
607 ret.push(
|
|
|
608 padZeros( hour, clength )
|
|
|
609 );
|
|
|
610 break;
|
|
|
611 case "H":
|
|
|
612 // Hours with no leading zero for single-digit hours, using 24-hour clock
|
|
|
613 case "HH":
|
|
|
614 // Hours with leading zero for single-digit hours, using 24-hour clock
|
|
|
615 ret.push(
|
|
|
616 padZeros( value.getHours(), clength )
|
|
|
617 );
|
|
|
618 break;
|
|
|
619 case "m":
|
|
|
620 // Minutes with no leading zero for single-digit minutes
|
|
|
621 case "mm":
|
|
|
622 // Minutes with leading zero for single-digit minutes
|
|
|
623 ret.push(
|
|
|
624 padZeros( value.getMinutes(), clength )
|
|
|
625 );
|
|
|
626 break;
|
|
|
627 case "s":
|
|
|
628 // Seconds with no leading zero for single-digit seconds
|
|
|
629 case "ss":
|
|
|
630 // Seconds with leading zero for single-digit seconds
|
|
|
631 ret.push(
|
|
|
632 padZeros( value.getSeconds(), clength )
|
|
|
633 );
|
|
|
634 break;
|
|
|
635 case "t":
|
|
|
636 // One character am/pm indicator ("a" or "p")
|
|
|
637 case "tt":
|
|
|
638 // Multicharacter am/pm indicator
|
|
|
639 part = value.getHours() < 12 ? ( cal.AM ? cal.AM[0] : " " ) : ( cal.PM ? cal.PM[0] : " " );
|
|
|
640 ret.push( clength === 1 ? part.charAt(0) : part );
|
|
|
641 break;
|
|
|
642 case "f":
|
|
|
643 // Deciseconds
|
|
|
644 case "ff":
|
|
|
645 // Centiseconds
|
|
|
646 case "fff":
|
|
|
647 // Milliseconds
|
|
|
648 ret.push(
|
|
|
649 padZeros( value.getMilliseconds(), 3 ).substr( 0, clength )
|
|
|
650 );
|
|
|
651 break;
|
|
|
652 case "z":
|
|
|
653 // Time zone offset, no leading zero
|
|
|
654 case "zz":
|
|
|
655 // Time zone offset with leading zero
|
|
|
656 hour = value.getTimezoneOffset() / 60;
|
|
|
657 ret.push(
|
|
|
658 ( hour <= 0 ? "+" : "-" ) + padZeros( Math.floor(Math.abs(hour)), clength )
|
|
|
659 );
|
|
|
660 break;
|
|
|
661 case "zzz":
|
|
|
662 // Time zone offset with leading zero
|
|
|
663 hour = value.getTimezoneOffset() / 60;
|
|
|
664 ret.push(
|
|
|
665 ( hour <= 0 ? "+" : "-" ) + padZeros( Math.floor(Math.abs(hour)), 2 ) +
|
|
|
666 // Hard coded ":" separator, rather than using cal.TimeSeparator
|
|
|
667 // Repeated here for consistency, plus ":" was already assumed in date parsing.
|
|
|
668 ":" + padZeros( Math.abs(value.getTimezoneOffset() % 60), 2 )
|
|
|
669 );
|
|
|
670 break;
|
|
|
671 case "g":
|
|
|
672 case "gg":
|
|
|
673 if ( cal.eras ) {
|
|
|
674 ret.push(
|
|
|
675 cal.eras[ getEra(value, eras) ].name
|
|
|
676 );
|
|
|
677 }
|
|
|
678 break;
|
|
|
679 case "/":
|
|
|
680 ret.push( cal["/"] );
|
|
|
681 break;
|
|
|
682 default:
|
|
|
683 throw "Invalid date format pattern \'" + current + "\'.";
|
|
|
684 }
|
|
|
685 }
|
|
|
686 return ret.join( "" );
|
|
|
687 };
|
|
|
688
|
|
|
689 // formatNumber
|
|
|
690 (function() {
|
|
|
691 var expandNumber;
|
|
|
692
|
|
|
693 expandNumber = function( number, precision, formatInfo ) {
|
|
|
694 var groupSizes = formatInfo.groupSizes,
|
|
|
695 curSize = groupSizes[ 0 ],
|
|
|
696 curGroupIndex = 1,
|
|
|
697 factor = Math.pow( 10, precision ),
|
|
|
698 rounded = Math.round( number * factor ) / factor;
|
|
|
699
|
|
|
700 if ( !isFinite(rounded) ) {
|
|
|
701 rounded = number;
|
|
|
702 }
|
|
|
703 number = rounded;
|
|
|
704
|
|
|
705 var numberString = number+"",
|
|
|
706 right = "",
|
|
|
707 split = numberString.split( /e/i ),
|
|
|
708 exponent = split.length > 1 ? parseInt( split[1], 10 ) : 0;
|
|
|
709 numberString = split[ 0 ];
|
|
|
710 split = numberString.split( "." );
|
|
|
711 numberString = split[ 0 ];
|
|
|
712 right = split.length > 1 ? split[ 1 ] : "";
|
|
|
713
|
|
|
714 if ( exponent > 0 ) {
|
|
|
715 right = zeroPad( right, exponent, false );
|
|
|
716 numberString += right.slice( 0, exponent );
|
|
|
717 right = right.substr( exponent );
|
|
|
718 }
|
|
|
719 else if ( exponent < 0 ) {
|
|
|
720 exponent = -exponent;
|
|
|
721 numberString = zeroPad( numberString, exponent + 1, true );
|
|
|
722 right = numberString.slice( -exponent, numberString.length ) + right;
|
|
|
723 numberString = numberString.slice( 0, -exponent );
|
|
|
724 }
|
|
|
725
|
|
|
726 if ( precision > 0 ) {
|
|
|
727 right = formatInfo[ "." ] +
|
|
|
728 ( (right.length > precision) ? right.slice(0, precision) : zeroPad(right, precision) );
|
|
|
729 }
|
|
|
730 else {
|
|
|
731 right = "";
|
|
|
732 }
|
|
|
733
|
|
|
734 var stringIndex = numberString.length - 1,
|
|
|
735 sep = formatInfo[ "," ],
|
|
|
736 ret = "";
|
|
|
737
|
|
|
738 while ( stringIndex >= 0 ) {
|
|
|
739 if ( curSize === 0 || curSize > stringIndex ) {
|
|
|
740 return numberString.slice( 0, stringIndex + 1 ) + ( ret.length ? (sep + ret + right) : right );
|
|
|
741 }
|
|
|
742 ret = numberString.slice( stringIndex - curSize + 1, stringIndex + 1 ) + ( ret.length ? (sep + ret) : "" );
|
|
|
743
|
|
|
744 stringIndex -= curSize;
|
|
|
745
|
|
|
746 if ( curGroupIndex < groupSizes.length ) {
|
|
|
747 curSize = groupSizes[ curGroupIndex ];
|
|
|
748 curGroupIndex++;
|
|
|
749 }
|
|
|
750 }
|
|
|
751
|
|
|
752 return numberString.slice( 0, stringIndex + 1 ) + sep + ret + right;
|
|
|
753 };
|
|
|
754
|
|
|
755 formatNumber = function( value, format, culture ) {
|
|
|
756 if ( !isFinite(value) ) {
|
|
|
757 if ( value === Infinity ) {
|
|
|
758 return culture.numberFormat.positiveInfinity;
|
|
|
759 }
|
|
|
760 if ( value === -Infinity ) {
|
|
|
761 return culture.numberFormat.negativeInfinity;
|
|
|
762 }
|
|
|
763 return culture.numberFormat.NaN;
|
|
|
764 }
|
|
|
765 if ( !format || format === "i" ) {
|
|
|
766 return culture.name.length ? value.toLocaleString() : value.toString();
|
|
|
767 }
|
|
|
768 format = format || "D";
|
|
|
769
|
|
|
770 var nf = culture.numberFormat,
|
|
|
771 number = Math.abs( value ),
|
|
|
772 precision = -1,
|
|
|
773 pattern;
|
|
|
774 if ( format.length > 1 ) precision = parseInt( format.slice(1), 10 );
|
|
|
775
|
|
|
776 var current = format.charAt( 0 ).toUpperCase(),
|
|
|
777 formatInfo;
|
|
|
778
|
|
|
779 switch ( current ) {
|
|
|
780 case "D":
|
|
|
781 pattern = "n";
|
|
|
782 number = truncate( number );
|
|
|
783 if ( precision !== -1 ) {
|
|
|
784 number = zeroPad( "" + number, precision, true );
|
|
|
785 }
|
|
|
786 if ( value < 0 ) number = "-" + number;
|
|
|
787 break;
|
|
|
788 case "N":
|
|
|
789 formatInfo = nf;
|
|
|
790 /* falls through */
|
|
|
791 case "C":
|
|
|
792 formatInfo = formatInfo || nf.currency;
|
|
|
793 /* falls through */
|
|
|
794 case "P":
|
|
|
795 formatInfo = formatInfo || nf.percent;
|
|
|
796 pattern = value < 0 ? formatInfo.pattern[ 0 ] : ( formatInfo.pattern[1] || "n" );
|
|
|
797 if ( precision === -1 ) precision = formatInfo.decimals;
|
|
|
798 number = expandNumber( number * (current === "P" ? 100 : 1), precision, formatInfo );
|
|
|
799 break;
|
|
|
800 default:
|
|
|
801 throw "Bad number format specifier: " + current;
|
|
|
802 }
|
|
|
803
|
|
|
804 var patternParts = /n|\$|-|%/g,
|
|
|
805 ret = "";
|
|
|
806 for ( ; ; ) {
|
|
|
807 var index = patternParts.lastIndex,
|
|
|
808 ar = patternParts.exec( pattern );
|
|
|
809
|
|
|
810 ret += pattern.slice( index, ar ? ar.index : pattern.length );
|
|
|
811
|
|
|
812 if ( !ar ) {
|
|
|
813 break;
|
|
|
814 }
|
|
|
815
|
|
|
816 switch ( ar[0] ) {
|
|
|
817 case "n":
|
|
|
818 ret += number;
|
|
|
819 break;
|
|
|
820 case "$":
|
|
|
821 ret += nf.currency.symbol;
|
|
|
822 break;
|
|
|
823 case "-":
|
|
|
824 // don't make 0 negative
|
|
|
825 if ( /[1-9]/.test(number) ) {
|
|
|
826 ret += nf[ "-" ];
|
|
|
827 }
|
|
|
828 break;
|
|
|
829 case "%":
|
|
|
830 ret += nf.percent.symbol;
|
|
|
831 break;
|
|
|
832 }
|
|
|
833 }
|
|
|
834
|
|
|
835 return ret;
|
|
|
836 };
|
|
|
837
|
|
|
838 }());
|
|
|
839
|
|
|
840 getTokenRegExp = function() {
|
|
|
841 // regular expression for matching date and time tokens in format strings.
|
|
|
842 return (/\/|dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z|gg|g/g);
|
|
|
843 };
|
|
|
844
|
|
|
845 getEra = function( date, eras ) {
|
|
|
846 if ( !eras ) return 0;
|
|
|
847 var start, ticks = date.getTime();
|
|
|
848 for ( var i = 0, l = eras.length; i < l; i++ ) {
|
|
|
849 start = eras[ i ].start;
|
|
|
850 if ( start === null || ticks >= start ) {
|
|
|
851 return i;
|
|
|
852 }
|
|
|
853 }
|
|
|
854 return 0;
|
|
|
855 };
|
|
|
856
|
|
|
857 getEraYear = function( date, cal, era, sortable ) {
|
|
|
858 var year = date.getFullYear();
|
|
|
859 if ( !sortable && cal.eras ) {
|
|
|
860 // convert normal gregorian year to era-shifted gregorian
|
|
|
861 // year by subtracting the era offset
|
|
|
862 year -= cal.eras[ era ].offset;
|
|
|
863 }
|
|
|
864 return year;
|
|
|
865 };
|
|
|
866
|
|
|
867 // parseExact
|
|
|
868 (function() {
|
|
|
869 var expandYear,
|
|
|
870 getDayIndex,
|
|
|
871 getMonthIndex,
|
|
|
872 getParseRegExp,
|
|
|
873 outOfRange,
|
|
|
874 toUpper,
|
|
|
875 toUpperArray;
|
|
|
876
|
|
|
877 expandYear = function( cal, year ) {
|
|
|
878 // expands 2-digit year into 4 digits.
|
|
|
879 if ( year < 100 ) {
|
|
|
880 var now = new Date(),
|
|
|
881 era = getEra( now ),
|
|
|
882 curr = getEraYear( now, cal, era ),
|
|
|
883 twoDigitYearMax = cal.twoDigitYearMax;
|
|
|
884 twoDigitYearMax = typeof twoDigitYearMax === "string" ? new Date().getFullYear() % 100 + parseInt( twoDigitYearMax, 10 ) : twoDigitYearMax;
|
|
|
885 year += curr - ( curr % 100 );
|
|
|
886 if ( year > twoDigitYearMax ) {
|
|
|
887 year -= 100;
|
|
|
888 }
|
|
|
889 }
|
|
|
890 return year;
|
|
|
891 };
|
|
|
892
|
|
|
893 getDayIndex = function ( cal, value, abbr ) {
|
|
|
894 var ret,
|
|
|
895 days = cal.days,
|
|
|
896 upperDays = cal._upperDays;
|
|
|
897 if ( !upperDays ) {
|
|
|
898 cal._upperDays = upperDays = [
|
|
|
899 toUpperArray( days.names ),
|
|
|
900 toUpperArray( days.namesAbbr ),
|
|
|
901 toUpperArray( days.namesShort )
|
|
|
902 ];
|
|
|
903 }
|
|
|
904 value = toUpper( value );
|
|
|
905 if ( abbr ) {
|
|
|
906 ret = arrayIndexOf( upperDays[1], value );
|
|
|
907 if ( ret === -1 ) {
|
|
|
908 ret = arrayIndexOf( upperDays[2], value );
|
|
|
909 }
|
|
|
910 }
|
|
|
911 else {
|
|
|
912 ret = arrayIndexOf( upperDays[0], value );
|
|
|
913 }
|
|
|
914 return ret;
|
|
|
915 };
|
|
|
916
|
|
|
917 getMonthIndex = function( cal, value, abbr ) {
|
|
|
918 var months = cal.months,
|
|
|
919 monthsGen = cal.monthsGenitive || cal.months,
|
|
|
920 upperMonths = cal._upperMonths,
|
|
|
921 upperMonthsGen = cal._upperMonthsGen;
|
|
|
922 if ( !upperMonths ) {
|
|
|
923 cal._upperMonths = upperMonths = [
|
|
|
924 toUpperArray( months.names ),
|
|
|
925 toUpperArray( months.namesAbbr )
|
|
|
926 ];
|
|
|
927 cal._upperMonthsGen = upperMonthsGen = [
|
|
|
928 toUpperArray( monthsGen.names ),
|
|
|
929 toUpperArray( monthsGen.namesAbbr )
|
|
|
930 ];
|
|
|
931 }
|
|
|
932 value = toUpper( value );
|
|
|
933 var i = arrayIndexOf( abbr ? upperMonths[1] : upperMonths[0], value );
|
|
|
934 if ( i < 0 ) {
|
|
|
935 i = arrayIndexOf( abbr ? upperMonthsGen[1] : upperMonthsGen[0], value );
|
|
|
936 }
|
|
|
937 return i;
|
|
|
938 };
|
|
|
939
|
|
|
940 getParseRegExp = function( cal, format ) {
|
|
|
941 // converts a format string into a regular expression with groups that
|
|
|
942 // can be used to extract date fields from a date string.
|
|
|
943 // check for a cached parse regex.
|
|
|
944 var re = cal._parseRegExp;
|
|
|
945 if ( !re ) {
|
|
|
946 cal._parseRegExp = re = {};
|
|
|
947 }
|
|
|
948 else {
|
|
|
949 var reFormat = re[ format ];
|
|
|
950 if ( reFormat ) {
|
|
|
951 return reFormat;
|
|
|
952 }
|
|
|
953 }
|
|
|
954
|
|
|
955 // expand single digit formats, then escape regular expression characters.
|
|
|
956 var expFormat = expandFormat( cal, format ).replace( /([\^\$\.\*\+\?\|\[\]\(\)\{\}])/g, "\\\\$1" ),
|
|
|
957 regexp = [ "^" ],
|
|
|
958 groups = [],
|
|
|
959 index = 0,
|
|
|
960 quoteCount = 0,
|
|
|
961 tokenRegExp = getTokenRegExp(),
|
|
|
962 match;
|
|
|
963
|
|
|
964 // iterate through each date token found.
|
|
|
965 while ( (match = tokenRegExp.exec(expFormat)) !== null ) {
|
|
|
966 var preMatch = expFormat.slice( index, match.index );
|
|
|
967 index = tokenRegExp.lastIndex;
|
|
|
968
|
|
|
969 // don't replace any matches that occur inside a string literal.
|
|
|
970 quoteCount += appendPreOrPostMatch( preMatch, regexp );
|
|
|
971 if ( quoteCount % 2 ) {
|
|
|
972 regexp.push( match[0] );
|
|
|
973 continue;
|
|
|
974 }
|
|
|
975
|
|
|
976 // add a regex group for the token.
|
|
|
977 var m = match[ 0 ],
|
|
|
978 len = m.length,
|
|
|
979 add;
|
|
|
980 switch ( m ) {
|
|
|
981 case "dddd": case "ddd":
|
|
|
982 case "MMMM": case "MMM":
|
|
|
983 case "gg": case "g":
|
|
|
984 add = "(\\D+)";
|
|
|
985 break;
|
|
|
986 case "tt": case "t":
|
|
|
987 add = "(\\D*)";
|
|
|
988 break;
|
|
|
989 case "yyyy":
|
|
|
990 case "fff":
|
|
|
991 case "ff":
|
|
|
992 case "f":
|
|
|
993 add = "(\\d{" + len + "})";
|
|
|
994 break;
|
|
|
995 case "dd": case "d":
|
|
|
996 case "MM": case "M":
|
|
|
997 case "yy": case "y":
|
|
|
998 case "HH": case "H":
|
|
|
999 case "hh": case "h":
|
|
|
1000 case "mm": case "m":
|
|
|
1001 case "ss": case "s":
|
|
|
1002 add = "(\\d\\d?)";
|
|
|
1003 break;
|
|
|
1004 case "zzz":
|
|
|
1005 add = "([+-]?\\d\\d?:\\d{2})";
|
|
|
1006 break;
|
|
|
1007 case "zz": case "z":
|
|
|
1008 add = "([+-]?\\d\\d?)";
|
|
|
1009 break;
|
|
|
1010 case "/":
|
|
|
1011 add = "(\\/)";
|
|
|
1012 break;
|
|
|
1013 default:
|
|
|
1014 throw "Invalid date format pattern \'" + m + "\'.";
|
|
|
1015 }
|
|
|
1016 if ( add ) {
|
|
|
1017 regexp.push( add );
|
|
|
1018 }
|
|
|
1019 groups.push( match[0] );
|
|
|
1020 }
|
|
|
1021 appendPreOrPostMatch( expFormat.slice(index), regexp );
|
|
|
1022 regexp.push( "$" );
|
|
|
1023
|
|
|
1024 // allow whitespace to differ when matching formats.
|
|
|
1025 var regexpStr = regexp.join( "" ).replace( /\s+/g, "\\s+" ),
|
|
|
1026 parseRegExp = { "regExp": regexpStr, "groups": groups };
|
|
|
1027
|
|
|
1028 // cache the regex for this format.
|
|
|
1029 return re[ format ] = parseRegExp;
|
|
|
1030 };
|
|
|
1031
|
|
|
1032 outOfRange = function( value, low, high ) {
|
|
|
1033 return value < low || value > high;
|
|
|
1034 };
|
|
|
1035
|
|
|
1036 toUpper = function( value ) {
|
|
|
1037 // "he-IL" has non-breaking space in weekday names.
|
|
|
1038 return value.split( "\u00A0" ).join( " " ).toUpperCase();
|
|
|
1039 };
|
|
|
1040
|
|
|
1041 toUpperArray = function( arr ) {
|
|
|
1042 var results = [];
|
|
|
1043 for ( var i = 0, l = arr.length; i < l; i++ ) {
|
|
|
1044 results[ i ] = toUpper( arr[i] );
|
|
|
1045 }
|
|
|
1046 return results;
|
|
|
1047 };
|
|
|
1048
|
|
|
1049 parseExact = function( value, format, culture ) {
|
|
|
1050 // try to parse the date string by matching against the format string
|
|
|
1051 // while using the specified culture for date field names.
|
|
|
1052 value = trim( value );
|
|
|
1053 var cal = culture.calendar,
|
|
|
1054 // convert date formats into regular expressions with groupings.
|
|
|
1055 // use the regexp to determine the input format and extract the date fields.
|
|
|
1056 parseInfo = getParseRegExp( cal, format ),
|
|
|
1057 match = new RegExp( parseInfo.regExp ).exec( value );
|
|
|
1058 if ( match === null ) {
|
|
|
1059 return null;
|
|
|
1060 }
|
|
|
1061 // found a date format that matches the input.
|
|
|
1062 var groups = parseInfo.groups,
|
|
|
1063 era = null, year = null, month = null, date = null, weekDay = null,
|
|
|
1064 hour = 0, hourOffset, min = 0, sec = 0, msec = 0, tzMinOffset = null,
|
|
|
1065 pmHour = false;
|
|
|
1066 // iterate the format groups to extract and set the date fields.
|
|
|
1067 for ( var j = 0, jl = groups.length; j < jl; j++ ) {
|
|
|
1068 var matchGroup = match[ j + 1 ];
|
|
|
1069 if ( matchGroup ) {
|
|
|
1070 var current = groups[ j ],
|
|
|
1071 clength = current.length,
|
|
|
1072 matchInt = parseInt( matchGroup, 10 );
|
|
|
1073 switch ( current ) {
|
|
|
1074 case "dd": case "d":
|
|
|
1075 // Day of month.
|
|
|
1076 date = matchInt;
|
|
|
1077 // check that date is generally in valid range, also checking overflow below.
|
|
|
1078 if ( outOfRange(date, 1, 31) ) return null;
|
|
|
1079 break;
|
|
|
1080 case "MMM": case "MMMM":
|
|
|
1081 month = getMonthIndex( cal, matchGroup, clength === 3 );
|
|
|
1082 if ( outOfRange(month, 0, 11) ) return null;
|
|
|
1083 break;
|
|
|
1084 case "M": case "MM":
|
|
|
1085 // Month.
|
|
|
1086 month = matchInt - 1;
|
|
|
1087 if ( outOfRange(month, 0, 11) ) return null;
|
|
|
1088 break;
|
|
|
1089 case "y": case "yy":
|
|
|
1090 case "yyyy":
|
|
|
1091 year = clength < 4 ? expandYear( cal, matchInt ) : matchInt;
|
|
|
1092 if ( outOfRange(year, 0, 9999) ) return null;
|
|
|
1093 break;
|
|
|
1094 case "h": case "hh":
|
|
|
1095 // Hours (12-hour clock).
|
|
|
1096 hour = matchInt;
|
|
|
1097 if ( hour === 12 ) hour = 0;
|
|
|
1098 if ( outOfRange(hour, 0, 11) ) return null;
|
|
|
1099 break;
|
|
|
1100 case "H": case "HH":
|
|
|
1101 // Hours (24-hour clock).
|
|
|
1102 hour = matchInt;
|
|
|
1103 if ( outOfRange(hour, 0, 23) ) return null;
|
|
|
1104 break;
|
|
|
1105 case "m": case "mm":
|
|
|
1106 // Minutes.
|
|
|
1107 min = matchInt;
|
|
|
1108 if ( outOfRange(min, 0, 59) ) return null;
|
|
|
1109 break;
|
|
|
1110 case "s": case "ss":
|
|
|
1111 // Seconds.
|
|
|
1112 sec = matchInt;
|
|
|
1113 if ( outOfRange(sec, 0, 59) ) return null;
|
|
|
1114 break;
|
|
|
1115 case "tt": case "t":
|
|
|
1116 // AM/PM designator.
|
|
|
1117 // see if it is standard, upper, or lower case PM. If not, ensure it is at least one of
|
|
|
1118 // the AM tokens. If not, fail the parse for this format.
|
|
|
1119 pmHour = cal.PM && ( matchGroup === cal.PM[0] || matchGroup === cal.PM[1] || matchGroup === cal.PM[2] );
|
|
|
1120 if (
|
|
|
1121 !pmHour && (
|
|
|
1122 !cal.AM || ( matchGroup !== cal.AM[0] && matchGroup !== cal.AM[1] && matchGroup !== cal.AM[2] )
|
|
|
1123 )
|
|
|
1124 ) return null;
|
|
|
1125 break;
|
|
|
1126 case "f":
|
|
|
1127 // Deciseconds.
|
|
|
1128 case "ff":
|
|
|
1129 // Centiseconds.
|
|
|
1130 case "fff":
|
|
|
1131 // Milliseconds.
|
|
|
1132 msec = matchInt * Math.pow( 10, 3 - clength );
|
|
|
1133 if ( outOfRange(msec, 0, 999) ) return null;
|
|
|
1134 break;
|
|
|
1135 case "ddd":
|
|
|
1136 // Day of week.
|
|
|
1137 case "dddd":
|
|
|
1138 // Day of week.
|
|
|
1139 weekDay = getDayIndex( cal, matchGroup, clength === 3 );
|
|
|
1140 if ( outOfRange(weekDay, 0, 6) ) return null;
|
|
|
1141 break;
|
|
|
1142 case "zzz":
|
|
|
1143 // Time zone offset in +/- hours:min.
|
|
|
1144 var offsets = matchGroup.split( /:/ );
|
|
|
1145 if ( offsets.length !== 2 ) return null;
|
|
|
1146 hourOffset = parseInt( offsets[0], 10 );
|
|
|
1147 if ( outOfRange(hourOffset, -12, 13) ) return null;
|
|
|
1148 var minOffset = parseInt( offsets[1], 10 );
|
|
|
1149 if ( outOfRange(minOffset, 0, 59) ) return null;
|
|
|
1150 tzMinOffset = ( hourOffset * 60 ) + ( startsWith(matchGroup, "-") ? -minOffset : minOffset );
|
|
|
1151 break;
|
|
|
1152 case "z": case "zz":
|
|
|
1153 // Time zone offset in +/- hours.
|
|
|
1154 hourOffset = matchInt;
|
|
|
1155 if ( outOfRange(hourOffset, -12, 13) ) return null;
|
|
|
1156 tzMinOffset = hourOffset * 60;
|
|
|
1157 break;
|
|
|
1158 case "g": case "gg":
|
|
|
1159 var eraName = matchGroup;
|
|
|
1160 if ( !eraName || !cal.eras ) return null;
|
|
|
1161 eraName = trim( eraName.toLowerCase() );
|
|
|
1162 for ( var i = 0, l = cal.eras.length; i < l; i++ ) {
|
|
|
1163 if ( eraName === cal.eras[i].name.toLowerCase() ) {
|
|
|
1164 era = i;
|
|
|
1165 break;
|
|
|
1166 }
|
|
|
1167 }
|
|
|
1168 // could not find an era with that name
|
|
|
1169 if ( era === null ) return null;
|
|
|
1170 break;
|
|
|
1171 }
|
|
|
1172 }
|
|
|
1173 }
|
|
|
1174 var result = new Date(), defaultYear, convert = cal.convert;
|
|
|
1175 defaultYear = convert ? convert.fromGregorian( result )[ 0 ] : result.getFullYear();
|
|
|
1176 if ( year === null ) {
|
|
|
1177 year = defaultYear;
|
|
|
1178 }
|
|
|
1179 else if ( cal.eras ) {
|
|
|
1180 // year must be shifted to normal gregorian year
|
|
|
1181 // but not if year was not specified, its already normal gregorian
|
|
|
1182 // per the main if clause above.
|
|
|
1183 year += cal.eras[( era || 0 )].offset;
|
|
|
1184 }
|
|
|
1185 // set default day and month to 1 and January, so if unspecified, these are the defaults
|
|
|
1186 // instead of the current day/month.
|
|
|
1187 if ( month === null ) {
|
|
|
1188 month = 0;
|
|
|
1189 }
|
|
|
1190 if ( date === null ) {
|
|
|
1191 date = 1;
|
|
|
1192 }
|
|
|
1193 // now have year, month, and date, but in the culture's calendar.
|
|
|
1194 // convert to gregorian if necessary
|
|
|
1195 if ( convert ) {
|
|
|
1196 result = convert.toGregorian( year, month, date );
|
|
|
1197 // conversion failed, must be an invalid match
|
|
|
1198 if ( result === null ) return null;
|
|
|
1199 }
|
|
|
1200 else {
|
|
|
1201 // have to set year, month and date together to avoid overflow based on current date.
|
|
|
1202 result.setFullYear( year, month, date );
|
|
|
1203 // check to see if date overflowed for specified month (only checked 1-31 above).
|
|
|
1204 if ( result.getDate() !== date ) return null;
|
|
|
1205 // invalid day of week.
|
|
|
1206 if ( weekDay !== null && result.getDay() !== weekDay ) {
|
|
|
1207 return null;
|
|
|
1208 }
|
|
|
1209 }
|
|
|
1210 // if pm designator token was found make sure the hours fit the 24-hour clock.
|
|
|
1211 if ( pmHour && hour < 12 ) {
|
|
|
1212 hour += 12;
|
|
|
1213 }
|
|
|
1214 result.setHours( hour, min, sec, msec );
|
|
|
1215 if ( tzMinOffset !== null ) {
|
|
|
1216 // adjust timezone to utc before applying local offset.
|
|
|
1217 var adjustedMin = result.getMinutes() - ( tzMinOffset + result.getTimezoneOffset() );
|
|
|
1218 // Safari limits hours and minutes to the range of -127 to 127. We need to use setHours
|
|
|
1219 // to ensure both these fields will not exceed this range. adjustedMin will range
|
|
|
1220 // somewhere between -1440 and 1500, so we only need to split this into hours.
|
|
|
1221 result.setHours( result.getHours() + parseInt(adjustedMin / 60, 10), adjustedMin % 60 );
|
|
|
1222 }
|
|
|
1223 return result;
|
|
|
1224 };
|
|
|
1225 }());
|
|
|
1226
|
|
|
1227 parseNegativePattern = function( value, nf, negativePattern ) {
|
|
|
1228 var neg = nf[ "-" ],
|
|
|
1229 pos = nf[ "+" ],
|
|
|
1230 ret;
|
|
|
1231 switch ( negativePattern ) {
|
|
|
1232 case "n -":
|
|
|
1233 neg = " " + neg;
|
|
|
1234 pos = " " + pos;
|
|
|
1235 /* falls through */
|
|
|
1236 case "n-":
|
|
|
1237 if ( endsWith(value, neg) ) {
|
|
|
1238 ret = [ "-", value.substr(0, value.length - neg.length) ];
|
|
|
1239 }
|
|
|
1240 else if ( endsWith(value, pos) ) {
|
|
|
1241 ret = [ "+", value.substr(0, value.length - pos.length) ];
|
|
|
1242 }
|
|
|
1243 break;
|
|
|
1244 case "- n":
|
|
|
1245 neg += " ";
|
|
|
1246 pos += " ";
|
|
|
1247 /* falls through */
|
|
|
1248 case "-n":
|
|
|
1249 if ( startsWith(value, neg) ) {
|
|
|
1250 ret = [ "-", value.substr(neg.length) ];
|
|
|
1251 }
|
|
|
1252 else if ( startsWith(value, pos) ) {
|
|
|
1253 ret = [ "+", value.substr(pos.length) ];
|
|
|
1254 }
|
|
|
1255 break;
|
|
|
1256 case "(n)":
|
|
|
1257 if ( startsWith(value, "(") && endsWith(value, ")") ) {
|
|
|
1258 ret = [ "-", value.substr(1, value.length - 2) ];
|
|
|
1259 }
|
|
|
1260 break;
|
|
|
1261 }
|
|
|
1262 return ret || [ "", value ];
|
|
|
1263 };
|
|
|
1264
|
|
|
1265 //
|
|
|
1266 // public instance functions
|
|
|
1267 //
|
|
|
1268
|
|
|
1269 Globalize.prototype.findClosestCulture = function( cultureSelector ) {
|
|
|
1270 return Globalize.findClosestCulture.call( this, cultureSelector );
|
|
|
1271 };
|
|
|
1272
|
|
|
1273 Globalize.prototype.format = function( value, format, cultureSelector ) {
|
|
|
1274 return Globalize.format.call( this, value, format, cultureSelector );
|
|
|
1275 };
|
|
|
1276
|
|
|
1277 Globalize.prototype.localize = function( key, cultureSelector ) {
|
|
|
1278 return Globalize.localize.call( this, key, cultureSelector );
|
|
|
1279 };
|
|
|
1280
|
|
|
1281 Globalize.prototype.parseInt = function( value, radix, cultureSelector ) {
|
|
|
1282 return Globalize.parseInt.call( this, value, radix, cultureSelector );
|
|
|
1283 };
|
|
|
1284
|
|
|
1285 Globalize.prototype.parseFloat = function( value, radix, cultureSelector ) {
|
|
|
1286 return Globalize.parseFloat.call( this, value, radix, cultureSelector );
|
|
|
1287 };
|
|
|
1288
|
|
|
1289 Globalize.prototype.culture = function( cultureSelector ) {
|
|
|
1290 return Globalize.culture.call( this, cultureSelector );
|
|
|
1291 };
|
|
|
1292
|
|
|
1293 //
|
|
|
1294 // public singleton functions
|
|
|
1295 //
|
|
|
1296
|
|
|
1297 Globalize.addCultureInfo = function( cultureName, baseCultureName, info ) {
|
|
|
1298
|
|
|
1299 var base = {},
|
|
|
1300 isNew = false;
|
|
|
1301
|
|
|
1302 if ( typeof cultureName !== "string" ) {
|
|
|
1303 // cultureName argument is optional string. If not specified, assume info is first
|
|
|
1304 // and only argument. Specified info deep-extends current culture.
|
|
|
1305 info = cultureName;
|
|
|
1306 cultureName = this.culture().name;
|
|
|
1307 base = this.cultures[ cultureName ];
|
|
|
1308 } else if ( typeof baseCultureName !== "string" ) {
|
|
|
1309 // baseCultureName argument is optional string. If not specified, assume info is second
|
|
|
1310 // argument. Specified info deep-extends specified culture.
|
|
|
1311 // If specified culture does not exist, create by deep-extending default
|
|
|
1312 info = baseCultureName;
|
|
|
1313 isNew = ( this.cultures[ cultureName ] == null );
|
|
|
1314 base = this.cultures[ cultureName ] || this.cultures[ "default" ];
|
|
|
1315 } else {
|
|
|
1316 // cultureName and baseCultureName specified. Assume a new culture is being created
|
|
|
1317 // by deep-extending an specified base culture
|
|
|
1318 isNew = true;
|
|
|
1319 base = this.cultures[ baseCultureName ];
|
|
|
1320 }
|
|
|
1321
|
|
|
1322 this.cultures[ cultureName ] = extend(true, {},
|
|
|
1323 base,
|
|
|
1324 info
|
|
|
1325 );
|
|
|
1326 // Make the standard calendar the current culture if it's a new culture
|
|
|
1327 if ( isNew ) {
|
|
|
1328 this.cultures[ cultureName ].calendar = this.cultures[ cultureName ].calendars.standard;
|
|
|
1329 }
|
|
|
1330 };
|
|
|
1331
|
|
|
1332 Globalize.findClosestCulture = function( name ) {
|
|
|
1333 var match;
|
|
|
1334 if ( !name ) {
|
|
|
1335 return this.findClosestCulture( this.cultureSelector ) || this.cultures[ "default" ];
|
|
|
1336 }
|
|
|
1337 if ( typeof name === "string" ) {
|
|
|
1338 name = name.split( "," );
|
|
|
1339 }
|
|
|
1340 if ( isArray(name) ) {
|
|
|
1341 var lang,
|
|
|
1342 cultures = this.cultures,
|
|
|
1343 list = name,
|
|
|
1344 i, l = list.length,
|
|
|
1345 prioritized = [];
|
|
|
1346 for ( i = 0; i < l; i++ ) {
|
|
|
1347 name = trim( list[i] );
|
|
|
1348 var pri, parts = name.split( ";" );
|
|
|
1349 lang = trim( parts[0] );
|
|
|
1350 if ( parts.length === 1 ) {
|
|
|
1351 pri = 1;
|
|
|
1352 }
|
|
|
1353 else {
|
|
|
1354 name = trim( parts[1] );
|
|
|
1355 if ( name.indexOf("q=") === 0 ) {
|
|
|
1356 name = name.substr( 2 );
|
|
|
1357 pri = parseFloat( name );
|
|
|
1358 pri = isNaN( pri ) ? 0 : pri;
|
|
|
1359 }
|
|
|
1360 else {
|
|
|
1361 pri = 1;
|
|
|
1362 }
|
|
|
1363 }
|
|
|
1364 prioritized.push({ lang: lang, pri: pri });
|
|
|
1365 }
|
|
|
1366 prioritized.sort(function( a, b ) {
|
|
|
1367 if ( a.pri < b.pri ) {
|
|
|
1368 return 1;
|
|
|
1369 } else if ( a.pri > b.pri ) {
|
|
|
1370 return -1;
|
|
|
1371 }
|
|
|
1372 return 0;
|
|
|
1373 });
|
|
|
1374 // exact match
|
|
|
1375 for ( i = 0; i < l; i++ ) {
|
|
|
1376 lang = prioritized[ i ].lang;
|
|
|
1377 match = cultures[ lang ];
|
|
|
1378 if ( match ) {
|
|
|
1379 return match;
|
|
|
1380 }
|
|
|
1381 }
|
|
|
1382
|
|
|
1383 // neutral language match
|
|
|
1384 for ( i = 0; i < l; i++ ) {
|
|
|
1385 lang = prioritized[ i ].lang;
|
|
|
1386 do {
|
|
|
1387 var index = lang.lastIndexOf( "-" );
|
|
|
1388 if ( index === -1 ) {
|
|
|
1389 break;
|
|
|
1390 }
|
|
|
1391 // strip off the last part. e.g. en-US => en
|
|
|
1392 lang = lang.substr( 0, index );
|
|
|
1393 match = cultures[ lang ];
|
|
|
1394 if ( match ) {
|
|
|
1395 return match;
|
|
|
1396 }
|
|
|
1397 }
|
|
|
1398 while ( 1 );
|
|
|
1399 }
|
|
|
1400
|
|
|
1401 // last resort: match first culture using that language
|
|
|
1402 for ( i = 0; i < l; i++ ) {
|
|
|
1403 lang = prioritized[ i ].lang;
|
|
|
1404 for ( var cultureKey in cultures ) {
|
|
|
1405 var culture = cultures[ cultureKey ];
|
|
|
1406 if ( culture.language === lang ) {
|
|
|
1407 return culture;
|
|
|
1408 }
|
|
|
1409 }
|
|
|
1410 }
|
|
|
1411 }
|
|
|
1412 else if ( typeof name === "object" ) {
|
|
|
1413 return name;
|
|
|
1414 }
|
|
|
1415 return match || null;
|
|
|
1416 };
|
|
|
1417
|
|
|
1418 Globalize.format = function( value, format, cultureSelector ) {
|
|
|
1419 var culture = this.findClosestCulture( cultureSelector );
|
|
|
1420 if ( value instanceof Date ) {
|
|
|
1421 value = formatDate( value, format, culture );
|
|
|
1422 }
|
|
|
1423 else if ( typeof value === "number" ) {
|
|
|
1424 value = formatNumber( value, format, culture );
|
|
|
1425 }
|
|
|
1426 return value;
|
|
|
1427 };
|
|
|
1428
|
|
|
1429 Globalize.localize = function( key, cultureSelector ) {
|
|
|
1430 return this.findClosestCulture( cultureSelector ).messages[ key ] ||
|
|
|
1431 this.cultures[ "default" ].messages[ key ];
|
|
|
1432 };
|
|
|
1433
|
|
|
1434 Globalize.parseDate = function( value, formats, culture ) {
|
|
|
1435 culture = this.findClosestCulture( culture );
|
|
|
1436
|
|
|
1437 var date, prop, patterns;
|
|
|
1438 if ( formats ) {
|
|
|
1439 if ( typeof formats === "string" ) {
|
|
|
1440 formats = [ formats ];
|
|
|
1441 }
|
|
|
1442 if ( formats.length ) {
|
|
|
1443 for ( var i = 0, l = formats.length; i < l; i++ ) {
|
|
|
1444 var format = formats[ i ];
|
|
|
1445 if ( format ) {
|
|
|
1446 date = parseExact( value, format, culture );
|
|
|
1447 if ( date ) {
|
|
|
1448 break;
|
|
|
1449 }
|
|
|
1450 }
|
|
|
1451 }
|
|
|
1452 }
|
|
|
1453 } else {
|
|
|
1454 patterns = culture.calendar.patterns;
|
|
|
1455 for ( prop in patterns ) {
|
|
|
1456 date = parseExact( value, patterns[prop], culture );
|
|
|
1457 if ( date ) {
|
|
|
1458 break;
|
|
|
1459 }
|
|
|
1460 }
|
|
|
1461 }
|
|
|
1462
|
|
|
1463 return date || null;
|
|
|
1464 };
|
|
|
1465
|
|
|
1466 Globalize.parseInt = function( value, radix, cultureSelector ) {
|
|
|
1467 return truncate( Globalize.parseFloat(value, radix, cultureSelector) );
|
|
|
1468 };
|
|
|
1469
|
|
|
1470 Globalize.parseFloat = function( value, radix, cultureSelector ) {
|
|
|
1471 // radix argument is optional
|
|
|
1472 if ( typeof radix !== "number" ) {
|
|
|
1473 cultureSelector = radix;
|
|
|
1474 radix = 10;
|
|
|
1475 }
|
|
|
1476
|
|
|
1477 var culture = this.findClosestCulture( cultureSelector );
|
|
|
1478 var ret = NaN,
|
|
|
1479 nf = culture.numberFormat;
|
|
|
1480
|
|
|
1481 if ( value.indexOf(culture.numberFormat.currency.symbol) > -1 ) {
|
|
|
1482 // remove currency symbol
|
|
|
1483 value = value.replace( culture.numberFormat.currency.symbol, "" );
|
|
|
1484 // replace decimal seperator
|
|
|
1485 value = value.replace( culture.numberFormat.currency["."], culture.numberFormat["."] );
|
|
|
1486 }
|
|
|
1487
|
|
|
1488 //Remove percentage character from number string before parsing
|
|
|
1489 if ( value.indexOf(culture.numberFormat.percent.symbol) > -1){
|
|
|
1490 value = value.replace( culture.numberFormat.percent.symbol, "" );
|
|
|
1491 }
|
|
|
1492
|
|
|
1493 // remove spaces: leading, trailing and between - and number. Used for negative currency pt-BR
|
|
|
1494 value = value.replace( / /g, "" );
|
|
|
1495
|
|
|
1496 // allow infinity or hexidecimal
|
|
|
1497 if ( regexInfinity.test(value) ) {
|
|
|
1498 ret = parseFloat( value );
|
|
|
1499 }
|
|
|
1500 else if ( !radix && regexHex.test(value) ) {
|
|
|
1501 ret = parseInt( value, 16 );
|
|
|
1502 }
|
|
|
1503 else {
|
|
|
1504
|
|
|
1505 // determine sign and number
|
|
|
1506 var signInfo = parseNegativePattern( value, nf, nf.pattern[0] ),
|
|
|
1507 sign = signInfo[ 0 ],
|
|
|
1508 num = signInfo[ 1 ];
|
|
|
1509
|
|
|
1510 // #44 - try parsing as "(n)"
|
|
|
1511 if ( sign === "" && nf.pattern[0] !== "(n)" ) {
|
|
|
1512 signInfo = parseNegativePattern( value, nf, "(n)" );
|
|
|
1513 sign = signInfo[ 0 ];
|
|
|
1514 num = signInfo[ 1 ];
|
|
|
1515 }
|
|
|
1516
|
|
|
1517 // try parsing as "-n"
|
|
|
1518 if ( sign === "" && nf.pattern[0] !== "-n" ) {
|
|
|
1519 signInfo = parseNegativePattern( value, nf, "-n" );
|
|
|
1520 sign = signInfo[ 0 ];
|
|
|
1521 num = signInfo[ 1 ];
|
|
|
1522 }
|
|
|
1523
|
|
|
1524 sign = sign || "+";
|
|
|
1525
|
|
|
1526 // determine exponent and number
|
|
|
1527 var exponent,
|
|
|
1528 intAndFraction,
|
|
|
1529 exponentPos = num.indexOf( "e" );
|
|
|
1530 if ( exponentPos < 0 ) exponentPos = num.indexOf( "E" );
|
|
|
1531 if ( exponentPos < 0 ) {
|
|
|
1532 intAndFraction = num;
|
|
|
1533 exponent = null;
|
|
|
1534 }
|
|
|
1535 else {
|
|
|
1536 intAndFraction = num.substr( 0, exponentPos );
|
|
|
1537 exponent = num.substr( exponentPos + 1 );
|
|
|
1538 }
|
|
|
1539 // determine decimal position
|
|
|
1540 var integer,
|
|
|
1541 fraction,
|
|
|
1542 decSep = nf[ "." ],
|
|
|
1543 decimalPos = intAndFraction.indexOf( decSep );
|
|
|
1544 if ( decimalPos < 0 ) {
|
|
|
1545 integer = intAndFraction;
|
|
|
1546 fraction = null;
|
|
|
1547 }
|
|
|
1548 else {
|
|
|
1549 integer = intAndFraction.substr( 0, decimalPos );
|
|
|
1550 fraction = intAndFraction.substr( decimalPos + decSep.length );
|
|
|
1551 }
|
|
|
1552 // handle groups (e.g. 1,000,000)
|
|
|
1553 var groupSep = nf[ "," ];
|
|
|
1554 integer = integer.split( groupSep ).join( "" );
|
|
|
1555 var altGroupSep = groupSep.replace( /\u00A0/g, " " );
|
|
|
1556 if ( groupSep !== altGroupSep ) {
|
|
|
1557 integer = integer.split( altGroupSep ).join( "" );
|
|
|
1558 }
|
|
|
1559 // build a natively parsable number string
|
|
|
1560 var p = sign + integer;
|
|
|
1561 if ( fraction !== null ) {
|
|
|
1562 p += "." + fraction;
|
|
|
1563 }
|
|
|
1564 if ( exponent !== null ) {
|
|
|
1565 // exponent itself may have a number patternd
|
|
|
1566 var expSignInfo = parseNegativePattern( exponent, nf, "-n" );
|
|
|
1567 p += "e" + ( expSignInfo[0] || "+" ) + expSignInfo[ 1 ];
|
|
|
1568 }
|
|
|
1569 if ( regexParseFloat.test(p) ) {
|
|
|
1570 ret = parseFloat( p );
|
|
|
1571 }
|
|
|
1572 }
|
|
|
1573 return ret;
|
|
|
1574 };
|
|
|
1575
|
|
|
1576 Globalize.culture = function( cultureSelector ) {
|
|
|
1577 // setter
|
|
|
1578 if ( typeof cultureSelector !== "undefined" ) {
|
|
|
1579 this.cultureSelector = cultureSelector;
|
|
|
1580 }
|
|
|
1581 // getter
|
|
|
1582 return this.findClosestCulture( cultureSelector ) || this.cultures[ "default" ];
|
|
|
1583 };
|
|
|
1584
|
|
|
1585 }( this )); |
