Workflow funktioniert nun wieder. Es gab Probleme nach Aenderungen.

ABER: Die Applikation funktioniert nur lokal. Die deployte Version geht noch nicht.

logic/node-red-data/node_modules/moment-parseformat/dist/moment-parseformat.js

@@ -0,0 +1,442 @@
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.momentParseformat = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+var parseFormat = require('./lib/parseformat')
+module.exports = parseFormat
+
+/* istanbul ignore next */
+if (typeof window !== 'undefined' && window.moment) {
+  window.moment.parseFormat = parseFormat
+}
+
+},{"./lib/parseformat":2}],2:[function(require,module,exports){
+module.exports = parseFormat
+
+var dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+var abbreviatedDayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+var shortestDayNames = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa']
+var monthNames = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+var timezoneNames = ['ACDT', 'ACST', 'ACWT', 'ADT', 'ACT', 'AEDT', 'AEST', 'AFT', 'AKDT', 'AKST', 'ALMT', 'AMT', 'AMST', 'ANAT', 'ANAST', 'AQTT', 'ART', 'AST', 'AWDT', 'AWST', 'AZOT', 'AZOST', 'AZT', 'AZST', 'BNT', 'BDT', 'BOT', 'BRT', 'BRST', 'BST', 'BTT', 'B', 'CAST', 'CAT', 'CCT', 'CDT', 'CEDT', 'CEST', 'CET', 'CHADT', 'CHAST', 'CHOT', 'CHOST', 'CHsT', 'CHUT', 'CIT', 'CKT', 'CLST', 'CLT', 'COT', 'CST', 'CVT', 'CWST', 'CXT', 'C', 'DAVT', 'DDUT', 'DST', 'EASST', 'EAST', 'EAT', 'ECT', 'EDT', 'EEDT', 'EEST', 'EET', 'EGT', 'EGST', 'EST', 'E', 'EIT', 'FET', 'FJT', 'FJST', 'FKST', 'FKT', 'FNT', 'F', 'GALT', 'GAMT', 'GET', 'GFT', 'GILT', 'GMT', 'GST', 'GYT', 'G', 'HADT', 'HAST', 'HKT', 'HOVT', 'HOVST', 'HST', 'ICT', 'IDT', 'IOT', 'IRDT', 'IRKT', 'IRKST', 'IRST', 'IST', 'JST', 'KGT', 'KOST', 'KRAT', 'KRAST', 'KST', 'KUYT', 'LHDT', 'LHST', 'LINT', 'L', 'MAGT', 'MAGST', 'MART', 'MAWT', 'MDT', 'MeST', 'MHT', 'MIST', 'MMT', 'MSD', 'MSK', 'MST', 'MUT', 'MVT', 'MYT', 'NCT', 'NDT', 'NFT', 'N', 'NOVT', 'NOVST', 'NPT', 'NRT', 'NST', 'NT', 'NUT', 'NZDT', 'NZST', 'OMST', 'OMSST', 'ORAT', 'O', 'PDT', 'PET', 'PETT', 'PETST', 'PGT', 'PHT', 'PHOT', 'PKT', 'PMDT', 'PMST', 'PONT', 'PST', 'PWT', 'PYT', 'PYST', 'P', 'QYZT', 'RET', 'ROTT', 'R', 'SAKT', 'SAMT', 'SAST', 'SBT', 'SCT', 'SGT', 'SRT', 'SLT', 'SLST', 'SRET', 'SST', 'SYOT', 'TAHT', 'TFT', 'TJT', 'TKT', 'TLT', 'TMT', 'TOT', 'TRUT', 'TVT', 'T', 'ULAT', 'ULAST', 'UTC', 'UYST', 'UYT', 'UZT', 'U', 'VET', 'VLAT', 'VLAST', 'VOLT', 'VUT', 'V', 'WAKT', 'WAT', 'WAST', 'WDT', 'WEDT', 'WEST', 'WET', 'WFT', 'WGT', 'WGST', 'WIB', 'WIT', 'WITA', 'WST', 'WT', 'YAKT', 'YAKST', 'YAP', 'YEK', 'YEKS']
+
+var abbreviatedMonthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+var regexDayNames = new RegExp(dayNames.join('|'), 'i')
+var regexAbbreviatedDayNames = new RegExp(abbreviatedDayNames.join('|'), 'i')
+var regexShortestDayNames = new RegExp('\\b(' + shortestDayNames.join('|') + ')\\b', 'i')
+var regexMonthNames = new RegExp(monthNames.join('|'), 'i')
+var regexAbbreviatedMonthNames = new RegExp(abbreviatedMonthNames.join('|'), 'i')
+var regexTimezoneNames = new RegExp('\\b(' + timezoneNames.join('|') + ')\\b', 'i')
+
+var regexFirstSecondThirdFourth = /(\d+)(st|nd|rd|th)\b/i
+var regexEndian = /(\d{1,4})([/.-])(\d{1,2})[/.-](\d{1,4})/
+
+var regexTimezone = /((\+|-)(12:00|11:00|10:00|09:30|09:00|08:00|07:00|06:00|05:00|04:00|03:30|03:00|02:00|01:00|00:00|01:00|02:00|03:00|03:30|04:00|04:30|05:00|05:30|05:45|06:00|06:30|07:00|08:00|08:45|09:00|09:30|10:00|10:30|11:00|12:00|12:45|13:00|14:00))$/
+var regexTimezoneNaked = /((\+|-)(1200|1100|1000|0930|0900|0800|0700|0600|0500|0400|0330|0300|0200|0100|0000|0100|0200|0300|0330|0400|0430|0500|0530|0545|0600|0630|0700|0800|0845|0900|0930|1000|1030|1100|1200|1245|1300|1400))$/
+
+var amOrPm = '(' + ['AM?', 'PM?'].join('|') + ')'
+var regexHoursWithLeadingZeroDigitMinutesSecondsAmPm = new RegExp('0\\d\\:\\d{1,2}\\:\\d{1,2}(\\s*)' + amOrPm, 'i')
+var regexHoursWithLeadingZeroDigitMinutesAmPm = new RegExp('0\\d\\:\\d{1,2}(\\s*)' + amOrPm, 'i')
+var regexHoursWithLeadingZeroDigitAmPm = new RegExp('0\\d(\\s*)' + amOrPm, 'i')
+var regexHoursMinutesSecondsAmPm = new RegExp('\\d{1,2}\\:\\d{1,2}\\:\\d{1,2}(\\s*)' + amOrPm, 'i')
+var regexHoursMinutesAmPm = new RegExp('\\d{1,2}\\:\\d{1,2}(\\s*)' + amOrPm, 'i')
+var regexHoursAmPm = new RegExp('\\d{1,2}(\\s*)' + amOrPm, 'i')
+var regexHours = new RegExp('\\d{1,2}')
+var regexMonthNameYearShort = new RegExp(monthNames.join('|') + '-\\d{2}', 'i')
+var regexMonthNameAbbreviatedYearShort = new RegExp(abbreviatedMonthNames.join('|') + '-\\d{2}', 'i')
+
+// Various forms of (D|DD)<SEP>(MMM|MMMM)<SEP>('?YY|YYYY)
+var regexDayMonthNameYear = new RegExp('(\\d{1,2})(\\D+)(' + monthNames.join('|') + '|' + abbreviatedMonthNames.join('|') + ')(\\2)(\'?\\d{2,4})')
+
+var regexISO8601HoursWithLeadingZeroMinutesSecondsMilliseconds = /\d{2}:\d{2}:\d{2}\.\d{3}/
+var regexISO8601HoursWithLeadingZeroMinutesSecondsCentiSeconds = /\d{2}:\d{2}:\d{2}\.\d{2}/
+var regexISO8601HoursWithLeadingZeroMinutesSecondsDeciSeconds = /\d{2}:\d{2}:\d{2}\.\d{1}/
+var regexISO8601HoursWithLeadingZeroMinutesSeconds = /T\d{2}:\d{2}:\d{2}/ // Weird test case - format don't usually come like this, but one of ours does.
+var regexHoursWithLeadingZeroMinutesSeconds = /0\d:\d{2}:\d{2}/
+var regexHoursWithLeadingZeroMinutes = /0\d:\d{2}/
+
+var regexHoursMinutesSeconds = /\b([01]?[0-9]|2[0-3]):[0-5][0-9]:\d{2}/
+var regexHoursMinutesSecondsMilliseconds = /\b([01]?[0-9]|2[0-3]):[0-5][0-9]:\d{2}\.\d{3}/
+var regexHoursMinutesSecondsCentiSeconds = /\b([01]?[0-9]|2[0-3]):[0-5][0-9]:\d{2}\.\d{2}/
+var regexHoursMinutesSecondsDeciSeconds = /\b([01]?[0-9]|2[0-3]):[0-5][0-9]:\d{2}\.\d{1}/
+var regexHoursMinutes = /\b([01]?[0-9]|2[0-3]):[0-5][0-9]/
+
+var regexExtended24HoursMinutesSeconds = /24:00:\d{2}/
+var regexExtended24HoursMinutesSecondsMilliseconds = /24:00:\d{2}\.\d{3}/
+var regexExtended24HoursMinutesSecondsCentiSeconds = /24:00:\d{2}\.\d{2}/
+var regexExtended24HoursMinutesSecondsDeciSeconds = /24:00:\d{2}\.\d{1}/
+var regexExtended24HoursMinutes = /24:00/
+
+var regexYearLong = /\d{4}/
+var regexYearShort = /\d{2}/
+var regexYearShortApostrophe = /'\d{2}/
+var regexDayLeadingZero = /0\d/
+var regexDay = /\d{1,2}/
+
+var regexMonthLeadingZero = /0\d/
+var regexMonth = /\d{1,2}/
+
+var regexDayShortMonthShort = /^([1-9])\/([1-9]|0[1-9])$/
+var regexDayShortMonth = /^([1-9])\/(1[012])$/
+var regexDayMonthShort = /^(0[1-9]|[12][0-9]|3[01])\/([1-9])$/
+var regexDayMonth = /^(0[1-9]|[12][0-9]|3[01])\/(1[012]|0[1-9])$/
+
+var regexMonthShortYearShort = /^([1-9])(\D)([1-9][0-9])$/
+var regexMonthShortDay = /^([1-9])(\D)([0][0-9])$/
+var regexMonthYearShort = /^(0[1-9]|1[012])(\D)([1-9][0-9])$/
+var regexMonthDay = /^(0[1-9]|1[012])(\D)([0][0-9])$/
+
+var formatIncludesMonth = /([/][M]|[M][/]|[MM]|[MMMM])/
+var formatIncludesNumericDay = /(D)/
+var formatIncludesYear = /(Y)/
+
+var formatHasMultipleRemainingSegments = /\d+\D.+$/
+var formatOnlyHasTerminatingNumbers = /\D+(\d+)($|Z)/
+var formatHasDayAfterMonthSegment = /M\s*\d{1,2}\b.+$/
+var formatHasDayWithLeadingZeroAfterMonthSegment = /M\D+(0[1-9])\b.+$/
+
+var formatHasTimeAfterRemainingDigits = /\d+\s+(H|h|k)/
+
+var regexFillingWords = /\b(at)\b/i
+
+var regexUnixMillisecondTimestamp = /\d{13}/
+var regexUnixTimestamp = /\d{10}/
+
+// option defaults
+var defaultOrder = {
+  '/': 'MDY',
+  '.': 'DMY',
+  '-': 'YMD'
+}
+
+function parseFormat (dateString, options) {
+  var format = dateString.toString()
+
+  // default options
+  options = options || {}
+
+  options.preferredOrder = options.preferredOrder || defaultOrder
+
+  // Unix Millisecond Timestamp ☛ x
+  format = format.replace(regexUnixMillisecondTimestamp, 'x')
+  // Unix Timestamp ☛ X
+  format = format.replace(regexUnixTimestamp, 'X')
+
+  // escape filling words
+  format = format.replace(regexFillingWords, '[$1]')
+
+  if (format.match(regexDayMonthNameYear)) {
+    const [, daySegment, sep1, monthSegment, sep2, yearSegment] = format.match(regexDayMonthNameYear)
+    const parts = []
+    // Handle Day segment
+    if ((daySegment.length === 2 && daySegment[0] === '0') || options.preferLongFormat) {
+      parts.push('DD')
+    } else {
+      parts.push('D')
+    }
+    // Handle day/month seperator
+    parts.push(sep1)
+    // Handle Month segment
+    if (monthSegment.match(monthNames)) {
+      parts.push('MMMM')
+    } else if (monthSegment.match(abbreviatedMonthNames)) {
+      parts.push('MMM')
+    } else {
+      parts.push(monthSegment)
+    }
+    // Handle month/year seperator
+    parts.push(sep2)
+    // Handle year segment
+    if (yearSegment[0] === "'") {
+      parts.push("'YY")
+    } else if (yearSegment.length === 2) {
+      parts.push('YY')
+    } else if (yearSegment.length === 4) {
+      parts.push('YYYY')
+    } else {
+      parts.push('YYYY')
+    }
+
+    var dayMonthNameYearFormat = parts.join('')
+    format = format.replace(regexDayMonthNameYear, dayMonthNameYearFormat)
+  }
+
+  //  DAYS
+
+  // Monday ☛ dddd
+  format = format.replace(regexDayNames, 'dddd')
+  // Mon ☛ ddd
+  format = format.replace(regexAbbreviatedDayNames, 'ddd')
+  // Mo ☛ dd
+  format = format.replace(regexShortestDayNames, 'dd')
+
+  // 1st, 2nd, 23rd ☛ do
+  format = format.replace(regexFirstSecondThirdFourth, 'Do')
+
+  // MONTHS
+
+  // January ☛ MMMM
+  format = format.replace(regexMonthNames, 'MMMM')
+  // Jan ☛ MMM
+  format = format.replace(regexAbbreviatedMonthNames, 'MMM')
+
+  // replace endians, like 8/20/2010, 20.8.2010 or 2010-8-20
+  format = format.replace(regexEndian, replaceEndian.bind(null, options))
+
+  // timezone name GMT ☛  [GMT]
+  format = format.replace(regexTimezoneNames, a => '[' + a + ']')
+  // timezone +02:00 ☛ Z
+  format = format.replace(regexTimezone, 'Z')
+  // timezone 0200 ☛ Z
+  format = format.replace(regexTimezoneNaked, 'ZZ')
+
+  // TIME
+  // 23:39:43.331 ☛ 'HH:mm:ss.SSS'
+  format = format.replace(regexISO8601HoursWithLeadingZeroMinutesSecondsMilliseconds, 'HH:mm:ss.SSS')
+  // 23:39:43.33 ☛ 'HH:mm:ss.SS'
+  format = format.replace(regexISO8601HoursWithLeadingZeroMinutesSecondsCentiSeconds, 'HH:mm:ss.SS')
+  // 23:39:43.3 ☛ 'HH:mm:ss.S'
+  format = format.replace(regexISO8601HoursWithLeadingZeroMinutesSecondsDeciSeconds, 'HH:mm:ss.S')
+  // 23:39:43 ☛ 'HH:mm:ss'
+  format = format.replace(regexISO8601HoursWithLeadingZeroMinutesSeconds, 'THH:mm:ss')
+  function replaceWithAmPm (timeFormat) {
+    return function (match, whitespace, amPm) {
+      return timeFormat + whitespace + (amPm[0].toUpperCase() === amPm[0] ? 'A' : 'a')
+    }
+  }
+  // 05:30:20pm ☛ hh:mm:ssa
+  format = format.replace(regexHoursWithLeadingZeroDigitMinutesSecondsAmPm, replaceWithAmPm('hh:mm:ss'))
+  // 10:30:20pm ☛ h:mm:ssa
+  format = format.replace(regexHoursMinutesSecondsAmPm, replaceWithAmPm('h:mm:ss'))
+  // 05:30pm ☛ hh:mma
+  format = format.replace(regexHoursWithLeadingZeroDigitMinutesAmPm, replaceWithAmPm('hh:mm'))
+  // 10:30pm ☛ h:mma
+  format = format.replace(regexHoursMinutesAmPm, replaceWithAmPm('h:mm'))
+  // 05pm ☛ hha
+  format = format.replace(regexHoursWithLeadingZeroDigitAmPm, replaceWithAmPm('hh'))
+  // 10pm ☛ ha
+  format = format.replace(regexHoursAmPm, replaceWithAmPm('h'))
+  // 05:30:20 ☛ HH:mm:ss
+  format = format.replace(regexHoursWithLeadingZeroMinutesSeconds, 'HH:mm:ss')
+  // 5:30:20.222 ☛ H:mm:ss.SSS
+  format = format.replace(regexHoursMinutesSecondsMilliseconds, 'H:mm:ss.SSS')
+  // 24:00:00.000 ☛ k:mm:ss.SSS|kk:mm:ss.SSS
+  format = format.replace(regexExtended24HoursMinutesSecondsMilliseconds, (options.preferLongFormat ? 'kk' : 'k') + ':mm:ss.SSS')
+  // 5:30:20.22 ☛ H:mm:ss.SS
+  format = format.replace(regexHoursMinutesSecondsCentiSeconds, 'H:mm:ss.SS')
+  // 24:00:00.00 ☛ k:mm:ss.SS|kk:mm:ss.SS
+  format = format.replace(regexExtended24HoursMinutesSecondsCentiSeconds, (options.preferLongFormat ? 'kk' : 'k') + ':mm:ss.SS')
+  // 5:30:20.2 ☛ H:mm:ss.S
+  format = format.replace(regexHoursMinutesSecondsDeciSeconds, 'H:mm:ss.S')
+  // 24:00:00.0 ☛ k:mm:ss.S|kk:mm:ss.S
+  format = format.replace(regexExtended24HoursMinutesSecondsDeciSeconds, (options.preferLongFormat ? 'kk' : 'k') + ':mm:ss.S')
+  // 10:30:20 ☛ H:mm:ss
+  format = format.replace(regexHoursMinutesSeconds, 'H:mm:ss')
+  // 24:00:00 ☛ k:mm:ss||kk:mm:ss
+  format = format.replace(regexExtended24HoursMinutesSeconds, (options.preferLongFormat ? 'kk' : 'k') + ':mm:ss')
+  // 05:30 ☛ H:mm
+  format = format.replace(regexHoursWithLeadingZeroMinutes, 'HH:mm')
+  // 10:30 ☛ HH:mm
+  format = format.replace(regexHoursMinutes, 'H:mm')
+  // 24:00 ☛ k:mm|kk:mm
+  format = format.replace(regexExtended24HoursMinutes, (options.preferLongFormat ? 'kk' : 'k') + ':mm')
+
+  // do we still have numbers left?
+  //
+  //
+
+  // Lets check for 4 digits first, these are years for sure
+  format = format.replace(regexYearLong, 'YYYY')
+  format = format.replace(regexYearShortApostrophe, '\'YY')
+
+  // Check for (MMM|MMMM)-(YY|YYYY) formats
+  format = format.replace(regexMonthNameYearShort, 'MMMM-YY')
+  format = format.replace(regexMonthNameAbbreviatedYearShort, 'MMM-YY')
+
+  // check if both numbers are < 13, then it must be D/M
+  format = format.replace(regexDayShortMonthShort, 'D/M')
+
+  // check if first number is < 10 && last < 13, then it must be D/MM
+  format = format.replace(regexDayShortMonth, 'D/MM')
+
+  // check if last number is < 32 && last < 10, then it must be DD/M
+  format = format.replace(regexDayMonthShort, 'DD/M')
+
+  // check if both numbers are > 10, but first < 32 && last < 13, then it must be DD/MM
+  format = format.replace(regexDayMonth, 'DD/MM')
+
+  // check if first < 10 && last > 12, then it must be M/YY
+  format = format.replace(regexMonthShortYearShort, 'M$2YY')
+
+  // check if first < 13 && last > 12, then it must be MM/YY
+  format = format.replace(regexMonthYearShort, 'MM$2YY')
+  //
+  // check if first < 10 && last < 10, then it must be M/DD
+  format = format.replace(regexMonthShortDay, 'M$2DD')
+
+  // check if first < 13 && last < 10, then it must be MM/DD
+  format = format.replace(regexMonthDay, 'MM$2DD')
+
+  // to prevent 9.20 gets formated to D.Y, we format the complete date first, then go for the time
+  if (format.match(formatIncludesMonth)) {
+    var regexHoursDotWithLeadingZeroOrDoubleDigitMinutes = /0\d\.\d{2}|\d{2}\.\d{2}/
+    var regexHoursDotMinutes = /\d{1}\.\d{2}/
+
+    format = format.replace(regexHoursDotWithLeadingZeroOrDoubleDigitMinutes, 'H.mm')
+    format = format.replace(regexHoursDotMinutes, 'h.mm')
+  }
+
+  // If the format includes a year format segment, but no month segment, then those numbers are a month
+
+  if (!format.match(formatIncludesMonth) && format.match(formatIncludesYear)) {
+    format = format.replace(regexMonthLeadingZero, 'MM')
+  }
+  if (!format.match(formatIncludesMonth) && format.match(formatIncludesYear)) {
+    format = format.replace(regexMonth, options.preferLongFormat ? 'MM' : 'M')
+  }
+
+  // Check for some odd cases, such as MMMM <some number that is a DAY> <more of the format>
+  if (format.match(formatHasDayWithLeadingZeroAfterMonthSegment) && !format.match(formatHasTimeAfterRemainingDigits)) {
+    format = format.replace(regexDayLeadingZero, 'DD')
+  }
+  if (format.match(formatHasDayAfterMonthSegment) && !format.match(formatHasTimeAfterRemainingDigits)) {
+    format = format.replace(regexDay, options.preferLongFormat ? 'DD' : 'D')
+  }
+
+  // now, the next number, if existing, must be a day IF it is the last set of numbers in the format
+  if (!format.match(formatIncludesNumericDay) && format.match(formatHasMultipleRemainingSegments) && !format.match(formatHasTimeAfterRemainingDigits)) {
+    format = format.replace(regexDayLeadingZero, 'DD')
+  }
+  if (!format.match(formatIncludesNumericDay) && format.match(formatHasMultipleRemainingSegments) && !format.match(formatHasTimeAfterRemainingDigits)) {
+    format = format.replace(regexDay, options.preferLongFormat ? 'DD' : 'D')
+  }
+
+  // there could still be a year left
+  if (!format.match(formatIncludesYear)) {
+    format = format.replace(regexYearShort, 'YY')
+  }
+
+  // if there are still numbers, it might be an odd naked hour that wasn't picked up earlier by the time checks
+  if (format.match(formatOnlyHasTerminatingNumbers)) {
+    var hour = format.match(formatOnlyHasTerminatingNumbers)[1]
+    var replacement
+    if (hour === '00') {
+      replacement = 'HH'
+    } else if (hour === '24') {
+      replacement = options.preferLongFormat ? 'kk' : 'k'
+    } else if (hour > 12) {
+      replacement = options.preferLongFormat ? 'HH' : 'H'
+    } else if (hour[0] === '0') {
+      replacement = options.preferLongFormat ? 'hh' : 'h'
+    } else {
+      replacement = options.preferLongFormat ? 'hh' : 'k'
+    }
+    format = format.replace(regexHours, replacement)
+  }
+
+  if (format.length < 1) {
+    format = undefined
+  }
+
+  return format
+}
+
+// if we can't find an endian based on the separator, but
+// there still is a short date with day, month & year,
+// we try to make a smart decision to identify the order
+function replaceEndian (options, matchedPart, first, separator, second, third) {
+  var parts
+
+  var FIRST = 0
+  var SECOND = 1
+  var THIRD = 2
+
+  var isSingleDigitMap = [
+    first.length === 1,
+    second.length === 1,
+    third.length === 1
+  ]
+
+  var startsWithZeroMap = [
+    first[0] === '0',
+    second[0] === '0',
+    third[0] === '0'
+  ]
+
+  var firstHasQuadDigit = first.length === 4
+  var secondHasQuadDigit = second.length === 4
+  var thirdHasQuadDigit = third.length === 4
+
+  var preferredOrder = typeof options.preferredOrder === 'string' ? options.preferredOrder : options.preferredOrder[separator]
+
+  first = parseInt(first, 10)
+  second = parseInt(second, 10)
+  third = parseInt(third, 10)
+  parts = [first, second, third]
+  preferredOrder = preferredOrder.toUpperCase()
+
+  var inferSingleDigitStatus = function (a, b) {
+    if (isSingleDigitMap[a] !== isSingleDigitMap[b]) {
+      if (!startsWithZeroMap[a] && !startsWithZeroMap[b]) {
+        isSingleDigitMap[a] = true
+        isSingleDigitMap[b] = true
+      }
+    }
+  }
+
+  // If first is a year, order will always be Year-Month-Day
+  if (first > 31) {
+    inferSingleDigitStatus(SECOND, THIRD)
+    parts[0] = firstHasQuadDigit ? 'YYYY' : 'YY'
+    parts[1] = isSingleDigitMap[SECOND] ? 'M' : 'MM'
+    parts[2] = isSingleDigitMap[THIRD] ? 'D' : 'DD'
+    return parts.join(separator)
+  }
+
+  // If first is a month, then the order will be Day-Month-Year
+  if (first > 12) {
+    inferSingleDigitStatus(FIRST, SECOND)
+    parts[0] = isSingleDigitMap[FIRST] ? 'D' : 'DD'
+    parts[1] = isSingleDigitMap[SECOND] ? 'M' : 'MM'
+    parts[2] = thirdHasQuadDigit ? 'YYYY' : 'YY'
+    return parts.join(separator)
+  }
+
+  // Second will never be the year. And if it is a day,
+  // the order will always be Month-Day-Year
+  if (second > 12) {
+    inferSingleDigitStatus(FIRST, SECOND)
+    parts[0] = isSingleDigitMap[FIRST] ? 'M' : 'MM'
+    parts[1] = isSingleDigitMap[SECOND] ? 'D' : 'DD'
+    parts[2] = thirdHasQuadDigit ? 'YYYY' : 'YY'
+    return parts.join(separator)
+  }
+
+  // if third is a year ...
+  if (third > 31) {
+    parts[2] = thirdHasQuadDigit ? 'YYYY' : 'YY'
+
+    // ... try to find day in first and second.
+    // If found, the remaining part is the month.
+    if (preferredOrder[0] === 'M' && first < 13) {
+      inferSingleDigitStatus(FIRST, SECOND)
+      parts[0] = isSingleDigitMap[FIRST] ? 'M' : 'MM'
+      parts[1] = isSingleDigitMap[SECOND] ? 'D' : 'DD'
+      return parts.join(separator)
+    }
+
+    inferSingleDigitStatus(FIRST, SECOND)
+    parts[0] = isSingleDigitMap[FIRST] ? 'D' : 'DD'
+    parts[1] = isSingleDigitMap[SECOND] ? 'M' : 'MM'
+    return parts.join(separator)
+  }
+
+  const hasQuadDigit = [firstHasQuadDigit, secondHasQuadDigit, thirdHasQuadDigit]
+
+  // if we had no luck until here, we use the preferred order
+  inferSingleDigitStatus(preferredOrder.indexOf('D'), preferredOrder.indexOf('M'))
+  parts[preferredOrder.indexOf('D')] = isSingleDigitMap[preferredOrder.indexOf('D')] ? 'D' : 'DD'
+  parts[preferredOrder.indexOf('M')] = isSingleDigitMap[preferredOrder.indexOf('M')] ? 'M' : 'MM'
+
+  parts[preferredOrder.indexOf('Y')] = hasQuadDigit[preferredOrder.indexOf('Y')] ? 'YYYY' : 'YY'
+  return parts.join(separator)
+}
+
+},{}]},{},[1])(1)
+});