'use strict' ;
var require$$0$1 = require ( 'obsidian' ) ;
function _interopDefaultLegacy ( e ) { return e && typeof e === 'object' && 'default' in e ? e : { 'default' : e } ; }
var require$$0 _ _default = /*#__PURE__*/ _interopDefaultLegacy ( require$$0$1 ) ;
/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Copyright ( c ) Microsoft Corporation .
Permission to use , copy , modify , and / or distribute this software for any
purpose with or without fee is hereby granted .
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS . IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL , DIRECT ,
INDIRECT , OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE , DATA OR PROFITS , WHETHER IN AN ACTION OF CONTRACT , NEGLIGENCE OR
OTHER TORTIOUS ACTION , ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /
function _ _awaiter ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
}
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : { } ;
function getDefaultExportFromCjs ( x ) {
return x && x . _ _esModule && Object . prototype . hasOwnProperty . call ( x , 'default' ) ? x [ 'default' ] : x ;
}
function getAugmentedNamespace ( n ) {
if ( n . _ _esModule ) return n ;
var a = Object . defineProperty ( { } , '__esModule' , { value : true } ) ;
Object . keys ( n ) . forEach ( function ( k ) {
var d = Object . getOwnPropertyDescriptor ( n , k ) ;
Object . defineProperty ( a , k , d . get ? d : {
enumerable : true ,
get : function ( ) {
return n [ k ] ;
}
} ) ;
} ) ;
return a ;
}
var main = { } ;
Object . defineProperty ( main , '__esModule' , { value : true } ) ;
var obsidian = require$$0 _ _default [ "default" ] ;
const DEFAULT _DAILY _NOTE _FORMAT = "YYYY-MM-DD" ;
const DEFAULT _WEEKLY _NOTE _FORMAT = "gggg-[W]ww" ;
const DEFAULT _MONTHLY _NOTE _FORMAT = "YYYY-MM" ;
const DEFAULT _QUARTERLY _NOTE _FORMAT = "YYYY-[Q]Q" ;
const DEFAULT _YEARLY _NOTE _FORMAT = "YYYY" ;
function shouldUsePeriodicNotesSettings ( periodicity ) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const periodicNotes = window . app . plugins . getPlugin ( "periodic-notes" ) ;
return periodicNotes && periodicNotes . settings ? . [ periodicity ] ? . enabled ;
}
/ * *
* Read the user settings for the ` daily-notes ` plugin
* to keep behavior of creating a new note in - sync .
* /
function getDailyNoteSettings ( ) {
try {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const { internalPlugins , plugins } = window . app ;
if ( shouldUsePeriodicNotesSettings ( "daily" ) ) {
const { format , folder , template } = plugins . getPlugin ( "periodic-notes" ) ? . settings ? . daily || { } ;
return {
format : format || DEFAULT _DAILY _NOTE _FORMAT ,
folder : folder ? . trim ( ) || "" ,
template : template ? . trim ( ) || "" ,
} ;
}
const { folder , format , template } = internalPlugins . getPluginById ( "daily-notes" ) ? . instance ? . options || { } ;
return {
format : format || DEFAULT _DAILY _NOTE _FORMAT ,
folder : folder ? . trim ( ) || "" ,
template : template ? . trim ( ) || "" ,
} ;
}
catch ( err ) {
console . info ( "No custom daily note settings found!" , err ) ;
}
}
/ * *
* Read the user settings for the ` weekly-notes ` plugin
* to keep behavior of creating a new note in - sync .
* /
function getWeeklyNoteSettings ( ) {
try {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const pluginManager = window . app . plugins ;
const calendarSettings = pluginManager . getPlugin ( "calendar" ) ? . options ;
const periodicNotesSettings = pluginManager . getPlugin ( "periodic-notes" ) ? . settings ? . weekly ;
if ( shouldUsePeriodicNotesSettings ( "weekly" ) ) {
return {
format : periodicNotesSettings . format || DEFAULT _WEEKLY _NOTE _FORMAT ,
folder : periodicNotesSettings . folder ? . trim ( ) || "" ,
template : periodicNotesSettings . template ? . trim ( ) || "" ,
} ;
}
const settings = calendarSettings || { } ;
return {
format : settings . weeklyNoteFormat || DEFAULT _WEEKLY _NOTE _FORMAT ,
folder : settings . weeklyNoteFolder ? . trim ( ) || "" ,
template : settings . weeklyNoteTemplate ? . trim ( ) || "" ,
} ;
}
catch ( err ) {
console . info ( "No custom weekly note settings found!" , err ) ;
}
}
/ * *
* Read the user settings for the ` periodic-notes ` plugin
* to keep behavior of creating a new note in - sync .
* /
function getMonthlyNoteSettings ( ) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const pluginManager = window . app . plugins ;
try {
const settings = ( shouldUsePeriodicNotesSettings ( "monthly" ) &&
pluginManager . getPlugin ( "periodic-notes" ) ? . settings ? . monthly ) ||
{ } ;
return {
format : settings . format || DEFAULT _MONTHLY _NOTE _FORMAT ,
folder : settings . folder ? . trim ( ) || "" ,
template : settings . template ? . trim ( ) || "" ,
} ;
}
catch ( err ) {
console . info ( "No custom monthly note settings found!" , err ) ;
}
}
/ * *
* Read the user settings for the ` periodic-notes ` plugin
* to keep behavior of creating a new note in - sync .
* /
function getQuarterlyNoteSettings ( ) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const pluginManager = window . app . plugins ;
try {
const settings = ( shouldUsePeriodicNotesSettings ( "quarterly" ) &&
pluginManager . getPlugin ( "periodic-notes" ) ? . settings ? . quarterly ) ||
{ } ;
return {
format : settings . format || DEFAULT _QUARTERLY _NOTE _FORMAT ,
folder : settings . folder ? . trim ( ) || "" ,
template : settings . template ? . trim ( ) || "" ,
} ;
}
catch ( err ) {
console . info ( "No custom quarterly note settings found!" , err ) ;
}
}
/ * *
* Read the user settings for the ` periodic-notes ` plugin
* to keep behavior of creating a new note in - sync .
* /
function getYearlyNoteSettings ( ) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const pluginManager = window . app . plugins ;
try {
const settings = ( shouldUsePeriodicNotesSettings ( "yearly" ) &&
pluginManager . getPlugin ( "periodic-notes" ) ? . settings ? . yearly ) ||
{ } ;
return {
format : settings . format || DEFAULT _YEARLY _NOTE _FORMAT ,
folder : settings . folder ? . trim ( ) || "" ,
template : settings . template ? . trim ( ) || "" ,
} ;
}
catch ( err ) {
console . info ( "No custom yearly note settings found!" , err ) ;
}
}
// Credit: @creationix/path.js
function join ( ... partSegments ) {
// Split the inputs into a list of path commands.
let parts = [ ] ;
for ( let i = 0 , l = partSegments . length ; i < l ; i ++ ) {
parts = parts . concat ( partSegments [ i ] . split ( "/" ) ) ;
}
// Interpret the path commands to get the new resolved path.
const newParts = [ ] ;
for ( let i = 0 , l = parts . length ; i < l ; i ++ ) {
const part = parts [ i ] ;
// Remove leading and trailing slashes
// Also remove "." segments
if ( ! part || part === "." )
continue ;
// Push new path segments.
else
newParts . push ( part ) ;
}
// Preserve the initial slash if there was one.
if ( parts [ 0 ] === "" )
newParts . unshift ( "" ) ;
// Turn back into a single string path.
return newParts . join ( "/" ) ;
}
function basename ( fullPath ) {
let base = fullPath . substring ( fullPath . lastIndexOf ( "/" ) + 1 ) ;
if ( base . lastIndexOf ( "." ) != - 1 )
base = base . substring ( 0 , base . lastIndexOf ( "." ) ) ;
return base ;
}
async function ensureFolderExists ( path ) {
const dirs = path . replace ( /\\/g , "/" ) . split ( "/" ) ;
dirs . pop ( ) ; // remove basename
if ( dirs . length ) {
const dir = join ( ... dirs ) ;
if ( ! window . app . vault . getAbstractFileByPath ( dir ) ) {
await window . app . vault . createFolder ( dir ) ;
}
}
}
async function getNotePath ( directory , filename ) {
if ( ! filename . endsWith ( ".md" ) ) {
filename += ".md" ;
}
const path = obsidian . normalizePath ( join ( directory , filename ) ) ;
await ensureFolderExists ( path ) ;
return path ;
}
async function getTemplateInfo ( template ) {
const { metadataCache , vault } = window . app ;
const templatePath = obsidian . normalizePath ( template ) ;
if ( templatePath === "/" ) {
return Promise . resolve ( [ "" , null ] ) ;
}
try {
const templateFile = metadataCache . getFirstLinkpathDest ( templatePath , "" ) ;
const contents = await vault . cachedRead ( templateFile ) ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const IFoldInfo = window . app . foldManager . load ( templateFile ) ;
return [ contents , IFoldInfo ] ;
}
catch ( err ) {
console . error ( ` Failed to read the daily note template ' ${ templatePath } ' ` , err ) ;
new obsidian . Notice ( "Failed to read the daily note template" ) ;
return [ "" , null ] ;
}
}
/ * *
* dateUID is a way of weekly identifying daily / weekly / monthly notes .
* They are prefixed with the granularity to avoid ambiguity .
* /
function getDateUID ( date , granularity = "day" ) {
const ts = date . clone ( ) . startOf ( granularity ) . format ( ) ;
return ` ${ granularity } - ${ ts } ` ;
}
function removeEscapedCharacters ( format ) {
return format . replace ( /\[[^\]]*\]/g , "" ) ; // remove everything within brackets
}
/ * *
* XXX : When parsing dates that contain both week numbers and months ,
* Moment choses to ignore the week numbers . For the week dateUID , we
* want the opposite behavior . Strip the MMM from the format to patch .
* /
function isFormatAmbiguous ( format , granularity ) {
if ( granularity === "week" ) {
const cleanFormat = removeEscapedCharacters ( format ) ;
return ( /w{1,2}/i . test ( cleanFormat ) &&
( /M{1,4}/ . test ( cleanFormat ) || /D{1,4}/ . test ( cleanFormat ) ) ) ;
}
return false ;
}
function getDateFromFile ( file , granularity ) {
return getDateFromFilename ( file . basename , granularity ) ;
}
function getDateFromPath ( path , granularity ) {
return getDateFromFilename ( basename ( path ) , granularity ) ;
}
function getDateFromFilename ( filename , granularity ) {
const getSettings = {
day : getDailyNoteSettings ,
week : getWeeklyNoteSettings ,
month : getMonthlyNoteSettings ,
quarter : getQuarterlyNoteSettings ,
year : getYearlyNoteSettings ,
} ;
const format = getSettings [ granularity ] ( ) . format . split ( "/" ) . pop ( ) ;
const noteDate = window . moment ( filename , format , true ) ;
if ( ! noteDate . isValid ( ) ) {
return null ;
}
if ( isFormatAmbiguous ( format , granularity ) ) {
if ( granularity === "week" ) {
const cleanFormat = removeEscapedCharacters ( format ) ;
if ( /w{1,2}/i . test ( cleanFormat ) ) {
return window . moment ( filename ,
// If format contains week, remove day & month formatting
format . replace ( /M{1,4}/g , "" ) . replace ( /D{1,4}/g , "" ) , false ) ;
}
}
}
return noteDate ;
}
class DailyNotesFolderMissingError extends Error {
}
/ * *
* This function mimics the behavior of the daily - notes plugin
* so it will replace { { date } } , { { title } } , and { { time } } with the
* formatted timestamp .
*
* Note : it has an added bonus that it 's not ' today ' specific .
* /
async function createDailyNote ( date ) {
const app = window . app ;
const { vault } = app ;
const moment = window . moment ;
const { template , format , folder } = getDailyNoteSettings ( ) ;
const [ templateContents , IFoldInfo ] = await getTemplateInfo ( template ) ;
const filename = date . format ( format ) ;
const normalizedPath = await getNotePath ( folder , filename ) ;
try {
const createdFile = await vault . create ( normalizedPath , templateContents
. replace ( /{{\s*date\s*}}/gi , filename )
. replace ( /{{\s*time\s*}}/gi , moment ( ) . format ( "HH:mm" ) )
. replace ( /{{\s*title\s*}}/gi , filename )
. replace ( /{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi , ( _ , _timeOrDate , calc , timeDelta , unit , momentFormat ) => {
const now = moment ( ) ;
const currentDate = date . clone ( ) . set ( {
hour : now . get ( "hour" ) ,
minute : now . get ( "minute" ) ,
second : now . get ( "second" ) ,
} ) ;
if ( calc ) {
currentDate . add ( parseInt ( timeDelta , 10 ) , unit ) ;
}
if ( momentFormat ) {
return currentDate . format ( momentFormat . substring ( 1 ) . trim ( ) ) ;
}
return currentDate . format ( format ) ;
} )
. replace ( /{{\s*yesterday\s*}}/gi , date . clone ( ) . subtract ( 1 , "day" ) . format ( format ) )
. replace ( /{{\s*tomorrow\s*}}/gi , date . clone ( ) . add ( 1 , "d" ) . format ( format ) ) ) ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
app . foldManager . save ( createdFile , IFoldInfo ) ;
return createdFile ;
}
catch ( err ) {
console . error ( ` Failed to create file: ' ${ normalizedPath } ' ` , err ) ;
new obsidian . Notice ( "Unable to create new file." ) ;
}
}
function getDailyNote ( date , dailyNotes ) {
return dailyNotes [ getDateUID ( date , "day" ) ] ? ? null ;
}
function getAllDailyNotes ( ) {
/ * *
* Find all daily notes in the daily note folder
* /
const { vault } = window . app ;
const { folder } = getDailyNoteSettings ( ) ;
const dailyNotesFolder = vault . getAbstractFileByPath ( obsidian . normalizePath ( folder ) ) ;
if ( ! dailyNotesFolder ) {
throw new DailyNotesFolderMissingError ( "Failed to find daily notes folder" ) ;
}
const dailyNotes = { } ;
obsidian . Vault . recurseChildren ( dailyNotesFolder , ( note ) => {
if ( note instanceof obsidian . TFile ) {
const date = getDateFromFile ( note , "day" ) ;
if ( date ) {
const dateString = getDateUID ( date , "day" ) ;
dailyNotes [ dateString ] = note ;
}
}
} ) ;
return dailyNotes ;
}
class WeeklyNotesFolderMissingError extends Error {
}
function getDaysOfWeek ( ) {
const { moment } = window ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let weekStart = moment . localeData ( ) . _week . dow ;
const daysOfWeek = [
"sunday" ,
"monday" ,
"tuesday" ,
"wednesday" ,
"thursday" ,
"friday" ,
"saturday" ,
] ;
while ( weekStart ) {
daysOfWeek . push ( daysOfWeek . shift ( ) ) ;
weekStart -- ;
}
return daysOfWeek ;
}
function getDayOfWeekNumericalValue ( dayOfWeekName ) {
return getDaysOfWeek ( ) . indexOf ( dayOfWeekName . toLowerCase ( ) ) ;
}
async function createWeeklyNote ( date ) {
const { vault } = window . app ;
const { template , format , folder } = getWeeklyNoteSettings ( ) ;
const [ templateContents , IFoldInfo ] = await getTemplateInfo ( template ) ;
const filename = date . format ( format ) ;
const normalizedPath = await getNotePath ( folder , filename ) ;
try {
const createdFile = await vault . create ( normalizedPath , templateContents
. replace ( /{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi , ( _ , _timeOrDate , calc , timeDelta , unit , momentFormat ) => {
const now = window . moment ( ) ;
const currentDate = date . clone ( ) . set ( {
hour : now . get ( "hour" ) ,
minute : now . get ( "minute" ) ,
second : now . get ( "second" ) ,
} ) ;
if ( calc ) {
currentDate . add ( parseInt ( timeDelta , 10 ) , unit ) ;
}
if ( momentFormat ) {
return currentDate . format ( momentFormat . substring ( 1 ) . trim ( ) ) ;
}
return currentDate . format ( format ) ;
} )
. replace ( /{{\s*title\s*}}/gi , filename )
. replace ( /{{\s*time\s*}}/gi , window . moment ( ) . format ( "HH:mm" ) )
. replace ( /{{\s*(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\s*:(.*?)}}/gi , ( _ , dayOfWeek , momentFormat ) => {
const day = getDayOfWeekNumericalValue ( dayOfWeek ) ;
return date . weekday ( day ) . format ( momentFormat . trim ( ) ) ;
} ) ) ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
window . app . foldManager . save ( createdFile , IFoldInfo ) ;
return createdFile ;
}
catch ( err ) {
console . error ( ` Failed to create file: ' ${ normalizedPath } ' ` , err ) ;
new obsidian . Notice ( "Unable to create new file." ) ;
}
}
function getWeeklyNote ( date , weeklyNotes ) {
return weeklyNotes [ getDateUID ( date , "week" ) ] ? ? null ;
}
function getAllWeeklyNotes ( ) {
const weeklyNotes = { } ;
if ( ! appHasWeeklyNotesPluginLoaded ( ) ) {
return weeklyNotes ;
}
const { vault } = window . app ;
const { folder } = getWeeklyNoteSettings ( ) ;
const weeklyNotesFolder = vault . getAbstractFileByPath ( obsidian . normalizePath ( folder ) ) ;
if ( ! weeklyNotesFolder ) {
throw new WeeklyNotesFolderMissingError ( "Failed to find weekly notes folder" ) ;
}
obsidian . Vault . recurseChildren ( weeklyNotesFolder , ( note ) => {
if ( note instanceof obsidian . TFile ) {
const date = getDateFromFile ( note , "week" ) ;
if ( date ) {
const dateString = getDateUID ( date , "week" ) ;
weeklyNotes [ dateString ] = note ;
}
}
} ) ;
return weeklyNotes ;
}
class MonthlyNotesFolderMissingError extends Error {
}
/ * *
* This function mimics the behavior of the daily - notes plugin
* so it will replace { { date } } , { { title } } , and { { time } } with the
* formatted timestamp .
*
* Note : it has an added bonus that it 's not ' today ' specific .
* /
async function createMonthlyNote ( date ) {
const { vault } = window . app ;
const { template , format , folder } = getMonthlyNoteSettings ( ) ;
const [ templateContents , IFoldInfo ] = await getTemplateInfo ( template ) ;
const filename = date . format ( format ) ;
const normalizedPath = await getNotePath ( folder , filename ) ;
try {
const createdFile = await vault . create ( normalizedPath , templateContents
. replace ( /{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi , ( _ , _timeOrDate , calc , timeDelta , unit , momentFormat ) => {
const now = window . moment ( ) ;
const currentDate = date . clone ( ) . set ( {
hour : now . get ( "hour" ) ,
minute : now . get ( "minute" ) ,
second : now . get ( "second" ) ,
} ) ;
if ( calc ) {
currentDate . add ( parseInt ( timeDelta , 10 ) , unit ) ;
}
if ( momentFormat ) {
return currentDate . format ( momentFormat . substring ( 1 ) . trim ( ) ) ;
}
return currentDate . format ( format ) ;
} )
. replace ( /{{\s*date\s*}}/gi , filename )
. replace ( /{{\s*time\s*}}/gi , window . moment ( ) . format ( "HH:mm" ) )
. replace ( /{{\s*title\s*}}/gi , filename ) ) ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
window . app . foldManager . save ( createdFile , IFoldInfo ) ;
return createdFile ;
}
catch ( err ) {
console . error ( ` Failed to create file: ' ${ normalizedPath } ' ` , err ) ;
new obsidian . Notice ( "Unable to create new file." ) ;
}
}
function getMonthlyNote ( date , monthlyNotes ) {
return monthlyNotes [ getDateUID ( date , "month" ) ] ? ? null ;
}
function getAllMonthlyNotes ( ) {
const monthlyNotes = { } ;
if ( ! appHasMonthlyNotesPluginLoaded ( ) ) {
return monthlyNotes ;
}
const { vault } = window . app ;
const { folder } = getMonthlyNoteSettings ( ) ;
const monthlyNotesFolder = vault . getAbstractFileByPath ( obsidian . normalizePath ( folder ) ) ;
if ( ! monthlyNotesFolder ) {
throw new MonthlyNotesFolderMissingError ( "Failed to find monthly notes folder" ) ;
}
obsidian . Vault . recurseChildren ( monthlyNotesFolder , ( note ) => {
if ( note instanceof obsidian . TFile ) {
const date = getDateFromFile ( note , "month" ) ;
if ( date ) {
const dateString = getDateUID ( date , "month" ) ;
monthlyNotes [ dateString ] = note ;
}
}
} ) ;
return monthlyNotes ;
}
class QuarterlyNotesFolderMissingError extends Error {
}
/ * *
* This function mimics the behavior of the daily - notes plugin
* so it will replace { { date } } , { { title } } , and { { time } } with the
* formatted timestamp .
*
* Note : it has an added bonus that it 's not ' today ' specific .
* /
async function createQuarterlyNote ( date ) {
const { vault } = window . app ;
const { template , format , folder } = getQuarterlyNoteSettings ( ) ;
const [ templateContents , IFoldInfo ] = await getTemplateInfo ( template ) ;
const filename = date . format ( format ) ;
const normalizedPath = await getNotePath ( folder , filename ) ;
try {
const createdFile = await vault . create ( normalizedPath , templateContents
. replace ( /{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi , ( _ , _timeOrDate , calc , timeDelta , unit , momentFormat ) => {
const now = window . moment ( ) ;
const currentDate = date . clone ( ) . set ( {
hour : now . get ( "hour" ) ,
minute : now . get ( "minute" ) ,
second : now . get ( "second" ) ,
} ) ;
if ( calc ) {
currentDate . add ( parseInt ( timeDelta , 10 ) , unit ) ;
}
if ( momentFormat ) {
return currentDate . format ( momentFormat . substring ( 1 ) . trim ( ) ) ;
}
return currentDate . format ( format ) ;
} )
. replace ( /{{\s*date\s*}}/gi , filename )
. replace ( /{{\s*time\s*}}/gi , window . moment ( ) . format ( "HH:mm" ) )
. replace ( /{{\s*title\s*}}/gi , filename ) ) ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
window . app . foldManager . save ( createdFile , IFoldInfo ) ;
return createdFile ;
}
catch ( err ) {
console . error ( ` Failed to create file: ' ${ normalizedPath } ' ` , err ) ;
new obsidian . Notice ( "Unable to create new file." ) ;
}
}
function getQuarterlyNote ( date , quarterly ) {
return quarterly [ getDateUID ( date , "quarter" ) ] ? ? null ;
}
function getAllQuarterlyNotes ( ) {
const quarterly = { } ;
if ( ! appHasQuarterlyNotesPluginLoaded ( ) ) {
return quarterly ;
}
const { vault } = window . app ;
const { folder } = getQuarterlyNoteSettings ( ) ;
const quarterlyFolder = vault . getAbstractFileByPath ( obsidian . normalizePath ( folder ) ) ;
if ( ! quarterlyFolder ) {
throw new QuarterlyNotesFolderMissingError ( "Failed to find quarterly notes folder" ) ;
}
obsidian . Vault . recurseChildren ( quarterlyFolder , ( note ) => {
if ( note instanceof obsidian . TFile ) {
const date = getDateFromFile ( note , "quarter" ) ;
if ( date ) {
const dateString = getDateUID ( date , "quarter" ) ;
quarterly [ dateString ] = note ;
}
}
} ) ;
return quarterly ;
}
class YearlyNotesFolderMissingError extends Error {
}
/ * *
* This function mimics the behavior of the daily - notes plugin
* so it will replace { { date } } , { { title } } , and { { time } } with the
* formatted timestamp .
*
* Note : it has an added bonus that it 's not ' today ' specific .
* /
async function createYearlyNote ( date ) {
const { vault } = window . app ;
const { template , format , folder } = getYearlyNoteSettings ( ) ;
const [ templateContents , IFoldInfo ] = await getTemplateInfo ( template ) ;
const filename = date . format ( format ) ;
const normalizedPath = await getNotePath ( folder , filename ) ;
try {
const createdFile = await vault . create ( normalizedPath , templateContents
. replace ( /{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi , ( _ , _timeOrDate , calc , timeDelta , unit , momentFormat ) => {
const now = window . moment ( ) ;
const currentDate = date . clone ( ) . set ( {
hour : now . get ( "hour" ) ,
minute : now . get ( "minute" ) ,
second : now . get ( "second" ) ,
} ) ;
if ( calc ) {
currentDate . add ( parseInt ( timeDelta , 10 ) , unit ) ;
}
if ( momentFormat ) {
return currentDate . format ( momentFormat . substring ( 1 ) . trim ( ) ) ;
}
return currentDate . format ( format ) ;
} )
. replace ( /{{\s*date\s*}}/gi , filename )
. replace ( /{{\s*time\s*}}/gi , window . moment ( ) . format ( "HH:mm" ) )
. replace ( /{{\s*title\s*}}/gi , filename ) ) ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
window . app . foldManager . save ( createdFile , IFoldInfo ) ;
return createdFile ;
}
catch ( err ) {
console . error ( ` Failed to create file: ' ${ normalizedPath } ' ` , err ) ;
new obsidian . Notice ( "Unable to create new file." ) ;
}
}
function getYearlyNote ( date , yearlyNotes ) {
return yearlyNotes [ getDateUID ( date , "year" ) ] ? ? null ;
}
function getAllYearlyNotes ( ) {
const yearlyNotes = { } ;
if ( ! appHasYearlyNotesPluginLoaded ( ) ) {
return yearlyNotes ;
}
const { vault } = window . app ;
const { folder } = getYearlyNoteSettings ( ) ;
const yearlyNotesFolder = vault . getAbstractFileByPath ( obsidian . normalizePath ( folder ) ) ;
if ( ! yearlyNotesFolder ) {
throw new YearlyNotesFolderMissingError ( "Failed to find yearly notes folder" ) ;
}
obsidian . Vault . recurseChildren ( yearlyNotesFolder , ( note ) => {
if ( note instanceof obsidian . TFile ) {
const date = getDateFromFile ( note , "year" ) ;
if ( date ) {
const dateString = getDateUID ( date , "year" ) ;
yearlyNotes [ dateString ] = note ;
}
}
} ) ;
return yearlyNotes ;
}
function appHasDailyNotesPluginLoaded ( ) {
const { app } = window ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const dailyNotesPlugin = app . internalPlugins . plugins [ "daily-notes" ] ;
if ( dailyNotesPlugin && dailyNotesPlugin . enabled ) {
return true ;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const periodicNotes = app . plugins . getPlugin ( "periodic-notes" ) ;
return periodicNotes && periodicNotes . settings ? . daily ? . enabled ;
}
/ * *
* XXX : "Weekly Notes" live in either the Calendar plugin or the periodic - notes plugin .
* Check both until the weekly notes feature is removed from the Calendar plugin .
* /
function appHasWeeklyNotesPluginLoaded ( ) {
const { app } = window ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
if ( app . plugins . getPlugin ( "calendar" ) ) {
return true ;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const periodicNotes = app . plugins . getPlugin ( "periodic-notes" ) ;
return periodicNotes && periodicNotes . settings ? . weekly ? . enabled ;
}
function appHasMonthlyNotesPluginLoaded ( ) {
const { app } = window ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const periodicNotes = app . plugins . getPlugin ( "periodic-notes" ) ;
return periodicNotes && periodicNotes . settings ? . monthly ? . enabled ;
}
function appHasQuarterlyNotesPluginLoaded ( ) {
const { app } = window ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const periodicNotes = app . plugins . getPlugin ( "periodic-notes" ) ;
return periodicNotes && periodicNotes . settings ? . quarterly ? . enabled ;
}
function appHasYearlyNotesPluginLoaded ( ) {
const { app } = window ;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const periodicNotes = app . plugins . getPlugin ( "periodic-notes" ) ;
return periodicNotes && periodicNotes . settings ? . yearly ? . enabled ;
}
function getPeriodicNoteSettings ( granularity ) {
const getSettings = {
day : getDailyNoteSettings ,
week : getWeeklyNoteSettings ,
month : getMonthlyNoteSettings ,
quarter : getQuarterlyNoteSettings ,
year : getYearlyNoteSettings ,
} [ granularity ] ;
return getSettings ( ) ;
}
function createPeriodicNote ( granularity , date ) {
const createFn = {
day : createDailyNote ,
month : createMonthlyNote ,
week : createWeeklyNote ,
} ;
return createFn [ granularity ] ( date ) ;
}
main . DEFAULT _DAILY _NOTE _FORMAT = DEFAULT _DAILY _NOTE _FORMAT ;
main . DEFAULT _MONTHLY _NOTE _FORMAT = DEFAULT _MONTHLY _NOTE _FORMAT ;
main . DEFAULT _QUARTERLY _NOTE _FORMAT = DEFAULT _QUARTERLY _NOTE _FORMAT ;
main . DEFAULT _WEEKLY _NOTE _FORMAT = DEFAULT _WEEKLY _NOTE _FORMAT ;
main . DEFAULT _YEARLY _NOTE _FORMAT = DEFAULT _YEARLY _NOTE _FORMAT ;
main . appHasDailyNotesPluginLoaded = appHasDailyNotesPluginLoaded ;
main . appHasMonthlyNotesPluginLoaded = appHasMonthlyNotesPluginLoaded ;
main . appHasQuarterlyNotesPluginLoaded = appHasQuarterlyNotesPluginLoaded ;
main . appHasWeeklyNotesPluginLoaded = appHasWeeklyNotesPluginLoaded ;
main . appHasYearlyNotesPluginLoaded = appHasYearlyNotesPluginLoaded ;
var createDailyNote _1 = main . createDailyNote = createDailyNote ;
main . createMonthlyNote = createMonthlyNote ;
main . createPeriodicNote = createPeriodicNote ;
main . createQuarterlyNote = createQuarterlyNote ;
main . createWeeklyNote = createWeeklyNote ;
main . createYearlyNote = createYearlyNote ;
var getAllDailyNotes _1 = main . getAllDailyNotes = getAllDailyNotes ;
main . getAllMonthlyNotes = getAllMonthlyNotes ;
main . getAllQuarterlyNotes = getAllQuarterlyNotes ;
main . getAllWeeklyNotes = getAllWeeklyNotes ;
main . getAllYearlyNotes = getAllYearlyNotes ;
var getDailyNote _1 = main . getDailyNote = getDailyNote ;
main . getDailyNoteSettings = getDailyNoteSettings ;
main . getDateFromFile = getDateFromFile ;
main . getDateFromPath = getDateFromPath ;
main . getDateUID = getDateUID ;
main . getMonthlyNote = getMonthlyNote ;
main . getMonthlyNoteSettings = getMonthlyNoteSettings ;
main . getPeriodicNoteSettings = getPeriodicNoteSettings ;
main . getQuarterlyNote = getQuarterlyNote ;
main . getQuarterlyNoteSettings = getQuarterlyNoteSettings ;
main . getTemplateInfo = getTemplateInfo ;
main . getWeeklyNote = getWeeklyNote ;
main . getWeeklyNoteSettings = getWeeklyNoteSettings ;
main . getYearlyNote = getYearlyNote ;
main . getYearlyNoteSettings = getYearlyNoteSettings ;
const daysOfWeek = [
"sunday" ,
"monday" ,
"tuesday" ,
"wednesday" ,
"thursday" ,
"friday" ,
"saturday" ,
] ;
function getWordBoundaries ( editor ) {
const cursor = editor . getCursor ( ) ;
const pos = editor . posToOffset ( cursor ) ;
const word = editor . cm . state . wordAt ( pos ) ;
const wordStart = editor . offsetToPos ( word . from ) ;
const wordEnd = editor . offsetToPos ( word . to ) ;
return {
from : wordStart ,
to : wordEnd ,
} ;
}
function getSelectedText ( editor ) {
if ( editor . somethingSelected ( ) ) {
return editor . getSelection ( ) ;
}
else {
const wordBoundaries = getWordBoundaries ( editor ) ;
editor . setSelection ( wordBoundaries . from , wordBoundaries . to ) ; // TODO check if this needs to be updated/improved
return editor . getSelection ( ) ;
}
}
function adjustCursor ( editor , cursor , newStr , oldStr ) {
const cursorOffset = newStr . length - oldStr . length ;
editor . setCursor ( {
line : cursor . line ,
ch : cursor . ch + cursorOffset ,
} ) ;
}
function getFormattedDate ( date , format ) {
return window . moment ( date ) . format ( format ) ;
}
function getLastDayOfMonth ( year , month ) {
return new Date ( year , month , 0 ) . getDate ( ) ;
}
function parseTruthy ( flag ) {
return [ "y" , "yes" , "1" , "t" , "true" ] . indexOf ( flag . toLowerCase ( ) ) >= 0 ;
}
function getWeekNumber ( dayOfWeek ) {
return daysOfWeek . indexOf ( dayOfWeek ) ;
}
function getLocaleWeekStart ( ) {
// @ts-ignore
const startOfWeek = window . moment . localeData ( ) . _week . dow ;
return daysOfWeek [ startOfWeek ] ;
}
function generateMarkdownLink ( app , subpath , alias ) {
const useMarkdownLinks = app . vault . getConfig ( "useMarkdownLinks" ) ;
const path = require$$0$1 . normalizePath ( subpath ) ;
if ( useMarkdownLinks ) {
if ( alias ) {
return ` [ ${ alias } ]( ${ path . replace ( / /g , "%20" ) } ) ` ;
}
else {
return ` [ ${ subpath } ]( ${ path } ) ` ;
}
}
else {
if ( alias ) {
return ` [[ ${ path } | ${ alias } ]] ` ;
}
else {
return ` [[ ${ path } ]] ` ;
}
}
}
function getOrCreateDailyNote ( date ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
// Borrowed from the Slated plugin:
// https://github.com/tgrosinger/slated-obsidian/blob/main/src/vault.ts#L17
const desiredNote = getDailyNote _1 ( date , getAllDailyNotes _1 ( ) ) ;
if ( desiredNote ) {
return Promise . resolve ( desiredNote ) ;
}
return createDailyNote _1 ( date ) ;
} ) ;
}
function extractTerms$1 ( dictionary ) {
let keys ;
if ( dictionary instanceof Array ) {
keys = [ ... dictionary ] ;
}
else if ( dictionary instanceof Map ) {
keys = Array . from ( dictionary . keys ( ) ) ;
}
else {
keys = Object . keys ( dictionary ) ;
}
return keys ;
}
function matchAnyPattern$1 ( dictionary ) {
const joinedTerms = extractTerms$1 ( dictionary )
. sort ( ( a , b ) => b . length - a . length )
. join ( "|" )
. replace ( /\./g , "\\." ) ;
return ` (?: ${ joinedTerms } ) ` ;
}
const ORDINAL _WORD _DICTIONARY = {
first : 1 ,
second : 2 ,
third : 3 ,
fourth : 4 ,
fifth : 5 ,
sixth : 6 ,
seventh : 7 ,
eighth : 8 ,
ninth : 9 ,
tenth : 10 ,
eleventh : 11 ,
twelfth : 12 ,
thirteenth : 13 ,
fourteenth : 14 ,
fifteenth : 15 ,
sixteenth : 16 ,
seventeenth : 17 ,
eighteenth : 18 ,
nineteenth : 19 ,
twentieth : 20 ,
"twenty first" : 21 ,
"twenty-first" : 21 ,
"twenty second" : 22 ,
"twenty-second" : 22 ,
"twenty third" : 23 ,
"twenty-third" : 23 ,
"twenty fourth" : 24 ,
"twenty-fourth" : 24 ,
"twenty fifth" : 25 ,
"twenty-fifth" : 25 ,
"twenty sixth" : 26 ,
"twenty-sixth" : 26 ,
"twenty seventh" : 27 ,
"twenty-seventh" : 27 ,
"twenty eighth" : 28 ,
"twenty-eighth" : 28 ,
"twenty ninth" : 29 ,
"twenty-ninth" : 29 ,
thirtieth : 30 ,
"thirty first" : 31 ,
"thirty-first" : 31 ,
} ;
const ORDINAL _NUMBER _PATTERN = ` (?: ${ matchAnyPattern$1 ( ORDINAL _WORD _DICTIONARY ) } |[0-9]{1,2}(?:st|nd|rd|th)?) ` ;
function parseOrdinalNumberPattern ( match ) {
let num = match . toLowerCase ( ) ;
if ( ORDINAL _WORD _DICTIONARY [ num ] !== undefined ) {
return ORDINAL _WORD _DICTIONARY [ num ] ;
}
num = num . replace ( /(?:st|nd|rd|th)$/i , "" ) ;
return parseInt ( num ) ;
}
class DatePickerModal extends require$$0$1 . Modal {
constructor ( app , plugin ) {
super ( app ) ;
this . plugin = plugin ;
}
onOpen ( ) {
let previewEl ;
let dateInput = "" ;
let momentFormat = this . plugin . settings . modalMomentFormat ;
let insertAsLink = this . plugin . settings . modalToggleLink ;
const getDateStr = ( ) => {
let cleanDateInput = dateInput ;
let shouldIncludeAlias = false ;
if ( dateInput . endsWith ( "|" ) ) {
shouldIncludeAlias = true ;
cleanDateInput = dateInput . slice ( 0 , - 1 ) ;
}
const parsedDate = this . plugin . parseDate ( cleanDateInput || "today" ) ;
let parsedDateString = parsedDate . moment . isValid ( )
? parsedDate . moment . format ( momentFormat )
: "" ;
if ( insertAsLink ) {
parsedDateString = generateMarkdownLink ( this . app , parsedDateString , shouldIncludeAlias ? cleanDateInput : undefined ) ;
}
return parsedDateString ;
} ;
this . contentEl . createEl ( "form" , { } , ( formEl ) => {
const dateInputEl = new require$$0$1 . Setting ( formEl )
. setName ( "Date" )
. setDesc ( getDateStr ( ) )
. addText ( ( textEl ) => {
textEl . setPlaceholder ( "Today" ) ;
textEl . onChange ( ( value ) => {
dateInput = value ;
previewEl . setText ( getDateStr ( ) ) ;
} ) ;
window . setTimeout ( ( ) => textEl . inputEl . focus ( ) , 10 ) ;
} ) ;
previewEl = dateInputEl . descEl ;
new require$$0$1 . Setting ( formEl )
. setName ( "Date Format" )
. setDesc ( "Moment format to be used" )
. addMomentFormat ( ( momentEl ) => {
momentEl . setPlaceholder ( "YYYY-MM-DD HH:mm" ) ;
momentEl . setValue ( momentFormat ) ;
momentEl . onChange ( ( value ) => {
momentFormat = value . trim ( ) || "YYYY-MM-DD HH:mm" ;
this . plugin . settings . modalMomentFormat = momentFormat ;
this . plugin . saveSettings ( ) ;
previewEl . setText ( getDateStr ( ) ) ;
} ) ;
} ) ;
new require$$0$1 . Setting ( formEl ) . setName ( "Add as link?" ) . addToggle ( ( toggleEl ) => {
toggleEl . setValue ( this . plugin . settings . modalToggleLink ) . onChange ( ( value ) => {
insertAsLink = value ;
this . plugin . settings . modalToggleLink = insertAsLink ;
this . plugin . saveSettings ( ) ;
previewEl . setText ( getDateStr ( ) ) ;
} ) ;
} ) ;
formEl . createDiv ( "modal-button-container" , ( buttonContainerEl ) => {
buttonContainerEl
. createEl ( "button" , { attr : { type : "button" } , text : "Never mind" } )
. addEventListener ( "click" , ( ) => this . close ( ) ) ;
buttonContainerEl . createEl ( "button" , {
attr : { type : "submit" } ,
cls : "mod-cta" ,
text : "Insert Date" ,
} ) ;
} ) ;
const activeView = this . app . workspace . getActiveViewOfType ( require$$0$1 . MarkdownView ) ;
const activeEditor = activeView . editor ;
formEl . addEventListener ( "submit" , ( e ) => {
e . preventDefault ( ) ;
this . close ( ) ;
activeEditor . replaceSelection ( getDateStr ( ) ) ;
} ) ;
} ) ;
}
}
var dist = { } ;
var en$1 = { } ;
var ENTimeUnitWithinFormatParser$1 = { } ;
var constants$7 = { } ;
var pattern = { } ;
Object . defineProperty ( pattern , "__esModule" , { value : true } ) ;
pattern . matchAnyPattern = pattern . extractTerms = pattern . repeatedTimeunitPattern = void 0 ;
function repeatedTimeunitPattern ( prefix , singleTimeunitPattern ) {
const singleTimeunitPatternNoCapture = singleTimeunitPattern . replace ( /\((?!\?)/g , "(?:" ) ;
return ` ${ prefix } ${ singleTimeunitPatternNoCapture } \\ s{0,5}(?:,? \\ s{0,5} ${ singleTimeunitPatternNoCapture } ){0,10} ` ;
}
pattern . repeatedTimeunitPattern = repeatedTimeunitPattern ;
function extractTerms ( dictionary ) {
let keys ;
if ( dictionary instanceof Array ) {
keys = [ ... dictionary ] ;
}
else if ( dictionary instanceof Map ) {
keys = Array . from ( dictionary . keys ( ) ) ;
}
else {
keys = Object . keys ( dictionary ) ;
}
return keys ;
}
pattern . extractTerms = extractTerms ;
function matchAnyPattern ( dictionary ) {
const joinedTerms = extractTerms ( dictionary )
. sort ( ( a , b ) => b . length - a . length )
. join ( "|" )
. replace ( /\./g , "\\." ) ;
return ` (?: ${ joinedTerms } ) ` ;
}
pattern . matchAnyPattern = matchAnyPattern ;
var years = { } ;
var SECONDS _A _MINUTE = 60 ;
var SECONDS _A _HOUR = SECONDS _A _MINUTE * 60 ;
var SECONDS _A _DAY = SECONDS _A _HOUR * 24 ;
var SECONDS _A _WEEK = SECONDS _A _DAY * 7 ;
var MILLISECONDS _A _SECOND = 1e3 ;
var MILLISECONDS _A _MINUTE = SECONDS _A _MINUTE * MILLISECONDS _A _SECOND ;
var MILLISECONDS _A _HOUR = SECONDS _A _HOUR * MILLISECONDS _A _SECOND ;
var MILLISECONDS _A _DAY = SECONDS _A _DAY * MILLISECONDS _A _SECOND ;
var MILLISECONDS _A _WEEK = SECONDS _A _WEEK * MILLISECONDS _A _SECOND ; // English locales
var MS = 'millisecond' ;
var S = 'second' ;
var MIN = 'minute' ;
var H = 'hour' ;
var D = 'day' ;
var W = 'week' ;
var M = 'month' ;
var Q = 'quarter' ;
var Y = 'year' ;
var DATE = 'date' ;
var FORMAT _DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ' ;
var INVALID _DATE _STRING = 'Invalid Date' ; // regex
var REGEX _PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[^0-9]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?\.?(\d+)?$/ ;
var REGEX _FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g ;
// English [en]
// We don't need weekdaysShort, weekdaysMin, monthsShort in en.js locale
var en = {
name : 'en' ,
weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday' . split ( '_' ) ,
months : 'January_February_March_April_May_June_July_August_September_October_November_December' . split ( '_' )
} ;
var padStart = function padStart ( string , length , pad ) {
var s = String ( string ) ;
if ( ! s || s . length >= length ) return string ;
return "" + Array ( length + 1 - s . length ) . join ( pad ) + string ;
} ;
var padZoneStr = function padZoneStr ( instance ) {
var negMinutes = - instance . utcOffset ( ) ;
var minutes = Math . abs ( negMinutes ) ;
var hourOffset = Math . floor ( minutes / 60 ) ;
var minuteOffset = minutes % 60 ;
return "" + ( negMinutes <= 0 ? '+' : '-' ) + padStart ( hourOffset , 2 , '0' ) + ":" + padStart ( minuteOffset , 2 , '0' ) ;
} ;
var monthDiff = function monthDiff ( a , b ) {
// function from moment.js in order to keep the same result
if ( a . date ( ) < b . date ( ) ) return - monthDiff ( b , a ) ;
var wholeMonthDiff = ( b . year ( ) - a . year ( ) ) * 12 + ( b . month ( ) - a . month ( ) ) ;
var anchor = a . clone ( ) . add ( wholeMonthDiff , M ) ;
var c = b - anchor < 0 ;
var anchor2 = a . clone ( ) . add ( wholeMonthDiff + ( c ? - 1 : 1 ) , M ) ;
return + ( - ( wholeMonthDiff + ( b - anchor ) / ( c ? anchor - anchor2 : anchor2 - anchor ) ) || 0 ) ;
} ;
var absFloor = function absFloor ( n ) {
return n < 0 ? Math . ceil ( n ) || 0 : Math . floor ( n ) ;
} ;
var prettyUnit = function prettyUnit ( u ) {
var special = {
M : M ,
y : Y ,
w : W ,
d : D ,
D : DATE ,
h : H ,
m : MIN ,
s : S ,
ms : MS ,
Q : Q
} ;
return special [ u ] || String ( u || '' ) . toLowerCase ( ) . replace ( /s$/ , '' ) ;
} ;
var isUndefined = function isUndefined ( s ) {
return s === undefined ;
} ;
var U = {
s : padStart ,
z : padZoneStr ,
m : monthDiff ,
a : absFloor ,
p : prettyUnit ,
u : isUndefined
} ;
var L = 'en' ; // global locale
var Ls = { } ; // global loaded locale
Ls [ L ] = en ;
var isDayjs = function isDayjs ( d ) {
return d instanceof Dayjs ;
} ; // eslint-disable-line no-use-before-define
var parseLocale = function parseLocale ( preset , object , isLocal ) {
var l ;
if ( ! preset ) return L ;
if ( typeof preset === 'string' ) {
if ( Ls [ preset ] ) {
l = preset ;
}
if ( object ) {
Ls [ preset ] = object ;
l = preset ;
}
} else {
var name = preset . name ;
Ls [ name ] = preset ;
l = name ;
}
if ( ! isLocal && l ) L = l ;
return l || ! isLocal && L ;
} ;
var dayjs$1 = function dayjs ( date , c ) {
if ( isDayjs ( date ) ) {
return date . clone ( ) ;
} // eslint-disable-next-line no-nested-ternary
var cfg = typeof c === 'object' ? c : { } ;
cfg . date = date ;
cfg . args = arguments ; // eslint-disable-line prefer-rest-params
return new Dayjs ( cfg ) ; // eslint-disable-line no-use-before-define
} ;
var wrapper = function wrapper ( date , instance ) {
return dayjs$1 ( date , {
locale : instance . $L ,
utc : instance . $u ,
x : instance . $x ,
$offset : instance . $offset // todo: refactor; do not use this.$offset in you code
} ) ;
} ;
var Utils = U ; // for plugin use
Utils . l = parseLocale ;
Utils . i = isDayjs ;
Utils . w = wrapper ;
var parseDate = function parseDate ( cfg ) {
var date = cfg . date ,
utc = cfg . utc ;
if ( date === null ) return new Date ( NaN ) ; // null is invalid
if ( Utils . u ( date ) ) return new Date ( ) ; // today
if ( date instanceof Date ) return new Date ( date ) ;
if ( typeof date === 'string' && ! /Z$/i . test ( date ) ) {
var d = date . match ( REGEX _PARSE ) ;
if ( d ) {
var m = d [ 2 ] - 1 || 0 ;
var ms = ( d [ 7 ] || '0' ) . substring ( 0 , 3 ) ;
if ( utc ) {
return new Date ( Date . UTC ( d [ 1 ] , m , d [ 3 ] || 1 , d [ 4 ] || 0 , d [ 5 ] || 0 , d [ 6 ] || 0 , ms ) ) ;
}
return new Date ( d [ 1 ] , m , d [ 3 ] || 1 , d [ 4 ] || 0 , d [ 5 ] || 0 , d [ 6 ] || 0 , ms ) ;
}
}
return new Date ( date ) ; // everything else
} ;
var Dayjs = /*#__PURE__*/ function ( ) {
function Dayjs ( cfg ) {
this . $L = parseLocale ( cfg . locale , null , true ) ;
this . parse ( cfg ) ; // for plugin
}
var _proto = Dayjs . prototype ;
_proto . parse = function parse ( cfg ) {
this . $d = parseDate ( cfg ) ;
this . $x = cfg . x || { } ;
this . init ( ) ;
} ;
_proto . init = function init ( ) {
var $d = this . $d ;
this . $y = $d . getFullYear ( ) ;
this . $M = $d . getMonth ( ) ;
this . $D = $d . getDate ( ) ;
this . $W = $d . getDay ( ) ;
this . $H = $d . getHours ( ) ;
this . $m = $d . getMinutes ( ) ;
this . $s = $d . getSeconds ( ) ;
this . $ms = $d . getMilliseconds ( ) ;
} // eslint-disable-next-line class-methods-use-this
;
_proto . $utils = function $utils ( ) {
return Utils ;
} ;
_proto . isValid = function isValid ( ) {
return ! ( this . $d . toString ( ) === INVALID _DATE _STRING ) ;
} ;
_proto . isSame = function isSame ( that , units ) {
var other = dayjs$1 ( that ) ;
return this . startOf ( units ) <= other && other <= this . endOf ( units ) ;
} ;
_proto . isAfter = function isAfter ( that , units ) {
return dayjs$1 ( that ) < this . startOf ( units ) ;
} ;
_proto . isBefore = function isBefore ( that , units ) {
return this . endOf ( units ) < dayjs$1 ( that ) ;
} ;
_proto . $g = function $g ( input , get , set ) {
if ( Utils . u ( input ) ) return this [ get ] ;
return this . set ( set , input ) ;
} ;
_proto . unix = function unix ( ) {
return Math . floor ( this . valueOf ( ) / 1000 ) ;
} ;
_proto . valueOf = function valueOf ( ) {
// timezone(hour) * 60 * 60 * 1000 => ms
return this . $d . getTime ( ) ;
} ;
_proto . startOf = function startOf ( units , _startOf ) {
var _this = this ;
// startOf -> endOf
var isStartOf = ! Utils . u ( _startOf ) ? _startOf : true ;
var unit = Utils . p ( units ) ;
var instanceFactory = function instanceFactory ( d , m ) {
var ins = Utils . w ( _this . $u ? Date . UTC ( _this . $y , m , d ) : new Date ( _this . $y , m , d ) , _this ) ;
return isStartOf ? ins : ins . endOf ( D ) ;
} ;
var instanceFactorySet = function instanceFactorySet ( method , slice ) {
var argumentStart = [ 0 , 0 , 0 , 0 ] ;
var argumentEnd = [ 23 , 59 , 59 , 999 ] ;
return Utils . w ( _this . toDate ( ) [ method ] . apply ( // eslint-disable-line prefer-spread
_this . toDate ( 's' ) , ( isStartOf ? argumentStart : argumentEnd ) . slice ( slice ) ) , _this ) ;
} ;
var $W = this . $W ,
$M = this . $M ,
$D = this . $D ;
var utcPad = "set" + ( this . $u ? 'UTC' : '' ) ;
switch ( unit ) {
case Y :
return isStartOf ? instanceFactory ( 1 , 0 ) : instanceFactory ( 31 , 11 ) ;
case M :
return isStartOf ? instanceFactory ( 1 , $M ) : instanceFactory ( 0 , $M + 1 ) ;
case W :
{
var weekStart = this . $locale ( ) . weekStart || 0 ;
var gap = ( $W < weekStart ? $W + 7 : $W ) - weekStart ;
return instanceFactory ( isStartOf ? $D - gap : $D + ( 6 - gap ) , $M ) ;
}
case D :
case DATE :
return instanceFactorySet ( utcPad + "Hours" , 0 ) ;
case H :
return instanceFactorySet ( utcPad + "Minutes" , 1 ) ;
case MIN :
return instanceFactorySet ( utcPad + "Seconds" , 2 ) ;
case S :
return instanceFactorySet ( utcPad + "Milliseconds" , 3 ) ;
default :
return this . clone ( ) ;
}
} ;
_proto . endOf = function endOf ( arg ) {
return this . startOf ( arg , false ) ;
} ;
_proto . $set = function $set ( units , _int ) {
var _C$D$C$DATE$C$M$C$Y$C ;
// private set
var unit = Utils . p ( units ) ;
var utcPad = "set" + ( this . $u ? 'UTC' : '' ) ;
var name = ( _C$D$C$DATE$C$M$C$Y$C = { } , _C$D$C$DATE$C$M$C$Y$C [ D ] = utcPad + "Date" , _C$D$C$DATE$C$M$C$Y$C [ DATE ] = utcPad + "Date" , _C$D$C$DATE$C$M$C$Y$C [ M ] = utcPad + "Month" , _C$D$C$DATE$C$M$C$Y$C [ Y ] = utcPad + "FullYear" , _C$D$C$DATE$C$M$C$Y$C [ H ] = utcPad + "Hours" , _C$D$C$DATE$C$M$C$Y$C [ MIN ] = utcPad + "Minutes" , _C$D$C$DATE$C$M$C$Y$C [ S ] = utcPad + "Seconds" , _C$D$C$DATE$C$M$C$Y$C [ MS ] = utcPad + "Milliseconds" , _C$D$C$DATE$C$M$C$Y$C ) [ unit ] ;
var arg = unit === D ? this . $D + ( _int - this . $W ) : _int ;
if ( unit === M || unit === Y ) {
// clone is for badMutable plugin
var date = this . clone ( ) . set ( DATE , 1 ) ;
date . $d [ name ] ( arg ) ;
date . init ( ) ;
this . $d = date . set ( DATE , Math . min ( this . $D , date . daysInMonth ( ) ) ) . $d ;
} else if ( name ) this . $d [ name ] ( arg ) ;
this . init ( ) ;
return this ;
} ;
_proto . set = function set ( string , _int2 ) {
return this . clone ( ) . $set ( string , _int2 ) ;
} ;
_proto . get = function get ( unit ) {
return this [ Utils . p ( unit ) ] ( ) ;
} ;
_proto . add = function add ( number , units ) {
var _this2 = this ,
_C$MIN$C$H$C$S$unit ;
number = Number ( number ) ; // eslint-disable-line no-param-reassign
var unit = Utils . p ( units ) ;
var instanceFactorySet = function instanceFactorySet ( n ) {
var d = dayjs$1 ( _this2 ) ;
return Utils . w ( d . date ( d . date ( ) + Math . round ( n * number ) ) , _this2 ) ;
} ;
if ( unit === M ) {
return this . set ( M , this . $M + number ) ;
}
if ( unit === Y ) {
return this . set ( Y , this . $y + number ) ;
}
if ( unit === D ) {
return instanceFactorySet ( 1 ) ;
}
if ( unit === W ) {
return instanceFactorySet ( 7 ) ;
}
var step = ( _C$MIN$C$H$C$S$unit = { } , _C$MIN$C$H$C$S$unit [ MIN ] = MILLISECONDS _A _MINUTE , _C$MIN$C$H$C$S$unit [ H ] = MILLISECONDS _A _HOUR , _C$MIN$C$H$C$S$unit [ S ] = MILLISECONDS _A _SECOND , _C$MIN$C$H$C$S$unit ) [ unit ] || 1 ; // ms
var nextTimeStamp = this . $d . getTime ( ) + number * step ;
return Utils . w ( nextTimeStamp , this ) ;
} ;
_proto . subtract = function subtract ( number , string ) {
return this . add ( number * - 1 , string ) ;
} ;
_proto . format = function format ( formatStr ) {
var _this3 = this ;
if ( ! this . isValid ( ) ) return INVALID _DATE _STRING ;
var str = formatStr || FORMAT _DEFAULT ;
var zoneStr = Utils . z ( this ) ;
var locale = this . $locale ( ) ;
var $H = this . $H ,
$m = this . $m ,
$M = this . $M ;
var weekdays = locale . weekdays ,
months = locale . months ,
meridiem = locale . meridiem ;
var getShort = function getShort ( arr , index , full , length ) {
return arr && ( arr [ index ] || arr ( _this3 , str ) ) || full [ index ] . substr ( 0 , length ) ;
} ;
var get$H = function get$H ( num ) {
return Utils . s ( $H % 12 || 12 , num , '0' ) ;
} ;
var meridiemFunc = meridiem || function ( hour , minute , isLowercase ) {
var m = hour < 12 ? 'AM' : 'PM' ;
return isLowercase ? m . toLowerCase ( ) : m ;
} ;
var matches = {
YY : String ( this . $y ) . slice ( - 2 ) ,
YYYY : this . $y ,
M : $M + 1 ,
MM : Utils . s ( $M + 1 , 2 , '0' ) ,
MMM : getShort ( locale . monthsShort , $M , months , 3 ) ,
MMMM : getShort ( months , $M ) ,
D : this . $D ,
DD : Utils . s ( this . $D , 2 , '0' ) ,
d : String ( this . $W ) ,
dd : getShort ( locale . weekdaysMin , this . $W , weekdays , 2 ) ,
ddd : getShort ( locale . weekdaysShort , this . $W , weekdays , 3 ) ,
dddd : weekdays [ this . $W ] ,
H : String ( $H ) ,
HH : Utils . s ( $H , 2 , '0' ) ,
h : get$H ( 1 ) ,
hh : get$H ( 2 ) ,
a : meridiemFunc ( $H , $m , true ) ,
A : meridiemFunc ( $H , $m , false ) ,
m : String ( $m ) ,
mm : Utils . s ( $m , 2 , '0' ) ,
s : String ( this . $s ) ,
ss : Utils . s ( this . $s , 2 , '0' ) ,
SSS : Utils . s ( this . $ms , 3 , '0' ) ,
Z : zoneStr // 'ZZ' logic below
} ;
return str . replace ( REGEX _FORMAT , function ( match , $1 ) {
return $1 || matches [ match ] || zoneStr . replace ( ':' , '' ) ;
} ) ; // 'ZZ'
} ;
_proto . utcOffset = function utcOffset ( ) {
// Because a bug at FF24, we're rounding the timezone offset around 15 minutes
// https://github.com/moment/moment/pull/1871
return - Math . round ( this . $d . getTimezoneOffset ( ) / 15 ) * 15 ;
} ;
_proto . diff = function diff ( input , units , _float ) {
var _C$Y$C$M$C$Q$C$W$C$D$ ;
var unit = Utils . p ( units ) ;
var that = dayjs$1 ( input ) ;
var zoneDelta = ( that . utcOffset ( ) - this . utcOffset ( ) ) * MILLISECONDS _A _MINUTE ;
var diff = this - that ;
var result = Utils . m ( this , that ) ;
result = ( _C$Y$C$M$C$Q$C$W$C$D$ = { } , _C$Y$C$M$C$Q$C$W$C$D$ [ Y ] = result / 12 , _C$Y$C$M$C$Q$C$W$C$D$ [ M ] = result , _C$Y$C$M$C$Q$C$W$C$D$ [ Q ] = result / 3 , _C$Y$C$M$C$Q$C$W$C$D$ [ W ] = ( diff - zoneDelta ) / MILLISECONDS _A _WEEK , _C$Y$C$M$C$Q$C$W$C$D$ [ D ] = ( diff - zoneDelta ) / MILLISECONDS _A _DAY , _C$Y$C$M$C$Q$C$W$C$D$ [ H ] = diff / MILLISECONDS _A _HOUR , _C$Y$C$M$C$Q$C$W$C$D$ [ MIN ] = diff / MILLISECONDS _A _MINUTE , _C$Y$C$M$C$Q$C$W$C$D$ [ S ] = diff / MILLISECONDS _A _SECOND , _C$Y$C$M$C$Q$C$W$C$D$ ) [ unit ] || diff ; // milliseconds
return _float ? result : Utils . a ( result ) ;
} ;
_proto . daysInMonth = function daysInMonth ( ) {
return this . endOf ( M ) . $D ;
} ;
_proto . $locale = function $locale ( ) {
// get locale object
return Ls [ this . $L ] ;
} ;
_proto . locale = function locale ( preset , object ) {
if ( ! preset ) return this . $L ;
var that = this . clone ( ) ;
var nextLocaleName = parseLocale ( preset , object , true ) ;
if ( nextLocaleName ) that . $L = nextLocaleName ;
return that ;
} ;
_proto . clone = function clone ( ) {
return Utils . w ( this . $d , this ) ;
} ;
_proto . toDate = function toDate ( ) {
return new Date ( this . valueOf ( ) ) ;
} ;
_proto . toJSON = function toJSON ( ) {
return this . isValid ( ) ? this . toISOString ( ) : null ;
} ;
_proto . toISOString = function toISOString ( ) {
// ie 8 return
// new Dayjs(this.valueOf() + this.$d.getTimezoneOffset() * 60000)
// .format('YYYY-MM-DDTHH:mm:ss.SSS[Z]')
return this . $d . toISOString ( ) ;
} ;
_proto . toString = function toString ( ) {
return this . $d . toUTCString ( ) ;
} ;
return Dayjs ;
} ( ) ;
var proto = Dayjs . prototype ;
dayjs$1 . prototype = proto ;
[ [ '$ms' , MS ] , [ '$s' , S ] , [ '$m' , MIN ] , [ '$H' , H ] , [ '$W' , D ] , [ '$M' , M ] , [ '$y' , Y ] , [ '$D' , DATE ] ] . forEach ( function ( g ) {
proto [ g [ 1 ] ] = function ( input ) {
return this . $g ( input , g [ 0 ] , g [ 1 ] ) ;
} ;
} ) ;
dayjs$1 . extend = function ( plugin , option ) {
if ( ! plugin . $i ) {
// install plugin only once
plugin ( option , Dayjs , dayjs$1 ) ;
plugin . $i = true ;
}
return dayjs$1 ;
} ;
dayjs$1 . locale = parseLocale ;
dayjs$1 . isDayjs = isDayjs ;
dayjs$1 . unix = function ( timestamp ) {
return dayjs$1 ( timestamp * 1e3 ) ;
} ;
dayjs$1 . en = Ls [ L ] ;
dayjs$1 . Ls = Ls ;
dayjs$1 . p = { } ;
var esm = /*#__PURE__*/ Object . freeze ( {
_ _proto _ _ : null ,
'default' : dayjs$1
} ) ;
var require$$0 = /*@__PURE__*/ getAugmentedNamespace ( esm ) ;
var _ _importDefault$I = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( years , "__esModule" , { value : true } ) ;
years . findYearClosestToRef = years . findMostLikelyADYear = void 0 ;
const dayjs _1$s = _ _importDefault$I ( require$$0 ) ;
function findMostLikelyADYear ( yearNumber ) {
if ( yearNumber < 100 ) {
if ( yearNumber > 50 ) {
yearNumber = yearNumber + 1900 ;
}
else {
yearNumber = yearNumber + 2000 ;
}
}
return yearNumber ;
}
years . findMostLikelyADYear = findMostLikelyADYear ;
function findYearClosestToRef ( refDate , day , month ) {
const refMoment = ( 0 , dayjs _1$s . default ) ( refDate ) ;
let dateMoment = refMoment ;
dateMoment = dateMoment . month ( month - 1 ) ;
dateMoment = dateMoment . date ( day ) ;
dateMoment = dateMoment . year ( refMoment . year ( ) ) ;
const nextYear = dateMoment . add ( 1 , "y" ) ;
const lastYear = dateMoment . add ( - 1 , "y" ) ;
if ( Math . abs ( nextYear . diff ( refMoment ) ) < Math . abs ( dateMoment . diff ( refMoment ) ) ) {
dateMoment = nextYear ;
}
else if ( Math . abs ( lastYear . diff ( refMoment ) ) < Math . abs ( dateMoment . diff ( refMoment ) ) ) {
dateMoment = lastYear ;
}
return dateMoment . year ( ) ;
}
years . findYearClosestToRef = findYearClosestToRef ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . parseTimeUnits = exports . TIME _UNITS _PATTERN = exports . parseYear = exports . YEAR _PATTERN = exports . parseOrdinalNumberPattern = exports . ORDINAL _NUMBER _PATTERN = exports . parseNumberPattern = exports . NUMBER _PATTERN = exports . TIME _UNIT _DICTIONARY = exports . ORDINAL _WORD _DICTIONARY = exports . INTEGER _WORD _DICTIONARY = exports . MONTH _DICTIONARY = exports . FULL _MONTH _NAME _DICTIONARY = exports . WEEKDAY _DICTIONARY = void 0 ;
const pattern _1 = pattern ;
const years _1 = years ;
exports . WEEKDAY _DICTIONARY = {
sunday : 0 ,
sun : 0 ,
"sun." : 0 ,
monday : 1 ,
mon : 1 ,
"mon." : 1 ,
tuesday : 2 ,
tue : 2 ,
"tue." : 2 ,
wednesday : 3 ,
wed : 3 ,
"wed." : 3 ,
thursday : 4 ,
thurs : 4 ,
"thurs." : 4 ,
thur : 4 ,
"thur." : 4 ,
thu : 4 ,
"thu." : 4 ,
friday : 5 ,
fri : 5 ,
"fri." : 5 ,
saturday : 6 ,
sat : 6 ,
"sat." : 6 ,
} ;
exports . FULL _MONTH _NAME _DICTIONARY = {
january : 1 ,
february : 2 ,
march : 3 ,
april : 4 ,
may : 5 ,
june : 6 ,
july : 7 ,
august : 8 ,
september : 9 ,
october : 10 ,
november : 11 ,
december : 12 ,
} ;
exports . MONTH _DICTIONARY = Object . assign ( Object . assign ( { } , exports . FULL _MONTH _NAME _DICTIONARY ) , { jan : 1 , "jan." : 1 , feb : 2 , "feb." : 2 , mar : 3 , "mar." : 3 , apr : 4 , "apr." : 4 , jun : 6 , "jun." : 6 , jul : 7 , "jul." : 7 , aug : 8 , "aug." : 8 , sep : 9 , "sep." : 9 , sept : 9 , "sept." : 9 , oct : 10 , "oct." : 10 , nov : 11 , "nov." : 11 , dec : 12 , "dec." : 12 } ) ;
exports . INTEGER _WORD _DICTIONARY = {
one : 1 ,
two : 2 ,
three : 3 ,
four : 4 ,
five : 5 ,
six : 6 ,
seven : 7 ,
eight : 8 ,
nine : 9 ,
ten : 10 ,
eleven : 11 ,
twelve : 12 ,
} ;
exports . ORDINAL _WORD _DICTIONARY = {
first : 1 ,
second : 2 ,
third : 3 ,
fourth : 4 ,
fifth : 5 ,
sixth : 6 ,
seventh : 7 ,
eighth : 8 ,
ninth : 9 ,
tenth : 10 ,
eleventh : 11 ,
twelfth : 12 ,
thirteenth : 13 ,
fourteenth : 14 ,
fifteenth : 15 ,
sixteenth : 16 ,
seventeenth : 17 ,
eighteenth : 18 ,
nineteenth : 19 ,
twentieth : 20 ,
"twenty first" : 21 ,
"twenty-first" : 21 ,
"twenty second" : 22 ,
"twenty-second" : 22 ,
"twenty third" : 23 ,
"twenty-third" : 23 ,
"twenty fourth" : 24 ,
"twenty-fourth" : 24 ,
"twenty fifth" : 25 ,
"twenty-fifth" : 25 ,
"twenty sixth" : 26 ,
"twenty-sixth" : 26 ,
"twenty seventh" : 27 ,
"twenty-seventh" : 27 ,
"twenty eighth" : 28 ,
"twenty-eighth" : 28 ,
"twenty ninth" : 29 ,
"twenty-ninth" : 29 ,
"thirtieth" : 30 ,
"thirty first" : 31 ,
"thirty-first" : 31 ,
} ;
exports . TIME _UNIT _DICTIONARY = {
sec : "second" ,
second : "second" ,
seconds : "second" ,
min : "minute" ,
mins : "minute" ,
minute : "minute" ,
minutes : "minute" ,
h : "hour" ,
hr : "hour" ,
hrs : "hour" ,
hour : "hour" ,
hours : "hour" ,
day : "d" ,
days : "d" ,
week : "week" ,
weeks : "week" ,
month : "month" ,
months : "month" ,
y : "year" ,
yr : "year" ,
year : "year" ,
years : "year" ,
} ;
exports . NUMBER _PATTERN = ` (?: ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . INTEGER _WORD _DICTIONARY ) } |[0-9]+|[0-9]+ \\ .[0-9]+|half(?: \\ s{0,2}an?)?|an? \\ b(?: \\ s{0,2}few)?|few|several|a? \\ s{0,2}couple \\ s{0,2}(?:of)?) ` ;
function parseNumberPattern ( match ) {
const num = match . toLowerCase ( ) ;
if ( exports . INTEGER _WORD _DICTIONARY [ num ] !== undefined ) {
return exports . INTEGER _WORD _DICTIONARY [ num ] ;
}
else if ( num === "a" || num === "an" ) {
return 1 ;
}
else if ( num . match ( /few/ ) ) {
return 3 ;
}
else if ( num . match ( /half/ ) ) {
return 0.5 ;
}
else if ( num . match ( /couple/ ) ) {
return 2 ;
}
else if ( num . match ( /several/ ) ) {
return 7 ;
}
return parseFloat ( num ) ;
}
exports . parseNumberPattern = parseNumberPattern ;
exports . ORDINAL _NUMBER _PATTERN = ` (?: ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . ORDINAL _WORD _DICTIONARY ) } |[0-9]{1,2}(?:st|nd|rd|th)?) ` ;
function parseOrdinalNumberPattern ( match ) {
let num = match . toLowerCase ( ) ;
if ( exports . ORDINAL _WORD _DICTIONARY [ num ] !== undefined ) {
return exports . ORDINAL _WORD _DICTIONARY [ num ] ;
}
num = num . replace ( /(?:st|nd|rd|th)$/i , "" ) ;
return parseInt ( num ) ;
}
exports . parseOrdinalNumberPattern = parseOrdinalNumberPattern ;
exports . YEAR _PATTERN = ` (?:[1-9][0-9]{0,3} \\ s{0,2}(?:BE|AD|BC|BCE|CE)|[1-2][0-9]{3}|[5-9][0-9]) ` ;
function parseYear ( match ) {
if ( /BE/i . test ( match ) ) {
match = match . replace ( /BE/i , "" ) ;
return parseInt ( match ) - 543 ;
}
if ( /BCE?/i . test ( match ) ) {
match = match . replace ( /BCE?/i , "" ) ;
return - parseInt ( match ) ;
}
if ( /(AD|CE)/i . test ( match ) ) {
match = match . replace ( /(AD|CE)/i , "" ) ;
return parseInt ( match ) ;
}
const rawYearNumber = parseInt ( match ) ;
return ( 0 , years _1 . findMostLikelyADYear ) ( rawYearNumber ) ;
}
exports . parseYear = parseYear ;
const SINGLE _TIME _UNIT _PATTERN = ` ( ${ exports . NUMBER _PATTERN } ) \\ s{0,3}( ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . TIME _UNIT _DICTIONARY ) } ) ` ;
const SINGLE _TIME _UNIT _REGEX = new RegExp ( SINGLE _TIME _UNIT _PATTERN , "i" ) ;
exports . TIME _UNITS _PATTERN = ( 0 , pattern _1 . repeatedTimeunitPattern ) ( ` (?:(?:about|around) \\ s{0,3})? ` , SINGLE _TIME _UNIT _PATTERN ) ;
function parseTimeUnits ( timeunitText ) {
const fragments = { } ;
let remainingText = timeunitText ;
let match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
while ( match ) {
collectDateTimeFragment ( fragments , match ) ;
remainingText = remainingText . substring ( match [ 0 ] . length ) . trim ( ) ;
match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
}
return fragments ;
}
exports . parseTimeUnits = parseTimeUnits ;
function collectDateTimeFragment ( fragments , match ) {
const num = parseNumberPattern ( match [ 1 ] ) ;
const unit = exports . TIME _UNIT _DICTIONARY [ match [ 2 ] . toLowerCase ( ) ] ;
fragments [ unit ] = num ;
}
} ( constants$7 ) ) ;
var results = { } ;
var quarterOfYear = { exports : { } } ;
( function ( module , exports ) {
! function ( t , n ) { module . exports = n ( ) ; } ( commonjsGlobal , function ( ) { var t = "month" , n = "quarter" ; return function ( r , i ) { var e = i . prototype ; e . quarter = function ( t ) { return this . $utils ( ) . u ( t ) ? Math . ceil ( ( this . month ( ) + 1 ) / 3 ) : this . month ( this . month ( ) % 3 + 3 * ( t - 1 ) ) } ; var u = e . add ; e . add = function ( r , i ) { return r = Number ( r ) , this . $utils ( ) . p ( i ) === n ? this . add ( 3 * r , t ) : u . bind ( this ) ( r , i ) } ; var s = e . startOf ; e . startOf = function ( r , i ) { var e = this . $utils ( ) , u = ! ! e . u ( i ) || i ; if ( e . p ( r ) === n ) { var a = this . quarter ( ) - 1 ; return u ? this . month ( 3 * a ) . startOf ( t ) . startOf ( "day" ) : this . month ( 3 * a + 2 ) . endOf ( t ) . endOf ( "day" ) } return s . bind ( this ) ( r , i ) } ; } } ) ;
} ( quarterOfYear ) ) ;
var weekday = { exports : { } } ;
( function ( module , exports ) {
! function ( e , t ) { module . exports = t ( ) ; } ( commonjsGlobal , function ( ) { return function ( e , t ) { t . prototype . weekday = function ( e ) { var t = this . $locale ( ) . weekStart || 0 , n = this . $W , i = ( n < t ? n + 7 : n ) - t ; return this . $utils ( ) . u ( e ) ? i : this . subtract ( i , "day" ) . add ( e , "day" ) } ; } } ) ;
} ( weekday ) ) ;
var dayjs = { } ;
Object . defineProperty ( dayjs , "__esModule" , { value : true } ) ;
dayjs . implySimilarTime = dayjs . assignSimilarTime = dayjs . assignSimilarDate = dayjs . assignTheNextDay = void 0 ;
const index _1$e = dist ;
function assignTheNextDay ( component , targetDayJs ) {
targetDayJs = targetDayJs . add ( 1 , "day" ) ;
assignSimilarDate ( component , targetDayJs ) ;
implySimilarTime ( component , targetDayJs ) ;
}
dayjs . assignTheNextDay = assignTheNextDay ;
function assignSimilarDate ( component , targetDayJs ) {
component . assign ( "day" , targetDayJs . date ( ) ) ;
component . assign ( "month" , targetDayJs . month ( ) + 1 ) ;
component . assign ( "year" , targetDayJs . year ( ) ) ;
}
dayjs . assignSimilarDate = assignSimilarDate ;
function assignSimilarTime ( component , targetDayJs ) {
component . assign ( "hour" , targetDayJs . hour ( ) ) ;
component . assign ( "minute" , targetDayJs . minute ( ) ) ;
component . assign ( "second" , targetDayJs . second ( ) ) ;
component . assign ( "millisecond" , targetDayJs . millisecond ( ) ) ;
if ( component . get ( "hour" ) < 12 ) {
component . assign ( "meridiem" , index _1$e . Meridiem . AM ) ;
}
else {
component . assign ( "meridiem" , index _1$e . Meridiem . PM ) ;
}
}
dayjs . assignSimilarTime = assignSimilarTime ;
function implySimilarTime ( component , targetDayJs ) {
component . imply ( "hour" , targetDayJs . hour ( ) ) ;
component . imply ( "minute" , targetDayJs . minute ( ) ) ;
component . imply ( "second" , targetDayJs . second ( ) ) ;
component . imply ( "millisecond" , targetDayJs . millisecond ( ) ) ;
}
dayjs . implySimilarTime = implySimilarTime ;
var timezone = { } ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . toTimezoneOffset = exports . TIMEZONE _ABBR _MAP = void 0 ;
exports . TIMEZONE _ABBR _MAP = {
ACDT : 630 ,
ACST : 570 ,
ADT : - 180 ,
AEDT : 660 ,
AEST : 600 ,
AFT : 270 ,
AKDT : - 480 ,
AKST : - 540 ,
ALMT : 360 ,
AMST : - 180 ,
AMT : - 240 ,
ANAST : 720 ,
ANAT : 720 ,
AQTT : 300 ,
ART : - 180 ,
AST : - 240 ,
AWDT : 540 ,
AWST : 480 ,
AZOST : 0 ,
AZOT : - 60 ,
AZST : 300 ,
AZT : 240 ,
BNT : 480 ,
BOT : - 240 ,
BRST : - 120 ,
BRT : - 180 ,
BST : 60 ,
BTT : 360 ,
CAST : 480 ,
CAT : 120 ,
CCT : 390 ,
CDT : - 300 ,
CEST : 120 ,
CET : 60 ,
CHADT : 825 ,
CHAST : 765 ,
CKT : - 600 ,
CLST : - 180 ,
CLT : - 240 ,
COT : - 300 ,
CST : - 360 ,
CVT : - 60 ,
CXT : 420 ,
ChST : 600 ,
DAVT : 420 ,
EASST : - 300 ,
EAST : - 360 ,
EAT : 180 ,
ECT : - 300 ,
EDT : - 240 ,
EEST : 180 ,
EET : 120 ,
EGST : 0 ,
EGT : - 60 ,
EST : - 300 ,
ET : - 300 ,
FJST : 780 ,
FJT : 720 ,
FKST : - 180 ,
FKT : - 240 ,
FNT : - 120 ,
GALT : - 360 ,
GAMT : - 540 ,
GET : 240 ,
GFT : - 180 ,
GILT : 720 ,
GMT : 0 ,
GST : 240 ,
GYT : - 240 ,
HAA : - 180 ,
HAC : - 300 ,
HADT : - 540 ,
HAE : - 240 ,
HAP : - 420 ,
HAR : - 360 ,
HAST : - 600 ,
HAT : - 90 ,
HAY : - 480 ,
HKT : 480 ,
HLV : - 210 ,
HNA : - 240 ,
HNC : - 360 ,
HNE : - 300 ,
HNP : - 480 ,
HNR : - 420 ,
HNT : - 150 ,
HNY : - 540 ,
HOVT : 420 ,
ICT : 420 ,
IDT : 180 ,
IOT : 360 ,
IRDT : 270 ,
IRKST : 540 ,
IRKT : 540 ,
IRST : 210 ,
IST : 330 ,
JST : 540 ,
KGT : 360 ,
KRAST : 480 ,
KRAT : 480 ,
KST : 540 ,
KUYT : 240 ,
LHDT : 660 ,
LHST : 630 ,
LINT : 840 ,
MAGST : 720 ,
MAGT : 720 ,
MART : - 510 ,
MAWT : 300 ,
MDT : - 360 ,
MESZ : 120 ,
MEZ : 60 ,
MHT : 720 ,
MMT : 390 ,
MSD : 240 ,
MSK : 180 ,
MST : - 420 ,
MUT : 240 ,
MVT : 300 ,
MYT : 480 ,
NCT : 660 ,
NDT : - 90 ,
NFT : 690 ,
NOVST : 420 ,
NOVT : 360 ,
NPT : 345 ,
NST : - 150 ,
NUT : - 660 ,
NZDT : 780 ,
NZST : 720 ,
OMSST : 420 ,
OMST : 420 ,
PDT : - 420 ,
PET : - 300 ,
PETST : 720 ,
PETT : 720 ,
PGT : 600 ,
PHOT : 780 ,
PHT : 480 ,
PKT : 300 ,
PMDT : - 120 ,
PMST : - 180 ,
PONT : 660 ,
PST : - 480 ,
PT : - 480 ,
PWT : 540 ,
PYST : - 180 ,
PYT : - 240 ,
RET : 240 ,
SAMT : 240 ,
SAST : 120 ,
SBT : 660 ,
SCT : 240 ,
SGT : 480 ,
SRT : - 180 ,
SST : - 660 ,
TAHT : - 600 ,
TFT : 300 ,
TJT : 300 ,
TKT : 780 ,
TLT : 540 ,
TMT : 300 ,
TVT : 720 ,
ULAT : 480 ,
UTC : 0 ,
UYST : - 120 ,
UYT : - 180 ,
UZT : 300 ,
VET : - 210 ,
VLAST : 660 ,
VLAT : 660 ,
VUT : 660 ,
WAST : 120 ,
WAT : 60 ,
WEST : 60 ,
WESZ : 60 ,
WET : 0 ,
WEZ : 0 ,
WFT : 720 ,
WGST : - 120 ,
WGT : - 180 ,
WIB : 420 ,
WIT : 540 ,
WITA : 480 ,
WST : 780 ,
WT : 0 ,
YAKST : 600 ,
YAKT : 600 ,
YAPT : 600 ,
YEKST : 360 ,
YEKT : 360 ,
} ;
function toTimezoneOffset ( timezoneInput ) {
var _a ;
if ( timezoneInput === null ) {
return null ;
}
if ( typeof timezoneInput === "number" ) {
return timezoneInput ;
}
return ( _a = exports . TIMEZONE _ABBR _MAP [ timezoneInput ] ) !== null && _a !== void 0 ? _a : 0 ;
}
exports . toTimezoneOffset = toTimezoneOffset ;
} ( timezone ) ) ;
var _ _importDefault$H = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( results , "__esModule" , { value : true } ) ;
results . ParsingResult = results . ParsingComponents = results . ReferenceWithTimezone = void 0 ;
const quarterOfYear _1 = _ _importDefault$H ( quarterOfYear . exports ) ;
const weekday _1 = _ _importDefault$H ( weekday . exports ) ;
const dayjs _1$r = _ _importDefault$H ( require$$0 ) ;
const dayjs _2$9 = dayjs ;
const timezone _1 = timezone ;
dayjs _1$r . default . extend ( quarterOfYear _1 . default ) ;
dayjs _1$r . default . extend ( weekday _1 . default ) ;
class ReferenceWithTimezone {
constructor ( input ) {
var _a ;
input = input !== null && input !== void 0 ? input : new Date ( ) ;
if ( input instanceof Date ) {
this . instant = input ;
this . timezoneOffset = - input . getTimezoneOffset ( ) ;
}
else {
this . instant = ( _a = input . instant ) !== null && _a !== void 0 ? _a : new Date ( ) ;
this . timezoneOffset = ( 0 , timezone _1 . toTimezoneOffset ) ( input . timezone ) ;
}
}
}
results . ReferenceWithTimezone = ReferenceWithTimezone ;
class ParsingComponents {
constructor ( reference , knownComponents ) {
this . reference = reference ;
this . knownValues = { } ;
this . impliedValues = { } ;
if ( knownComponents ) {
for ( const key in knownComponents ) {
this . knownValues [ key ] = knownComponents [ key ] ;
}
}
const refDayJs = ( 0 , dayjs _1$r . default ) ( reference . instant ) ;
this . imply ( "day" , refDayJs . date ( ) ) ;
this . imply ( "month" , refDayJs . month ( ) + 1 ) ;
this . imply ( "year" , refDayJs . year ( ) ) ;
this . imply ( "hour" , 12 ) ;
this . imply ( "minute" , 0 ) ;
this . imply ( "second" , 0 ) ;
this . imply ( "millisecond" , 0 ) ;
}
get ( component ) {
if ( component in this . knownValues ) {
return this . knownValues [ component ] ;
}
if ( component in this . impliedValues ) {
return this . impliedValues [ component ] ;
}
return null ;
}
isCertain ( component ) {
return component in this . knownValues ;
}
getCertainComponents ( ) {
return Object . keys ( this . knownValues ) ;
}
imply ( component , value ) {
if ( component in this . knownValues ) {
return this ;
}
this . impliedValues [ component ] = value ;
return this ;
}
assign ( component , value ) {
this . knownValues [ component ] = value ;
delete this . impliedValues [ component ] ;
return this ;
}
delete ( component ) {
delete this . knownValues [ component ] ;
delete this . impliedValues [ component ] ;
}
clone ( ) {
const component = new ParsingComponents ( this . reference ) ;
component . knownValues = { } ;
component . impliedValues = { } ;
for ( const key in this . knownValues ) {
component . knownValues [ key ] = this . knownValues [ key ] ;
}
for ( const key in this . impliedValues ) {
component . impliedValues [ key ] = this . impliedValues [ key ] ;
}
return component ;
}
isOnlyDate ( ) {
return ! this . isCertain ( "hour" ) && ! this . isCertain ( "minute" ) && ! this . isCertain ( "second" ) ;
}
isOnlyTime ( ) {
return ! this . isCertain ( "weekday" ) && ! this . isCertain ( "day" ) && ! this . isCertain ( "month" ) ;
}
isOnlyWeekdayComponent ( ) {
return this . isCertain ( "weekday" ) && ! this . isCertain ( "day" ) && ! this . isCertain ( "month" ) ;
}
isOnlyDayMonthComponent ( ) {
return this . isCertain ( "day" ) && this . isCertain ( "month" ) && ! this . isCertain ( "year" ) ;
}
isValidDate ( ) {
const date = this . dateWithoutTimezoneAdjustment ( ) ;
if ( date . getFullYear ( ) !== this . get ( "year" ) )
return false ;
if ( date . getMonth ( ) !== this . get ( "month" ) - 1 )
return false ;
if ( date . getDate ( ) !== this . get ( "day" ) )
return false ;
if ( this . get ( "hour" ) != null && date . getHours ( ) != this . get ( "hour" ) )
return false ;
if ( this . get ( "minute" ) != null && date . getMinutes ( ) != this . get ( "minute" ) )
return false ;
return true ;
}
toString ( ) {
return ` [ParsingComponents {knownValues: ${ JSON . stringify ( this . knownValues ) } , impliedValues: ${ JSON . stringify ( this . impliedValues ) } }] ` ;
}
dayjs ( ) {
return ( 0 , dayjs _1$r . default ) ( this . date ( ) ) ;
}
date ( ) {
const date = this . dateWithoutTimezoneAdjustment ( ) ;
return new Date ( date . getTime ( ) + this . getSystemTimezoneAdjustmentMinute ( date ) * 60000 ) ;
}
dateWithoutTimezoneAdjustment ( ) {
const date = new Date ( this . get ( "year" ) , this . get ( "month" ) - 1 , this . get ( "day" ) , this . get ( "hour" ) , this . get ( "minute" ) , this . get ( "second" ) , this . get ( "millisecond" ) ) ;
date . setFullYear ( this . get ( "year" ) ) ;
return date ;
}
getSystemTimezoneAdjustmentMinute ( date ) {
var _a , _b ;
if ( ! date || date . getTime ( ) < 0 ) {
date = new Date ( ) ;
}
const currentTimezoneOffset = - date . getTimezoneOffset ( ) ;
const targetTimezoneOffset = ( _b = ( _a = this . get ( "timezoneOffset" ) ) !== null && _a !== void 0 ? _a : this . reference . timezoneOffset ) !== null && _b !== void 0 ? _b : currentTimezoneOffset ;
return currentTimezoneOffset - targetTimezoneOffset ;
}
static createRelativeFromReference ( reference , fragments ) {
let date = ( 0 , dayjs _1$r . default ) ( reference . instant ) ;
for ( const key in fragments ) {
date = date . add ( fragments [ key ] , key ) ;
}
const components = new ParsingComponents ( reference ) ;
if ( fragments [ "hour" ] || fragments [ "minute" ] || fragments [ "second" ] ) {
( 0 , dayjs _2$9 . assignSimilarTime ) ( components , date ) ;
( 0 , dayjs _2$9 . assignSimilarDate ) ( components , date ) ;
if ( reference . timezoneOffset !== null ) {
components . assign ( "timezoneOffset" , - reference . instant . getTimezoneOffset ( ) ) ;
}
}
else {
( 0 , dayjs _2$9 . implySimilarTime ) ( components , date ) ;
if ( reference . timezoneOffset !== null ) {
components . imply ( "timezoneOffset" , - reference . instant . getTimezoneOffset ( ) ) ;
}
if ( fragments [ "d" ] ) {
components . assign ( "day" , date . date ( ) ) ;
components . assign ( "month" , date . month ( ) + 1 ) ;
components . assign ( "year" , date . year ( ) ) ;
}
else {
if ( fragments [ "week" ] ) {
components . imply ( "weekday" , date . day ( ) ) ;
}
components . imply ( "day" , date . date ( ) ) ;
if ( fragments [ "month" ] ) {
components . assign ( "month" , date . month ( ) + 1 ) ;
components . assign ( "year" , date . year ( ) ) ;
}
else {
components . imply ( "month" , date . month ( ) + 1 ) ;
if ( fragments [ "year" ] ) {
components . assign ( "year" , date . year ( ) ) ;
}
else {
components . imply ( "year" , date . year ( ) ) ;
}
}
}
}
return components ;
}
}
results . ParsingComponents = ParsingComponents ;
class ParsingResult {
constructor ( reference , index , text , start , end ) {
this . reference = reference ;
this . refDate = reference . instant ;
this . index = index ;
this . text = text ;
this . start = start || new ParsingComponents ( reference ) ;
this . end = end ;
}
clone ( ) {
const result = new ParsingResult ( this . reference , this . index , this . text ) ;
result . start = this . start ? this . start . clone ( ) : null ;
result . end = this . end ? this . end . clone ( ) : null ;
return result ;
}
date ( ) {
return this . start . date ( ) ;
}
toString ( ) {
return ` [ParsingResult {index: ${ this . index } , text: ' ${ this . text } ', ...}] ` ;
}
}
results . ParsingResult = ParsingResult ;
var AbstractParserWithWordBoundary = { } ;
Object . defineProperty ( AbstractParserWithWordBoundary , "__esModule" , { value : true } ) ;
AbstractParserWithWordBoundary . AbstractParserWithWordBoundaryChecking = void 0 ;
class AbstractParserWithWordBoundaryChecking {
constructor ( ) {
this . cachedInnerPattern = null ;
this . cachedPattern = null ;
}
pattern ( context ) {
const innerPattern = this . innerPattern ( context ) ;
if ( innerPattern == this . cachedInnerPattern ) {
return this . cachedPattern ;
}
this . cachedPattern = new RegExp ( ` ( \\ W|^) ${ innerPattern . source } ` , innerPattern . flags ) ;
this . cachedInnerPattern = innerPattern ;
return this . cachedPattern ;
}
extract ( context , match ) {
var _a ;
const header = ( _a = match [ 1 ] ) !== null && _a !== void 0 ? _a : "" ;
match . index = match . index + header . length ;
match [ 0 ] = match [ 0 ] . substring ( header . length ) ;
for ( let i = 2 ; i < match . length ; i ++ ) {
match [ i - 1 ] = match [ i ] ;
}
return this . innerExtract ( context , match ) ;
}
}
AbstractParserWithWordBoundary . AbstractParserWithWordBoundaryChecking = AbstractParserWithWordBoundaryChecking ;
Object . defineProperty ( ENTimeUnitWithinFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$C = constants$7 ;
const results _1$e = results ;
const AbstractParserWithWordBoundary _1$R = AbstractParserWithWordBoundary ;
const PATTERN _WITH _PREFIX = new RegExp ( ` (?:within|in|for) \\ s* ` +
` (?:(?:about|around|roughly|approximately|just) \\ s*(?:~ \\ s*)?)?( ${ constants _1$C . TIME _UNITS _PATTERN } )(?= \\ W| $ ) ` , "i" ) ;
const PATTERN _WITHOUT _PREFIX = new RegExp ( ` (?:(?:about|around|roughly|approximately|just) \\ s*(?:~ \\ s*)?)?( ${ constants _1$C . TIME _UNITS _PATTERN } )(?= \\ W| $ ) ` , "i" ) ;
class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary _1$R . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return context . option . forwardDate ? PATTERN _WITHOUT _PREFIX : PATTERN _WITH _PREFIX ;
}
innerExtract ( context , match ) {
const timeUnits = ( 0 , constants _1$C . parseTimeUnits ) ( match [ 1 ] ) ;
return results _1$e . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
}
ENTimeUnitWithinFormatParser$1 . default = ENTimeUnitWithinFormatParser ;
var ENMonthNameLittleEndianParser$1 = { } ;
Object . defineProperty ( ENMonthNameLittleEndianParser$1 , "__esModule" , { value : true } ) ;
const years _1$9 = years ;
const constants _1$B = constants$7 ;
const constants _2$7 = constants$7 ;
const constants _3$3 = constants$7 ;
const pattern _1$h = pattern ;
const AbstractParserWithWordBoundary _1$Q = AbstractParserWithWordBoundary ;
const PATTERN$B = new RegExp ( ` (?:on \\ s{0,3})? ` +
` ( ${ constants _3$3 . ORDINAL _NUMBER _PATTERN } ) ` +
` (?: ` +
` \\ s{0,3}(?:to| \\ -| \\ – \\ s{0,3} ` +
` ( ${ constants _3$3 . ORDINAL _NUMBER _PATTERN } ) ` +
")?" +
` (?:-|/| \\ s{0,3}(?:of)? \\ s{0,3}) ` +
` ( ${ ( 0 , pattern _1$h . matchAnyPattern ) ( constants _1$B . MONTH _DICTIONARY ) } ) ` +
"(?:" +
` (?:-|/|,? \\ s{0,3}) ` +
` ( ${ constants _2$7 . YEAR _PATTERN } (?![^ \\ s] \\ d)) ` +
")?" +
"(?=\\W|$)" , "i" ) ;
const DATE _GROUP$7 = 1 ;
const DATE _TO _GROUP$5 = 2 ;
const MONTH _NAME _GROUP$9 = 3 ;
const YEAR _GROUP$c = 4 ;
class ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundary _1$Q . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$B ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const month = constants _1$B . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$9 ] . toLowerCase ( ) ] ;
const day = ( 0 , constants _3$3 . parseOrdinalNumberPattern ) ( match [ DATE _GROUP$7 ] ) ;
if ( day > 31 ) {
match . index = match . index + match [ DATE _GROUP$7 ] . length ;
return null ;
}
result . start . assign ( "month" , month ) ;
result . start . assign ( "day" , day ) ;
if ( match [ YEAR _GROUP$c ] ) {
const yearNumber = ( 0 , constants _2$7 . parseYear ) ( match [ YEAR _GROUP$c ] ) ;
result . start . assign ( "year" , yearNumber ) ;
}
else {
const year = ( 0 , years _1$9 . findYearClosestToRef ) ( context . refDate , day , month ) ;
result . start . imply ( "year" , year ) ;
}
if ( match [ DATE _TO _GROUP$5 ] ) {
const endDate = ( 0 , constants _3$3 . parseOrdinalNumberPattern ) ( match [ DATE _TO _GROUP$5 ] ) ;
result . end = result . start . clone ( ) ;
result . end . assign ( "day" , endDate ) ;
}
return result ;
}
}
ENMonthNameLittleEndianParser$1 . default = ENMonthNameLittleEndianParser ;
var ENMonthNameMiddleEndianParser$1 = { } ;
Object . defineProperty ( ENMonthNameMiddleEndianParser$1 , "__esModule" , { value : true } ) ;
const years _1$8 = years ;
const constants _1$A = constants$7 ;
const constants _2$6 = constants$7 ;
const constants _3$2 = constants$7 ;
const pattern _1$g = pattern ;
const AbstractParserWithWordBoundary _1$P = AbstractParserWithWordBoundary ;
const PATTERN$A = new RegExp ( ` ( ${ ( 0 , pattern _1$g . matchAnyPattern ) ( constants _1$A . MONTH _DICTIONARY ) } ) ` +
"(?:-|/|\\s*,?\\s*)" +
` ( ${ constants _2$6 . ORDINAL _NUMBER _PATTERN } )(?! \\ s*(?:am|pm)) \\ s* ` +
"(?:" +
"(?:to|\\-)\\s*" +
` ( ${ constants _2$6 . ORDINAL _NUMBER _PATTERN } ) \\ s* ` +
")?" +
"(?:" +
"(?:-|/|\\s*,?\\s*)" +
` ( ${ constants _3$2 . YEAR _PATTERN } ) ` +
")?" +
"(?=\\W|$)(?!\\:\\d)" , "i" ) ;
const MONTH _NAME _GROUP$8 = 1 ;
const DATE _GROUP$6 = 2 ;
const DATE _TO _GROUP$4 = 3 ;
const YEAR _GROUP$b = 4 ;
class ENMonthNameMiddleEndianParser extends AbstractParserWithWordBoundary _1$P . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$A ;
}
innerExtract ( context , match ) {
const month = constants _1$A . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$8 ] . toLowerCase ( ) ] ;
const day = ( 0 , constants _2$6 . parseOrdinalNumberPattern ) ( match [ DATE _GROUP$6 ] ) ;
if ( day > 31 ) {
return null ;
}
const components = context . createParsingComponents ( {
day : day ,
month : month ,
} ) ;
if ( match [ YEAR _GROUP$b ] ) {
const year = ( 0 , constants _3$2 . parseYear ) ( match [ YEAR _GROUP$b ] ) ;
components . assign ( "year" , year ) ;
}
else {
const year = ( 0 , years _1$8 . findYearClosestToRef ) ( context . refDate , day , month ) ;
components . imply ( "year" , year ) ;
}
if ( ! match [ DATE _TO _GROUP$4 ] ) {
return components ;
}
const endDate = ( 0 , constants _2$6 . parseOrdinalNumberPattern ) ( match [ DATE _TO _GROUP$4 ] ) ;
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
result . start = components ;
result . end = components . clone ( ) ;
result . end . assign ( "day" , endDate ) ;
return result ;
}
}
ENMonthNameMiddleEndianParser$1 . default = ENMonthNameMiddleEndianParser ;
var ENMonthNameParser$1 = { } ;
Object . defineProperty ( ENMonthNameParser$1 , "__esModule" , { value : true } ) ;
const constants _1$z = constants$7 ;
const years _1$7 = years ;
const pattern _1$f = pattern ;
const constants _2$5 = constants$7 ;
const AbstractParserWithWordBoundary _1$O = AbstractParserWithWordBoundary ;
const PATTERN$z = new RegExp ( ` ((?:in) \\ s*)? ` +
` ( ${ ( 0 , pattern _1$f . matchAnyPattern ) ( constants _1$z . MONTH _DICTIONARY ) } ) ` +
` \\ s* ` +
` (?: ` +
` [,-]? \\ s*( ${ constants _2$5 . YEAR _PATTERN } )? ` +
")?" +
"(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)" , "i" ) ;
const PREFIX _GROUP$4 = 1 ;
const MONTH _NAME _GROUP$7 = 2 ;
const YEAR _GROUP$a = 3 ;
class ENMonthNameParser extends AbstractParserWithWordBoundary _1$O . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$z ;
}
innerExtract ( context , match ) {
const monthName = match [ MONTH _NAME _GROUP$7 ] . toLowerCase ( ) ;
if ( match [ 0 ] . length <= 3 && ! constants _1$z . FULL _MONTH _NAME _DICTIONARY [ monthName ] ) {
return null ;
}
const result = context . createParsingResult ( match . index + ( match [ PREFIX _GROUP$4 ] || "" ) . length , match . index + match [ 0 ] . length ) ;
result . start . imply ( "day" , 1 ) ;
const month = constants _1$z . MONTH _DICTIONARY [ monthName ] ;
result . start . assign ( "month" , month ) ;
if ( match [ YEAR _GROUP$a ] ) {
const year = ( 0 , constants _2$5 . parseYear ) ( match [ YEAR _GROUP$a ] ) ;
result . start . assign ( "year" , year ) ;
}
else {
const year = ( 0 , years _1$7 . findYearClosestToRef ) ( context . refDate , 1 , month ) ;
result . start . imply ( "year" , year ) ;
}
return result ;
}
}
ENMonthNameParser$1 . default = ENMonthNameParser ;
var ENCasualYearMonthDayParser$1 = { } ;
Object . defineProperty ( ENCasualYearMonthDayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$y = constants$7 ;
const pattern _1$e = pattern ;
const AbstractParserWithWordBoundary _1$N = AbstractParserWithWordBoundary ;
const PATTERN$y = new RegExp ( ` ([0-9]{4})[ \\ . \\ / \\ s] ` +
` (?:( ${ ( 0 , pattern _1$e . matchAnyPattern ) ( constants _1$y . MONTH _DICTIONARY ) } )|([0-9]{1,2}))[ \\ . \\ / \\ s] ` +
` ([0-9]{1,2}) ` +
"(?=\\W|$)" , "i" ) ;
const YEAR _NUMBER _GROUP$3 = 1 ;
const MONTH _NAME _GROUP$6 = 2 ;
const MONTH _NUMBER _GROUP$2 = 3 ;
const DATE _NUMBER _GROUP$2 = 4 ;
class ENCasualYearMonthDayParser extends AbstractParserWithWordBoundary _1$N . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$y ;
}
innerExtract ( context , match ) {
const month = match [ MONTH _NUMBER _GROUP$2 ]
? parseInt ( match [ MONTH _NUMBER _GROUP$2 ] )
: constants _1$y . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$6 ] . toLowerCase ( ) ] ;
if ( month < 1 || month > 12 ) {
return null ;
}
const year = parseInt ( match [ YEAR _NUMBER _GROUP$3 ] ) ;
const day = parseInt ( match [ DATE _NUMBER _GROUP$2 ] ) ;
return {
day : day ,
month : month ,
year : year ,
} ;
}
}
ENCasualYearMonthDayParser$1 . default = ENCasualYearMonthDayParser ;
var ENSlashMonthFormatParser$1 = { } ;
Object . defineProperty ( ENSlashMonthFormatParser$1 , "__esModule" , { value : true } ) ;
const AbstractParserWithWordBoundary _1$M = AbstractParserWithWordBoundary ;
const PATTERN$x = new RegExp ( "([0-9]|0[1-9]|1[012])/([0-9]{4})" + "" , "i" ) ;
const MONTH _GROUP$4 = 1 ;
const YEAR _GROUP$9 = 2 ;
class ENSlashMonthFormatParser extends AbstractParserWithWordBoundary _1$M . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$x ;
}
innerExtract ( context , match ) {
const year = parseInt ( match [ YEAR _GROUP$9 ] ) ;
const month = parseInt ( match [ MONTH _GROUP$4 ] ) ;
return context . createParsingComponents ( ) . imply ( "day" , 1 ) . assign ( "month" , month ) . assign ( "year" , year ) ;
}
}
ENSlashMonthFormatParser$1 . default = ENSlashMonthFormatParser ;
var ENTimeExpressionParser$1 = { } ;
var AbstractTimeExpressionParser$1 = { } ;
Object . defineProperty ( AbstractTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
AbstractTimeExpressionParser$1 . AbstractTimeExpressionParser = void 0 ;
const index _1$d = dist ;
function primaryTimePattern ( primaryPrefix , primarySuffix ) {
return new RegExp ( "(^|\\s|T|\\b)" +
` ${ primaryPrefix } ` +
"(\\d{1,4})" +
"(?:" +
"(?:\\.|\\:|\\： +
"(\\d{1,2})" +
"(?:" +
"(?:\\:|\\： +
"(\\d{2})" +
"(?:\\.(\\d{1,6}))?" +
")?" +
")?" +
"(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?" +
` ${ primarySuffix } ` , "i" ) ;
}
function followingTimePatten ( followingPhase , followingSuffix ) {
return new RegExp ( ` ^( ${ followingPhase } ) ` +
"(\\d{1,4})" +
"(?:" +
"(?:\\.|\\:|\\： +
"(\\d{1,2})" +
"(?:" +
"(?:\\.|\\:|\\： +
"(\\d{1,2})(?:\\.(\\d{1,6}))?" +
")?" +
")?" +
"(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?" +
` ${ followingSuffix } ` , "i" ) ;
}
const HOUR _GROUP$3 = 2 ;
const MINUTE _GROUP$3 = 3 ;
const SECOND _GROUP$3 = 4 ;
const MILLI _SECOND _GROUP = 5 ;
const AM _PM _HOUR _GROUP$3 = 6 ;
class AbstractTimeExpressionParser {
constructor ( strictMode = false ) {
this . cachedPrimaryPrefix = null ;
this . cachedPrimarySuffix = null ;
this . cachedPrimaryTimePattern = null ;
this . cachedFollowingPhase = null ;
this . cachedFollowingSuffix = null ;
this . cachedFollowingTimePatten = null ;
this . strictMode = strictMode ;
}
primarySuffix ( ) {
return "(?=\\W|$)" ;
}
followingSuffix ( ) {
return "(?=\\W|$)" ;
}
pattern ( context ) {
return this . getPrimaryTimePatternThroughCache ( ) ;
}
extract ( context , match ) {
const startComponents = this . extractPrimaryTimeComponents ( context , match ) ;
if ( ! startComponents ) {
match . index += match [ 0 ] . length ;
return null ;
}
const index = match . index + match [ 1 ] . length ;
const text = match [ 0 ] . substring ( match [ 1 ] . length ) ;
const result = context . createParsingResult ( index , text , startComponents ) ;
match . index += match [ 0 ] . length ;
const remainingText = context . text . substring ( match . index ) ;
const followingPattern = this . getFollowingTimePatternThroughCache ( ) ;
const followingMatch = followingPattern . exec ( remainingText ) ;
if ( ! followingMatch ||
followingMatch [ 0 ] . match ( /^\s*([+-])\s*\d{3,4}$/ ) ) {
return this . checkAndReturnWithoutFollowingPattern ( result ) ;
}
result . end = this . extractFollowingTimeComponents ( context , followingMatch , result ) ;
if ( result . end ) {
result . text += followingMatch [ 0 ] ;
}
return this . checkAndReturnWithFollowingPattern ( result ) ;
}
extractPrimaryTimeComponents ( context , match , strict = false ) {
const components = context . createParsingComponents ( ) ;
let minute = 0 ;
let meridiem = null ;
let hour = parseInt ( match [ HOUR _GROUP$3 ] ) ;
if ( hour > 100 ) {
if ( this . strictMode || match [ MINUTE _GROUP$3 ] != null ) {
return null ;
}
minute = hour % 100 ;
hour = Math . floor ( hour / 100 ) ;
}
if ( hour > 24 ) {
return null ;
}
if ( match [ MINUTE _GROUP$3 ] != null ) {
if ( match [ MINUTE _GROUP$3 ] . length == 1 && ! match [ AM _PM _HOUR _GROUP$3 ] ) {
return null ;
}
minute = parseInt ( match [ MINUTE _GROUP$3 ] ) ;
}
if ( minute >= 60 ) {
return null ;
}
if ( hour > 12 ) {
meridiem = index _1$d . Meridiem . PM ;
}
if ( match [ AM _PM _HOUR _GROUP$3 ] != null ) {
if ( hour > 12 )
return null ;
const ampm = match [ AM _PM _HOUR _GROUP$3 ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = index _1$d . Meridiem . AM ;
if ( hour == 12 ) {
hour = 0 ;
}
}
if ( ampm == "p" ) {
meridiem = index _1$d . Meridiem . PM ;
if ( hour != 12 ) {
hour += 12 ;
}
}
}
components . assign ( "hour" , hour ) ;
components . assign ( "minute" , minute ) ;
if ( meridiem !== null ) {
components . assign ( "meridiem" , meridiem ) ;
}
else {
if ( hour < 12 ) {
components . imply ( "meridiem" , index _1$d . Meridiem . AM ) ;
}
else {
components . imply ( "meridiem" , index _1$d . Meridiem . PM ) ;
}
}
if ( match [ MILLI _SECOND _GROUP ] != null ) {
const millisecond = parseInt ( match [ MILLI _SECOND _GROUP ] . substring ( 0 , 3 ) ) ;
if ( millisecond >= 1000 )
return null ;
components . assign ( "millisecond" , millisecond ) ;
}
if ( match [ SECOND _GROUP$3 ] != null ) {
const second = parseInt ( match [ SECOND _GROUP$3 ] ) ;
if ( second >= 60 )
return null ;
components . assign ( "second" , second ) ;
}
return components ;
}
extractFollowingTimeComponents ( context , match , result ) {
const components = context . createParsingComponents ( ) ;
if ( match [ MILLI _SECOND _GROUP ] != null ) {
const millisecond = parseInt ( match [ MILLI _SECOND _GROUP ] . substring ( 0 , 3 ) ) ;
if ( millisecond >= 1000 )
return null ;
components . assign ( "millisecond" , millisecond ) ;
}
if ( match [ SECOND _GROUP$3 ] != null ) {
const second = parseInt ( match [ SECOND _GROUP$3 ] ) ;
if ( second >= 60 )
return null ;
components . assign ( "second" , second ) ;
}
let hour = parseInt ( match [ HOUR _GROUP$3 ] ) ;
let minute = 0 ;
let meridiem = - 1 ;
if ( match [ MINUTE _GROUP$3 ] != null ) {
minute = parseInt ( match [ MINUTE _GROUP$3 ] ) ;
}
else if ( hour > 100 ) {
minute = hour % 100 ;
hour = Math . floor ( hour / 100 ) ;
}
if ( minute >= 60 || hour > 24 ) {
return null ;
}
if ( hour >= 12 ) {
meridiem = index _1$d . Meridiem . PM ;
}
if ( match [ AM _PM _HOUR _GROUP$3 ] != null ) {
if ( hour > 12 ) {
return null ;
}
const ampm = match [ AM _PM _HOUR _GROUP$3 ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = index _1$d . Meridiem . AM ;
if ( hour == 12 ) {
hour = 0 ;
if ( ! components . isCertain ( "day" ) ) {
components . imply ( "day" , components . get ( "day" ) + 1 ) ;
}
}
}
if ( ampm == "p" ) {
meridiem = index _1$d . Meridiem . PM ;
if ( hour != 12 )
hour += 12 ;
}
if ( ! result . start . isCertain ( "meridiem" ) ) {
if ( meridiem == index _1$d . Meridiem . AM ) {
result . start . imply ( "meridiem" , index _1$d . Meridiem . AM ) ;
if ( result . start . get ( "hour" ) == 12 ) {
result . start . assign ( "hour" , 0 ) ;
}
}
else {
result . start . imply ( "meridiem" , index _1$d . Meridiem . PM ) ;
if ( result . start . get ( "hour" ) != 12 ) {
result . start . assign ( "hour" , result . start . get ( "hour" ) + 12 ) ;
}
}
}
}
components . assign ( "hour" , hour ) ;
components . assign ( "minute" , minute ) ;
if ( meridiem >= 0 ) {
components . assign ( "meridiem" , meridiem ) ;
}
else {
const startAtPM = result . start . isCertain ( "meridiem" ) && result . start . get ( "hour" ) > 12 ;
if ( startAtPM ) {
if ( result . start . get ( "hour" ) - 12 > hour ) {
components . imply ( "meridiem" , index _1$d . Meridiem . AM ) ;
}
else if ( hour <= 12 ) {
components . assign ( "hour" , hour + 12 ) ;
components . assign ( "meridiem" , index _1$d . Meridiem . PM ) ;
}
}
else if ( hour > 12 ) {
components . imply ( "meridiem" , index _1$d . Meridiem . PM ) ;
}
else if ( hour <= 12 ) {
components . imply ( "meridiem" , index _1$d . Meridiem . AM ) ;
}
}
if ( components . date ( ) . getTime ( ) < result . start . date ( ) . getTime ( ) ) {
components . imply ( "day" , components . get ( "day" ) + 1 ) ;
}
return components ;
}
checkAndReturnWithoutFollowingPattern ( result ) {
if ( result . text . match ( /^\d$/ ) ) {
return null ;
}
if ( result . text . match ( /\d[apAP]$/ ) ) {
return null ;
}
const endingWithNumbers = result . text . match ( /[^\d:.](\d[\d.]+)$/ ) ;
if ( endingWithNumbers ) {
const endingNumbers = endingWithNumbers [ 1 ] ;
if ( this . strictMode ) {
return null ;
}
if ( endingNumbers . includes ( "." ) && ! endingNumbers . match ( /\d(\.\d{2})+$/ ) ) {
return null ;
}
const endingNumberVal = parseInt ( endingNumbers ) ;
if ( endingNumberVal > 24 ) {
return null ;
}
}
return result ;
}
checkAndReturnWithFollowingPattern ( result ) {
if ( result . text . match ( /^\d+-\d+$/ ) ) {
return null ;
}
const endingWithNumbers = result . text . match ( /[^\d:.](\d[\d.]+)\s*-\s*(\d[\d.]+)$/ ) ;
if ( endingWithNumbers ) {
if ( this . strictMode ) {
return null ;
}
const startingNumbers = endingWithNumbers [ 1 ] ;
const endingNumbers = endingWithNumbers [ 2 ] ;
if ( endingNumbers . includes ( "." ) && ! endingNumbers . match ( /\d(\.\d{2})+$/ ) ) {
return null ;
}
const endingNumberVal = parseInt ( endingNumbers ) ;
const startingNumberVal = parseInt ( startingNumbers ) ;
if ( endingNumberVal > 24 || startingNumberVal > 24 ) {
return null ;
}
}
return result ;
}
getPrimaryTimePatternThroughCache ( ) {
const primaryPrefix = this . primaryPrefix ( ) ;
const primarySuffix = this . primarySuffix ( ) ;
if ( this . cachedPrimaryPrefix === primaryPrefix && this . cachedPrimarySuffix === primarySuffix ) {
return this . cachedPrimaryTimePattern ;
}
this . cachedPrimaryTimePattern = primaryTimePattern ( primaryPrefix , primarySuffix ) ;
this . cachedPrimaryPrefix = primaryPrefix ;
this . cachedPrimarySuffix = primarySuffix ;
return this . cachedPrimaryTimePattern ;
}
getFollowingTimePatternThroughCache ( ) {
const followingPhase = this . followingPhase ( ) ;
const followingSuffix = this . followingSuffix ( ) ;
if ( this . cachedFollowingPhase === followingPhase && this . cachedFollowingSuffix === followingSuffix ) {
return this . cachedFollowingTimePatten ;
}
this . cachedFollowingTimePatten = followingTimePatten ( followingPhase , followingSuffix ) ;
this . cachedFollowingPhase = followingPhase ;
this . cachedFollowingSuffix = followingSuffix ;
return this . cachedFollowingTimePatten ;
}
}
AbstractTimeExpressionParser$1 . AbstractTimeExpressionParser = AbstractTimeExpressionParser ;
Object . defineProperty ( ENTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const index _1$c = dist ;
const AbstractTimeExpressionParser _1$4 = AbstractTimeExpressionParser$1 ;
class ENTimeExpressionParser extends AbstractTimeExpressionParser _1$4 . AbstractTimeExpressionParser {
constructor ( strictMode ) {
super ( strictMode ) ;
}
followingPhase ( ) {
return "\\s*(?:\\-|\\– ;
}
primaryPrefix ( ) {
return "(?:(?:at|from)\\s*)??" ;
}
primarySuffix ( ) {
return "(?:\\s*(?:o\\W*clock|at\\s*night|in\\s*the\\s*(?:morning|afternoon)))?(?!/)(?=\\W|$)" ;
}
extractPrimaryTimeComponents ( context , match ) {
const components = super . extractPrimaryTimeComponents ( context , match ) ;
if ( components ) {
if ( match [ 0 ] . endsWith ( "night" ) ) {
const hour = components . get ( "hour" ) ;
if ( hour >= 6 && hour < 12 ) {
components . assign ( "hour" , components . get ( "hour" ) + 12 ) ;
components . assign ( "meridiem" , index _1$c . Meridiem . PM ) ;
}
else if ( hour < 6 ) {
components . assign ( "meridiem" , index _1$c . Meridiem . AM ) ;
}
}
if ( match [ 0 ] . endsWith ( "afternoon" ) ) {
components . assign ( "meridiem" , index _1$c . Meridiem . PM ) ;
const hour = components . get ( "hour" ) ;
if ( hour >= 0 && hour <= 6 ) {
components . assign ( "hour" , components . get ( "hour" ) + 12 ) ;
}
}
if ( match [ 0 ] . endsWith ( "morning" ) ) {
components . assign ( "meridiem" , index _1$c . Meridiem . AM ) ;
const hour = components . get ( "hour" ) ;
if ( hour < 12 ) {
components . assign ( "hour" , components . get ( "hour" ) ) ;
}
}
}
return components ;
}
}
ENTimeExpressionParser$1 . default = ENTimeExpressionParser ;
var ENTimeUnitAgoFormatParser$1 = { } ;
var timeunits = { } ;
Object . defineProperty ( timeunits , "__esModule" , { value : true } ) ;
timeunits . addImpliedTimeUnits = timeunits . reverseTimeUnits = void 0 ;
function reverseTimeUnits ( timeUnits ) {
const reversed = { } ;
for ( const key in timeUnits ) {
reversed [ key ] = - timeUnits [ key ] ;
}
return reversed ;
}
timeunits . reverseTimeUnits = reverseTimeUnits ;
function addImpliedTimeUnits ( components , timeUnits ) {
const output = components . clone ( ) ;
let date = components . dayjs ( ) ;
for ( const key in timeUnits ) {
date = date . add ( timeUnits [ key ] , key ) ;
}
if ( "day" in timeUnits || "d" in timeUnits || "week" in timeUnits || "month" in timeUnits || "year" in timeUnits ) {
output . imply ( "day" , date . date ( ) ) ;
output . imply ( "month" , date . month ( ) + 1 ) ;
output . imply ( "year" , date . year ( ) ) ;
}
if ( "second" in timeUnits || "minute" in timeUnits || "hour" in timeUnits ) {
output . imply ( "second" , date . second ( ) ) ;
output . imply ( "minute" , date . minute ( ) ) ;
output . imply ( "hour" , date . hour ( ) ) ;
}
return output ;
}
timeunits . addImpliedTimeUnits = addImpliedTimeUnits ;
Object . defineProperty ( ENTimeUnitAgoFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$x = constants$7 ;
const results _1$d = results ;
const AbstractParserWithWordBoundary _1$L = AbstractParserWithWordBoundary ;
const timeunits _1$6 = timeunits ;
const PATTERN$w = new RegExp ( ` ( ${ constants _1$x . TIME _UNITS _PATTERN } ) \\ s{0,5}(?:ago|before|earlier)(?=(?: \\ W| $ )) ` , "i" ) ;
const STRICT _PATTERN$3 = new RegExp ( ` ( ${ constants _1$x . TIME _UNITS _PATTERN } ) \\ s{0,5}ago(?=(?: \\ W| $ )) ` , "i" ) ;
class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary _1$L . AbstractParserWithWordBoundaryChecking {
constructor ( strictMode ) {
super ( ) ;
this . strictMode = strictMode ;
}
innerPattern ( ) {
return this . strictMode ? STRICT _PATTERN$3 : PATTERN$w ;
}
innerExtract ( context , match ) {
const timeUnits = ( 0 , constants _1$x . parseTimeUnits ) ( match [ 1 ] ) ;
const outputTimeUnits = ( 0 , timeunits _1$6 . reverseTimeUnits ) ( timeUnits ) ;
return results _1$d . ParsingComponents . createRelativeFromReference ( context . reference , outputTimeUnits ) ;
}
}
ENTimeUnitAgoFormatParser$1 . default = ENTimeUnitAgoFormatParser ;
var ENTimeUnitLaterFormatParser$1 = { } ;
Object . defineProperty ( ENTimeUnitLaterFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$w = constants$7 ;
const results _1$c = results ;
const AbstractParserWithWordBoundary _1$K = AbstractParserWithWordBoundary ;
const PATTERN$v = new RegExp ( ` ( ${ constants _1$w . TIME _UNITS _PATTERN } ) \\ s{0,5}(?:later|after|from now|henceforth|forward|out) ` + "(?=(?:\\W|$))" , "i" ) ;
const STRICT _PATTERN$2 = new RegExp ( "" + "(" + constants _1$w . TIME _UNITS _PATTERN + ")" + "(later|from now)" + "(?=(?:\\W|$))" , "i" ) ;
const GROUP _NUM _TIMEUNITS$1 = 1 ;
class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundary _1$K . AbstractParserWithWordBoundaryChecking {
constructor ( strictMode ) {
super ( ) ;
this . strictMode = strictMode ;
}
innerPattern ( ) {
return this . strictMode ? STRICT _PATTERN$2 : PATTERN$v ;
}
innerExtract ( context , match ) {
const fragments = ( 0 , constants _1$w . parseTimeUnits ) ( match [ GROUP _NUM _TIMEUNITS$1 ] ) ;
return results _1$c . ParsingComponents . createRelativeFromReference ( context . reference , fragments ) ;
}
}
ENTimeUnitLaterFormatParser$1 . default = ENTimeUnitLaterFormatParser ;
var ENMergeDateRangeRefiner$1 = { } ;
var AbstractMergeDateRangeRefiner$1 = { } ;
var abstractRefiners = { } ;
Object . defineProperty ( abstractRefiners , "__esModule" , { value : true } ) ;
abstractRefiners . MergingRefiner = abstractRefiners . Filter = void 0 ;
class Filter {
refine ( context , results ) {
return results . filter ( ( r ) => this . isValid ( context , r ) ) ;
}
}
abstractRefiners . Filter = Filter ;
class MergingRefiner {
refine ( context , results ) {
if ( results . length < 2 ) {
return results ;
}
const mergedResults = [ ] ;
let curResult = results [ 0 ] ;
let nextResult = null ;
for ( let i = 1 ; i < results . length ; i ++ ) {
nextResult = results [ i ] ;
const textBetween = context . text . substring ( curResult . index + curResult . text . length , nextResult . index ) ;
if ( ! this . shouldMergeResults ( textBetween , curResult , nextResult , context ) ) {
mergedResults . push ( curResult ) ;
curResult = nextResult ;
}
else {
const left = curResult ;
const right = nextResult ;
const mergedResult = this . mergeResults ( textBetween , left , right , context ) ;
context . debug ( ( ) => {
console . log ( ` ${ this . constructor . name } merged ${ left } and ${ right } into ${ mergedResult } ` ) ;
} ) ;
curResult = mergedResult ;
}
}
if ( curResult != null ) {
mergedResults . push ( curResult ) ;
}
return mergedResults ;
}
}
abstractRefiners . MergingRefiner = MergingRefiner ;
Object . defineProperty ( AbstractMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const abstractRefiners _1$3 = abstractRefiners ;
class AbstractMergeDateRangeRefiner extends abstractRefiners _1$3 . MergingRefiner {
shouldMergeResults ( textBetween , currentResult , nextResult ) {
return ! currentResult . end && ! nextResult . end && textBetween . match ( this . patternBetween ( ) ) != null ;
}
mergeResults ( textBetween , fromResult , toResult ) {
if ( ! fromResult . start . isOnlyWeekdayComponent ( ) && ! toResult . start . isOnlyWeekdayComponent ( ) ) {
toResult . start . getCertainComponents ( ) . forEach ( ( key ) => {
if ( ! fromResult . start . isCertain ( key ) ) {
fromResult . start . assign ( key , toResult . start . get ( key ) ) ;
}
} ) ;
fromResult . start . getCertainComponents ( ) . forEach ( ( key ) => {
if ( ! toResult . start . isCertain ( key ) ) {
toResult . start . assign ( key , fromResult . start . get ( key ) ) ;
}
} ) ;
}
if ( fromResult . start . date ( ) . getTime ( ) > toResult . start . date ( ) . getTime ( ) ) {
let fromMoment = fromResult . start . dayjs ( ) ;
let toMoment = toResult . start . dayjs ( ) ;
if ( fromResult . start . isOnlyWeekdayComponent ( ) && fromMoment . add ( - 7 , "days" ) . isBefore ( toMoment ) ) {
fromMoment = fromMoment . add ( - 7 , "days" ) ;
fromResult . start . imply ( "day" , fromMoment . date ( ) ) ;
fromResult . start . imply ( "month" , fromMoment . month ( ) + 1 ) ;
fromResult . start . imply ( "year" , fromMoment . year ( ) ) ;
}
else if ( toResult . start . isOnlyWeekdayComponent ( ) && toMoment . add ( 7 , "days" ) . isAfter ( fromMoment ) ) {
toMoment = toMoment . add ( 7 , "days" ) ;
toResult . start . imply ( "day" , toMoment . date ( ) ) ;
toResult . start . imply ( "month" , toMoment . month ( ) + 1 ) ;
toResult . start . imply ( "year" , toMoment . year ( ) ) ;
}
else {
[ toResult , fromResult ] = [ fromResult , toResult ] ;
}
}
const result = fromResult . clone ( ) ;
result . start = fromResult . start ;
result . end = toResult . start ;
result . index = Math . min ( fromResult . index , toResult . index ) ;
if ( fromResult . index < toResult . index ) {
result . text = fromResult . text + textBetween + toResult . text ;
}
else {
result . text = toResult . text + textBetween + fromResult . text ;
}
return result ;
}
}
AbstractMergeDateRangeRefiner$1 . default = AbstractMergeDateRangeRefiner ;
var _ _importDefault$G = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ENMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$7 = _ _importDefault$G ( AbstractMergeDateRangeRefiner$1 ) ;
class ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$7 . default {
patternBetween ( ) {
return /^\s*(to|-)\s*$/i ;
}
}
ENMergeDateRangeRefiner$1 . default = ENMergeDateRangeRefiner ;
var ENMergeDateTimeRefiner$2 = { } ;
var AbstractMergeDateTimeRefiner = { } ;
var mergingCalculation = { } ;
Object . defineProperty ( mergingCalculation , "__esModule" , { value : true } ) ;
mergingCalculation . mergeDateTimeComponent = mergingCalculation . mergeDateTimeResult = void 0 ;
const index _1$b = dist ;
function mergeDateTimeResult ( dateResult , timeResult ) {
const result = dateResult . clone ( ) ;
const beginDate = dateResult . start ;
const beginTime = timeResult . start ;
result . start = mergeDateTimeComponent ( beginDate , beginTime ) ;
if ( dateResult . end != null || timeResult . end != null ) {
const endDate = dateResult . end == null ? dateResult . start : dateResult . end ;
const endTime = timeResult . end == null ? timeResult . start : timeResult . end ;
const endDateTime = mergeDateTimeComponent ( endDate , endTime ) ;
if ( dateResult . end == null && endDateTime . date ( ) . getTime ( ) < result . start . date ( ) . getTime ( ) ) {
if ( endDateTime . isCertain ( "day" ) ) {
endDateTime . assign ( "day" , endDateTime . get ( "day" ) + 1 ) ;
}
else {
endDateTime . imply ( "day" , endDateTime . get ( "day" ) + 1 ) ;
}
}
result . end = endDateTime ;
}
return result ;
}
mergingCalculation . mergeDateTimeResult = mergeDateTimeResult ;
function mergeDateTimeComponent ( dateComponent , timeComponent ) {
const dateTimeComponent = dateComponent . clone ( ) ;
if ( timeComponent . isCertain ( "hour" ) ) {
dateTimeComponent . assign ( "hour" , timeComponent . get ( "hour" ) ) ;
dateTimeComponent . assign ( "minute" , timeComponent . get ( "minute" ) ) ;
if ( timeComponent . isCertain ( "second" ) ) {
dateTimeComponent . assign ( "second" , timeComponent . get ( "second" ) ) ;
if ( timeComponent . isCertain ( "millisecond" ) ) {
dateTimeComponent . assign ( "millisecond" , timeComponent . get ( "millisecond" ) ) ;
}
else {
dateTimeComponent . imply ( "millisecond" , timeComponent . get ( "millisecond" ) ) ;
}
}
else {
dateTimeComponent . imply ( "second" , timeComponent . get ( "second" ) ) ;
dateTimeComponent . imply ( "millisecond" , timeComponent . get ( "millisecond" ) ) ;
}
}
else {
dateTimeComponent . imply ( "hour" , timeComponent . get ( "hour" ) ) ;
dateTimeComponent . imply ( "minute" , timeComponent . get ( "minute" ) ) ;
dateTimeComponent . imply ( "second" , timeComponent . get ( "second" ) ) ;
dateTimeComponent . imply ( "millisecond" , timeComponent . get ( "millisecond" ) ) ;
}
if ( timeComponent . isCertain ( "timezoneOffset" ) ) {
dateTimeComponent . assign ( "timezoneOffset" , timeComponent . get ( "timezoneOffset" ) ) ;
}
if ( timeComponent . isCertain ( "meridiem" ) ) {
dateTimeComponent . assign ( "meridiem" , timeComponent . get ( "meridiem" ) ) ;
}
else if ( timeComponent . get ( "meridiem" ) != null && dateTimeComponent . get ( "meridiem" ) == null ) {
dateTimeComponent . imply ( "meridiem" , timeComponent . get ( "meridiem" ) ) ;
}
if ( dateTimeComponent . get ( "meridiem" ) == index _1$b . Meridiem . PM && dateTimeComponent . get ( "hour" ) < 12 ) {
if ( timeComponent . isCertain ( "hour" ) ) {
dateTimeComponent . assign ( "hour" , dateTimeComponent . get ( "hour" ) + 12 ) ;
}
else {
dateTimeComponent . imply ( "hour" , dateTimeComponent . get ( "hour" ) + 12 ) ;
}
}
return dateTimeComponent ;
}
mergingCalculation . mergeDateTimeComponent = mergeDateTimeComponent ;
Object . defineProperty ( AbstractMergeDateTimeRefiner , "__esModule" , { value : true } ) ;
const abstractRefiners _1$2 = abstractRefiners ;
const mergingCalculation _1 = mergingCalculation ;
class ENMergeDateTimeRefiner$1 extends abstractRefiners _1$2 . MergingRefiner {
shouldMergeResults ( textBetween , currentResult , nextResult ) {
return ( ( ( currentResult . start . isOnlyDate ( ) && nextResult . start . isOnlyTime ( ) ) ||
( nextResult . start . isOnlyDate ( ) && currentResult . start . isOnlyTime ( ) ) ) &&
textBetween . match ( this . patternBetween ( ) ) != null ) ;
}
mergeResults ( textBetween , currentResult , nextResult ) {
const result = currentResult . start . isOnlyDate ( )
? ( 0 , mergingCalculation _1 . mergeDateTimeResult ) ( currentResult , nextResult )
: ( 0 , mergingCalculation _1 . mergeDateTimeResult ) ( nextResult , currentResult ) ;
result . index = currentResult . index ;
result . text = currentResult . text + textBetween + nextResult . text ;
return result ;
}
}
AbstractMergeDateTimeRefiner . default = ENMergeDateTimeRefiner$1 ;
var _ _importDefault$F = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ENMergeDateTimeRefiner$2 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1$6 = _ _importDefault$F ( AbstractMergeDateTimeRefiner ) ;
class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1$6 . default {
patternBetween ( ) {
return new RegExp ( "^\\s*(T|at|after|before|on|of|,|-)?\\s*$" ) ;
}
}
ENMergeDateTimeRefiner$2 . default = ENMergeDateTimeRefiner ;
var configurations = { } ;
var ExtractTimezoneAbbrRefiner$1 = { } ;
Object . defineProperty ( ExtractTimezoneAbbrRefiner$1 , "__esModule" , { value : true } ) ;
const TIMEZONE _NAME _PATTERN = new RegExp ( "^\\s*,?\\s*\\(?([A-Z]{2,4})\\)?(?=\\W|$)" , "i" ) ;
const DEFAULT _TIMEZONE _ABBR _MAP = {
ACDT : 630 ,
ACST : 570 ,
ADT : - 180 ,
AEDT : 660 ,
AEST : 600 ,
AFT : 270 ,
AKDT : - 480 ,
AKST : - 540 ,
ALMT : 360 ,
AMST : - 180 ,
AMT : - 240 ,
ANAST : 720 ,
ANAT : 720 ,
AQTT : 300 ,
ART : - 180 ,
AST : - 240 ,
AWDT : 540 ,
AWST : 480 ,
AZOST : 0 ,
AZOT : - 60 ,
AZST : 300 ,
AZT : 240 ,
BNT : 480 ,
BOT : - 240 ,
BRST : - 120 ,
BRT : - 180 ,
BST : 60 ,
BTT : 360 ,
CAST : 480 ,
CAT : 120 ,
CCT : 390 ,
CDT : - 300 ,
CEST : 120 ,
CET : 60 ,
CHADT : 825 ,
CHAST : 765 ,
CKT : - 600 ,
CLST : - 180 ,
CLT : - 240 ,
COT : - 300 ,
CST : - 360 ,
CVT : - 60 ,
CXT : 420 ,
ChST : 600 ,
DAVT : 420 ,
EASST : - 300 ,
EAST : - 360 ,
EAT : 180 ,
ECT : - 300 ,
EDT : - 240 ,
EEST : 180 ,
EET : 120 ,
EGST : 0 ,
EGT : - 60 ,
EST : - 300 ,
ET : - 300 ,
FJST : 780 ,
FJT : 720 ,
FKST : - 180 ,
FKT : - 240 ,
FNT : - 120 ,
GALT : - 360 ,
GAMT : - 540 ,
GET : 240 ,
GFT : - 180 ,
GILT : 720 ,
GMT : 0 ,
GST : 240 ,
GYT : - 240 ,
HAA : - 180 ,
HAC : - 300 ,
HADT : - 540 ,
HAE : - 240 ,
HAP : - 420 ,
HAR : - 360 ,
HAST : - 600 ,
HAT : - 90 ,
HAY : - 480 ,
HKT : 480 ,
HLV : - 210 ,
HNA : - 240 ,
HNC : - 360 ,
HNE : - 300 ,
HNP : - 480 ,
HNR : - 420 ,
HNT : - 150 ,
HNY : - 540 ,
HOVT : 420 ,
ICT : 420 ,
IDT : 180 ,
IOT : 360 ,
IRDT : 270 ,
IRKST : 540 ,
IRKT : 540 ,
IRST : 210 ,
IST : 330 ,
JST : 540 ,
KGT : 360 ,
KRAST : 480 ,
KRAT : 480 ,
KST : 540 ,
KUYT : 240 ,
LHDT : 660 ,
LHST : 630 ,
LINT : 840 ,
MAGST : 720 ,
MAGT : 720 ,
MART : - 510 ,
MAWT : 300 ,
MDT : - 360 ,
MESZ : 120 ,
MEZ : 60 ,
MHT : 720 ,
MMT : 390 ,
MSD : 240 ,
MSK : 240 ,
MST : - 420 ,
MUT : 240 ,
MVT : 300 ,
MYT : 480 ,
NCT : 660 ,
NDT : - 90 ,
NFT : 690 ,
NOVST : 420 ,
NOVT : 360 ,
NPT : 345 ,
NST : - 150 ,
NUT : - 660 ,
NZDT : 780 ,
NZST : 720 ,
OMSST : 420 ,
OMST : 420 ,
PDT : - 420 ,
PET : - 300 ,
PETST : 720 ,
PETT : 720 ,
PGT : 600 ,
PHOT : 780 ,
PHT : 480 ,
PKT : 300 ,
PMDT : - 120 ,
PMST : - 180 ,
PONT : 660 ,
PST : - 480 ,
PT : - 480 ,
PWT : 540 ,
PYST : - 180 ,
PYT : - 240 ,
RET : 240 ,
SAMT : 240 ,
SAST : 120 ,
SBT : 660 ,
SCT : 240 ,
SGT : 480 ,
SRT : - 180 ,
SST : - 660 ,
TAHT : - 600 ,
TFT : 300 ,
TJT : 300 ,
TKT : 780 ,
TLT : 540 ,
TMT : 300 ,
TVT : 720 ,
ULAT : 480 ,
UTC : 0 ,
UYST : - 120 ,
UYT : - 180 ,
UZT : 300 ,
VET : - 210 ,
VLAST : 660 ,
VLAT : 660 ,
VUT : 660 ,
WAST : 120 ,
WAT : 60 ,
WEST : 60 ,
WESZ : 60 ,
WET : 0 ,
WEZ : 0 ,
WFT : 720 ,
WGST : - 120 ,
WGT : - 180 ,
WIB : 420 ,
WIT : 540 ,
WITA : 480 ,
WST : 780 ,
WT : 0 ,
YAKST : 600 ,
YAKT : 600 ,
YAPT : 600 ,
YEKST : 360 ,
YEKT : 360 ,
} ;
class ExtractTimezoneAbbrRefiner {
constructor ( timezoneOverrides ) {
this . timezone = Object . assign ( Object . assign ( { } , DEFAULT _TIMEZONE _ABBR _MAP ) , timezoneOverrides ) ;
}
refine ( context , results ) {
var _a ;
const timezoneOverrides = ( _a = context . option . timezones ) !== null && _a !== void 0 ? _a : { } ;
results . forEach ( ( result ) => {
var _a , _b ;
const suffix = context . text . substring ( result . index + result . text . length ) ;
const match = TIMEZONE _NAME _PATTERN . exec ( suffix ) ;
if ( ! match ) {
return ;
}
const timezoneAbbr = match [ 1 ] . toUpperCase ( ) ;
const extractedTimezoneOffset = ( _b = ( _a = timezoneOverrides [ timezoneAbbr ] ) !== null && _a !== void 0 ? _a : this . timezone [ timezoneAbbr ] ) !== null && _b !== void 0 ? _b : null ;
if ( extractedTimezoneOffset === null ) {
return ;
}
context . debug ( ( ) => {
console . log ( ` Extracting timezone: ' ${ timezoneAbbr } ' into : ${ extractedTimezoneOffset } ` ) ;
} ) ;
const currentTimezoneOffset = result . start . get ( "timezoneOffset" ) ;
if ( currentTimezoneOffset !== null && extractedTimezoneOffset != currentTimezoneOffset ) {
if ( result . start . isCertain ( "timezoneOffset" ) ) {
return ;
}
if ( timezoneAbbr != match [ 1 ] ) {
return ;
}
}
if ( result . start . isOnlyDate ( ) ) {
if ( timezoneAbbr != match [ 1 ] ) {
return ;
}
}
result . text += match [ 0 ] ;
if ( ! result . start . isCertain ( "timezoneOffset" ) ) {
result . start . assign ( "timezoneOffset" , extractedTimezoneOffset ) ;
}
if ( result . end != null && ! result . end . isCertain ( "timezoneOffset" ) ) {
result . end . assign ( "timezoneOffset" , extractedTimezoneOffset ) ;
}
} ) ;
return results ;
}
}
ExtractTimezoneAbbrRefiner$1 . default = ExtractTimezoneAbbrRefiner ;
var ExtractTimezoneOffsetRefiner$1 = { } ;
Object . defineProperty ( ExtractTimezoneOffsetRefiner$1 , "__esModule" , { value : true } ) ;
const TIMEZONE _OFFSET _PATTERN = new RegExp ( "^\\s*(?:(?:GMT|UTC)\\s?)?([+-])(\\d{1,2})(?::?(\\d{2}))?" , "i" ) ;
const TIMEZONE _OFFSET _SIGN _GROUP = 1 ;
const TIMEZONE _OFFSET _HOUR _OFFSET _GROUP = 2 ;
const TIMEZONE _OFFSET _MINUTE _OFFSET _GROUP = 3 ;
class ExtractTimezoneOffsetRefiner {
refine ( context , results ) {
results . forEach ( function ( result ) {
if ( result . start . isCertain ( "timezoneOffset" ) ) {
return ;
}
const suffix = context . text . substring ( result . index + result . text . length ) ;
const match = TIMEZONE _OFFSET _PATTERN . exec ( suffix ) ;
if ( ! match ) {
return ;
}
context . debug ( ( ) => {
console . log ( ` Extracting timezone: ' ${ match [ 0 ] } ' into : ${ result } ` ) ;
} ) ;
const hourOffset = parseInt ( match [ TIMEZONE _OFFSET _HOUR _OFFSET _GROUP ] ) ;
const minuteOffset = parseInt ( match [ TIMEZONE _OFFSET _MINUTE _OFFSET _GROUP ] || "0" ) ;
let timezoneOffset = hourOffset * 60 + minuteOffset ;
if ( match [ TIMEZONE _OFFSET _SIGN _GROUP ] === "-" ) {
timezoneOffset = - timezoneOffset ;
}
if ( result . end != null ) {
result . end . assign ( "timezoneOffset" , timezoneOffset ) ;
}
result . start . assign ( "timezoneOffset" , timezoneOffset ) ;
result . text += match [ 0 ] ;
} ) ;
return results ;
}
}
ExtractTimezoneOffsetRefiner$1 . default = ExtractTimezoneOffsetRefiner ;
var OverlapRemovalRefiner$1 = { } ;
Object . defineProperty ( OverlapRemovalRefiner$1 , "__esModule" , { value : true } ) ;
class OverlapRemovalRefiner {
refine ( context , results ) {
if ( results . length < 2 ) {
return results ;
}
const filteredResults = [ ] ;
let prevResult = results [ 0 ] ;
for ( let i = 1 ; i < results . length ; i ++ ) {
const result = results [ i ] ;
if ( result . index < prevResult . index + prevResult . text . length ) {
if ( result . text . length > prevResult . text . length ) {
prevResult = result ;
}
}
else {
filteredResults . push ( prevResult ) ;
prevResult = result ;
}
}
if ( prevResult != null ) {
filteredResults . push ( prevResult ) ;
}
return filteredResults ;
}
}
OverlapRemovalRefiner$1 . default = OverlapRemovalRefiner ;
var ForwardDateRefiner$1 = { } ;
var _ _importDefault$E = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ForwardDateRefiner$1 , "__esModule" , { value : true } ) ;
const dayjs _1$q = _ _importDefault$E ( require$$0 ) ;
class ForwardDateRefiner {
refine ( context , results ) {
if ( ! context . option . forwardDate ) {
return results ;
}
results . forEach ( function ( result ) {
let refMoment = ( 0 , dayjs _1$q . default ) ( context . refDate ) ;
if ( result . start . isOnlyDayMonthComponent ( ) && refMoment . isAfter ( result . start . dayjs ( ) ) ) {
for ( let i = 0 ; i < 3 && refMoment . isAfter ( result . start . dayjs ( ) ) ; i ++ ) {
result . start . imply ( "year" , result . start . get ( "year" ) + 1 ) ;
context . debug ( ( ) => {
console . log ( ` Forward yearly adjusted for ${ result } ( ${ result . start } ) ` ) ;
} ) ;
if ( result . end && ! result . end . isCertain ( "year" ) ) {
result . end . imply ( "year" , result . end . get ( "year" ) + 1 ) ;
context . debug ( ( ) => {
console . log ( ` Forward yearly adjusted for ${ result } ( ${ result . end } ) ` ) ;
} ) ;
}
}
}
if ( result . start . isOnlyWeekdayComponent ( ) && refMoment . isAfter ( result . start . dayjs ( ) ) ) {
if ( refMoment . day ( ) >= result . start . get ( "weekday" ) ) {
refMoment = refMoment . day ( result . start . get ( "weekday" ) + 7 ) ;
}
else {
refMoment = refMoment . day ( result . start . get ( "weekday" ) ) ;
}
result . start . imply ( "day" , refMoment . date ( ) ) ;
result . start . imply ( "month" , refMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , refMoment . year ( ) ) ;
context . debug ( ( ) => {
console . log ( ` Forward weekly adjusted for ${ result } ( ${ result . start } ) ` ) ;
} ) ;
if ( result . end && result . end . isOnlyWeekdayComponent ( ) ) {
if ( refMoment . day ( ) > result . end . get ( "weekday" ) ) {
refMoment = refMoment . day ( result . end . get ( "weekday" ) + 7 ) ;
}
else {
refMoment = refMoment . day ( result . end . get ( "weekday" ) ) ;
}
result . end . imply ( "day" , refMoment . date ( ) ) ;
result . end . imply ( "month" , refMoment . month ( ) + 1 ) ;
result . end . imply ( "year" , refMoment . year ( ) ) ;
context . debug ( ( ) => {
console . log ( ` Forward weekly adjusted for ${ result } ( ${ result . end } ) ` ) ;
} ) ;
}
}
} ) ;
return results ;
}
}
ForwardDateRefiner$1 . default = ForwardDateRefiner ;
var UnlikelyFormatFilter$1 = { } ;
Object . defineProperty ( UnlikelyFormatFilter$1 , "__esModule" , { value : true } ) ;
const abstractRefiners _1$1 = abstractRefiners ;
class UnlikelyFormatFilter extends abstractRefiners _1$1 . Filter {
constructor ( strictMode ) {
super ( ) ;
this . strictMode = strictMode ;
}
isValid ( context , result ) {
if ( result . text . replace ( " " , "" ) . match ( /^\d*(\.\d*)?$/ ) ) {
context . debug ( ( ) => {
console . log ( ` Removing unlikely result ' ${ result . text } ' ` ) ;
} ) ;
return false ;
}
if ( ! result . start . isValidDate ( ) ) {
context . debug ( ( ) => {
console . log ( ` Removing invalid result: ${ result } ( ${ result . start } ) ` ) ;
} ) ;
return false ;
}
if ( result . end && ! result . end . isValidDate ( ) ) {
context . debug ( ( ) => {
console . log ( ` Removing invalid result: ${ result } ( ${ result . end } ) ` ) ;
} ) ;
return false ;
}
if ( this . strictMode ) {
return this . isStrictModeValid ( context , result ) ;
}
return true ;
}
isStrictModeValid ( context , result ) {
if ( result . start . isOnlyWeekdayComponent ( ) ) {
context . debug ( ( ) => {
console . log ( ` (Strict) Removing weekday only component: ${ result } ( ${ result . end } ) ` ) ;
} ) ;
return false ;
}
if ( result . start . isOnlyTime ( ) && ( ! result . start . isCertain ( "hour" ) || ! result . start . isCertain ( "minute" ) ) ) {
context . debug ( ( ) => {
console . log ( ` (Strict) Removing uncertain time component: ${ result } ( ${ result . end } ) ` ) ;
} ) ;
return false ;
}
return true ;
}
}
UnlikelyFormatFilter$1 . default = UnlikelyFormatFilter ;
var ISOFormatParser$1 = { } ;
Object . defineProperty ( ISOFormatParser$1 , "__esModule" , { value : true } ) ;
const AbstractParserWithWordBoundary _1$J = AbstractParserWithWordBoundary ;
const PATTERN$u = new RegExp ( "([0-9]{4})\\-([0-9]{1,2})\\-([0-9]{1,2})" +
"(?:T" +
"([0-9]{1,2}):([0-9]{1,2})" +
"(?:" +
":([0-9]{1,2})(?:\\.(\\d{1,4}))?" +
")?" +
"(?:" +
"Z|([+-]\\d{2}):?(\\d{2})?" +
")?" +
")?" +
"(?=\\W|$)" , "i" ) ;
const YEAR _NUMBER _GROUP$2 = 1 ;
const MONTH _NUMBER _GROUP$1 = 2 ;
const DATE _NUMBER _GROUP$1 = 3 ;
const HOUR _NUMBER _GROUP = 4 ;
const MINUTE _NUMBER _GROUP = 5 ;
const SECOND _NUMBER _GROUP = 6 ;
const MILLISECOND _NUMBER _GROUP = 7 ;
const TZD _HOUR _OFFSET _GROUP = 8 ;
const TZD _MINUTE _OFFSET _GROUP = 9 ;
class ISOFormatParser extends AbstractParserWithWordBoundary _1$J . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$u ;
}
innerExtract ( context , match ) {
const components = { } ;
components [ "year" ] = parseInt ( match [ YEAR _NUMBER _GROUP$2 ] ) ;
components [ "month" ] = parseInt ( match [ MONTH _NUMBER _GROUP$1 ] ) ;
components [ "day" ] = parseInt ( match [ DATE _NUMBER _GROUP$1 ] ) ;
if ( match [ HOUR _NUMBER _GROUP ] != null ) {
components [ "hour" ] = parseInt ( match [ HOUR _NUMBER _GROUP ] ) ;
components [ "minute" ] = parseInt ( match [ MINUTE _NUMBER _GROUP ] ) ;
if ( match [ SECOND _NUMBER _GROUP ] != null ) {
components [ "second" ] = parseInt ( match [ SECOND _NUMBER _GROUP ] ) ;
}
if ( match [ MILLISECOND _NUMBER _GROUP ] != null ) {
components [ "millisecond" ] = parseInt ( match [ MILLISECOND _NUMBER _GROUP ] ) ;
}
if ( match [ TZD _HOUR _OFFSET _GROUP ] == null ) {
components [ "timezoneOffset" ] = 0 ;
}
else {
const hourOffset = parseInt ( match [ TZD _HOUR _OFFSET _GROUP ] ) ;
let minuteOffset = 0 ;
if ( match [ TZD _MINUTE _OFFSET _GROUP ] != null ) {
minuteOffset = parseInt ( match [ TZD _MINUTE _OFFSET _GROUP ] ) ;
}
let offset = hourOffset * 60 ;
if ( offset < 0 ) {
offset -= minuteOffset ;
}
else {
offset += minuteOffset ;
}
components [ "timezoneOffset" ] = offset ;
}
}
return components ;
}
}
ISOFormatParser$1 . default = ISOFormatParser ;
var MergeWeekdayComponentRefiner$1 = { } ;
Object . defineProperty ( MergeWeekdayComponentRefiner$1 , "__esModule" , { value : true } ) ;
const abstractRefiners _1 = abstractRefiners ;
class MergeWeekdayComponentRefiner extends abstractRefiners _1 . MergingRefiner {
mergeResults ( textBetween , currentResult , nextResult ) {
const newResult = nextResult . clone ( ) ;
newResult . index = currentResult . index ;
newResult . text = currentResult . text + textBetween + newResult . text ;
newResult . start . assign ( "weekday" , currentResult . start . get ( "weekday" ) ) ;
if ( newResult . end ) {
newResult . end . assign ( "weekday" , currentResult . start . get ( "weekday" ) ) ;
}
return newResult ;
}
shouldMergeResults ( textBetween , currentResult , nextResult ) {
const weekdayThenNormalDate = currentResult . start . isOnlyWeekdayComponent ( ) &&
! currentResult . start . isCertain ( "hour" ) &&
nextResult . start . isCertain ( "day" ) ;
return weekdayThenNormalDate && textBetween . match ( /^,?\s*$/ ) != null ;
}
}
MergeWeekdayComponentRefiner$1 . default = MergeWeekdayComponentRefiner ;
var _ _importDefault$D = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( configurations , "__esModule" , { value : true } ) ;
configurations . includeCommonConfiguration = void 0 ;
const ExtractTimezoneAbbrRefiner _1 = _ _importDefault$D ( ExtractTimezoneAbbrRefiner$1 ) ;
const ExtractTimezoneOffsetRefiner _1 = _ _importDefault$D ( ExtractTimezoneOffsetRefiner$1 ) ;
const OverlapRemovalRefiner _1 = _ _importDefault$D ( OverlapRemovalRefiner$1 ) ;
const ForwardDateRefiner _1 = _ _importDefault$D ( ForwardDateRefiner$1 ) ;
const UnlikelyFormatFilter _1 = _ _importDefault$D ( UnlikelyFormatFilter$1 ) ;
const ISOFormatParser _1 = _ _importDefault$D ( ISOFormatParser$1 ) ;
const MergeWeekdayComponentRefiner _1 = _ _importDefault$D ( MergeWeekdayComponentRefiner$1 ) ;
function includeCommonConfiguration ( configuration , strictMode = false ) {
configuration . parsers . unshift ( new ISOFormatParser _1 . default ( ) ) ;
configuration . refiners . unshift ( new MergeWeekdayComponentRefiner _1 . default ( ) ) ;
configuration . refiners . unshift ( new ExtractTimezoneAbbrRefiner _1 . default ( ) ) ;
configuration . refiners . unshift ( new ExtractTimezoneOffsetRefiner _1 . default ( ) ) ;
configuration . refiners . unshift ( new OverlapRemovalRefiner _1 . default ( ) ) ;
configuration . refiners . push ( new OverlapRemovalRefiner _1 . default ( ) ) ;
configuration . refiners . push ( new ForwardDateRefiner _1 . default ( ) ) ;
configuration . refiners . push ( new UnlikelyFormatFilter _1 . default ( strictMode ) ) ;
return configuration ;
}
configurations . includeCommonConfiguration = includeCommonConfiguration ;
var ENCasualDateParser$1 = { } ;
var casualReferences = { } ;
var _ _importDefault$C = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( casualReferences , "__esModule" , { value : true } ) ;
casualReferences . tonight = casualReferences . tomorrow = casualReferences . yesterday = casualReferences . today = casualReferences . now = void 0 ;
const results _1$b = results ;
const dayjs _1$p = _ _importDefault$C ( require$$0 ) ;
const dayjs _2$8 = dayjs ;
const index _1$a = dist ;
function now ( reference ) {
const targetDate = ( 0 , dayjs _1$p . default ) ( reference . instant ) ;
const component = new results _1$b . ParsingComponents ( reference , { } ) ;
( 0 , dayjs _2$8 . assignSimilarDate ) ( component , targetDate ) ;
( 0 , dayjs _2$8 . assignSimilarTime ) ( component , targetDate ) ;
if ( reference . timezoneOffset !== null ) {
component . assign ( "timezoneOffset" , targetDate . utcOffset ( ) ) ;
}
return component ;
}
casualReferences . now = now ;
function today ( reference ) {
const targetDate = ( 0 , dayjs _1$p . default ) ( reference . instant ) ;
const component = new results _1$b . ParsingComponents ( reference , { } ) ;
( 0 , dayjs _2$8 . assignSimilarDate ) ( component , targetDate ) ;
( 0 , dayjs _2$8 . implySimilarTime ) ( component , targetDate ) ;
return component ;
}
casualReferences . today = today ;
function yesterday ( reference ) {
let targetDate = ( 0 , dayjs _1$p . default ) ( reference . instant ) ;
const component = new results _1$b . ParsingComponents ( reference , { } ) ;
targetDate = targetDate . add ( - 1 , "day" ) ;
( 0 , dayjs _2$8 . assignSimilarDate ) ( component , targetDate ) ;
( 0 , dayjs _2$8 . implySimilarTime ) ( component , targetDate ) ;
return component ;
}
casualReferences . yesterday = yesterday ;
function tomorrow ( reference ) {
const targetDate = ( 0 , dayjs _1$p . default ) ( reference . instant ) ;
const component = new results _1$b . ParsingComponents ( reference , { } ) ;
( 0 , dayjs _2$8 . assignTheNextDay ) ( component , targetDate ) ;
return component ;
}
casualReferences . tomorrow = tomorrow ;
function tonight ( reference , implyHour = 22 ) {
const targetDate = ( 0 , dayjs _1$p . default ) ( reference . instant ) ;
const component = new results _1$b . ParsingComponents ( reference , { } ) ;
component . imply ( "hour" , implyHour ) ;
component . imply ( "meridiem" , index _1$a . Meridiem . PM ) ;
( 0 , dayjs _2$8 . assignSimilarDate ) ( component , targetDate ) ;
return component ;
}
casualReferences . tonight = tonight ;
var _ _createBinding$5 = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault$5 = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar$5 = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding$5 ( result , mod , k ) ;
_ _setModuleDefault$5 ( result , mod ) ;
return result ;
} ;
var _ _importDefault$B = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ENCasualDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$o = _ _importDefault$B ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$I = AbstractParserWithWordBoundary ;
const dayjs _2$7 = dayjs ;
const references$5 = _ _importStar$5 ( casualReferences ) ;
const PATTERN$t = /(now|today|tonight|tomorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i ;
class ENCasualDateParser extends AbstractParserWithWordBoundary _1$I . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return PATTERN$t ;
}
innerExtract ( context , match ) {
let targetDate = ( 0 , dayjs _1$o . default ) ( context . refDate ) ;
const lowerText = match [ 0 ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
switch ( lowerText ) {
case "now" :
return references$5 . now ( context . reference ) ;
case "today" :
return references$5 . today ( context . reference ) ;
case "yesterday" :
return references$5 . yesterday ( context . reference ) ;
case "tomorrow" :
case "tmr" :
case "tmrw" :
return references$5 . tomorrow ( context . reference ) ;
case "tonight" :
return references$5 . tonight ( context . reference ) ;
default :
if ( lowerText . match ( /last\s*night/ ) ) {
if ( targetDate . hour ( ) > 6 ) {
targetDate = targetDate . add ( - 1 , "day" ) ;
}
( 0 , dayjs _2$7 . assignSimilarDate ) ( component , targetDate ) ;
component . imply ( "hour" , 0 ) ;
}
break ;
}
return component ;
}
}
ENCasualDateParser$1 . default = ENCasualDateParser ;
var ENCasualTimeParser$1 = { } ;
var _ _importDefault$A = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ENCasualTimeParser$1 , "__esModule" , { value : true } ) ;
const index _1$9 = dist ;
const AbstractParserWithWordBoundary _1$H = AbstractParserWithWordBoundary ;
const dayjs _1$n = _ _importDefault$A ( require$$0 ) ;
const dayjs _2$6 = dayjs ;
const PATTERN$s = /(?:this)?\s{0,3}(morning|afternoon|evening|night|midnight|noon)(?=\W|$)/i ;
class ENCasualTimeParser extends AbstractParserWithWordBoundary _1$H . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$s ;
}
innerExtract ( context , match ) {
const targetDate = ( 0 , dayjs _1$n . default ) ( context . refDate ) ;
const component = context . createParsingComponents ( ) ;
switch ( match [ 1 ] . toLowerCase ( ) ) {
case "afternoon" :
component . imply ( "meridiem" , index _1$9 . Meridiem . PM ) ;
component . imply ( "hour" , 15 ) ;
break ;
case "evening" :
case "night" :
component . imply ( "meridiem" , index _1$9 . Meridiem . PM ) ;
component . imply ( "hour" , 20 ) ;
break ;
case "midnight" :
( 0 , dayjs _2$6 . assignTheNextDay ) ( component , targetDate ) ;
component . imply ( "hour" , 0 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
break ;
case "morning" :
component . imply ( "meridiem" , index _1$9 . Meridiem . AM ) ;
component . imply ( "hour" , 6 ) ;
break ;
case "noon" :
component . imply ( "meridiem" , index _1$9 . Meridiem . AM ) ;
component . imply ( "hour" , 12 ) ;
break ;
}
return component ;
}
}
ENCasualTimeParser$1 . default = ENCasualTimeParser ;
var ENWeekdayParser$1 = { } ;
var weeks = { } ;
var _ _importDefault$z = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( weeks , "__esModule" , { value : true } ) ;
weeks . toDayJSClosestWeekday = weeks . toDayJSWeekday = void 0 ;
const dayjs _1$m = _ _importDefault$z ( require$$0 ) ;
function toDayJSWeekday ( refDate , offset , modifier , locale ) {
var _a ;
if ( ! modifier ) {
return toDayJSClosestWeekday ( refDate , offset , locale ) ;
}
let date = ( 0 , dayjs _1$m . default ) ( refDate ) . locale ( "en" , locale ) ;
const weekStart = ( _a = locale === null || locale === void 0 ? void 0 : locale . weekStart ) !== null && _a !== void 0 ? _a : 0 ;
const weekdayOffset = ( 7 + offset - weekStart ) % 7 ;
switch ( modifier ) {
case "this" :
date = date . weekday ( weekdayOffset ) ;
break ;
case "next" :
date = date . weekday ( weekdayOffset + 7 ) ;
break ;
case "last" :
date = date . weekday ( weekdayOffset - 7 ) ;
break ;
}
return date ;
}
weeks . toDayJSWeekday = toDayJSWeekday ;
function toDayJSClosestWeekday ( refDate , offset , locale ) {
var _a ;
let date = ( 0 , dayjs _1$m . default ) ( refDate ) . locale ( "en" , locale ) ;
const refOffset = date . weekday ( ) ;
const weekStart = ( _a = locale === null || locale === void 0 ? void 0 : locale . weekStart ) !== null && _a !== void 0 ? _a : 0 ;
const weekdayOffset = ( 7 + offset - weekStart ) % 7 ;
if ( Math . abs ( weekdayOffset - 7 - refOffset ) < Math . abs ( weekdayOffset - refOffset ) ) {
date = date . weekday ( weekdayOffset - 7 ) ;
}
else if ( Math . abs ( weekdayOffset + 7 - refOffset ) < Math . abs ( weekdayOffset - refOffset ) ) {
date = date . weekday ( weekdayOffset + 7 ) ;
}
else {
date = date . weekday ( weekdayOffset ) ;
}
return date ;
}
weeks . toDayJSClosestWeekday = toDayJSClosestWeekday ;
Object . defineProperty ( ENWeekdayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$v = constants$7 ;
const pattern _1$d = pattern ;
const AbstractParserWithWordBoundary _1$G = AbstractParserWithWordBoundary ;
const weeks _1$4 = weeks ;
const PATTERN$r = new RegExp ( "(?:(?:\\,|\\(|\\（ +
"(?:on\\s*?)?" +
"(?:(this|last|past|next)\\s*)?" +
` ( ${ ( 0 , pattern _1$d . matchAnyPattern ) ( constants _1$v . WEEKDAY _DICTIONARY ) } ) ` +
"(?:\\s*(?:\\,|\\)|\\） +
"(?:\\s*(this|last|past|next)\\s*week)?" +
"(?=\\W|$)" , "i" ) ;
const PREFIX _GROUP$3 = 1 ;
const WEEKDAY _GROUP$4 = 2 ;
const POSTFIX _GROUP$3 = 3 ;
class ENWeekdayParser extends AbstractParserWithWordBoundary _1$G . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$r ;
}
innerExtract ( context , match ) {
const dayOfWeek = match [ WEEKDAY _GROUP$4 ] . toLowerCase ( ) ;
const offset = constants _1$v . WEEKDAY _DICTIONARY [ dayOfWeek ] ;
const prefix = match [ PREFIX _GROUP$3 ] ;
const postfix = match [ POSTFIX _GROUP$3 ] ;
let modifierWord = prefix || postfix ;
modifierWord = modifierWord || "" ;
modifierWord = modifierWord . toLowerCase ( ) ;
let modifier = null ;
if ( modifierWord == "last" || modifierWord == "past" ) {
modifier = "last" ;
}
else if ( modifierWord == "next" ) {
modifier = "next" ;
}
else if ( modifierWord == "this" ) {
modifier = "this" ;
}
const date = ( 0 , weeks _1$4 . toDayJSWeekday ) ( context . refDate , offset , modifier , context . option . locale ) ;
return context
. createParsingComponents ( )
. assign ( "weekday" , offset )
. imply ( "day" , date . date ( ) )
. imply ( "month" , date . month ( ) + 1 )
. imply ( "year" , date . year ( ) ) ;
}
}
ENWeekdayParser$1 . default = ENWeekdayParser ;
var ENRelativeDateFormatParser$1 = { } ;
var _ _importDefault$y = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ENRelativeDateFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$u = constants$7 ;
const results _1$a = results ;
const dayjs _1$l = _ _importDefault$y ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$F = AbstractParserWithWordBoundary ;
const pattern _1$c = pattern ;
const PATTERN$q = new RegExp ( ` (this|next|last|past) \\ s*( ${ ( 0 , pattern _1$c . matchAnyPattern ) ( constants _1$u . TIME _UNIT _DICTIONARY ) } )(?= \\ s*) ` + "(?=\\W|$)" , "i" ) ;
const MODIFIER _WORD _GROUP$1 = 1 ;
const RELATIVE _WORD _GROUP$1 = 2 ;
class ENRelativeDateFormatParser extends AbstractParserWithWordBoundary _1$F . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$q ;
}
innerExtract ( context , match ) {
const modifier = match [ MODIFIER _WORD _GROUP$1 ] . toLowerCase ( ) ;
const unitWord = match [ RELATIVE _WORD _GROUP$1 ] . toLowerCase ( ) ;
const timeunit = constants _1$u . TIME _UNIT _DICTIONARY [ unitWord ] ;
if ( modifier == "next" ) {
const timeUnits = { } ;
timeUnits [ timeunit ] = 1 ;
return results _1$a . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
if ( modifier == "last" || modifier == "past" ) {
const timeUnits = { } ;
timeUnits [ timeunit ] = - 1 ;
return results _1$a . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
const components = context . createParsingComponents ( ) ;
let date = ( 0 , dayjs _1$l . default ) ( context . reference . instant ) ;
if ( unitWord . match ( /week/i ) ) {
date = date . add ( - date . get ( "d" ) , "d" ) ;
components . imply ( "day" , date . date ( ) ) ;
components . imply ( "month" , date . month ( ) + 1 ) ;
components . imply ( "year" , date . year ( ) ) ;
}
else if ( unitWord . match ( /month/i ) ) {
date = date . add ( - date . date ( ) + 1 , "d" ) ;
components . imply ( "day" , date . date ( ) ) ;
components . assign ( "year" , date . year ( ) ) ;
components . assign ( "month" , date . month ( ) + 1 ) ;
}
else if ( unitWord . match ( /year/i ) ) {
date = date . add ( - date . date ( ) + 1 , "d" ) ;
date = date . add ( - date . month ( ) , "month" ) ;
components . imply ( "day" , date . date ( ) ) ;
components . imply ( "month" , date . month ( ) + 1 ) ;
components . assign ( "year" , date . year ( ) ) ;
}
return components ;
}
}
ENRelativeDateFormatParser$1 . default = ENRelativeDateFormatParser ;
var chrono$1 = { } ;
Object . defineProperty ( chrono$1 , "__esModule" , { value : true } ) ;
chrono$1 . ParsingContext = chrono$1 . Chrono = void 0 ;
const results _1$9 = results ;
const en _1 = en$1 ;
class Chrono {
constructor ( configuration ) {
configuration = configuration || ( 0 , en _1 . createCasualConfiguration ) ( ) ;
this . parsers = [ ... configuration . parsers ] ;
this . refiners = [ ... configuration . refiners ] ;
}
clone ( ) {
return new Chrono ( {
parsers : [ ... this . parsers ] ,
refiners : [ ... this . refiners ] ,
} ) ;
}
parseDate ( text , referenceDate , option ) {
const results = this . parse ( text , referenceDate , option ) ;
return results . length > 0 ? results [ 0 ] . start . date ( ) : null ;
}
parse ( text , referenceDate , option ) {
const context = new ParsingContext ( text , referenceDate , option ) ;
let results = [ ] ;
this . parsers . forEach ( ( parser ) => {
const parsedResults = Chrono . executeParser ( context , parser ) ;
results = results . concat ( parsedResults ) ;
} ) ;
results . sort ( ( a , b ) => {
return a . index - b . index ;
} ) ;
this . refiners . forEach ( function ( refiner ) {
results = refiner . refine ( context , results ) ;
} ) ;
return results ;
}
static executeParser ( context , parser ) {
const results = [ ] ;
const pattern = parser . pattern ( context ) ;
const originalText = context . text ;
let remainingText = context . text ;
let match = pattern . exec ( remainingText ) ;
while ( match ) {
const index = match . index + originalText . length - remainingText . length ;
match . index = index ;
const result = parser . extract ( context , match ) ;
if ( ! result ) {
remainingText = originalText . substring ( match . index + 1 ) ;
match = pattern . exec ( remainingText ) ;
continue ;
}
let parsedResult = null ;
if ( result instanceof results _1$9 . ParsingResult ) {
parsedResult = result ;
}
else if ( result instanceof results _1$9 . ParsingComponents ) {
parsedResult = context . createParsingResult ( match . index , match [ 0 ] ) ;
parsedResult . start = result ;
}
else {
parsedResult = context . createParsingResult ( match . index , match [ 0 ] , result ) ;
}
context . debug ( ( ) => console . log ( ` ${ parser . constructor . name } extracted result ${ parsedResult } ` ) ) ;
results . push ( parsedResult ) ;
remainingText = originalText . substring ( index + parsedResult . text . length ) ;
match = pattern . exec ( remainingText ) ;
}
return results ;
}
}
chrono$1 . Chrono = Chrono ;
class ParsingContext {
constructor ( text , refDate , option ) {
this . text = text ;
this . reference = new results _1$9 . ReferenceWithTimezone ( refDate ) ;
this . option = option !== null && option !== void 0 ? option : { } ;
this . refDate = this . reference . instant ;
}
createParsingComponents ( components ) {
if ( components instanceof results _1$9 . ParsingComponents ) {
return components ;
}
return new results _1$9 . ParsingComponents ( this . reference , components ) ;
}
createParsingResult ( index , textOrEndIndex , startComponents , endComponents ) {
const text = typeof textOrEndIndex === "string" ? textOrEndIndex : this . text . substring ( index , textOrEndIndex ) ;
const start = startComponents ? this . createParsingComponents ( startComponents ) : null ;
const end = endComponents ? this . createParsingComponents ( endComponents ) : null ;
return new results _1$9 . ParsingResult ( this . reference , index , text , start , end ) ;
}
debug ( block ) {
if ( this . option . debug ) {
if ( this . option . debug instanceof Function ) {
this . option . debug ( block ) ;
}
else {
const handler = this . option . debug ;
handler . debug ( block ) ;
}
}
}
}
chrono$1 . ParsingContext = ParsingContext ;
var SlashDateFormatParser$1 = { } ;
Object . defineProperty ( SlashDateFormatParser$1 , "__esModule" , { value : true } ) ;
const years _1$6 = years ;
const PATTERN$p = new RegExp ( "([^\\d]|^)" +
"([0-3]{0,1}[0-9]{1})[\\/\\.\\-]([0-3]{0,1}[0-9]{1})" +
"(?:[\\/\\.\\-]([0-9]{4}|[0-9]{2}))?" +
"(\\W|$)" , "i" ) ;
const OPENING _GROUP = 1 ;
const ENDING _GROUP = 5 ;
const FIRST _NUMBERS _GROUP = 2 ;
const SECOND _NUMBERS _GROUP = 3 ;
const YEAR _GROUP$8 = 4 ;
class SlashDateFormatParser {
constructor ( littleEndian ) {
this . groupNumberMonth = littleEndian ? SECOND _NUMBERS _GROUP : FIRST _NUMBERS _GROUP ;
this . groupNumberDay = littleEndian ? FIRST _NUMBERS _GROUP : SECOND _NUMBERS _GROUP ;
}
pattern ( ) {
return PATTERN$p ;
}
extract ( context , match ) {
if ( match [ OPENING _GROUP ] == "/" || match [ ENDING _GROUP ] == "/" ) {
match . index += match [ 0 ] . length ;
return ;
}
const index = match . index + match [ OPENING _GROUP ] . length ;
const text = match [ 0 ] . substr ( match [ OPENING _GROUP ] . length , match [ 0 ] . length - match [ OPENING _GROUP ] . length - match [ ENDING _GROUP ] . length ) ;
if ( text . match ( /^\d\.\d$/ ) || text . match ( /^\d\.\d{1,2}\.\d{1,2}\s*$/ ) ) {
return ;
}
if ( ! match [ YEAR _GROUP$8 ] && match [ 0 ] . indexOf ( "/" ) < 0 ) {
return ;
}
const result = context . createParsingResult ( index , text ) ;
let month = parseInt ( match [ this . groupNumberMonth ] ) ;
let day = parseInt ( match [ this . groupNumberDay ] ) ;
if ( month < 1 || month > 12 ) {
if ( month > 12 ) {
if ( day >= 1 && day <= 12 && month <= 31 ) {
[ day , month ] = [ month , day ] ;
}
else {
return null ;
}
}
}
if ( day < 1 || day > 31 ) {
return null ;
}
result . start . assign ( "day" , day ) ;
result . start . assign ( "month" , month ) ;
if ( match [ YEAR _GROUP$8 ] ) {
const rawYearNumber = parseInt ( match [ YEAR _GROUP$8 ] ) ;
const year = ( 0 , years _1$6 . findMostLikelyADYear ) ( rawYearNumber ) ;
result . start . assign ( "year" , year ) ;
}
else {
const year = ( 0 , years _1$6 . findYearClosestToRef ) ( context . refDate , day , month ) ;
result . start . imply ( "year" , year ) ;
}
return result ;
}
}
SlashDateFormatParser$1 . default = SlashDateFormatParser ;
var ENTimeUnitCasualRelativeFormatParser$1 = { } ;
Object . defineProperty ( ENTimeUnitCasualRelativeFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$t = constants$7 ;
const results _1$8 = results ;
const AbstractParserWithWordBoundary _1$E = AbstractParserWithWordBoundary ;
const timeunits _1$5 = timeunits ;
const PATTERN$o = new RegExp ( ` (this|last|past|next| \\ +|-) \\ s*( ${ constants _1$t . TIME _UNITS _PATTERN } )(?= \\ W| $ ) ` , "i" ) ;
class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary _1$E . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$o ;
}
innerExtract ( context , match ) {
const prefix = match [ 1 ] . toLowerCase ( ) ;
let timeUnits = ( 0 , constants _1$t . parseTimeUnits ) ( match [ 2 ] ) ;
switch ( prefix ) {
case "last" :
case "past" :
case "-" :
timeUnits = ( 0 , timeunits _1$5 . reverseTimeUnits ) ( timeUnits ) ;
break ;
}
return results _1$8 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
}
ENTimeUnitCasualRelativeFormatParser$1 . default = ENTimeUnitCasualRelativeFormatParser ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . GB = exports . strict = exports . casual = void 0 ;
const ENTimeUnitWithinFormatParser _1 = _ _importDefault ( ENTimeUnitWithinFormatParser$1 ) ;
const ENMonthNameLittleEndianParser _1 = _ _importDefault ( ENMonthNameLittleEndianParser$1 ) ;
const ENMonthNameMiddleEndianParser _1 = _ _importDefault ( ENMonthNameMiddleEndianParser$1 ) ;
const ENMonthNameParser _1 = _ _importDefault ( ENMonthNameParser$1 ) ;
const ENCasualYearMonthDayParser _1 = _ _importDefault ( ENCasualYearMonthDayParser$1 ) ;
const ENSlashMonthFormatParser _1 = _ _importDefault ( ENSlashMonthFormatParser$1 ) ;
const ENTimeExpressionParser _1 = _ _importDefault ( ENTimeExpressionParser$1 ) ;
const ENTimeUnitAgoFormatParser _1 = _ _importDefault ( ENTimeUnitAgoFormatParser$1 ) ;
const ENTimeUnitLaterFormatParser _1 = _ _importDefault ( ENTimeUnitLaterFormatParser$1 ) ;
const ENMergeDateRangeRefiner _1 = _ _importDefault ( ENMergeDateRangeRefiner$1 ) ;
const ENMergeDateTimeRefiner _1 = _ _importDefault ( ENMergeDateTimeRefiner$2 ) ;
const configurations _1 = configurations ;
const ENCasualDateParser _1 = _ _importDefault ( ENCasualDateParser$1 ) ;
const ENCasualTimeParser _1 = _ _importDefault ( ENCasualTimeParser$1 ) ;
const ENWeekdayParser _1 = _ _importDefault ( ENWeekdayParser$1 ) ;
const ENRelativeDateFormatParser _1 = _ _importDefault ( ENRelativeDateFormatParser$1 ) ;
const chrono _1 = chrono$1 ;
const SlashDateFormatParser _1 = _ _importDefault ( SlashDateFormatParser$1 ) ;
const ENTimeUnitCasualRelativeFormatParser _1 = _ _importDefault ( ENTimeUnitCasualRelativeFormatParser$1 ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( false ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( true , false ) ) ;
exports . GB = new chrono _1 . Chrono ( createConfiguration ( false , true ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( littleEndian = false ) {
const option = createConfiguration ( false , littleEndian ) ;
option . parsers . unshift ( new ENCasualDateParser _1 . default ( ) ) ;
option . parsers . unshift ( new ENCasualTimeParser _1 . default ( ) ) ;
option . parsers . unshift ( new ENMonthNameParser _1 . default ( ) ) ;
option . parsers . unshift ( new ENRelativeDateFormatParser _1 . default ( ) ) ;
option . parsers . unshift ( new ENTimeUnitCasualRelativeFormatParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( strictMode = true , littleEndian = false ) {
return ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new SlashDateFormatParser _1 . default ( littleEndian ) ,
new ENTimeUnitWithinFormatParser _1 . default ( ) ,
new ENMonthNameLittleEndianParser _1 . default ( ) ,
new ENMonthNameMiddleEndianParser _1 . default ( ) ,
new ENWeekdayParser _1 . default ( ) ,
new ENCasualYearMonthDayParser _1 . default ( ) ,
new ENSlashMonthFormatParser _1 . default ( ) ,
new ENTimeExpressionParser _1 . default ( strictMode ) ,
new ENTimeUnitAgoFormatParser _1 . default ( strictMode ) ,
new ENTimeUnitLaterFormatParser _1 . default ( strictMode ) ,
] ,
refiners : [ new ENMergeDateTimeRefiner _1 . default ( ) , new ENMergeDateRangeRefiner _1 . default ( ) ] ,
} , strictMode ) ;
}
exports . createConfiguration = createConfiguration ;
} ( en$1 ) ) ;
var de = { } ;
var DETimeExpressionParser$1 = { } ;
Object . defineProperty ( DETimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const AbstractTimeExpressionParser _1$3 = AbstractTimeExpressionParser$1 ;
const index _1$8 = dist ;
class DETimeExpressionParser extends AbstractTimeExpressionParser _1$3 . AbstractTimeExpressionParser {
primaryPrefix ( ) {
return "(?:(?:um|von)\\s*)?" ;
}
followingPhase ( ) {
return "\\s*(?:\\-|\\– ;
}
primarySuffix ( ) {
return "(?:\\s*uhr)?(?:\\s*(?:morgens|vormittags|nachmittags|abends|nachts))?(?=\\W|$)" ;
}
extractPrimaryTimeComponents ( context , match ) {
const components = super . extractPrimaryTimeComponents ( context , match ) ;
if ( components ) {
if ( match [ 0 ] . endsWith ( "morgens" ) || match [ 0 ] . endsWith ( "vormittags" ) ) {
components . assign ( "meridiem" , index _1$8 . Meridiem . AM ) ;
const hour = components . get ( "hour" ) ;
if ( hour < 12 ) {
components . assign ( "hour" , components . get ( "hour" ) ) ;
}
}
if ( match [ 0 ] . endsWith ( "nachmittags" ) || match [ 0 ] . endsWith ( "abends" ) || match [ 0 ] . endsWith ( "nachts" ) ) {
components . assign ( "meridiem" , index _1$8 . Meridiem . PM ) ;
const hour = components . get ( "hour" ) ;
if ( hour < 12 ) {
components . assign ( "hour" , components . get ( "hour" ) + 12 ) ;
}
}
}
return components ;
}
}
DETimeExpressionParser$1 . default = DETimeExpressionParser ;
var DEWeekdayParser$1 = { } ;
var constants$6 = { } ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . parseTimeUnits = exports . TIME _UNITS _PATTERN = exports . parseYear = exports . YEAR _PATTERN = exports . parseNumberPattern = exports . NUMBER _PATTERN = exports . TIME _UNIT _DICTIONARY = exports . INTEGER _WORD _DICTIONARY = exports . MONTH _DICTIONARY = exports . WEEKDAY _DICTIONARY = void 0 ;
const pattern _1 = pattern ;
const years _1 = years ;
exports . WEEKDAY _DICTIONARY = {
"sonntag" : 0 ,
"so" : 0 ,
"montag" : 1 ,
"mo" : 1 ,
"dienstag" : 2 ,
"di" : 2 ,
"mittwoch" : 3 ,
"mi" : 3 ,
"donnerstag" : 4 ,
"do" : 4 ,
"freitag" : 5 ,
"fr" : 5 ,
"samstag" : 6 ,
"sa" : 6 ,
} ;
exports . MONTH _DICTIONARY = {
"januar" : 1 ,
"jan" : 1 ,
"jan." : 1 ,
"februar" : 2 ,
"feb" : 2 ,
"feb." : 2 ,
"märz" : 3 ,
"maerz" : 3 ,
"mär" : 3 ,
"mär." : 3 ,
"mrz" : 3 ,
"mrz." : 3 ,
"april" : 4 ,
"apr" : 4 ,
"apr." : 4 ,
"mai" : 5 ,
"juni" : 6 ,
"jun" : 6 ,
"jun." : 6 ,
"juli" : 7 ,
"jul" : 7 ,
"jul." : 7 ,
"august" : 8 ,
"aug" : 8 ,
"aug." : 8 ,
"september" : 9 ,
"sep" : 9 ,
"sep." : 9 ,
"sept" : 9 ,
"sept." : 9 ,
"oktober" : 10 ,
"okt" : 10 ,
"okt." : 10 ,
"november" : 11 ,
"nov" : 11 ,
"nov." : 11 ,
"dezember" : 12 ,
"dez" : 12 ,
"dez." : 12 ,
} ;
exports . INTEGER _WORD _DICTIONARY = {
"eins" : 1 ,
"zwei" : 2 ,
"drei" : 3 ,
"vier" : 4 ,
"fünf" : 5 ,
"fuenf" : 5 ,
"sechs" : 6 ,
"sieben" : 7 ,
"acht" : 8 ,
"neun" : 9 ,
"zehn" : 10 ,
"elf" : 11 ,
"zwölf" : 12 ,
"zwoelf" : 12 ,
} ;
exports . TIME _UNIT _DICTIONARY = {
sec : "second" ,
second : "second" ,
seconds : "second" ,
min : "minute" ,
mins : "minute" ,
minute : "minute" ,
minutes : "minute" ,
h : "hour" ,
hr : "hour" ,
hrs : "hour" ,
hour : "hour" ,
hours : "hour" ,
day : "d" ,
days : "d" ,
week : "week" ,
weeks : "week" ,
month : "month" ,
months : "month" ,
y : "year" ,
yr : "year" ,
year : "year" ,
years : "year" ,
} ;
exports . NUMBER _PATTERN = ` (?: ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . INTEGER _WORD _DICTIONARY ) } |[0-9]+|[0-9]+ \\ .[0-9]+|half(?: \\ s*an?)?|an? \\ b(?: \\ s*few)?|few|several|a? \\ s*couple \\ s*(?:of)?) ` ;
function parseNumberPattern ( match ) {
const num = match . toLowerCase ( ) ;
if ( exports . INTEGER _WORD _DICTIONARY [ num ] !== undefined ) {
return exports . INTEGER _WORD _DICTIONARY [ num ] ;
}
else if ( num === "a" || num === "an" ) {
return 1 ;
}
else if ( num . match ( /few/ ) ) {
return 3 ;
}
else if ( num . match ( /half/ ) ) {
return 0.5 ;
}
else if ( num . match ( /couple/ ) ) {
return 2 ;
}
else if ( num . match ( /several/ ) ) {
return 7 ;
}
return parseFloat ( num ) ;
}
exports . parseNumberPattern = parseNumberPattern ;
exports . YEAR _PATTERN = ` (?:[0-9]{1,4}(?: \\ s*[vn] \\ .? \\ s*C(?:hr)? \\ .?)?) ` ;
function parseYear ( match ) {
if ( /v/i . test ( match ) ) {
return - parseInt ( match . replace ( /[^0-9]+/gi , "" ) ) ;
}
if ( /n/i . test ( match ) ) {
return parseInt ( match . replace ( /[^0-9]+/gi , "" ) ) ;
}
const rawYearNumber = parseInt ( match ) ;
return ( 0 , years _1 . findMostLikelyADYear ) ( rawYearNumber ) ;
}
exports . parseYear = parseYear ;
const SINGLE _TIME _UNIT _PATTERN = ` ( ${ exports . NUMBER _PATTERN } ) \\ s{0,5}( ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . TIME _UNIT _DICTIONARY ) } ) \\ s{0,5} ` ;
const SINGLE _TIME _UNIT _REGEX = new RegExp ( SINGLE _TIME _UNIT _PATTERN , "i" ) ;
exports . TIME _UNITS _PATTERN = ( 0 , pattern _1 . repeatedTimeunitPattern ) ( "" , SINGLE _TIME _UNIT _PATTERN ) ;
function parseTimeUnits ( timeunitText ) {
const fragments = { } ;
let remainingText = timeunitText ;
let match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
while ( match ) {
collectDateTimeFragment ( fragments , match ) ;
remainingText = remainingText . substring ( match [ 0 ] . length ) ;
match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
}
return fragments ;
}
exports . parseTimeUnits = parseTimeUnits ;
function collectDateTimeFragment ( fragments , match ) {
const num = parseNumberPattern ( match [ 1 ] ) ;
const unit = exports . TIME _UNIT _DICTIONARY [ match [ 2 ] . toLowerCase ( ) ] ;
fragments [ unit ] = num ;
}
} ( constants$6 ) ) ;
Object . defineProperty ( DEWeekdayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$s = constants$6 ;
const pattern _1$b = pattern ;
const AbstractParserWithWordBoundary _1$D = AbstractParserWithWordBoundary ;
const weeks _1$3 = weeks ;
const PATTERN$n = new RegExp ( "(?:(?:\\,|\\(|\\（ +
"(?:a[mn]\\s*?)?" +
"(?:(diese[mn]|letzte[mn]|n(?:ä|ae)chste[mn])\\s*)?" +
` ( ${ ( 0 , pattern _1$b . matchAnyPattern ) ( constants _1$s . WEEKDAY _DICTIONARY ) } ) ` +
"(?:\\s*(?:\\,|\\)|\\） +
"(?:\\s*(diese|letzte|n(?:ä|ae)chste)\\s*woche)?" +
"(?=\\W|$)" , "i" ) ;
const PREFIX _GROUP$2 = 1 ;
const SUFFIX _GROUP = 3 ;
const WEEKDAY _GROUP$3 = 2 ;
class DEWeekdayParser extends AbstractParserWithWordBoundary _1$D . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$n ;
}
innerExtract ( context , match ) {
const dayOfWeek = match [ WEEKDAY _GROUP$3 ] . toLowerCase ( ) ;
const offset = constants _1$s . WEEKDAY _DICTIONARY [ dayOfWeek ] ;
const prefix = match [ PREFIX _GROUP$2 ] ;
const postfix = match [ SUFFIX _GROUP ] ;
let modifierWord = prefix || postfix ;
modifierWord = modifierWord || "" ;
modifierWord = modifierWord . toLowerCase ( ) ;
let modifier = null ;
if ( modifierWord . match ( /letzte/ ) ) {
modifier = "last" ;
}
else if ( modifierWord . match ( /chste/ ) ) {
modifier = "next" ;
}
else if ( modifierWord . match ( /diese/ ) ) {
modifier = "this" ;
}
const date = ( 0 , weeks _1$3 . toDayJSWeekday ) ( context . refDate , offset , modifier ) ;
return context
. createParsingComponents ( )
. assign ( "weekday" , offset )
. imply ( "day" , date . date ( ) )
. imply ( "month" , date . month ( ) + 1 )
. imply ( "year" , date . year ( ) ) ;
}
}
DEWeekdayParser$1 . default = DEWeekdayParser ;
var DEMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$x = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( DEMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$6 = _ _importDefault$x ( AbstractMergeDateRangeRefiner$1 ) ;
class DEMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$6 . default {
patternBetween ( ) {
return /^\s*(bis(?:\s*(?:am|zum))?|-)\s*$/i ;
}
}
DEMergeDateRangeRefiner$1 . default = DEMergeDateRangeRefiner ;
var DEMergeDateTimeRefiner$1 = { } ;
var _ _importDefault$w = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( DEMergeDateTimeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1$5 = _ _importDefault$w ( AbstractMergeDateTimeRefiner ) ;
class DEMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1$5 . default {
patternBetween ( ) {
return new RegExp ( "^\\s*(T|um|am|,|-)?\\s*$" ) ;
}
}
DEMergeDateTimeRefiner$1 . default = DEMergeDateTimeRefiner ;
var DECasualDateParser$1 = { } ;
var DECasualTimeParser$1 = { } ;
var _ _importDefault$v = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( DECasualTimeParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$k = _ _importDefault$v ( require$$0 ) ;
const index _1$7 = dist ;
const AbstractParserWithWordBoundary _1$C = AbstractParserWithWordBoundary ;
const dayjs _2$5 = dayjs ;
const timeunits _1$4 = timeunits ;
class DECasualTimeParser extends AbstractParserWithWordBoundary _1$C . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return /(diesen)?\s*(morgen|vormittag|mittags?|nachmittag|abend|nacht|mitternacht)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const targetDate = ( 0 , dayjs _1$k . default ) ( context . refDate ) ;
const timeKeywordPattern = match [ 2 ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
( 0 , dayjs _2$5 . implySimilarTime ) ( component , targetDate ) ;
return DECasualTimeParser . extractTimeComponents ( component , timeKeywordPattern ) ;
}
static extractTimeComponents ( component , timeKeywordPattern ) {
switch ( timeKeywordPattern ) {
case "morgen" :
component . imply ( "hour" , 6 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . AM ) ;
break ;
case "vormittag" :
component . imply ( "hour" , 9 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . AM ) ;
break ;
case "mittag" :
case "mittags" :
component . imply ( "hour" , 12 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . AM ) ;
break ;
case "nachmittag" :
component . imply ( "hour" , 15 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . PM ) ;
break ;
case "abend" :
component . imply ( "hour" , 18 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . PM ) ;
break ;
case "nacht" :
component . imply ( "hour" , 22 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . PM ) ;
break ;
case "mitternacht" :
if ( component . get ( "hour" ) > 1 ) {
component = ( 0 , timeunits _1$4 . addImpliedTimeUnits ) ( component , { "day" : 1 } ) ;
}
component . imply ( "hour" , 0 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
component . imply ( "meridiem" , index _1$7 . Meridiem . AM ) ;
break ;
}
return component ;
}
}
DECasualTimeParser$1 . default = DECasualTimeParser ;
var _ _createBinding$4 = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault$4 = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar$4 = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding$4 ( result , mod , k ) ;
_ _setModuleDefault$4 ( result , mod ) ;
return result ;
} ;
var _ _importDefault$u = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( DECasualDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$j = _ _importDefault$u ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$B = AbstractParserWithWordBoundary ;
const dayjs _2$4 = dayjs ;
const DECasualTimeParser _1 = _ _importDefault$u ( DECasualTimeParser$1 ) ;
const references$4 = _ _importStar$4 ( casualReferences ) ;
const PATTERN$m = new RegExp ( ` (jetzt|heute|morgen|übermorgen|uebermorgen|gestern|vorgestern|letzte \\ s*nacht) ` +
` (?: \\ s*(morgen|vormittag|mittags?|nachmittag|abend|nacht|mitternacht))? ` +
` (?= \\ W| $ ) ` , "i" ) ;
const DATE _GROUP$5 = 1 ;
const TIME _GROUP = 2 ;
class DECasualDateParser extends AbstractParserWithWordBoundary _1$B . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return PATTERN$m ;
}
innerExtract ( context , match ) {
let targetDate = ( 0 , dayjs _1$j . default ) ( context . refDate ) ;
const dateKeyword = ( match [ DATE _GROUP$5 ] || "" ) . toLowerCase ( ) ;
const timeKeyword = ( match [ TIME _GROUP ] || "" ) . toLowerCase ( ) ;
let component = context . createParsingComponents ( ) ;
switch ( dateKeyword ) {
case "jetzt" :
component = references$4 . now ( context . reference ) ;
break ;
case "heute" :
component = references$4 . today ( context . reference ) ;
break ;
case "morgen" :
( 0 , dayjs _2$4 . assignTheNextDay ) ( component , targetDate ) ;
break ;
case "übermorgen" :
case "uebermorgen" :
targetDate = targetDate . add ( 1 , "day" ) ;
( 0 , dayjs _2$4 . assignTheNextDay ) ( component , targetDate ) ;
break ;
case "gestern" :
targetDate = targetDate . add ( - 1 , "day" ) ;
( 0 , dayjs _2$4 . assignSimilarDate ) ( component , targetDate ) ;
( 0 , dayjs _2$4 . implySimilarTime ) ( component , targetDate ) ;
break ;
case "vorgestern" :
targetDate = targetDate . add ( - 2 , "day" ) ;
( 0 , dayjs _2$4 . assignSimilarDate ) ( component , targetDate ) ;
( 0 , dayjs _2$4 . implySimilarTime ) ( component , targetDate ) ;
break ;
default :
if ( dateKeyword . match ( /letzte\s*nacht/ ) ) {
if ( targetDate . hour ( ) > 6 ) {
targetDate = targetDate . add ( - 1 , "day" ) ;
}
( 0 , dayjs _2$4 . assignSimilarDate ) ( component , targetDate ) ;
component . imply ( "hour" , 0 ) ;
}
break ;
}
if ( timeKeyword ) {
component = DECasualTimeParser _1 . default . extractTimeComponents ( component , timeKeyword ) ;
}
return component ;
}
}
DECasualDateParser$1 . default = DECasualDateParser ;
var DEMonthNameLittleEndianParser$1 = { } ;
Object . defineProperty ( DEMonthNameLittleEndianParser$1 , "__esModule" , { value : true } ) ;
const years _1$5 = years ;
const constants _1$r = constants$6 ;
const constants _2$4 = constants$6 ;
const pattern _1$a = pattern ;
const AbstractParserWithWordBoundary _1$A = AbstractParserWithWordBoundary ;
const PATTERN$l = new RegExp ( "(?:am\\s*?)?" +
"(?:den\\s*?)?" +
` ([0-9]{1,2}) \\ . ` +
` (?: \\ s*(?:bis(?: \\ s*(?:am|zum))?| \\ -| \\ – \\ s) \\ s*([0-9]{1,2}) \\ .?)? \\ s* ` +
` ( ${ ( 0 , pattern _1$a . matchAnyPattern ) ( constants _1$r . MONTH _DICTIONARY ) } ) ` +
` (?:(?:-|/|,? \\ s*)( ${ constants _2$4 . YEAR _PATTERN } (?![^ \\ s] \\ d)))? ` +
` (?= \\ W| $ ) ` , "i" ) ;
const DATE _GROUP$4 = 1 ;
const DATE _TO _GROUP$3 = 2 ;
const MONTH _NAME _GROUP$5 = 3 ;
const YEAR _GROUP$7 = 4 ;
class DEMonthNameLittleEndianParser extends AbstractParserWithWordBoundary _1$A . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$l ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const month = constants _1$r . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$5 ] . toLowerCase ( ) ] ;
const day = parseInt ( match [ DATE _GROUP$4 ] ) ;
if ( day > 31 ) {
match . index = match . index + match [ DATE _GROUP$4 ] . length ;
return null ;
}
result . start . assign ( "month" , month ) ;
result . start . assign ( "day" , day ) ;
if ( match [ YEAR _GROUP$7 ] ) {
const yearNumber = ( 0 , constants _2$4 . parseYear ) ( match [ YEAR _GROUP$7 ] ) ;
result . start . assign ( "year" , yearNumber ) ;
}
else {
const year = ( 0 , years _1$5 . findYearClosestToRef ) ( context . refDate , day , month ) ;
result . start . imply ( "year" , year ) ;
}
if ( match [ DATE _TO _GROUP$3 ] ) {
const endDate = parseInt ( match [ DATE _TO _GROUP$3 ] ) ;
result . end = result . start . clone ( ) ;
result . end . assign ( "day" , endDate ) ;
}
return result ;
}
}
DEMonthNameLittleEndianParser$1 . default = DEMonthNameLittleEndianParser ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = void 0 ;
const configurations _1 = configurations ;
const chrono _1 = chrono$1 ;
const SlashDateFormatParser _1 = _ _importDefault ( SlashDateFormatParser$1 ) ;
const ISOFormatParser _1 = _ _importDefault ( ISOFormatParser$1 ) ;
const DETimeExpressionParser _1 = _ _importDefault ( DETimeExpressionParser$1 ) ;
const DEWeekdayParser _1 = _ _importDefault ( DEWeekdayParser$1 ) ;
const DEMergeDateRangeRefiner _1 = _ _importDefault ( DEMergeDateRangeRefiner$1 ) ;
const DEMergeDateTimeRefiner _1 = _ _importDefault ( DEMergeDateTimeRefiner$1 ) ;
const DECasualDateParser _1 = _ _importDefault ( DECasualDateParser$1 ) ;
const DECasualTimeParser _1 = _ _importDefault ( DECasualTimeParser$1 ) ;
const DEMonthNameLittleEndianParser _1 = _ _importDefault ( DEMonthNameLittleEndianParser$1 ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( true ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( littleEndian = true ) {
const option = createConfiguration ( false , littleEndian ) ;
option . parsers . unshift ( new DECasualTimeParser _1 . default ( ) ) ;
option . parsers . unshift ( new DECasualDateParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( strictMode = true , littleEndian = true ) {
return ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new ISOFormatParser _1 . default ( ) ,
new SlashDateFormatParser _1 . default ( littleEndian ) ,
new DETimeExpressionParser _1 . default ( ) ,
new DEMonthNameLittleEndianParser _1 . default ( ) ,
new DEWeekdayParser _1 . default ( ) ,
] ,
refiners : [ new DEMergeDateRangeRefiner _1 . default ( ) , new DEMergeDateTimeRefiner _1 . default ( ) ] ,
} , strictMode ) ;
}
exports . createConfiguration = createConfiguration ;
} ( de ) ) ;
var fr = { } ;
var FRCasualDateParser$1 = { } ;
var _ _createBinding$3 = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault$3 = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar$3 = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding$3 ( result , mod , k ) ;
_ _setModuleDefault$3 ( result , mod ) ;
return result ;
} ;
var _ _importDefault$t = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( FRCasualDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$i = _ _importDefault$t ( require$$0 ) ;
const index _1$6 = dist ;
const AbstractParserWithWordBoundary _1$z = AbstractParserWithWordBoundary ;
const dayjs _2$3 = dayjs ;
const references$3 = _ _importStar$3 ( casualReferences ) ;
class FRCasualDateParser extends AbstractParserWithWordBoundary _1$z . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return /(maintenant|aujourd'hui|demain|hier|cette\s*nuit|la\s*veille)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
let targetDate = ( 0 , dayjs _1$i . default ) ( context . refDate ) ;
const lowerText = match [ 0 ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
switch ( lowerText ) {
case "maintenant" :
return references$3 . now ( context . reference ) ;
case "aujourd'hui" :
return references$3 . today ( context . reference ) ;
case "hier" :
return references$3 . yesterday ( context . reference ) ;
case "demain" :
return references$3 . tomorrow ( context . reference ) ;
default :
if ( lowerText . match ( /cette\s*nuit/ ) ) {
( 0 , dayjs _2$3 . assignSimilarDate ) ( component , targetDate ) ;
component . imply ( "hour" , 22 ) ;
component . imply ( "meridiem" , index _1$6 . Meridiem . PM ) ;
}
else if ( lowerText . match ( /la\s*veille/ ) ) {
targetDate = targetDate . add ( - 1 , "day" ) ;
( 0 , dayjs _2$3 . assignSimilarDate ) ( component , targetDate ) ;
component . imply ( "hour" , 0 ) ;
}
}
return component ;
}
}
FRCasualDateParser$1 . default = FRCasualDateParser ;
var FRCasualTimeParser$1 = { } ;
Object . defineProperty ( FRCasualTimeParser$1 , "__esModule" , { value : true } ) ;
const index _1$5 = dist ;
const AbstractParserWithWordBoundary _1$y = AbstractParserWithWordBoundary ;
class FRCasualTimeParser extends AbstractParserWithWordBoundary _1$y . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return /(cet?)?\s*(matin|soir|après-midi|aprem|a midi|à minuit)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const suffixLower = match [ 2 ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
switch ( suffixLower ) {
case "après-midi" :
case "aprem" :
component . imply ( "hour" , 14 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "meridiem" , index _1$5 . Meridiem . PM ) ;
break ;
case "soir" :
component . imply ( "hour" , 18 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "meridiem" , index _1$5 . Meridiem . PM ) ;
break ;
case "matin" :
component . imply ( "hour" , 8 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "meridiem" , index _1$5 . Meridiem . AM ) ;
break ;
case "a midi" :
component . imply ( "hour" , 12 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "meridiem" , index _1$5 . Meridiem . AM ) ;
break ;
case "à minuit" :
component . imply ( "hour" , 0 ) ;
component . imply ( "meridiem" , index _1$5 . Meridiem . AM ) ;
break ;
}
return component ;
}
}
FRCasualTimeParser$1 . default = FRCasualTimeParser ;
var FRTimeExpressionParser$1 = { } ;
Object . defineProperty ( FRTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const AbstractTimeExpressionParser _1$2 = AbstractTimeExpressionParser$1 ;
class FRTimeExpressionParser extends AbstractTimeExpressionParser _1$2 . AbstractTimeExpressionParser {
primaryPrefix ( ) {
return "(?:(?:[àa])\\s*)?" ;
}
followingPhase ( ) {
return "\\s*(?:\\-|\\– ;
}
extractPrimaryTimeComponents ( context , match ) {
if ( match [ 0 ] . match ( /^\s*\d{4}\s*$/ ) ) {
return null ;
}
return super . extractPrimaryTimeComponents ( context , match ) ;
}
}
FRTimeExpressionParser$1 . default = FRTimeExpressionParser ;
var FRMergeDateTimeRefiner$1 = { } ;
var _ _importDefault$s = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( FRMergeDateTimeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1$4 = _ _importDefault$s ( AbstractMergeDateTimeRefiner ) ;
class FRMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1$4 . default {
patternBetween ( ) {
return new RegExp ( "^\\s*(T|à|a|vers|de|,|-)?\\s*$" ) ;
}
}
FRMergeDateTimeRefiner$1 . default = FRMergeDateTimeRefiner ;
var FRMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$r = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( FRMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$5 = _ _importDefault$r ( AbstractMergeDateRangeRefiner$1 ) ;
class FRMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$5 . default {
patternBetween ( ) {
return /^\s*(à|a|-)\s*$/i ;
}
}
FRMergeDateRangeRefiner$1 . default = FRMergeDateRangeRefiner ;
var FRWeekdayParser$1 = { } ;
var constants$5 = { } ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . parseTimeUnits = exports . TIME _UNITS _PATTERN = exports . parseYear = exports . YEAR _PATTERN = exports . parseOrdinalNumberPattern = exports . ORDINAL _NUMBER _PATTERN = exports . parseNumberPattern = exports . NUMBER _PATTERN = exports . TIME _UNIT _DICTIONARY = exports . INTEGER _WORD _DICTIONARY = exports . MONTH _DICTIONARY = exports . WEEKDAY _DICTIONARY = void 0 ;
const pattern _1 = pattern ;
exports . WEEKDAY _DICTIONARY = {
"dimanche" : 0 ,
"dim" : 0 ,
"lundi" : 1 ,
"lun" : 1 ,
"mardi" : 2 ,
"mar" : 2 ,
"mercredi" : 3 ,
"mer" : 3 ,
"jeudi" : 4 ,
"jeu" : 4 ,
"vendredi" : 5 ,
"ven" : 5 ,
"samedi" : 6 ,
"sam" : 6 ,
} ;
exports . MONTH _DICTIONARY = {
"janvier" : 1 ,
"jan" : 1 ,
"jan." : 1 ,
"février" : 2 ,
"fév" : 2 ,
"fév." : 2 ,
"fevrier" : 2 ,
"fev" : 2 ,
"fev." : 2 ,
"mars" : 3 ,
"mar" : 3 ,
"mar." : 3 ,
"avril" : 4 ,
"avr" : 4 ,
"avr." : 4 ,
"mai" : 5 ,
"juin" : 6 ,
"jun" : 6 ,
"juillet" : 7 ,
"juil" : 7 ,
"jul" : 7 ,
"jul." : 7 ,
"août" : 8 ,
"aout" : 8 ,
"septembre" : 9 ,
"sep" : 9 ,
"sep." : 9 ,
"sept" : 9 ,
"sept." : 9 ,
"octobre" : 10 ,
"oct" : 10 ,
"oct." : 10 ,
"novembre" : 11 ,
"nov" : 11 ,
"nov." : 11 ,
"décembre" : 12 ,
"decembre" : 12 ,
"dec" : 12 ,
"dec." : 12 ,
} ;
exports . INTEGER _WORD _DICTIONARY = {
"un" : 1 ,
"deux" : 2 ,
"trois" : 3 ,
"quatre" : 4 ,
"cinq" : 5 ,
"six" : 6 ,
"sept" : 7 ,
"huit" : 8 ,
"neuf" : 9 ,
"dix" : 10 ,
"onze" : 11 ,
"douze" : 12 ,
"treize" : 13 ,
} ;
exports . TIME _UNIT _DICTIONARY = {
"sec" : "second" ,
"seconde" : "second" ,
"secondes" : "second" ,
"min" : "minute" ,
"mins" : "minute" ,
"minute" : "minute" ,
"minutes" : "minute" ,
"h" : "hour" ,
"hr" : "hour" ,
"hrs" : "hour" ,
"heure" : "hour" ,
"heures" : "hour" ,
"jour" : "d" ,
"jours" : "d" ,
"semaine" : "week" ,
"semaines" : "week" ,
"mois" : "month" ,
"trimestre" : "quarter" ,
"trimestres" : "quarter" ,
"ans" : "year" ,
"année" : "year" ,
"années" : "year" ,
} ;
exports . NUMBER _PATTERN = ` (?: ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . INTEGER _WORD _DICTIONARY ) } |[0-9]+|[0-9]+ \\ .[0-9]+|une? \\ b|quelques?|demi-?) ` ;
function parseNumberPattern ( match ) {
const num = match . toLowerCase ( ) ;
if ( exports . INTEGER _WORD _DICTIONARY [ num ] !== undefined ) {
return exports . INTEGER _WORD _DICTIONARY [ num ] ;
}
else if ( num === "une" || num === "un" ) {
return 1 ;
}
else if ( num . match ( /quelques?/ ) ) {
return 3 ;
}
else if ( num . match ( /demi-?/ ) ) {
return 0.5 ;
}
return parseFloat ( num ) ;
}
exports . parseNumberPattern = parseNumberPattern ;
exports . ORDINAL _NUMBER _PATTERN = ` (?:[0-9]{1,2}(?:er)?) ` ;
function parseOrdinalNumberPattern ( match ) {
let num = match . toLowerCase ( ) ;
num = num . replace ( /(?:er)$/i , "" ) ;
return parseInt ( num ) ;
}
exports . parseOrdinalNumberPattern = parseOrdinalNumberPattern ;
exports . YEAR _PATTERN = ` (?:[1-9][0-9]{0,3} \\ s*(?:AC|AD|p \\ . \\ s*C(?:hr?)? \\ . \\ s*n \\ .)|[1-2][0-9]{3}|[5-9][0-9]) ` ;
function parseYear ( match ) {
if ( /AC/i . test ( match ) ) {
match = match . replace ( /BC/i , "" ) ;
return - parseInt ( match ) ;
}
if ( /AD/i . test ( match ) || /C/i . test ( match ) ) {
match = match . replace ( /[^\d]+/i , "" ) ;
return parseInt ( match ) ;
}
let yearNumber = parseInt ( match ) ;
if ( yearNumber < 100 ) {
if ( yearNumber > 50 ) {
yearNumber = yearNumber + 1900 ;
}
else {
yearNumber = yearNumber + 2000 ;
}
}
return yearNumber ;
}
exports . parseYear = parseYear ;
const SINGLE _TIME _UNIT _PATTERN = ` ( ${ exports . NUMBER _PATTERN } ) \\ s{0,5}( ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . TIME _UNIT _DICTIONARY ) } ) \\ s{0,5} ` ;
const SINGLE _TIME _UNIT _REGEX = new RegExp ( SINGLE _TIME _UNIT _PATTERN , "i" ) ;
exports . TIME _UNITS _PATTERN = ( 0 , pattern _1 . repeatedTimeunitPattern ) ( "" , SINGLE _TIME _UNIT _PATTERN ) ;
function parseTimeUnits ( timeunitText ) {
const fragments = { } ;
let remainingText = timeunitText ;
let match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
while ( match ) {
collectDateTimeFragment ( fragments , match ) ;
remainingText = remainingText . substring ( match [ 0 ] . length ) ;
match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
}
return fragments ;
}
exports . parseTimeUnits = parseTimeUnits ;
function collectDateTimeFragment ( fragments , match ) {
const num = parseNumberPattern ( match [ 1 ] ) ;
const unit = exports . TIME _UNIT _DICTIONARY [ match [ 2 ] . toLowerCase ( ) ] ;
fragments [ unit ] = num ;
}
} ( constants$5 ) ) ;
Object . defineProperty ( FRWeekdayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$q = constants$5 ;
const pattern _1$9 = pattern ;
const AbstractParserWithWordBoundary _1$x = AbstractParserWithWordBoundary ;
const weeks _1$2 = weeks ;
const PATTERN$k = new RegExp ( "(?:(?:\\,|\\(|\\（ +
"(?:(?:ce)\\s*)?" +
` ( ${ ( 0 , pattern _1$9 . matchAnyPattern ) ( constants _1$q . WEEKDAY _DICTIONARY ) } ) ` +
"(?:\\s*(?:\\,|\\)|\\） +
"(?:\\s*(dernier|prochain)\\s*)?" +
"(?=\\W|\\d|$)" , "i" ) ;
const WEEKDAY _GROUP$2 = 1 ;
const POSTFIX _GROUP$2 = 2 ;
class FRWeekdayParser extends AbstractParserWithWordBoundary _1$x . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$k ;
}
innerExtract ( context , match ) {
const dayOfWeek = match [ WEEKDAY _GROUP$2 ] . toLowerCase ( ) ;
const offset = constants _1$q . WEEKDAY _DICTIONARY [ dayOfWeek ] ;
if ( offset === undefined ) {
return null ;
}
let suffix = match [ POSTFIX _GROUP$2 ] ;
suffix = suffix || "" ;
suffix = suffix . toLowerCase ( ) ;
let modifier = null ;
if ( suffix == "dernier" ) {
modifier = "last" ;
}
else if ( suffix == "prochain" ) {
modifier = "next" ;
}
const date = ( 0 , weeks _1$2 . toDayJSWeekday ) ( context . refDate , offset , modifier ) ;
return context
. createParsingComponents ( )
. assign ( "weekday" , offset )
. imply ( "day" , date . date ( ) )
. imply ( "month" , date . month ( ) + 1 )
. imply ( "year" , date . year ( ) ) ;
}
}
FRWeekdayParser$1 . default = FRWeekdayParser ;
var FRSpecificTimeExpressionParser$1 = { } ;
Object . defineProperty ( FRSpecificTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const index _1$4 = dist ;
const FIRST _REG _PATTERN$2 = new RegExp ( "(^|\\s|T)" +
"(?:(?:[àa])\\s*)?" +
"(\\d{1,2})(?:h|:)?" +
"(?:(\\d{1,2})(?:m|:)?)?" +
"(?:(\\d{1,2})(?:s|:)?)?" +
"(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?))?" +
"(?=\\W|$)" , "i" ) ;
const SECOND _REG _PATTERN$2 = new RegExp ( "^\\s*(\\-|\\– +
"(\\d{1,2})(?:h|:)?" +
"(?:(\\d{1,2})(?:m|:)?)?" +
"(?:(\\d{1,2})(?:s|:)?)?" +
"(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?))?" +
"(?=\\W|$)" , "i" ) ;
const HOUR _GROUP$2 = 2 ;
const MINUTE _GROUP$2 = 3 ;
const SECOND _GROUP$2 = 4 ;
const AM _PM _HOUR _GROUP$2 = 5 ;
class FRSpecificTimeExpressionParser {
pattern ( context ) {
return FIRST _REG _PATTERN$2 ;
}
extract ( context , match ) {
const result = context . createParsingResult ( match . index + match [ 1 ] . length , match [ 0 ] . substring ( match [ 1 ] . length ) ) ;
if ( result . text . match ( /^\d{4}$/ ) ) {
match . index += match [ 0 ] . length ;
return null ;
}
result . start = FRSpecificTimeExpressionParser . extractTimeComponent ( result . start . clone ( ) , match ) ;
if ( ! result . start ) {
match . index += match [ 0 ] . length ;
return null ;
}
const remainingText = context . text . substring ( match . index + match [ 0 ] . length ) ;
const secondMatch = SECOND _REG _PATTERN$2 . exec ( remainingText ) ;
if ( secondMatch ) {
result . end = FRSpecificTimeExpressionParser . extractTimeComponent ( result . start . clone ( ) , secondMatch ) ;
if ( result . end ) {
result . text += secondMatch [ 0 ] ;
}
}
return result ;
}
static extractTimeComponent ( extractingComponents , match ) {
let hour = 0 ;
let minute = 0 ;
let meridiem = null ;
hour = parseInt ( match [ HOUR _GROUP$2 ] ) ;
if ( match [ MINUTE _GROUP$2 ] != null ) {
minute = parseInt ( match [ MINUTE _GROUP$2 ] ) ;
}
if ( minute >= 60 || hour > 24 ) {
return null ;
}
if ( hour >= 12 ) {
meridiem = index _1$4 . Meridiem . PM ;
}
if ( match [ AM _PM _HOUR _GROUP$2 ] != null ) {
if ( hour > 12 )
return null ;
const ampm = match [ AM _PM _HOUR _GROUP$2 ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = index _1$4 . Meridiem . AM ;
if ( hour == 12 ) {
hour = 0 ;
}
}
if ( ampm == "p" ) {
meridiem = index _1$4 . Meridiem . PM ;
if ( hour != 12 ) {
hour += 12 ;
}
}
}
extractingComponents . assign ( "hour" , hour ) ;
extractingComponents . assign ( "minute" , minute ) ;
if ( meridiem !== null ) {
extractingComponents . assign ( "meridiem" , meridiem ) ;
}
else {
if ( hour < 12 ) {
extractingComponents . imply ( "meridiem" , index _1$4 . Meridiem . AM ) ;
}
else {
extractingComponents . imply ( "meridiem" , index _1$4 . Meridiem . PM ) ;
}
}
if ( match [ SECOND _GROUP$2 ] != null ) {
const second = parseInt ( match [ SECOND _GROUP$2 ] ) ;
if ( second >= 60 )
return null ;
extractingComponents . assign ( "second" , second ) ;
}
return extractingComponents ;
}
}
FRSpecificTimeExpressionParser$1 . default = FRSpecificTimeExpressionParser ;
var FRMonthNameLittleEndianParser$1 = { } ;
Object . defineProperty ( FRMonthNameLittleEndianParser$1 , "__esModule" , { value : true } ) ;
const years _1$4 = years ;
const constants _1$p = constants$5 ;
const constants _2$3 = constants$5 ;
const constants _3$1 = constants$5 ;
const pattern _1$8 = pattern ;
const AbstractParserWithWordBoundary _1$w = AbstractParserWithWordBoundary ;
const PATTERN$j = new RegExp ( "(?:on\\s*?)?" +
` ( ${ constants _3$1 . ORDINAL _NUMBER _PATTERN } ) ` +
` (?: \\ s*(?:au| \\ -| \\ – \\ s) \\ s*( ${ constants _3$1 . ORDINAL _NUMBER _PATTERN } ))? ` +
` (?:-|/| \\ s*(?:de)? \\ s*) ` +
` ( ${ ( 0 , pattern _1$8 . matchAnyPattern ) ( constants _1$p . MONTH _DICTIONARY ) } ) ` +
` (?:(?:-|/|,? \\ s*)( ${ constants _2$3 . YEAR _PATTERN } (?![^ \\ s] \\ d)))? ` +
` (?= \\ W| $ ) ` , "i" ) ;
const DATE _GROUP$3 = 1 ;
const DATE _TO _GROUP$2 = 2 ;
const MONTH _NAME _GROUP$4 = 3 ;
const YEAR _GROUP$6 = 4 ;
class FRMonthNameLittleEndianParser extends AbstractParserWithWordBoundary _1$w . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$j ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const month = constants _1$p . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$4 ] . toLowerCase ( ) ] ;
const day = ( 0 , constants _3$1 . parseOrdinalNumberPattern ) ( match [ DATE _GROUP$3 ] ) ;
if ( day > 31 ) {
match . index = match . index + match [ DATE _GROUP$3 ] . length ;
return null ;
}
result . start . assign ( "month" , month ) ;
result . start . assign ( "day" , day ) ;
if ( match [ YEAR _GROUP$6 ] ) {
const yearNumber = ( 0 , constants _2$3 . parseYear ) ( match [ YEAR _GROUP$6 ] ) ;
result . start . assign ( "year" , yearNumber ) ;
}
else {
const year = ( 0 , years _1$4 . findYearClosestToRef ) ( context . refDate , day , month ) ;
result . start . imply ( "year" , year ) ;
}
if ( match [ DATE _TO _GROUP$2 ] ) {
const endDate = ( 0 , constants _3$1 . parseOrdinalNumberPattern ) ( match [ DATE _TO _GROUP$2 ] ) ;
result . end = result . start . clone ( ) ;
result . end . assign ( "day" , endDate ) ;
}
return result ;
}
}
FRMonthNameLittleEndianParser$1 . default = FRMonthNameLittleEndianParser ;
var FRTimeUnitAgoFormatParser$2 = { } ;
Object . defineProperty ( FRTimeUnitAgoFormatParser$2 , "__esModule" , { value : true } ) ;
const constants _1$o = constants$5 ;
const results _1$7 = results ;
const AbstractParserWithWordBoundary _1$v = AbstractParserWithWordBoundary ;
const timeunits _1$3 = timeunits ;
class FRTimeUnitAgoFormatParser$1 extends AbstractParserWithWordBoundary _1$v . AbstractParserWithWordBoundaryChecking {
constructor ( ) {
super ( ) ;
}
innerPattern ( ) {
return new RegExp ( ` il y a \\ s*( ${ constants _1$o . TIME _UNITS _PATTERN } )(?=(?: \\ W| $ )) ` , "i" ) ;
}
innerExtract ( context , match ) {
const timeUnits = ( 0 , constants _1$o . parseTimeUnits ) ( match [ 1 ] ) ;
const outputTimeUnits = ( 0 , timeunits _1$3 . reverseTimeUnits ) ( timeUnits ) ;
return results _1$7 . ParsingComponents . createRelativeFromReference ( context . reference , outputTimeUnits ) ;
}
}
FRTimeUnitAgoFormatParser$2 . default = FRTimeUnitAgoFormatParser$1 ;
var FRTimeUnitWithinFormatParser$1 = { } ;
Object . defineProperty ( FRTimeUnitWithinFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$n = constants$5 ;
const results _1$6 = results ;
const AbstractParserWithWordBoundary _1$u = AbstractParserWithWordBoundary ;
class FRTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary _1$u . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return new RegExp ( ` (?:dans|en|pour|pendant) \\ s*( ${ constants _1$n . TIME _UNITS _PATTERN } )(?= \\ W| $ ) ` , "i" ) ;
}
innerExtract ( context , match ) {
const timeUnits = ( 0 , constants _1$n . parseTimeUnits ) ( match [ 1 ] ) ;
return results _1$6 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
}
FRTimeUnitWithinFormatParser$1 . default = FRTimeUnitWithinFormatParser ;
var FRTimeUnitRelativeFormatParser = { } ;
Object . defineProperty ( FRTimeUnitRelativeFormatParser , "__esModule" , { value : true } ) ;
const constants _1$m = constants$5 ;
const results _1$5 = results ;
const AbstractParserWithWordBoundary _1$t = AbstractParserWithWordBoundary ;
const timeunits _1$2 = timeunits ;
const pattern _1$7 = pattern ;
class FRTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary _1$t . AbstractParserWithWordBoundaryChecking {
constructor ( ) {
super ( ) ;
}
innerPattern ( ) {
return new RegExp ( ` (?:les?|la|l'|du|des?) \\ s* ` +
` ( ${ constants _1$m . NUMBER _PATTERN } )? ` +
` (?: \\ s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))? ` +
` \\ s*( ${ ( 0 , pattern _1$7 . matchAnyPattern ) ( constants _1$m . TIME _UNIT _DICTIONARY ) } ) ` +
` (?: \\ s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))? ` , "i" ) ;
}
innerExtract ( context , match ) {
const num = match [ 1 ] ? ( 0 , constants _1$m . parseNumberPattern ) ( match [ 1 ] ) : 1 ;
const unit = constants _1$m . TIME _UNIT _DICTIONARY [ match [ 3 ] . toLowerCase ( ) ] ;
let timeUnits = { } ;
timeUnits [ unit ] = num ;
let modifier = match [ 2 ] || match [ 4 ] || "" ;
modifier = modifier . toLowerCase ( ) ;
if ( ! modifier ) {
return ;
}
if ( /derni[eè]re?s?/ . test ( modifier ) || /pass[ée]e?s?/ . test ( modifier ) || /pr[ée]c[ée]dents?/ . test ( modifier ) ) {
timeUnits = ( 0 , timeunits _1$2 . reverseTimeUnits ) ( timeUnits ) ;
}
return results _1$5 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
}
FRTimeUnitRelativeFormatParser . default = FRTimeUnitAgoFormatParser ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = void 0 ;
const configurations _1 = configurations ;
const chrono _1 = chrono$1 ;
const FRCasualDateParser _1 = _ _importDefault ( FRCasualDateParser$1 ) ;
const FRCasualTimeParser _1 = _ _importDefault ( FRCasualTimeParser$1 ) ;
const SlashDateFormatParser _1 = _ _importDefault ( SlashDateFormatParser$1 ) ;
const FRTimeExpressionParser _1 = _ _importDefault ( FRTimeExpressionParser$1 ) ;
const FRMergeDateTimeRefiner _1 = _ _importDefault ( FRMergeDateTimeRefiner$1 ) ;
const FRMergeDateRangeRefiner _1 = _ _importDefault ( FRMergeDateRangeRefiner$1 ) ;
const FRWeekdayParser _1 = _ _importDefault ( FRWeekdayParser$1 ) ;
const FRSpecificTimeExpressionParser _1 = _ _importDefault ( FRSpecificTimeExpressionParser$1 ) ;
const FRMonthNameLittleEndianParser _1 = _ _importDefault ( FRMonthNameLittleEndianParser$1 ) ;
const FRTimeUnitAgoFormatParser _1 = _ _importDefault ( FRTimeUnitAgoFormatParser$2 ) ;
const FRTimeUnitWithinFormatParser _1 = _ _importDefault ( FRTimeUnitWithinFormatParser$1 ) ;
const FRTimeUnitRelativeFormatParser _1 = _ _importDefault ( FRTimeUnitRelativeFormatParser ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( true ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( littleEndian = true ) {
const option = createConfiguration ( false , littleEndian ) ;
option . parsers . unshift ( new FRCasualDateParser _1 . default ( ) ) ;
option . parsers . unshift ( new FRCasualTimeParser _1 . default ( ) ) ;
option . parsers . unshift ( new FRTimeUnitRelativeFormatParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( strictMode = true , littleEndian = true ) {
return ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new SlashDateFormatParser _1 . default ( littleEndian ) ,
new FRMonthNameLittleEndianParser _1 . default ( ) ,
new FRTimeExpressionParser _1 . default ( ) ,
new FRSpecificTimeExpressionParser _1 . default ( ) ,
new FRTimeUnitAgoFormatParser _1 . default ( ) ,
new FRTimeUnitWithinFormatParser _1 . default ( ) ,
new FRWeekdayParser _1 . default ( ) ,
] ,
refiners : [ new FRMergeDateTimeRefiner _1 . default ( ) , new FRMergeDateRangeRefiner _1 . default ( ) ] ,
} , strictMode ) ;
}
exports . createConfiguration = createConfiguration ;
} ( fr ) ) ;
var ja = { } ;
var JPStandardParser$1 = { } ;
var constants$4 = { } ;
Object . defineProperty ( constants$4 , "__esModule" , { value : true } ) ;
constants$4 . toHankaku = void 0 ;
function toHankaku ( text ) {
return String ( text )
. replace ( /\u2019/g , "\u0027" )
. replace ( /\u201D/g , "\u0022" )
. replace ( /\u3000/g , "\u0020" )
. replace ( /\uFFE5/g , "\u00A5" )
. replace ( /[\uFF01\uFF03-\uFF06\uFF08\uFF09\uFF0C-\uFF19\uFF1C-\uFF1F\uFF21-\uFF3B\uFF3D\uFF3F\uFF41-\uFF5B\uFF5D\uFF5E]/g , alphaNum ) ;
}
constants$4 . toHankaku = toHankaku ;
function alphaNum ( token ) {
return String . fromCharCode ( token . charCodeAt ( 0 ) - 65248 ) ;
}
var _ _importDefault$q = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( JPStandardParser$1 , "__esModule" , { value : true } ) ;
const constants _1$l = constants$4 ;
const years _1$3 = years ;
const dayjs _1$h = _ _importDefault$q ( require$$0 ) ;
const PATTERN$i = /(?:(?:([同今本])|((昭和|平成|令和)?([0-9０ ９ ０ ９ ０ ９ ;
const SPECIAL _YEAR _GROUP = 1 ;
const TYPICAL _YEAR _GROUP = 2 ;
const ERA _GROUP = 3 ;
const YEAR _NUMBER _GROUP$1 = 4 ;
const MONTH _GROUP$3 = 5 ;
const DAY _GROUP$3 = 6 ;
class JPStandardParser {
pattern ( ) {
return PATTERN$i ;
}
extract ( context , match ) {
const month = parseInt ( ( 0 , constants _1$l . toHankaku ) ( match [ MONTH _GROUP$3 ] ) ) ;
const day = parseInt ( ( 0 , constants _1$l . toHankaku ) ( match [ DAY _GROUP$3 ] ) ) ;
const components = context . createParsingComponents ( {
day : day ,
month : month ,
} ) ;
if ( match [ SPECIAL _YEAR _GROUP ] && match [ SPECIAL _YEAR _GROUP ] . match ( "同|今|本" ) ) {
const moment = ( 0 , dayjs _1$h . default ) ( context . refDate ) ;
components . assign ( "year" , moment . year ( ) ) ;
}
if ( match [ TYPICAL _YEAR _GROUP ] ) {
const yearNumText = match [ YEAR _NUMBER _GROUP$1 ] ;
let year = yearNumText == "元" ? 1 : parseInt ( ( 0 , constants _1$l . toHankaku ) ( yearNumText ) ) ;
if ( match [ ERA _GROUP ] == "令和" ) {
year += 2018 ;
}
else if ( match [ ERA _GROUP ] == "平成" ) {
year += 1988 ;
}
else if ( match [ ERA _GROUP ] == "昭和" ) {
year += 1925 ;
}
components . assign ( "year" , year ) ;
}
else {
const year = ( 0 , years _1$3 . findYearClosestToRef ) ( context . refDate , day , month ) ;
components . imply ( "year" , year ) ;
}
return components ;
}
}
JPStandardParser$1 . default = JPStandardParser ;
var JPMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$p = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( JPMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$4 = _ _importDefault$p ( AbstractMergeDateRangeRefiner$1 ) ;
class JPMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$4 . default {
patternBetween ( ) {
return /^\s*(から|ー|-)\s*$/i ;
}
}
JPMergeDateRangeRefiner$1 . default = JPMergeDateRangeRefiner ;
var JPCasualDateParser$1 = { } ;
var _ _createBinding$2 = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault$2 = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar$2 = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding$2 ( result , mod , k ) ;
_ _setModuleDefault$2 ( result , mod ) ;
return result ;
} ;
var _ _importDefault$o = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( JPCasualDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$g = _ _importDefault$o ( require$$0 ) ;
const index _1$3 = dist ;
const references$2 = _ _importStar$2 ( casualReferences ) ;
const PATTERN$h = /今日|当日|昨日|明日|今夜|今夕|今晩|今朝/i ;
class JPCasualDateParser {
pattern ( ) {
return PATTERN$h ;
}
extract ( context , match ) {
const text = match [ 0 ] ;
const date = ( 0 , dayjs _1$g . default ) ( context . refDate ) ;
const components = context . createParsingComponents ( ) ;
switch ( text ) {
case "昨日" :
return references$2 . yesterday ( context . reference ) ;
case "明日" :
return references$2 . tomorrow ( context . reference ) ;
case "今日" :
case "当日" :
return references$2 . today ( context . reference ) ;
}
if ( text == "今夜" || text == "今夕" || text == "今晩" ) {
components . imply ( "hour" , 22 ) ;
components . assign ( "meridiem" , index _1$3 . Meridiem . PM ) ;
}
else if ( text . match ( "今朝" ) ) {
components . imply ( "hour" , 6 ) ;
components . assign ( "meridiem" , index _1$3 . Meridiem . AM ) ;
}
components . assign ( "day" , date . date ( ) ) ;
components . assign ( "month" , date . month ( ) + 1 ) ;
components . assign ( "year" , date . year ( ) ) ;
return components ;
}
}
JPCasualDateParser$1 . default = JPCasualDateParser ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = void 0 ;
const JPStandardParser _1 = _ _importDefault ( JPStandardParser$1 ) ;
const JPMergeDateRangeRefiner _1 = _ _importDefault ( JPMergeDateRangeRefiner$1 ) ;
const JPCasualDateParser _1 = _ _importDefault ( JPCasualDateParser$1 ) ;
const chrono _1 = chrono$1 ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( ) {
const option = createConfiguration ( ) ;
option . parsers . unshift ( new JPCasualDateParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( ) {
return {
parsers : [ new JPStandardParser _1 . default ( ) ] ,
refiners : [ new JPMergeDateRangeRefiner _1 . default ( ) ] ,
} ;
}
exports . createConfiguration = createConfiguration ;
} ( ja ) ) ;
var pt = { } ;
var PTWeekdayParser$1 = { } ;
var constants$3 = { } ;
Object . defineProperty ( constants$3 , "__esModule" , { value : true } ) ;
constants$3 . parseYear = constants$3 . YEAR _PATTERN = constants$3 . MONTH _DICTIONARY = constants$3 . WEEKDAY _DICTIONARY = void 0 ;
constants$3 . WEEKDAY _DICTIONARY = {
"domingo" : 0 ,
"dom" : 0 ,
"segunda" : 1 ,
"segunda-feira" : 1 ,
"seg" : 1 ,
"terça" : 2 ,
"terça-feira" : 2 ,
"ter" : 2 ,
"quarta" : 3 ,
"quarta-feira" : 3 ,
"qua" : 3 ,
"quinta" : 4 ,
"quinta-feira" : 4 ,
"qui" : 4 ,
"sexta" : 5 ,
"sexta-feira" : 5 ,
"sex" : 5 ,
"sábado" : 6 ,
"sabado" : 6 ,
"sab" : 6 ,
} ;
constants$3 . MONTH _DICTIONARY = {
"janeiro" : 1 ,
"jan" : 1 ,
"jan." : 1 ,
"fevereiro" : 2 ,
"fev" : 2 ,
"fev." : 2 ,
"março" : 3 ,
"mar" : 3 ,
"mar." : 3 ,
"abril" : 4 ,
"abr" : 4 ,
"abr." : 4 ,
"maio" : 5 ,
"mai" : 5 ,
"mai." : 5 ,
"junho" : 6 ,
"jun" : 6 ,
"jun." : 6 ,
"julho" : 7 ,
"jul" : 7 ,
"jul." : 7 ,
"agosto" : 8 ,
"ago" : 8 ,
"ago." : 8 ,
"setembro" : 9 ,
"set" : 9 ,
"set." : 9 ,
"outubro" : 10 ,
"out" : 10 ,
"out." : 10 ,
"novembro" : 11 ,
"nov" : 11 ,
"nov." : 11 ,
"dezembro" : 12 ,
"dez" : 12 ,
"dez." : 12 ,
} ;
constants$3 . YEAR _PATTERN = "[0-9]{1,4}(?![^\\s]\\d)(?:\\s*[a|d]\\.?\\s*c\\.?|\\s*a\\.?\\s*d\\.?)?" ;
function parseYear ( match ) {
if ( match . match ( /^[0-9]{1,4}$/ ) ) {
let yearNumber = parseInt ( match ) ;
if ( yearNumber < 100 ) {
if ( yearNumber > 50 ) {
yearNumber = yearNumber + 1900 ;
}
else {
yearNumber = yearNumber + 2000 ;
}
}
return yearNumber ;
}
if ( match . match ( /a\.?\s*c\.?/i ) ) {
match = match . replace ( /a\.?\s*c\.?/i , "" ) ;
return - parseInt ( match ) ;
}
return parseInt ( match ) ;
}
constants$3 . parseYear = parseYear ;
Object . defineProperty ( PTWeekdayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$k = constants$3 ;
const pattern _1$6 = pattern ;
const AbstractParserWithWordBoundary _1$s = AbstractParserWithWordBoundary ;
const weeks _1$1 = weeks ;
const PATTERN$g = new RegExp ( "(?:(?:\\,|\\(|\\（ +
"(?:(este|esta|passado|pr[oó]ximo)\\s*)?" +
` ( ${ ( 0 , pattern _1$6 . matchAnyPattern ) ( constants _1$k . WEEKDAY _DICTIONARY ) } ) ` +
"(?:\\s*(?:\\,|\\)|\\） +
"(?:\\s*(este|esta|passado|pr[óo]ximo)\\s*semana)?" +
"(?=\\W|\\d|$)" , "i" ) ;
const PREFIX _GROUP$1 = 1 ;
const WEEKDAY _GROUP$1 = 2 ;
const POSTFIX _GROUP$1 = 3 ;
class PTWeekdayParser extends AbstractParserWithWordBoundary _1$s . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$g ;
}
innerExtract ( context , match ) {
const dayOfWeek = match [ WEEKDAY _GROUP$1 ] . toLowerCase ( ) ;
const offset = constants _1$k . WEEKDAY _DICTIONARY [ dayOfWeek ] ;
if ( offset === undefined ) {
return null ;
}
const prefix = match [ PREFIX _GROUP$1 ] ;
const postfix = match [ POSTFIX _GROUP$1 ] ;
let norm = prefix || postfix || "" ;
norm = norm . toLowerCase ( ) ;
let modifier = null ;
if ( norm == "passado" ) {
modifier = "this" ;
}
else if ( norm == "próximo" || norm == "proximo" ) {
modifier = "next" ;
}
else if ( norm == "este" ) {
modifier = "this" ;
}
const date = ( 0 , weeks _1$1 . toDayJSWeekday ) ( context . refDate , offset , modifier ) ;
return context
. createParsingComponents ( )
. assign ( "weekday" , offset )
. imply ( "day" , date . date ( ) )
. imply ( "month" , date . month ( ) + 1 )
. imply ( "year" , date . year ( ) ) ;
}
}
PTWeekdayParser$1 . default = PTWeekdayParser ;
var PTTimeExpressionParser$1 = { } ;
Object . defineProperty ( PTTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const AbstractTimeExpressionParser _1$1 = AbstractTimeExpressionParser$1 ;
class PTTimeExpressionParser extends AbstractTimeExpressionParser _1$1 . AbstractTimeExpressionParser {
primaryPrefix ( ) {
return "(?:(?:ao?|às?|das|da|de|do)\\s*)?" ;
}
followingPhase ( ) {
return "\\s*(?:\\-|\\– ;
}
}
PTTimeExpressionParser$1 . default = PTTimeExpressionParser ;
var PTMergeDateTimeRefiner$1 = { } ;
var _ _importDefault$n = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( PTMergeDateTimeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1$3 = _ _importDefault$n ( AbstractMergeDateTimeRefiner ) ;
class PTMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1$3 . default {
patternBetween ( ) {
return new RegExp ( "^\\s*(?:,|à)?\\s*$" ) ;
}
}
PTMergeDateTimeRefiner$1 . default = PTMergeDateTimeRefiner ;
var PTMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$m = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( PTMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$3 = _ _importDefault$m ( AbstractMergeDateRangeRefiner$1 ) ;
class PTMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$3 . default {
patternBetween ( ) {
return /^\s*(?:-)\s*$/i ;
}
}
PTMergeDateRangeRefiner$1 . default = PTMergeDateRangeRefiner ;
var PTMonthNameLittleEndianParser$1 = { } ;
Object . defineProperty ( PTMonthNameLittleEndianParser$1 , "__esModule" , { value : true } ) ;
const years _1$2 = years ;
const constants _1$j = constants$3 ;
const constants _2$2 = constants$3 ;
const pattern _1$5 = pattern ;
const AbstractParserWithWordBoundary _1$r = AbstractParserWithWordBoundary ;
const PATTERN$f = new RegExp ( ` ([0-9]{1,2})(?:º|ª|°)? ` +
"(?:\\s*(?:desde|de|\\-|\\– +
` (?:-|/| \\ s*(?:de|,)? \\ s*) ` +
` ( ${ ( 0 , pattern _1$5 . matchAnyPattern ) ( constants _1$j . MONTH _DICTIONARY ) } ) ` +
` (?: \\ s*(?:de|,)? \\ s*( ${ constants _2$2 . YEAR _PATTERN } ))? ` +
` (?= \\ W| $ ) ` , "i" ) ;
const DATE _GROUP$2 = 1 ;
const DATE _TO _GROUP$1 = 2 ;
const MONTH _NAME _GROUP$3 = 3 ;
const YEAR _GROUP$5 = 4 ;
class PTMonthNameLittleEndianParser extends AbstractParserWithWordBoundary _1$r . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$f ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const month = constants _1$j . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$3 ] . toLowerCase ( ) ] ;
const day = parseInt ( match [ DATE _GROUP$2 ] ) ;
if ( day > 31 ) {
match . index = match . index + match [ DATE _GROUP$2 ] . length ;
return null ;
}
result . start . assign ( "month" , month ) ;
result . start . assign ( "day" , day ) ;
if ( match [ YEAR _GROUP$5 ] ) {
const yearNumber = ( 0 , constants _2$2 . parseYear ) ( match [ YEAR _GROUP$5 ] ) ;
result . start . assign ( "year" , yearNumber ) ;
}
else {
const year = ( 0 , years _1$2 . findYearClosestToRef ) ( context . refDate , day , month ) ;
result . start . imply ( "year" , year ) ;
}
if ( match [ DATE _TO _GROUP$1 ] ) {
const endDate = parseInt ( match [ DATE _TO _GROUP$1 ] ) ;
result . end = result . start . clone ( ) ;
result . end . assign ( "day" , endDate ) ;
}
return result ;
}
}
PTMonthNameLittleEndianParser$1 . default = PTMonthNameLittleEndianParser ;
var PTCasualDateParser$1 = { } ;
var _ _createBinding$1 = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault$1 = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar$1 = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding$1 ( result , mod , k ) ;
_ _setModuleDefault$1 ( result , mod ) ;
return result ;
} ;
Object . defineProperty ( PTCasualDateParser$1 , "__esModule" , { value : true } ) ;
const AbstractParserWithWordBoundary _1$q = AbstractParserWithWordBoundary ;
const references$1 = _ _importStar$1 ( casualReferences ) ;
class PTCasualDateParser extends AbstractParserWithWordBoundary _1$q . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return /(agora|hoje|amanha|amanhã|ontem)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const lowerText = match [ 0 ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
switch ( lowerText ) {
case "agora" :
return references$1 . now ( context . reference ) ;
case "hoje" :
return references$1 . today ( context . reference ) ;
case "amanha" :
case "amanhã" :
return references$1 . tomorrow ( context . reference ) ;
case "ontem" :
return references$1 . yesterday ( context . reference ) ;
}
return component ;
}
}
PTCasualDateParser$1 . default = PTCasualDateParser ;
var PTCasualTimeParser$1 = { } ;
var _ _importDefault$l = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( PTCasualTimeParser$1 , "__esModule" , { value : true } ) ;
const index _1$2 = dist ;
const AbstractParserWithWordBoundary _1$p = AbstractParserWithWordBoundary ;
const dayjs _1$f = dayjs ;
const dayjs _2$2 = _ _importDefault$l ( require$$0 ) ;
class PTCasualTimeParser extends AbstractParserWithWordBoundary _1$p . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return /(?:esta\s*)?(manha|manhã|tarde|meia-noite|meio-dia|noite)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const targetDate = ( 0 , dayjs _2$2 . default ) ( context . refDate ) ;
const component = context . createParsingComponents ( ) ;
switch ( match [ 1 ] . toLowerCase ( ) ) {
case "tarde" :
component . imply ( "meridiem" , index _1$2 . Meridiem . PM ) ;
component . imply ( "hour" , 15 ) ;
break ;
case "noite" :
component . imply ( "meridiem" , index _1$2 . Meridiem . PM ) ;
component . imply ( "hour" , 22 ) ;
break ;
case "manha" :
case "manhã" :
component . imply ( "meridiem" , index _1$2 . Meridiem . AM ) ;
component . imply ( "hour" , 6 ) ;
break ;
case "meia-noite" :
( 0 , dayjs _1$f . assignTheNextDay ) ( component , targetDate ) ;
component . imply ( "hour" , 0 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
break ;
case "meio-dia" :
component . imply ( "meridiem" , index _1$2 . Meridiem . AM ) ;
component . imply ( "hour" , 12 ) ;
break ;
}
return component ;
}
}
PTCasualTimeParser$1 . default = PTCasualTimeParser ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = void 0 ;
const configurations _1 = configurations ;
const chrono _1 = chrono$1 ;
const SlashDateFormatParser _1 = _ _importDefault ( SlashDateFormatParser$1 ) ;
const PTWeekdayParser _1 = _ _importDefault ( PTWeekdayParser$1 ) ;
const PTTimeExpressionParser _1 = _ _importDefault ( PTTimeExpressionParser$1 ) ;
const PTMergeDateTimeRefiner _1 = _ _importDefault ( PTMergeDateTimeRefiner$1 ) ;
const PTMergeDateRangeRefiner _1 = _ _importDefault ( PTMergeDateRangeRefiner$1 ) ;
const PTMonthNameLittleEndianParser _1 = _ _importDefault ( PTMonthNameLittleEndianParser$1 ) ;
const PTCasualDateParser _1 = _ _importDefault ( PTCasualDateParser$1 ) ;
const PTCasualTimeParser _1 = _ _importDefault ( PTCasualTimeParser$1 ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( true ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( littleEndian = true ) {
const option = createConfiguration ( false , littleEndian ) ;
option . parsers . push ( new PTCasualDateParser _1 . default ( ) ) ;
option . parsers . push ( new PTCasualTimeParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( strictMode = true , littleEndian = true ) {
return ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new SlashDateFormatParser _1 . default ( littleEndian ) ,
new PTWeekdayParser _1 . default ( ) ,
new PTTimeExpressionParser _1 . default ( ) ,
new PTMonthNameLittleEndianParser _1 . default ( ) ,
] ,
refiners : [ new PTMergeDateTimeRefiner _1 . default ( ) , new PTMergeDateRangeRefiner _1 . default ( ) ] ,
} , strictMode ) ;
}
exports . createConfiguration = createConfiguration ;
} ( pt ) ) ;
var nl = { } ;
var NLMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$k = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( NLMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$2 = _ _importDefault$k ( AbstractMergeDateRangeRefiner$1 ) ;
class NLMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$2 . default {
patternBetween ( ) {
return /^\s*(tot|-)\s*$/i ;
}
}
NLMergeDateRangeRefiner$1 . default = NLMergeDateRangeRefiner ;
var NLMergeDateTimeRefiner$1 = { } ;
var _ _importDefault$j = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( NLMergeDateTimeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1$2 = _ _importDefault$j ( AbstractMergeDateTimeRefiner ) ;
class NLMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1$2 . default {
patternBetween ( ) {
return new RegExp ( "^\\s*(om|na|voor|in de|,|-)?\\s*$" ) ;
}
}
NLMergeDateTimeRefiner$1 . default = NLMergeDateTimeRefiner ;
var NLCasualDateParser$1 = { } ;
var _ _createBinding = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
Object . defineProperty ( NLCasualDateParser$1 , "__esModule" , { value : true } ) ;
const AbstractParserWithWordBoundary _1$o = AbstractParserWithWordBoundary ;
const references = _ _importStar ( casualReferences ) ;
class NLCasualDateParser extends AbstractParserWithWordBoundary _1$o . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return /(nu|vandaag|morgen|morgend|gisteren)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const lowerText = match [ 0 ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
switch ( lowerText ) {
case "nu" :
return references . now ( context . reference ) ;
case "vandaag" :
return references . today ( context . reference ) ;
case "morgen" :
case "morgend" :
return references . tomorrow ( context . reference ) ;
case "gisteren" :
return references . yesterday ( context . reference ) ;
}
return component ;
}
}
NLCasualDateParser$1 . default = NLCasualDateParser ;
var NLCasualTimeParser$1 = { } ;
var _ _importDefault$i = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( NLCasualTimeParser$1 , "__esModule" , { value : true } ) ;
const index _1$1 = dist ;
const AbstractParserWithWordBoundary _1$n = AbstractParserWithWordBoundary ;
const dayjs _1$e = _ _importDefault$i ( require$$0 ) ;
const dayjs _2$1 = dayjs ;
const DAY _GROUP$2 = 1 ;
const MOMENT _GROUP = 2 ;
class NLCasualTimeParser extends AbstractParserWithWordBoundary _1$n . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return /(deze)?\s*(namiddag|avond|middernacht|ochtend|middag|'s middags|'s avonds|'s ochtends)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const targetDate = ( 0 , dayjs _1$e . default ) ( context . refDate ) ;
const component = context . createParsingComponents ( ) ;
if ( match [ DAY _GROUP$2 ] === "deze" ) {
component . assign ( "day" , context . refDate . getDate ( ) ) ;
component . assign ( "month" , context . refDate . getMonth ( ) + 1 ) ;
component . assign ( "year" , context . refDate . getFullYear ( ) ) ;
}
switch ( match [ MOMENT _GROUP ] . toLowerCase ( ) ) {
case "namiddag" :
case "'s namiddags" :
component . imply ( "meridiem" , index _1$1 . Meridiem . PM ) ;
component . imply ( "hour" , 15 ) ;
break ;
case "avond" :
case "'s avonds'" :
component . imply ( "meridiem" , index _1$1 . Meridiem . PM ) ;
component . imply ( "hour" , 20 ) ;
break ;
case "middernacht" :
( 0 , dayjs _2$1 . assignTheNextDay ) ( component , targetDate ) ;
component . imply ( "hour" , 0 ) ;
component . imply ( "minute" , 0 ) ;
component . imply ( "second" , 0 ) ;
break ;
case "ochtend" :
case "'s ochtends" :
component . imply ( "meridiem" , index _1$1 . Meridiem . AM ) ;
component . imply ( "hour" , 6 ) ;
break ;
case "middag" :
case "'s middags" :
component . imply ( "meridiem" , index _1$1 . Meridiem . AM ) ;
component . imply ( "hour" , 12 ) ;
break ;
}
return component ;
}
}
NLCasualTimeParser$1 . default = NLCasualTimeParser ;
var NLTimeUnitWithinFormatParser$1 = { } ;
var constants$2 = { } ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . parseTimeUnits = exports . TIME _UNITS _PATTERN = exports . parseYear = exports . YEAR _PATTERN = exports . parseOrdinalNumberPattern = exports . ORDINAL _NUMBER _PATTERN = exports . parseNumberPattern = exports . NUMBER _PATTERN = exports . TIME _UNIT _DICTIONARY = exports . ORDINAL _WORD _DICTIONARY = exports . INTEGER _WORD _DICTIONARY = exports . MONTH _DICTIONARY = exports . WEEKDAY _DICTIONARY = void 0 ;
const pattern _1 = pattern ;
const years _1 = years ;
exports . WEEKDAY _DICTIONARY = {
zondag : 0 ,
zon : 0 ,
"zon." : 0 ,
zo : 0 ,
"zo." : 0 ,
maandag : 1 ,
ma : 1 ,
"ma." : 1 ,
dinsdag : 2 ,
din : 2 ,
"din." : 2 ,
di : 2 ,
"di." : 2 ,
woensdag : 3 ,
woe : 3 ,
"woe." : 3 ,
wo : 3 ,
"wo." : 3 ,
donderdag : 4 ,
dond : 4 ,
"dond." : 4 ,
do : 4 ,
"do." : 4 ,
vrijdag : 5 ,
vrij : 5 ,
"vrij." : 5 ,
vr : 5 ,
"vr." : 5 ,
zaterdag : 6 ,
zat : 6 ,
"zat." : 6 ,
"za" : 6 ,
"za." : 6 ,
} ;
exports . MONTH _DICTIONARY = {
januari : 1 ,
jan : 1 ,
"jan." : 1 ,
februari : 2 ,
feb : 2 ,
"feb." : 2 ,
maart : 3 ,
mar : 3 ,
"mar." : 3 ,
april : 4 ,
apr : 4 ,
"apr." : 4 ,
mei : 5 ,
juni : 6 ,
jun : 6 ,
"jun." : 6 ,
juli : 7 ,
jul : 7 ,
"jul." : 7 ,
augustus : 8 ,
aug : 8 ,
"aug." : 8 ,
september : 9 ,
sep : 9 ,
"sep." : 9 ,
sept : 9 ,
"sept." : 9 ,
oktober : 10 ,
okt : 10 ,
"okt." : 10 ,
november : 11 ,
nov : 11 ,
"nov." : 11 ,
december : 12 ,
dec : 12 ,
"dec." : 12 ,
} ;
exports . INTEGER _WORD _DICTIONARY = {
een : 1 ,
twee : 2 ,
drie : 3 ,
vier : 4 ,
vijf : 5 ,
zes : 6 ,
zeven : 7 ,
acht : 8 ,
negen : 9 ,
tien : 10 ,
elf : 11 ,
twaalf : 12 ,
} ;
exports . ORDINAL _WORD _DICTIONARY = {
eerste : 1 ,
tweede : 2 ,
derde : 3 ,
vierde : 4 ,
vijfde : 5 ,
zesde : 6 ,
zevende : 7 ,
achtste : 8 ,
negende : 9 ,
tiende : 10 ,
elfde : 11 ,
twaalfde : 12 ,
dertiende : 13 ,
veertiende : 14 ,
vijftiende : 15 ,
zestiende : 16 ,
zeventiende : 17 ,
achttiende : 18 ,
negentiende : 19 ,
twintigste : 20 ,
"eenentwintigste" : 21 ,
"tweeëntwintigste" : 22 ,
"drieentwintigste" : 23 ,
"vierentwintigste" : 24 ,
"vijfentwintigste" : 25 ,
"zesentwintigste" : 26 ,
"zevenentwintigste" : 27 ,
"achtentwintig" : 28 ,
"negenentwintig" : 29 ,
"dertigste" : 30 ,
"eenendertigste" : 31 ,
} ;
exports . TIME _UNIT _DICTIONARY = {
sec : "second" ,
second : "second" ,
seconden : "second" ,
min : "minute" ,
mins : "minute" ,
minute : "minute" ,
minuut : "minute" ,
minuten : "minute" ,
minuutje : "minute" ,
h : "hour" ,
hr : "hour" ,
hrs : "hour" ,
uur : "hour" ,
u : "hour" ,
uren : "hour" ,
dag : "d" ,
dagen : "d" ,
week : "week" ,
weken : "week" ,
maand : "month" ,
maanden : "month" ,
jaar : "year" ,
jr : "year" ,
jaren : "year" ,
} ;
exports . NUMBER _PATTERN = ` (?: ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . INTEGER _WORD _DICTIONARY ) } |[0-9]+|[0-9]+[ \\ .,][0-9]+|halve?|half|paar) ` ;
function parseNumberPattern ( match ) {
const num = match . toLowerCase ( ) ;
if ( exports . INTEGER _WORD _DICTIONARY [ num ] !== undefined ) {
return exports . INTEGER _WORD _DICTIONARY [ num ] ;
}
else if ( num === "paar" ) {
return 2 ;
}
else if ( num === "half" || num . match ( /halve?/ ) ) {
return 0.5 ;
}
return parseFloat ( num . replace ( "," , "." ) ) ;
}
exports . parseNumberPattern = parseNumberPattern ;
exports . ORDINAL _NUMBER _PATTERN = ` (?: ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . ORDINAL _WORD _DICTIONARY ) } |[0-9]{1,2}(?:ste|de)?) ` ;
function parseOrdinalNumberPattern ( match ) {
let num = match . toLowerCase ( ) ;
if ( exports . ORDINAL _WORD _DICTIONARY [ num ] !== undefined ) {
return exports . ORDINAL _WORD _DICTIONARY [ num ] ;
}
num = num . replace ( /(?:ste|de)$/i , "" ) ;
return parseInt ( num ) ;
}
exports . parseOrdinalNumberPattern = parseOrdinalNumberPattern ;
exports . YEAR _PATTERN = ` (?:[1-9][0-9]{0,3} \\ s*(?:voor Christus|na Christus)|[1-2][0-9]{3}|[5-9][0-9]) ` ;
function parseYear ( match ) {
if ( /voor Christus/i . test ( match ) ) {
match = match . replace ( /voor Christus/i , "" ) ;
return - parseInt ( match ) ;
}
if ( /na Christus/i . test ( match ) ) {
match = match . replace ( /na Christus/i , "" ) ;
return parseInt ( match ) ;
}
const rawYearNumber = parseInt ( match ) ;
return ( 0 , years _1 . findMostLikelyADYear ) ( rawYearNumber ) ;
}
exports . parseYear = parseYear ;
const SINGLE _TIME _UNIT _PATTERN = ` ( ${ exports . NUMBER _PATTERN } ) \\ s{0,5}( ${ ( 0 , pattern _1 . matchAnyPattern ) ( exports . TIME _UNIT _DICTIONARY ) } ) \\ s{0,5} ` ;
const SINGLE _TIME _UNIT _REGEX = new RegExp ( SINGLE _TIME _UNIT _PATTERN , "i" ) ;
exports . TIME _UNITS _PATTERN = ( 0 , pattern _1 . repeatedTimeunitPattern ) ( ` (?:(?:binnen|in) \\ s*)? ` , SINGLE _TIME _UNIT _PATTERN ) ;
function parseTimeUnits ( timeunitText ) {
const fragments = { } ;
let remainingText = timeunitText ;
let match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
while ( match ) {
collectDateTimeFragment ( fragments , match ) ;
remainingText = remainingText . substring ( match [ 0 ] . length ) ;
match = SINGLE _TIME _UNIT _REGEX . exec ( remainingText ) ;
}
return fragments ;
}
exports . parseTimeUnits = parseTimeUnits ;
function collectDateTimeFragment ( fragments , match ) {
const num = parseNumberPattern ( match [ 1 ] ) ;
const unit = exports . TIME _UNIT _DICTIONARY [ match [ 2 ] . toLowerCase ( ) ] ;
fragments [ unit ] = num ;
}
} ( constants$2 ) ) ;
Object . defineProperty ( NLTimeUnitWithinFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$i = constants$2 ;
const results _1$4 = results ;
const AbstractParserWithWordBoundary _1$m = AbstractParserWithWordBoundary ;
class NLTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary _1$m . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return new RegExp ( ` (?:binnen|in|binnen de|voor) \\ s* ` + "(" + constants _1$i . TIME _UNITS _PATTERN + ")" + ` (?= \\ W| $ ) ` , "i" ) ;
}
innerExtract ( context , match ) {
const timeUnits = ( 0 , constants _1$i . parseTimeUnits ) ( match [ 1 ] ) ;
return results _1$4 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
}
NLTimeUnitWithinFormatParser$1 . default = NLTimeUnitWithinFormatParser ;
var NLWeekdayParser$1 = { } ;
Object . defineProperty ( NLWeekdayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$h = constants$2 ;
const pattern _1$4 = pattern ;
const AbstractParserWithWordBoundary _1$l = AbstractParserWithWordBoundary ;
const weeks _1 = weeks ;
const PATTERN$e = new RegExp ( "(?:(?:\\,|\\(|\\（ +
"(?:op\\s*?)?" +
"(?:(deze|vorige|volgende)\\s*(?:week\\s*)?)?" +
` ( ${ ( 0 , pattern _1$4 . matchAnyPattern ) ( constants _1$h . WEEKDAY _DICTIONARY ) } ) ` +
"(?=\\W|$)" , "i" ) ;
const PREFIX _GROUP = 1 ;
const WEEKDAY _GROUP = 2 ;
const POSTFIX _GROUP = 3 ;
class NLWeekdayParser extends AbstractParserWithWordBoundary _1$l . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$e ;
}
innerExtract ( context , match ) {
const dayOfWeek = match [ WEEKDAY _GROUP ] . toLowerCase ( ) ;
const offset = constants _1$h . WEEKDAY _DICTIONARY [ dayOfWeek ] ;
const prefix = match [ PREFIX _GROUP ] ;
const postfix = match [ POSTFIX _GROUP ] ;
let modifierWord = prefix || postfix ;
modifierWord = modifierWord || "" ;
modifierWord = modifierWord . toLowerCase ( ) ;
let modifier = null ;
if ( modifierWord == "vorige" ) {
modifier = "last" ;
}
else if ( modifierWord == "volgende" ) {
modifier = "next" ;
}
else if ( modifierWord == "deze" ) {
modifier = "this" ;
}
const date = ( 0 , weeks _1 . toDayJSWeekday ) ( context . refDate , offset , modifier ) ;
return context
. createParsingComponents ( )
. assign ( "weekday" , offset )
. imply ( "day" , date . date ( ) )
. imply ( "month" , date . month ( ) + 1 )
. imply ( "year" , date . year ( ) ) ;
}
}
NLWeekdayParser$1 . default = NLWeekdayParser ;
var NLMonthNameMiddleEndianParser$1 = { } ;
Object . defineProperty ( NLMonthNameMiddleEndianParser$1 , "__esModule" , { value : true } ) ;
const years _1$1 = years ;
const constants _1$g = constants$2 ;
const constants _2$1 = constants$2 ;
const constants _3 = constants$2 ;
const pattern _1$3 = pattern ;
const AbstractParserWithWordBoundary _1$k = AbstractParserWithWordBoundary ;
const PATTERN$d = new RegExp ( "(?:on\\s*?)?" +
` ( ${ constants _2$1 . ORDINAL _NUMBER _PATTERN } ) ` +
"(?:\\s*" +
"(?:tot|\\-|\\– +
` ( ${ constants _2$1 . ORDINAL _NUMBER _PATTERN } ) ` +
")?" +
"(?:-|/|\\s*(?:of)?\\s*)" +
"(" +
( 0 , pattern _1$3 . matchAnyPattern ) ( constants _1$g . MONTH _DICTIONARY ) +
")" +
"(?:" +
"(?:-|/|,?\\s*)" +
` ( ${ constants _3 . YEAR _PATTERN } (?![^ \\ s] \\ d)) ` +
")?" +
"(?=\\W|$)" , "i" ) ;
const MONTH _NAME _GROUP$2 = 3 ;
const DATE _GROUP$1 = 1 ;
const DATE _TO _GROUP = 2 ;
const YEAR _GROUP$4 = 4 ;
class NLMonthNameMiddleEndianParser extends AbstractParserWithWordBoundary _1$k . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$d ;
}
innerExtract ( context , match ) {
const month = constants _1$g . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP$2 ] . toLowerCase ( ) ] ;
const day = ( 0 , constants _2$1 . parseOrdinalNumberPattern ) ( match [ DATE _GROUP$1 ] ) ;
if ( day > 31 ) {
match . index = match . index + match [ DATE _GROUP$1 ] . length ;
return null ;
}
const components = context . createParsingComponents ( {
day : day ,
month : month ,
} ) ;
if ( match [ YEAR _GROUP$4 ] ) {
const year = ( 0 , constants _3 . parseYear ) ( match [ YEAR _GROUP$4 ] ) ;
components . assign ( "year" , year ) ;
}
else {
const year = ( 0 , years _1$1 . findYearClosestToRef ) ( context . refDate , day , month ) ;
components . imply ( "year" , year ) ;
}
if ( ! match [ DATE _TO _GROUP ] ) {
return components ;
}
const endDate = ( 0 , constants _2$1 . parseOrdinalNumberPattern ) ( match [ DATE _TO _GROUP ] ) ;
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
result . start = components ;
result . end = components . clone ( ) ;
result . end . assign ( "day" , endDate ) ;
return result ;
}
}
NLMonthNameMiddleEndianParser$1 . default = NLMonthNameMiddleEndianParser ;
var NLMonthNameParser$1 = { } ;
Object . defineProperty ( NLMonthNameParser$1 , "__esModule" , { value : true } ) ;
const constants _1$f = constants$2 ;
const years _1 = years ;
const pattern _1$2 = pattern ;
const constants _2 = constants$2 ;
const AbstractParserWithWordBoundary _1$j = AbstractParserWithWordBoundary ;
const PATTERN$c = new RegExp ( ` ( ${ ( 0 , pattern _1$2 . matchAnyPattern ) ( constants _1$f . MONTH _DICTIONARY ) } ) ` +
` \\ s* ` +
` (?: ` +
` [,-]? \\ s*( ${ constants _2 . YEAR _PATTERN } )? ` +
")?" +
"(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)" , "i" ) ;
const MONTH _NAME _GROUP$1 = 1 ;
const YEAR _GROUP$3 = 2 ;
class NLMonthNameParser extends AbstractParserWithWordBoundary _1$j . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$c ;
}
innerExtract ( context , match ) {
const components = context . createParsingComponents ( ) ;
components . imply ( "day" , 1 ) ;
const monthName = match [ MONTH _NAME _GROUP$1 ] ;
const month = constants _1$f . MONTH _DICTIONARY [ monthName . toLowerCase ( ) ] ;
components . assign ( "month" , month ) ;
if ( match [ YEAR _GROUP$3 ] ) {
const year = ( 0 , constants _2 . parseYear ) ( match [ YEAR _GROUP$3 ] ) ;
components . assign ( "year" , year ) ;
}
else {
const year = ( 0 , years _1 . findYearClosestToRef ) ( context . refDate , 1 , month ) ;
components . imply ( "year" , year ) ;
}
return components ;
}
}
NLMonthNameParser$1 . default = NLMonthNameParser ;
var NLSlashMonthFormatParser$1 = { } ;
Object . defineProperty ( NLSlashMonthFormatParser$1 , "__esModule" , { value : true } ) ;
const AbstractParserWithWordBoundary _1$i = AbstractParserWithWordBoundary ;
const PATTERN$b = new RegExp ( "([0-9]|0[1-9]|1[012])/([0-9]{4})" + "" , "i" ) ;
const MONTH _GROUP$2 = 1 ;
const YEAR _GROUP$2 = 2 ;
class NLSlashMonthFormatParser extends AbstractParserWithWordBoundary _1$i . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$b ;
}
innerExtract ( context , match ) {
const year = parseInt ( match [ YEAR _GROUP$2 ] ) ;
const month = parseInt ( match [ MONTH _GROUP$2 ] ) ;
return context . createParsingComponents ( ) . imply ( "day" , 1 ) . assign ( "month" , month ) . assign ( "year" , year ) ;
}
}
NLSlashMonthFormatParser$1 . default = NLSlashMonthFormatParser ;
var NLTimeExpressionParser$1 = { } ;
Object . defineProperty ( NLTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const AbstractTimeExpressionParser _1 = AbstractTimeExpressionParser$1 ;
class NLTimeExpressionParser extends AbstractTimeExpressionParser _1 . AbstractTimeExpressionParser {
primaryPrefix ( ) {
return "(?:(?:om)\\s*)?" ;
}
followingPhase ( ) {
return "\\s*(?:\\-|\\– ;
}
primarySuffix ( ) {
return "(?:\\s*(?:uur))?(?!/)(?=\\W|$)" ;
}
extractPrimaryTimeComponents ( context , match ) {
if ( match [ 0 ] . match ( /^\s*\d{4}\s*$/ ) ) {
return null ;
}
return super . extractPrimaryTimeComponents ( context , match ) ;
}
}
NLTimeExpressionParser$1 . default = NLTimeExpressionParser ;
var NLCasualYearMonthDayParser$1 = { } ;
Object . defineProperty ( NLCasualYearMonthDayParser$1 , "__esModule" , { value : true } ) ;
const constants _1$e = constants$2 ;
const pattern _1$1 = pattern ;
const AbstractParserWithWordBoundary _1$h = AbstractParserWithWordBoundary ;
const PATTERN$a = new RegExp ( ` ([0-9]{4})[ \\ . \\ / \\ s] ` +
` (?:( ${ ( 0 , pattern _1$1 . matchAnyPattern ) ( constants _1$e . MONTH _DICTIONARY ) } )|([0-9]{1,2}))[ \\ . \\ / \\ s] ` +
` ([0-9]{1,2}) ` +
"(?=\\W|$)" , "i" ) ;
const YEAR _NUMBER _GROUP = 1 ;
const MONTH _NAME _GROUP = 2 ;
const MONTH _NUMBER _GROUP = 3 ;
const DATE _NUMBER _GROUP = 4 ;
class NLCasualYearMonthDayParser extends AbstractParserWithWordBoundary _1$h . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$a ;
}
innerExtract ( context , match ) {
const month = match [ MONTH _NUMBER _GROUP ]
? parseInt ( match [ MONTH _NUMBER _GROUP ] )
: constants _1$e . MONTH _DICTIONARY [ match [ MONTH _NAME _GROUP ] . toLowerCase ( ) ] ;
if ( month < 1 || month > 12 ) {
return null ;
}
const year = parseInt ( match [ YEAR _NUMBER _GROUP ] ) ;
const day = parseInt ( match [ DATE _NUMBER _GROUP ] ) ;
return {
day : day ,
month : month ,
year : year ,
} ;
}
}
NLCasualYearMonthDayParser$1 . default = NLCasualYearMonthDayParser ;
var NLCasualDateTimeParser$1 = { } ;
var _ _importDefault$h = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( NLCasualDateTimeParser$1 , "__esModule" , { value : true } ) ;
const AbstractParserWithWordBoundary _1$g = AbstractParserWithWordBoundary ;
const index _1 = dist ;
const dayjs _1$d = dayjs ;
const dayjs _2 = _ _importDefault$h ( require$$0 ) ;
const DATE _GROUP = 1 ;
const TIME _OF _DAY _GROUP = 2 ;
class NLCasualDateTimeParser extends AbstractParserWithWordBoundary _1$g . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return /(gisteren|morgen|van)(ochtend|middag|namiddag|avond|nacht)(?=\W|$)/i ;
}
innerExtract ( context , match ) {
const dateText = match [ DATE _GROUP ] . toLowerCase ( ) ;
const timeText = match [ TIME _OF _DAY _GROUP ] . toLowerCase ( ) ;
const component = context . createParsingComponents ( ) ;
const targetDate = ( 0 , dayjs _2 . default ) ( context . refDate ) ;
switch ( dateText ) {
case "gisteren" :
( 0 , dayjs _1$d . assignSimilarDate ) ( component , targetDate . add ( - 1 , "day" ) ) ;
break ;
case "van" :
( 0 , dayjs _1$d . assignSimilarDate ) ( component , targetDate ) ;
break ;
case "morgen" :
( 0 , dayjs _1$d . assignTheNextDay ) ( component , targetDate ) ;
break ;
}
switch ( timeText ) {
case "ochtend" :
component . imply ( "meridiem" , index _1 . Meridiem . AM ) ;
component . imply ( "hour" , 6 ) ;
break ;
case "middag" :
component . imply ( "meridiem" , index _1 . Meridiem . AM ) ;
component . imply ( "hour" , 12 ) ;
break ;
case "namiddag" :
component . imply ( "meridiem" , index _1 . Meridiem . PM ) ;
component . imply ( "hour" , 15 ) ;
break ;
case "avond" :
component . imply ( "meridiem" , index _1 . Meridiem . PM ) ;
component . imply ( "hour" , 20 ) ;
break ;
}
return component ;
}
}
NLCasualDateTimeParser$1 . default = NLCasualDateTimeParser ;
var NLTimeUnitCasualRelativeFormatParser$1 = { } ;
Object . defineProperty ( NLTimeUnitCasualRelativeFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$d = constants$2 ;
const results _1$3 = results ;
const AbstractParserWithWordBoundary _1$f = AbstractParserWithWordBoundary ;
const timeunits _1$1 = timeunits ;
const PATTERN$9 = new RegExp ( ` (deze|vorige|afgelopen|komende|over| \\ +|-) \\ s*( ${ constants _1$d . TIME _UNITS _PATTERN } )(?= \\ W| $ ) ` , "i" ) ;
class NLTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary _1$f . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$9 ;
}
innerExtract ( context , match ) {
const prefix = match [ 1 ] . toLowerCase ( ) ;
let timeUnits = ( 0 , constants _1$d . parseTimeUnits ) ( match [ 2 ] ) ;
switch ( prefix ) {
case "vorige" :
case "afgelopen" :
case "-" :
timeUnits = ( 0 , timeunits _1$1 . reverseTimeUnits ) ( timeUnits ) ;
break ;
}
return results _1$3 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
}
NLTimeUnitCasualRelativeFormatParser$1 . default = NLTimeUnitCasualRelativeFormatParser ;
var NLRelativeDateFormatParser$1 = { } ;
var _ _importDefault$g = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( NLRelativeDateFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$c = constants$2 ;
const results _1$2 = results ;
const dayjs _1$c = _ _importDefault$g ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$e = AbstractParserWithWordBoundary ;
const pattern _1 = pattern ;
const PATTERN$8 = new RegExp ( ` (dit|deze|komende|volgend|volgende|afgelopen|vorige) \\ s*( ${ ( 0 , pattern _1 . matchAnyPattern ) ( constants _1$c . TIME _UNIT _DICTIONARY ) } )(?= \\ s*) ` +
"(?=\\W|$)" , "i" ) ;
const MODIFIER _WORD _GROUP = 1 ;
const RELATIVE _WORD _GROUP = 2 ;
class NLRelativeDateFormatParser extends AbstractParserWithWordBoundary _1$e . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$8 ;
}
innerExtract ( context , match ) {
const modifier = match [ MODIFIER _WORD _GROUP ] . toLowerCase ( ) ;
const unitWord = match [ RELATIVE _WORD _GROUP ] . toLowerCase ( ) ;
const timeunit = constants _1$c . TIME _UNIT _DICTIONARY [ unitWord ] ;
if ( modifier == "volgend" || modifier == "volgende" || modifier == "komende" ) {
const timeUnits = { } ;
timeUnits [ timeunit ] = 1 ;
return results _1$2 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
if ( modifier == "afgelopen" || modifier == "vorige" ) {
const timeUnits = { } ;
timeUnits [ timeunit ] = - 1 ;
return results _1$2 . ParsingComponents . createRelativeFromReference ( context . reference , timeUnits ) ;
}
const components = context . createParsingComponents ( ) ;
let date = ( 0 , dayjs _1$c . default ) ( context . reference . instant ) ;
if ( unitWord . match ( /week/i ) ) {
date = date . add ( - date . get ( "d" ) , "d" ) ;
components . imply ( "day" , date . date ( ) ) ;
components . imply ( "month" , date . month ( ) + 1 ) ;
components . imply ( "year" , date . year ( ) ) ;
}
else if ( unitWord . match ( /maand/i ) ) {
date = date . add ( - date . date ( ) + 1 , "d" ) ;
components . imply ( "day" , date . date ( ) ) ;
components . assign ( "year" , date . year ( ) ) ;
components . assign ( "month" , date . month ( ) + 1 ) ;
}
else if ( unitWord . match ( /jaar/i ) ) {
date = date . add ( - date . date ( ) + 1 , "d" ) ;
date = date . add ( - date . month ( ) , "month" ) ;
components . imply ( "day" , date . date ( ) ) ;
components . imply ( "month" , date . month ( ) + 1 ) ;
components . assign ( "year" , date . year ( ) ) ;
}
return components ;
}
}
NLRelativeDateFormatParser$1 . default = NLRelativeDateFormatParser ;
var NLTimeUnitAgoFormatParser$1 = { } ;
Object . defineProperty ( NLTimeUnitAgoFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$b = constants$2 ;
const results _1$1 = results ;
const AbstractParserWithWordBoundary _1$d = AbstractParserWithWordBoundary ;
const timeunits _1 = timeunits ;
const PATTERN$7 = new RegExp ( "" + "(" + constants _1$b . TIME _UNITS _PATTERN + ")" + "(?:geleden|voor|eerder)(?=(?:\\W|$))" , "i" ) ;
const STRICT _PATTERN$1 = new RegExp ( "" + "(" + constants _1$b . TIME _UNITS _PATTERN + ")" + "geleden(?=(?:\\W|$))" , "i" ) ;
class NLTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary _1$d . AbstractParserWithWordBoundaryChecking {
constructor ( strictMode ) {
super ( ) ;
this . strictMode = strictMode ;
}
innerPattern ( ) {
return this . strictMode ? STRICT _PATTERN$1 : PATTERN$7 ;
}
innerExtract ( context , match ) {
const timeUnits = ( 0 , constants _1$b . parseTimeUnits ) ( match [ 1 ] ) ;
const outputTimeUnits = ( 0 , timeunits _1 . reverseTimeUnits ) ( timeUnits ) ;
return results _1$1 . ParsingComponents . createRelativeFromReference ( context . reference , outputTimeUnits ) ;
}
}
NLTimeUnitAgoFormatParser$1 . default = NLTimeUnitAgoFormatParser ;
var NLTimeUnitLaterFormatParser$1 = { } ;
Object . defineProperty ( NLTimeUnitLaterFormatParser$1 , "__esModule" , { value : true } ) ;
const constants _1$a = constants$2 ;
const results _1 = results ;
const AbstractParserWithWordBoundary _1$c = AbstractParserWithWordBoundary ;
const PATTERN$6 = new RegExp ( "" + "(" + constants _1$a . TIME _UNITS _PATTERN + ")" + "(later|na|vanaf nu|voortaan|vooruit|uit)" + "(?=(?:\\W|$))" , "i" ) ;
const STRICT _PATTERN = new RegExp ( "" + "(" + constants _1$a . TIME _UNITS _PATTERN + ")" + "(later|vanaf nu)" + "(?=(?:\\W|$))" , "i" ) ;
const GROUP _NUM _TIMEUNITS = 1 ;
class NLTimeUnitLaterFormatParser extends AbstractParserWithWordBoundary _1$c . AbstractParserWithWordBoundaryChecking {
constructor ( strictMode ) {
super ( ) ;
this . strictMode = strictMode ;
}
innerPattern ( ) {
return this . strictMode ? STRICT _PATTERN : PATTERN$6 ;
}
innerExtract ( context , match ) {
const fragments = ( 0 , constants _1$a . parseTimeUnits ) ( match [ GROUP _NUM _TIMEUNITS ] ) ;
return results _1 . ParsingComponents . createRelativeFromReference ( context . reference , fragments ) ;
}
}
NLTimeUnitLaterFormatParser$1 . default = NLTimeUnitLaterFormatParser ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = void 0 ;
const configurations _1 = configurations ;
const chrono _1 = chrono$1 ;
const NLMergeDateRangeRefiner _1 = _ _importDefault ( NLMergeDateRangeRefiner$1 ) ;
const NLMergeDateTimeRefiner _1 = _ _importDefault ( NLMergeDateTimeRefiner$1 ) ;
const NLCasualDateParser _1 = _ _importDefault ( NLCasualDateParser$1 ) ;
const NLCasualTimeParser _1 = _ _importDefault ( NLCasualTimeParser$1 ) ;
const SlashDateFormatParser _1 = _ _importDefault ( SlashDateFormatParser$1 ) ;
const NLTimeUnitWithinFormatParser _1 = _ _importDefault ( NLTimeUnitWithinFormatParser$1 ) ;
const NLWeekdayParser _1 = _ _importDefault ( NLWeekdayParser$1 ) ;
const NLMonthNameMiddleEndianParser _1 = _ _importDefault ( NLMonthNameMiddleEndianParser$1 ) ;
const NLMonthNameParser _1 = _ _importDefault ( NLMonthNameParser$1 ) ;
const NLSlashMonthFormatParser _1 = _ _importDefault ( NLSlashMonthFormatParser$1 ) ;
const NLTimeExpressionParser _1 = _ _importDefault ( NLTimeExpressionParser$1 ) ;
const NLCasualYearMonthDayParser _1 = _ _importDefault ( NLCasualYearMonthDayParser$1 ) ;
const NLCasualDateTimeParser _1 = _ _importDefault ( NLCasualDateTimeParser$1 ) ;
const NLTimeUnitCasualRelativeFormatParser _1 = _ _importDefault ( NLTimeUnitCasualRelativeFormatParser$1 ) ;
const NLRelativeDateFormatParser _1 = _ _importDefault ( NLRelativeDateFormatParser$1 ) ;
const NLTimeUnitAgoFormatParser _1 = _ _importDefault ( NLTimeUnitAgoFormatParser$1 ) ;
const NLTimeUnitLaterFormatParser _1 = _ _importDefault ( NLTimeUnitLaterFormatParser$1 ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( true ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( littleEndian = true ) {
const option = createConfiguration ( false , littleEndian ) ;
option . parsers . unshift ( new NLCasualDateParser _1 . default ( ) ) ;
option . parsers . unshift ( new NLCasualTimeParser _1 . default ( ) ) ;
option . parsers . unshift ( new NLCasualDateTimeParser _1 . default ( ) ) ;
option . parsers . unshift ( new NLMonthNameParser _1 . default ( ) ) ;
option . parsers . unshift ( new NLRelativeDateFormatParser _1 . default ( ) ) ;
option . parsers . unshift ( new NLTimeUnitCasualRelativeFormatParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( strictMode = true , littleEndian = true ) {
return ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new SlashDateFormatParser _1 . default ( littleEndian ) ,
new NLTimeUnitWithinFormatParser _1 . default ( ) ,
new NLMonthNameMiddleEndianParser _1 . default ( ) ,
new NLMonthNameParser _1 . default ( ) ,
new NLWeekdayParser _1 . default ( ) ,
new NLCasualYearMonthDayParser _1 . default ( ) ,
new NLSlashMonthFormatParser _1 . default ( ) ,
new NLTimeExpressionParser _1 . default ( strictMode ) ,
new NLTimeUnitAgoFormatParser _1 . default ( strictMode ) ,
new NLTimeUnitLaterFormatParser _1 . default ( strictMode ) ,
] ,
refiners : [ new NLMergeDateTimeRefiner _1 . default ( ) , new NLMergeDateRangeRefiner _1 . default ( ) ] ,
} , strictMode ) ;
}
exports . createConfiguration = createConfiguration ;
} ( nl ) ) ;
var zh = { } ;
var hant = { } ;
var ZHHantCasualDateParser$1 = { } ;
var _ _importDefault$f = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantCasualDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$b = _ _importDefault$f ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$b = AbstractParserWithWordBoundary ;
const NOW _GROUP$1 = 1 ;
const DAY _GROUP _1$3 = 2 ;
const TIME _GROUP _1$1 = 3 ;
const TIME _GROUP _2$1 = 4 ;
const DAY _GROUP _3$3 = 5 ;
const TIME _GROUP _3$1 = 6 ;
class ZHHantCasualDateParser extends AbstractParserWithWordBoundary _1$b . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return new RegExp ( "(而家|立(?:刻|即)|即刻)|" +
"(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|" +
"(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
"(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)" +
"(?:[\\s|,|， +
"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" , "i" ) ;
}
innerExtract ( context , match ) {
const index = match . index ;
const result = context . createParsingResult ( index , match [ 0 ] ) ;
const refMoment = ( 0 , dayjs _1$b . default ) ( context . refDate ) ;
let startMoment = refMoment ;
if ( match [ NOW _GROUP$1 ] ) {
result . start . imply ( "hour" , refMoment . hour ( ) ) ;
result . start . imply ( "minute" , refMoment . minute ( ) ) ;
result . start . imply ( "second" , refMoment . second ( ) ) ;
result . start . imply ( "millisecond" , refMoment . millisecond ( ) ) ;
}
else if ( match [ DAY _GROUP _1$3 ] ) {
const day1 = match [ DAY _GROUP _1$3 ] ;
const time1 = match [ TIME _GROUP _1$1 ] ;
if ( day1 == "明" || day1 == "聽" ) {
if ( refMoment . hour ( ) > 1 ) {
startMoment = startMoment . add ( 1 , "day" ) ;
}
}
else if ( day1 == "昨" || day1 == "尋" || day1 == "琴" ) {
startMoment = startMoment . add ( - 1 , "day" ) ;
}
else if ( day1 == "前" ) {
startMoment = startMoment . add ( - 2 , "day" ) ;
}
else if ( day1 == "大前" ) {
startMoment = startMoment . add ( - 3 , "day" ) ;
}
else if ( day1 == "後" ) {
startMoment = startMoment . add ( 2 , "day" ) ;
}
else if ( day1 == "大後" ) {
startMoment = startMoment . add ( 3 , "day" ) ;
}
if ( time1 == "早" || time1 == "朝" ) {
result . start . imply ( "hour" , 6 ) ;
}
else if ( time1 == "晚" ) {
result . start . imply ( "hour" , 22 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
}
else if ( match [ TIME _GROUP _2$1 ] ) {
const timeString2 = match [ TIME _GROUP _2$1 ] ;
const time2 = timeString2 [ 0 ] ;
if ( time2 == "早" || time2 == "朝" || time2 == "上" ) {
result . start . imply ( "hour" , 6 ) ;
}
else if ( time2 == "下" || time2 == "晏" ) {
result . start . imply ( "hour" , 15 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time2 == "中" ) {
result . start . imply ( "hour" , 12 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time2 == "夜" || time2 == "晚" ) {
result . start . imply ( "hour" , 22 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time2 == "凌" ) {
result . start . imply ( "hour" , 0 ) ;
}
}
else if ( match [ DAY _GROUP _3$3 ] ) {
const day3 = match [ DAY _GROUP _3$3 ] ;
if ( day3 == "明" || day3 == "聽" ) {
if ( refMoment . hour ( ) > 1 ) {
startMoment = startMoment . add ( 1 , "day" ) ;
}
}
else if ( day3 == "昨" || day3 == "尋" || day3 == "琴" ) {
startMoment = startMoment . add ( - 1 , "day" ) ;
}
else if ( day3 == "前" ) {
startMoment = startMoment . add ( - 2 , "day" ) ;
}
else if ( day3 == "大前" ) {
startMoment = startMoment . add ( - 3 , "day" ) ;
}
else if ( day3 == "後" ) {
startMoment = startMoment . add ( 2 , "day" ) ;
}
else if ( day3 == "大後" ) {
startMoment = startMoment . add ( 3 , "day" ) ;
}
const timeString3 = match [ TIME _GROUP _3$1 ] ;
if ( timeString3 ) {
const time3 = timeString3 [ 0 ] ;
if ( time3 == "早" || time3 == "朝" || time3 == "上" ) {
result . start . imply ( "hour" , 6 ) ;
}
else if ( time3 == "下" || time3 == "晏" ) {
result . start . imply ( "hour" , 15 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time3 == "中" ) {
result . start . imply ( "hour" , 12 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time3 == "夜" || time3 == "晚" ) {
result . start . imply ( "hour" , 22 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time3 == "凌" ) {
result . start . imply ( "hour" , 0 ) ;
}
}
}
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
return result ;
}
}
ZHHantCasualDateParser$1 . default = ZHHantCasualDateParser ;
var ZHHantDateParser$1 = { } ;
var constants$1 = { } ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . zhStringToYear = exports . zhStringToNumber = exports . WEEKDAY _OFFSET = exports . NUMBER = void 0 ;
exports . NUMBER = {
"零" : 0 ,
"一" : 1 ,
"二" : 2 ,
"兩" : 2 ,
"三" : 3 ,
"四" : 4 ,
"五" : 5 ,
"六" : 6 ,
"七" : 7 ,
"八" : 8 ,
"九" : 9 ,
"十" : 10 ,
"廿" : 20 ,
"卅" : 30 ,
} ;
exports . WEEKDAY _OFFSET = {
"天" : 0 ,
"日" : 0 ,
"一" : 1 ,
"二" : 2 ,
"三" : 3 ,
"四" : 4 ,
"五" : 5 ,
"六" : 6 ,
} ;
function zhStringToNumber ( text ) {
let number = 0 ;
for ( let i = 0 ; i < text . length ; i ++ ) {
const char = text [ i ] ;
if ( char === "十" ) {
number = number === 0 ? exports . NUMBER [ char ] : number * exports . NUMBER [ char ] ;
}
else {
number += exports . NUMBER [ char ] ;
}
}
return number ;
}
exports . zhStringToNumber = zhStringToNumber ;
function zhStringToYear ( text ) {
let string = "" ;
for ( let i = 0 ; i < text . length ; i ++ ) {
const char = text [ i ] ;
string = string + exports . NUMBER [ char ] ;
}
return parseInt ( string ) ;
}
exports . zhStringToYear = zhStringToYear ;
} ( constants$1 ) ) ;
var _ _importDefault$e = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$a = _ _importDefault$e ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$a = AbstractParserWithWordBoundary ;
const constants _1$9 = constants$1 ;
const YEAR _GROUP$1 = 1 ;
const MONTH _GROUP$1 = 2 ;
const DAY _GROUP$1 = 3 ;
class ZHHantDateParser extends AbstractParserWithWordBoundary _1$a . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return new RegExp ( "(" +
"\\d{2,4}|" +
"[" + Object . keys ( constants _1$9 . NUMBER ) . join ( "" ) + "]{4}|" +
"[" + Object . keys ( constants _1$9 . NUMBER ) . join ( "" ) + "]{2}" +
")?" +
"(?:\\s*)" +
"(?:年)?" +
"(?:[\\s|,|， +
"(" +
"\\d{1,2}|" +
"[" + Object . keys ( constants _1$9 . NUMBER ) . join ( "" ) + "]{1,2}" +
")" +
"(?:\\s*)" +
"(?:月)" +
"(?:\\s*)" +
"(" +
"\\d{1,2}|" +
"[" + Object . keys ( constants _1$9 . NUMBER ) . join ( "" ) + "]{1,2}" +
")?" +
"(?:\\s*)" +
"(?:日|號)?" ) ;
}
innerExtract ( context , match ) {
const startMoment = ( 0 , dayjs _1$a . default ) ( context . refDate ) ;
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
let month = parseInt ( match [ MONTH _GROUP$1 ] ) ;
if ( isNaN ( month ) )
month = ( 0 , constants _1$9 . zhStringToNumber ) ( match [ MONTH _GROUP$1 ] ) ;
result . start . assign ( "month" , month ) ;
if ( match [ DAY _GROUP$1 ] ) {
let day = parseInt ( match [ DAY _GROUP$1 ] ) ;
if ( isNaN ( day ) )
day = ( 0 , constants _1$9 . zhStringToNumber ) ( match [ DAY _GROUP$1 ] ) ;
result . start . assign ( "day" , day ) ;
}
else {
result . start . imply ( "day" , startMoment . date ( ) ) ;
}
if ( match [ YEAR _GROUP$1 ] ) {
let year = parseInt ( match [ YEAR _GROUP$1 ] ) ;
if ( isNaN ( year ) )
year = ( 0 , constants _1$9 . zhStringToYear ) ( match [ YEAR _GROUP$1 ] ) ;
result . start . assign ( "year" , year ) ;
}
else {
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
return result ;
}
}
ZHHantDateParser$1 . default = ZHHantDateParser ;
var ZHHantDeadlineFormatParser$1 = { } ;
var _ _importDefault$d = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantDeadlineFormatParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$9 = _ _importDefault$d ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$9 = AbstractParserWithWordBoundary ;
const constants _1$8 = constants$1 ;
const PATTERN$5 = new RegExp ( "(\\d+|[" +
Object . keys ( constants _1$8 . NUMBER ) . join ( "" ) +
"]+|半|幾)(?:\\s*)" +
"(?:個)?" +
"(秒(?:鐘)?|分鐘|小時|鐘|日|天|星期|禮拜|月|年)" +
"(?:(?:之|過)?後|(?:之)?內)" , "i" ) ;
const NUMBER _GROUP$1 = 1 ;
const UNIT _GROUP$1 = 2 ;
class ZHHantDeadlineFormatParser extends AbstractParserWithWordBoundary _1$9 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$5 ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
let number = parseInt ( match [ NUMBER _GROUP$1 ] ) ;
if ( isNaN ( number ) ) {
number = ( 0 , constants _1$8 . zhStringToNumber ) ( match [ NUMBER _GROUP$1 ] ) ;
}
if ( isNaN ( number ) ) {
const string = match [ NUMBER _GROUP$1 ] ;
if ( string === "幾" ) {
number = 3 ;
}
else if ( string === "半" ) {
number = 0.5 ;
}
else {
return null ;
}
}
let date = ( 0 , dayjs _1$9 . default ) ( context . refDate ) ;
const unit = match [ UNIT _GROUP$1 ] ;
const unitAbbr = unit [ 0 ] ;
if ( unitAbbr . match ( /[日天星禮月年]/ ) ) {
if ( unitAbbr == "日" || unitAbbr == "天" ) {
date = date . add ( number , "d" ) ;
}
else if ( unitAbbr == "星" || unitAbbr == "禮" ) {
date = date . add ( number * 7 , "d" ) ;
}
else if ( unitAbbr == "月" ) {
date = date . add ( number , "month" ) ;
}
else if ( unitAbbr == "年" ) {
date = date . add ( number , "year" ) ;
}
result . start . assign ( "year" , date . year ( ) ) ;
result . start . assign ( "month" , date . month ( ) + 1 ) ;
result . start . assign ( "day" , date . date ( ) ) ;
return result ;
}
if ( unitAbbr == "秒" ) {
date = date . add ( number , "second" ) ;
}
else if ( unitAbbr == "分" ) {
date = date . add ( number , "minute" ) ;
}
else if ( unitAbbr == "小" || unitAbbr == "鐘" ) {
date = date . add ( number , "hour" ) ;
}
result . start . imply ( "year" , date . year ( ) ) ;
result . start . imply ( "month" , date . month ( ) + 1 ) ;
result . start . imply ( "day" , date . date ( ) ) ;
result . start . assign ( "hour" , date . hour ( ) ) ;
result . start . assign ( "minute" , date . minute ( ) ) ;
result . start . assign ( "second" , date . second ( ) ) ;
return result ;
}
}
ZHHantDeadlineFormatParser$1 . default = ZHHantDeadlineFormatParser ;
var ZHHantRelationWeekdayParser$1 = { } ;
var _ _importDefault$c = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantRelationWeekdayParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$8 = _ _importDefault$c ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$8 = AbstractParserWithWordBoundary ;
const constants _1$7 = constants$1 ;
const PATTERN$4 = new RegExp ( "(?<prefix>上|今|下|這|呢)(?:個)?(?:星期|禮拜|週)(?<weekday>" + Object . keys ( constants _1$7 . WEEKDAY _OFFSET ) . join ( "|" ) + ")" ) ;
class ZHHantRelationWeekdayParser extends AbstractParserWithWordBoundary _1$8 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$4 ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const dayOfWeek = match . groups . weekday ;
const offset = constants _1$7 . WEEKDAY _OFFSET [ dayOfWeek ] ;
if ( offset === undefined )
return null ;
let modifier = null ;
const prefix = match . groups . prefix ;
if ( prefix == "上" ) {
modifier = "last" ;
}
else if ( prefix == "下" ) {
modifier = "next" ;
}
else if ( prefix == "今" || prefix == "這" || prefix == "呢" ) {
modifier = "this" ;
}
let startMoment = ( 0 , dayjs _1$8 . default ) ( context . refDate ) ;
let startMomentFixed = false ;
const refOffset = startMoment . day ( ) ;
if ( modifier == "last" || modifier == "past" ) {
startMoment = startMoment . day ( offset - 7 ) ;
startMomentFixed = true ;
}
else if ( modifier == "next" ) {
startMoment = startMoment . day ( offset + 7 ) ;
startMomentFixed = true ;
}
else if ( modifier == "this" ) {
startMoment = startMoment . day ( offset ) ;
}
else {
if ( Math . abs ( offset - 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset - 7 ) ;
}
else if ( Math . abs ( offset + 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset + 7 ) ;
}
else {
startMoment = startMoment . day ( offset ) ;
}
}
result . start . assign ( "weekday" , offset ) ;
if ( startMomentFixed ) {
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
}
else {
result . start . imply ( "day" , startMoment . date ( ) ) ;
result . start . imply ( "month" , startMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
return result ;
}
}
ZHHantRelationWeekdayParser$1 . default = ZHHantRelationWeekdayParser ;
var ZHHantTimeExpressionParser$1 = { } ;
var _ _importDefault$b = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$7 = _ _importDefault$b ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$7 = AbstractParserWithWordBoundary ;
const constants _1$6 = constants$1 ;
const FIRST _REG _PATTERN$1 = new RegExp ( "(?:由|從|自)?" +
"(?:" +
"(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|" +
"(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
"(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)" +
"(?:[\\s,， +
"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" +
")?" +
"(?:[\\s,， +
"(?:(\\d+|[" +
Object . keys ( constants _1$6 . NUMBER ) . join ( "" ) +
"]+)(?:\\s*)(?:點|時|:|： +
"(?:\\s*)" +
"(\\d+|半|正|整|[" +
Object . keys ( constants _1$6 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:分|:|： +
"(?:\\s*)" +
"(\\d+|[" +
Object . keys ( constants _1$6 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:秒)?)" +
"(?:\\s*(A.M.|P.M.|AM?|PM?))?" , "i" ) ;
const SECOND _REG _PATTERN$1 = new RegExp ( "(?:^\\s*(?:到|至|\\-|\\– +
"(?:" +
"(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|" +
"(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
"(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)" +
"(?:[\\s,， +
"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" +
")?" +
"(?:[\\s,， +
"(?:(\\d+|[" +
Object . keys ( constants _1$6 . NUMBER ) . join ( "" ) +
"]+)(?:\\s*)(?:點|時|:|： +
"(?:\\s*)" +
"(\\d+|半|正|整|[" +
Object . keys ( constants _1$6 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:分|:|： +
"(?:\\s*)" +
"(\\d+|[" +
Object . keys ( constants _1$6 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:秒)?)" +
"(?:\\s*(A.M.|P.M.|AM?|PM?))?" , "i" ) ;
const DAY _GROUP _1$2 = 1 ;
const ZH _AM _PM _HOUR _GROUP _1$1 = 2 ;
const ZH _AM _PM _HOUR _GROUP _2$1 = 3 ;
const DAY _GROUP _3$2 = 4 ;
const ZH _AM _PM _HOUR _GROUP _3$1 = 5 ;
const HOUR _GROUP$1 = 6 ;
const MINUTE _GROUP$1 = 7 ;
const SECOND _GROUP$1 = 8 ;
const AM _PM _HOUR _GROUP$1 = 9 ;
class ZHHantTimeExpressionParser extends AbstractParserWithWordBoundary _1$7 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return FIRST _REG _PATTERN$1 ;
}
innerExtract ( context , match ) {
if ( match . index > 0 && context . text [ match . index - 1 ] . match ( /\w/ ) ) {
return null ;
}
const refMoment = ( 0 , dayjs _1$7 . default ) ( context . refDate ) ;
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const startMoment = refMoment . clone ( ) ;
if ( match [ DAY _GROUP _1$2 ] ) {
var day1 = match [ DAY _GROUP _1$2 ] ;
if ( day1 == "明" || day1 == "聽" ) {
if ( refMoment . hour ( ) > 1 ) {
startMoment . add ( 1 , "day" ) ;
}
}
else if ( day1 == "昨" || day1 == "尋" || day1 == "琴" ) {
startMoment . add ( - 1 , "day" ) ;
}
else if ( day1 == "前" ) {
startMoment . add ( - 2 , "day" ) ;
}
else if ( day1 == "大前" ) {
startMoment . add ( - 3 , "day" ) ;
}
else if ( day1 == "後" ) {
startMoment . add ( 2 , "day" ) ;
}
else if ( day1 == "大後" ) {
startMoment . add ( 3 , "day" ) ;
}
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
}
else if ( match [ DAY _GROUP _3$2 ] ) {
var day3 = match [ DAY _GROUP _3$2 ] ;
if ( day3 == "明" || day3 == "聽" ) {
startMoment . add ( 1 , "day" ) ;
}
else if ( day3 == "昨" || day3 == "尋" || day3 == "琴" ) {
startMoment . add ( - 1 , "day" ) ;
}
else if ( day3 == "前" ) {
startMoment . add ( - 2 , "day" ) ;
}
else if ( day3 == "大前" ) {
startMoment . add ( - 3 , "day" ) ;
}
else if ( day3 == "後" ) {
startMoment . add ( 2 , "day" ) ;
}
else if ( day3 == "大後" ) {
startMoment . add ( 3 , "day" ) ;
}
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
}
else {
result . start . imply ( "day" , startMoment . date ( ) ) ;
result . start . imply ( "month" , startMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
let hour = 0 ;
let minute = 0 ;
let meridiem = - 1 ;
if ( match [ SECOND _GROUP$1 ] ) {
var second = parseInt ( match [ SECOND _GROUP$1 ] ) ;
if ( isNaN ( second ) ) {
second = ( 0 , constants _1$6 . zhStringToNumber ) ( match [ SECOND _GROUP$1 ] ) ;
}
if ( second >= 60 )
return null ;
result . start . assign ( "second" , second ) ;
}
hour = parseInt ( match [ HOUR _GROUP$1 ] ) ;
if ( isNaN ( hour ) ) {
hour = ( 0 , constants _1$6 . zhStringToNumber ) ( match [ HOUR _GROUP$1 ] ) ;
}
if ( match [ MINUTE _GROUP$1 ] ) {
if ( match [ MINUTE _GROUP$1 ] == "半" ) {
minute = 30 ;
}
else if ( match [ MINUTE _GROUP$1 ] == "正" || match [ MINUTE _GROUP$1 ] == "整" ) {
minute = 0 ;
}
else {
minute = parseInt ( match [ MINUTE _GROUP$1 ] ) ;
if ( isNaN ( minute ) ) {
minute = ( 0 , constants _1$6 . zhStringToNumber ) ( match [ MINUTE _GROUP$1 ] ) ;
}
}
}
else if ( hour > 100 ) {
minute = hour % 100 ;
hour = Math . floor ( hour / 100 ) ;
}
if ( minute >= 60 ) {
return null ;
}
if ( hour > 24 ) {
return null ;
}
if ( hour >= 12 ) {
meridiem = 1 ;
}
if ( match [ AM _PM _HOUR _GROUP$1 ] ) {
if ( hour > 12 )
return null ;
var ampm = match [ AM _PM _HOUR _GROUP$1 ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
if ( ampm == "p" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _1$1 ] ) {
var zhAMPMString1 = match [ ZH _AM _PM _HOUR _GROUP _1$1 ] ;
var zhAMPM1 = zhAMPMString1 [ 0 ] ;
if ( zhAMPM1 == "朝" || zhAMPM1 == "早" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM1 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _2$1 ] ) {
var zhAMPMString2 = match [ ZH _AM _PM _HOUR _GROUP _2$1 ] ;
var zhAMPM2 = zhAMPMString2 [ 0 ] ;
if ( zhAMPM2 == "上" || zhAMPM2 == "朝" || zhAMPM2 == "早" || zhAMPM2 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM2 == "下" || zhAMPM2 == "晏" || zhAMPM2 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _3$1 ] ) {
var zhAMPMString3 = match [ ZH _AM _PM _HOUR _GROUP _3$1 ] ;
var zhAMPM3 = zhAMPMString3 [ 0 ] ;
if ( zhAMPM3 == "上" || zhAMPM3 == "朝" || zhAMPM3 == "早" || zhAMPM3 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM3 == "下" || zhAMPM3 == "晏" || zhAMPM3 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
result . start . assign ( "hour" , hour ) ;
result . start . assign ( "minute" , minute ) ;
if ( meridiem >= 0 ) {
result . start . assign ( "meridiem" , meridiem ) ;
}
else {
if ( hour < 12 ) {
result . start . imply ( "meridiem" , 0 ) ;
}
else {
result . start . imply ( "meridiem" , 1 ) ;
}
}
match = SECOND _REG _PATTERN$1 . exec ( context . text . substring ( result . index + result . text . length ) ) ;
if ( ! match ) {
if ( result . text . match ( /^\d+$/ ) ) {
return null ;
}
return result ;
}
const endMoment = startMoment . clone ( ) ;
result . end = context . createParsingComponents ( ) ;
if ( match [ DAY _GROUP _1$2 ] ) {
var day1 = match [ DAY _GROUP _1$2 ] ;
if ( day1 == "明" || day1 == "聽" ) {
if ( refMoment . hour ( ) > 1 ) {
endMoment . add ( 1 , "day" ) ;
}
}
else if ( day1 == "昨" || day1 == "尋" || day1 == "琴" ) {
endMoment . add ( - 1 , "day" ) ;
}
else if ( day1 == "前" ) {
endMoment . add ( - 2 , "day" ) ;
}
else if ( day1 == "大前" ) {
endMoment . add ( - 3 , "day" ) ;
}
else if ( day1 == "後" ) {
endMoment . add ( 2 , "day" ) ;
}
else if ( day1 == "大後" ) {
endMoment . add ( 3 , "day" ) ;
}
result . end . assign ( "day" , endMoment . date ( ) ) ;
result . end . assign ( "month" , endMoment . month ( ) + 1 ) ;
result . end . assign ( "year" , endMoment . year ( ) ) ;
}
else if ( match [ DAY _GROUP _3$2 ] ) {
var day3 = match [ DAY _GROUP _3$2 ] ;
if ( day3 == "明" || day3 == "聽" ) {
endMoment . add ( 1 , "day" ) ;
}
else if ( day3 == "昨" || day3 == "尋" || day3 == "琴" ) {
endMoment . add ( - 1 , "day" ) ;
}
else if ( day3 == "前" ) {
endMoment . add ( - 2 , "day" ) ;
}
else if ( day3 == "大前" ) {
endMoment . add ( - 3 , "day" ) ;
}
else if ( day3 == "後" ) {
endMoment . add ( 2 , "day" ) ;
}
else if ( day3 == "大後" ) {
endMoment . add ( 3 , "day" ) ;
}
result . end . assign ( "day" , endMoment . date ( ) ) ;
result . end . assign ( "month" , endMoment . month ( ) + 1 ) ;
result . end . assign ( "year" , endMoment . year ( ) ) ;
}
else {
result . end . imply ( "day" , endMoment . date ( ) ) ;
result . end . imply ( "month" , endMoment . month ( ) + 1 ) ;
result . end . imply ( "year" , endMoment . year ( ) ) ;
}
hour = 0 ;
minute = 0 ;
meridiem = - 1 ;
if ( match [ SECOND _GROUP$1 ] ) {
var second = parseInt ( match [ SECOND _GROUP$1 ] ) ;
if ( isNaN ( second ) ) {
second = ( 0 , constants _1$6 . zhStringToNumber ) ( match [ SECOND _GROUP$1 ] ) ;
}
if ( second >= 60 )
return null ;
result . end . assign ( "second" , second ) ;
}
hour = parseInt ( match [ HOUR _GROUP$1 ] ) ;
if ( isNaN ( hour ) ) {
hour = ( 0 , constants _1$6 . zhStringToNumber ) ( match [ HOUR _GROUP$1 ] ) ;
}
if ( match [ MINUTE _GROUP$1 ] ) {
if ( match [ MINUTE _GROUP$1 ] == "半" ) {
minute = 30 ;
}
else if ( match [ MINUTE _GROUP$1 ] == "正" || match [ MINUTE _GROUP$1 ] == "整" ) {
minute = 0 ;
}
else {
minute = parseInt ( match [ MINUTE _GROUP$1 ] ) ;
if ( isNaN ( minute ) ) {
minute = ( 0 , constants _1$6 . zhStringToNumber ) ( match [ MINUTE _GROUP$1 ] ) ;
}
}
}
else if ( hour > 100 ) {
minute = hour % 100 ;
hour = Math . floor ( hour / 100 ) ;
}
if ( minute >= 60 ) {
return null ;
}
if ( hour > 24 ) {
return null ;
}
if ( hour >= 12 ) {
meridiem = 1 ;
}
if ( match [ AM _PM _HOUR _GROUP$1 ] ) {
if ( hour > 12 )
return null ;
var ampm = match [ AM _PM _HOUR _GROUP$1 ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
if ( ampm == "p" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
if ( ! result . start . isCertain ( "meridiem" ) ) {
if ( meridiem == 0 ) {
result . start . imply ( "meridiem" , 0 ) ;
if ( result . start . get ( "hour" ) == 12 ) {
result . start . assign ( "hour" , 0 ) ;
}
}
else {
result . start . imply ( "meridiem" , 1 ) ;
if ( result . start . get ( "hour" ) != 12 ) {
result . start . assign ( "hour" , result . start . get ( "hour" ) + 12 ) ;
}
}
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _1$1 ] ) {
var zhAMPMString1 = match [ ZH _AM _PM _HOUR _GROUP _1$1 ] ;
var zhAMPM1 = zhAMPMString1 [ 0 ] ;
if ( zhAMPM1 == "朝" || zhAMPM1 == "早" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM1 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _2$1 ] ) {
var zhAMPMString2 = match [ ZH _AM _PM _HOUR _GROUP _2$1 ] ;
var zhAMPM2 = zhAMPMString2 [ 0 ] ;
if ( zhAMPM2 == "上" || zhAMPM2 == "朝" || zhAMPM2 == "早" || zhAMPM2 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM2 == "下" || zhAMPM2 == "晏" || zhAMPM2 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _3$1 ] ) {
var zhAMPMString3 = match [ ZH _AM _PM _HOUR _GROUP _3$1 ] ;
var zhAMPM3 = zhAMPMString3 [ 0 ] ;
if ( zhAMPM3 == "上" || zhAMPM3 == "朝" || zhAMPM3 == "早" || zhAMPM3 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM3 == "下" || zhAMPM3 == "晏" || zhAMPM3 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
result . text = result . text + match [ 0 ] ;
result . end . assign ( "hour" , hour ) ;
result . end . assign ( "minute" , minute ) ;
if ( meridiem >= 0 ) {
result . end . assign ( "meridiem" , meridiem ) ;
}
else {
const startAtPM = result . start . isCertain ( "meridiem" ) && result . start . get ( "meridiem" ) == 1 ;
if ( startAtPM && result . start . get ( "hour" ) > hour ) {
result . end . imply ( "meridiem" , 0 ) ;
}
else if ( hour > 12 ) {
result . end . imply ( "meridiem" , 1 ) ;
}
}
if ( result . end . date ( ) . getTime ( ) < result . start . date ( ) . getTime ( ) ) {
result . end . imply ( "day" , result . end . get ( "day" ) + 1 ) ;
}
return result ;
}
}
ZHHantTimeExpressionParser$1 . default = ZHHantTimeExpressionParser ;
var ZHHantWeekdayParser$1 = { } ;
var _ _importDefault$a = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantWeekdayParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$6 = _ _importDefault$a ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$6 = AbstractParserWithWordBoundary ;
const constants _1$5 = constants$1 ;
const PATTERN$3 = new RegExp ( "(?:星期|禮拜|週)(?<weekday>" + Object . keys ( constants _1$5 . WEEKDAY _OFFSET ) . join ( "|" ) + ")" ) ;
class ZHHantWeekdayParser extends AbstractParserWithWordBoundary _1$6 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$3 ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const dayOfWeek = match . groups . weekday ;
const offset = constants _1$5 . WEEKDAY _OFFSET [ dayOfWeek ] ;
if ( offset === undefined )
return null ;
let startMoment = ( 0 , dayjs _1$6 . default ) ( context . refDate ) ;
const refOffset = startMoment . day ( ) ;
if ( Math . abs ( offset - 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset - 7 ) ;
}
else if ( Math . abs ( offset + 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset + 7 ) ;
}
else {
startMoment = startMoment . day ( offset ) ;
}
result . start . assign ( "weekday" , offset ) ;
{
result . start . imply ( "day" , startMoment . date ( ) ) ;
result . start . imply ( "month" , startMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
return result ;
}
}
ZHHantWeekdayParser$1 . default = ZHHantWeekdayParser ;
var ZHHantMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$9 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1$1 = _ _importDefault$9 ( AbstractMergeDateRangeRefiner$1 ) ;
class ZHHantMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1$1 . default {
patternBetween ( ) {
return /^\s*(至|到|\-|\~|～ － ;
}
}
ZHHantMergeDateRangeRefiner$1 . default = ZHHantMergeDateRangeRefiner ;
var ZHHantMergeDateTimeRefiner$1 = { } ;
var _ _importDefault$8 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHantMergeDateTimeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1$1 = _ _importDefault$8 ( AbstractMergeDateTimeRefiner ) ;
class ZHHantMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1$1 . default {
patternBetween ( ) {
return /^\s*$/i ;
}
}
ZHHantMergeDateTimeRefiner$1 . default = ZHHantMergeDateTimeRefiner ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = exports . hant = void 0 ;
const chrono _1 = chrono$1 ;
const ExtractTimezoneOffsetRefiner _1 = _ _importDefault ( ExtractTimezoneOffsetRefiner$1 ) ;
const configurations _1 = configurations ;
const ZHHantCasualDateParser _1 = _ _importDefault ( ZHHantCasualDateParser$1 ) ;
const ZHHantDateParser _1 = _ _importDefault ( ZHHantDateParser$1 ) ;
const ZHHantDeadlineFormatParser _1 = _ _importDefault ( ZHHantDeadlineFormatParser$1 ) ;
const ZHHantRelationWeekdayParser _1 = _ _importDefault ( ZHHantRelationWeekdayParser$1 ) ;
const ZHHantTimeExpressionParser _1 = _ _importDefault ( ZHHantTimeExpressionParser$1 ) ;
const ZHHantWeekdayParser _1 = _ _importDefault ( ZHHantWeekdayParser$1 ) ;
const ZHHantMergeDateRangeRefiner _1 = _ _importDefault ( ZHHantMergeDateRangeRefiner$1 ) ;
const ZHHantMergeDateTimeRefiner _1 = _ _importDefault ( ZHHantMergeDateTimeRefiner$1 ) ;
exports . hant = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( ) {
const option = createConfiguration ( ) ;
option . parsers . unshift ( new ZHHantCasualDateParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( ) {
const configuration = ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new ZHHantDateParser _1 . default ( ) ,
new ZHHantRelationWeekdayParser _1 . default ( ) ,
new ZHHantWeekdayParser _1 . default ( ) ,
new ZHHantTimeExpressionParser _1 . default ( ) ,
new ZHHantDeadlineFormatParser _1 . default ( ) ,
] ,
refiners : [ new ZHHantMergeDateRangeRefiner _1 . default ( ) , new ZHHantMergeDateTimeRefiner _1 . default ( ) ] ,
} ) ;
configuration . refiners = configuration . refiners . filter ( ( refiner ) => ! ( refiner instanceof ExtractTimezoneOffsetRefiner _1 . default ) ) ;
return configuration ;
}
exports . createConfiguration = createConfiguration ;
} ( hant ) ) ;
var hans = { } ;
var ZHHansCasualDateParser$1 = { } ;
var _ _importDefault$7 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansCasualDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$5 = _ _importDefault$7 ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$5 = AbstractParserWithWordBoundary ;
const NOW _GROUP = 1 ;
const DAY _GROUP _1$1 = 2 ;
const TIME _GROUP _1 = 3 ;
const TIME _GROUP _2 = 4 ;
const DAY _GROUP _3$1 = 5 ;
const TIME _GROUP _3 = 6 ;
class ZHHansCasualDateParser extends AbstractParserWithWordBoundary _1$5 . AbstractParserWithWordBoundaryChecking {
innerPattern ( context ) {
return new RegExp ( "(现在|立(?:刻|即)|即刻)|" +
"(今|明|前|大前|后|大后|昨)(早|晚)|" +
"(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
"(今|明|前|大前|后|大后|昨)(?:日|天)" +
"(?:[\\s|,|， +
"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" , "i" ) ;
}
innerExtract ( context , match ) {
const index = match . index ;
const result = context . createParsingResult ( index , match [ 0 ] ) ;
const refMoment = ( 0 , dayjs _1$5 . default ) ( context . refDate ) ;
let startMoment = refMoment ;
if ( match [ NOW _GROUP ] ) {
result . start . imply ( "hour" , refMoment . hour ( ) ) ;
result . start . imply ( "minute" , refMoment . minute ( ) ) ;
result . start . imply ( "second" , refMoment . second ( ) ) ;
result . start . imply ( "millisecond" , refMoment . millisecond ( ) ) ;
}
else if ( match [ DAY _GROUP _1$1 ] ) {
const day1 = match [ DAY _GROUP _1$1 ] ;
const time1 = match [ TIME _GROUP _1 ] ;
if ( day1 == "明" ) {
if ( refMoment . hour ( ) > 1 ) {
startMoment = startMoment . add ( 1 , "day" ) ;
}
}
else if ( day1 == "昨" ) {
startMoment = startMoment . add ( - 1 , "day" ) ;
}
else if ( day1 == "前" ) {
startMoment = startMoment . add ( - 2 , "day" ) ;
}
else if ( day1 == "大前" ) {
startMoment = startMoment . add ( - 3 , "day" ) ;
}
else if ( day1 == "后" ) {
startMoment = startMoment . add ( 2 , "day" ) ;
}
else if ( day1 == "大后" ) {
startMoment = startMoment . add ( 3 , "day" ) ;
}
if ( time1 == "早" ) {
result . start . imply ( "hour" , 6 ) ;
}
else if ( time1 == "晚" ) {
result . start . imply ( "hour" , 22 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
}
else if ( match [ TIME _GROUP _2 ] ) {
const timeString2 = match [ TIME _GROUP _2 ] ;
const time2 = timeString2 [ 0 ] ;
if ( time2 == "早" || time2 == "上" ) {
result . start . imply ( "hour" , 6 ) ;
}
else if ( time2 == "下" ) {
result . start . imply ( "hour" , 15 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time2 == "中" ) {
result . start . imply ( "hour" , 12 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time2 == "夜" || time2 == "晚" ) {
result . start . imply ( "hour" , 22 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time2 == "凌" ) {
result . start . imply ( "hour" , 0 ) ;
}
}
else if ( match [ DAY _GROUP _3$1 ] ) {
const day3 = match [ DAY _GROUP _3$1 ] ;
if ( day3 == "明" ) {
if ( refMoment . hour ( ) > 1 ) {
startMoment = startMoment . add ( 1 , "day" ) ;
}
}
else if ( day3 == "昨" ) {
startMoment = startMoment . add ( - 1 , "day" ) ;
}
else if ( day3 == "前" ) {
startMoment = startMoment . add ( - 2 , "day" ) ;
}
else if ( day3 == "大前" ) {
startMoment = startMoment . add ( - 3 , "day" ) ;
}
else if ( day3 == "后" ) {
startMoment = startMoment . add ( 2 , "day" ) ;
}
else if ( day3 == "大后" ) {
startMoment = startMoment . add ( 3 , "day" ) ;
}
const timeString3 = match [ TIME _GROUP _3 ] ;
if ( timeString3 ) {
const time3 = timeString3 [ 0 ] ;
if ( time3 == "早" || time3 == "上" ) {
result . start . imply ( "hour" , 6 ) ;
}
else if ( time3 == "下" ) {
result . start . imply ( "hour" , 15 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time3 == "中" ) {
result . start . imply ( "hour" , 12 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time3 == "夜" || time3 == "晚" ) {
result . start . imply ( "hour" , 22 ) ;
result . start . imply ( "meridiem" , 1 ) ;
}
else if ( time3 == "凌" ) {
result . start . imply ( "hour" , 0 ) ;
}
}
}
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
return result ;
}
}
ZHHansCasualDateParser$1 . default = ZHHansCasualDateParser ;
var ZHHansDateParser$1 = { } ;
var constants = { } ;
( function ( exports ) {
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . zhStringToYear = exports . zhStringToNumber = exports . WEEKDAY _OFFSET = exports . NUMBER = void 0 ;
exports . NUMBER = {
"零" : 0 ,
"〇 : 0 ,
"一" : 1 ,
"二" : 2 ,
"两" : 2 ,
"三" : 3 ,
"四" : 4 ,
"五" : 5 ,
"六" : 6 ,
"七" : 7 ,
"八" : 8 ,
"九" : 9 ,
"十" : 10 ,
} ;
exports . WEEKDAY _OFFSET = {
"天" : 0 ,
"日" : 0 ,
"一" : 1 ,
"二" : 2 ,
"三" : 3 ,
"四" : 4 ,
"五" : 5 ,
"六" : 6 ,
} ;
function zhStringToNumber ( text ) {
let number = 0 ;
for ( let i = 0 ; i < text . length ; i ++ ) {
const char = text [ i ] ;
if ( char === "十" ) {
number = number === 0 ? exports . NUMBER [ char ] : number * exports . NUMBER [ char ] ;
}
else {
number += exports . NUMBER [ char ] ;
}
}
return number ;
}
exports . zhStringToNumber = zhStringToNumber ;
function zhStringToYear ( text ) {
let string = "" ;
for ( let i = 0 ; i < text . length ; i ++ ) {
const char = text [ i ] ;
string = string + exports . NUMBER [ char ] ;
}
return parseInt ( string ) ;
}
exports . zhStringToYear = zhStringToYear ;
} ( constants ) ) ;
var _ _importDefault$6 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansDateParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$4 = _ _importDefault$6 ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$4 = AbstractParserWithWordBoundary ;
const constants _1$4 = constants ;
const YEAR _GROUP = 1 ;
const MONTH _GROUP = 2 ;
const DAY _GROUP = 3 ;
class ZHHansDateParser extends AbstractParserWithWordBoundary _1$4 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return new RegExp ( "(" +
"\\d{2,4}|" +
"[" +
Object . keys ( constants _1$4 . NUMBER ) . join ( "" ) +
"]{4}|" +
"[" +
Object . keys ( constants _1$4 . NUMBER ) . join ( "" ) +
"]{2}" +
")?" +
"(?:\\s*)" +
"(?:年)?" +
"(?:[\\s|,|， +
"(" +
"\\d{1,2}|" +
"[" +
Object . keys ( constants _1$4 . NUMBER ) . join ( "" ) +
"]{1,3}" +
")" +
"(?:\\s*)" +
"(?:月)" +
"(?:\\s*)" +
"(" +
"\\d{1,2}|" +
"[" +
Object . keys ( constants _1$4 . NUMBER ) . join ( "" ) +
"]{1,3}" +
")?" +
"(?:\\s*)" +
"(?:日|号)?" ) ;
}
innerExtract ( context , match ) {
const startMoment = ( 0 , dayjs _1$4 . default ) ( context . refDate ) ;
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
let month = parseInt ( match [ MONTH _GROUP ] ) ;
if ( isNaN ( month ) )
month = ( 0 , constants _1$4 . zhStringToNumber ) ( match [ MONTH _GROUP ] ) ;
result . start . assign ( "month" , month ) ;
if ( match [ DAY _GROUP ] ) {
let day = parseInt ( match [ DAY _GROUP ] ) ;
if ( isNaN ( day ) )
day = ( 0 , constants _1$4 . zhStringToNumber ) ( match [ DAY _GROUP ] ) ;
result . start . assign ( "day" , day ) ;
}
else {
result . start . imply ( "day" , startMoment . date ( ) ) ;
}
if ( match [ YEAR _GROUP ] ) {
let year = parseInt ( match [ YEAR _GROUP ] ) ;
if ( isNaN ( year ) )
year = ( 0 , constants _1$4 . zhStringToYear ) ( match [ YEAR _GROUP ] ) ;
result . start . assign ( "year" , year ) ;
}
else {
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
return result ;
}
}
ZHHansDateParser$1 . default = ZHHansDateParser ;
var ZHHansDeadlineFormatParser$1 = { } ;
var _ _importDefault$5 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansDeadlineFormatParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$3 = _ _importDefault$5 ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$3 = AbstractParserWithWordBoundary ;
const constants _1$3 = constants ;
const PATTERN$2 = new RegExp ( "(\\d+|[" +
Object . keys ( constants _1$3 . NUMBER ) . join ( "" ) +
"]+|半|几)(?:\\s*)" +
"(?:个)?" +
"(秒(?:钟)?|分钟|小时|钟|日|天|星期|礼拜|月|年)" +
"(?:(?:之|过)?后|(?:之)?内)" , "i" ) ;
const NUMBER _GROUP = 1 ;
const UNIT _GROUP = 2 ;
class ZHHansDeadlineFormatParser extends AbstractParserWithWordBoundary _1$3 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$2 ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
let number = parseInt ( match [ NUMBER _GROUP ] ) ;
if ( isNaN ( number ) ) {
number = ( 0 , constants _1$3 . zhStringToNumber ) ( match [ NUMBER _GROUP ] ) ;
}
if ( isNaN ( number ) ) {
const string = match [ NUMBER _GROUP ] ;
if ( string === "几" ) {
number = 3 ;
}
else if ( string === "半" ) {
number = 0.5 ;
}
else {
return null ;
}
}
let date = ( 0 , dayjs _1$3 . default ) ( context . refDate ) ;
const unit = match [ UNIT _GROUP ] ;
const unitAbbr = unit [ 0 ] ;
if ( unitAbbr . match ( /[日天星礼月年]/ ) ) {
if ( unitAbbr == "日" || unitAbbr == "天" ) {
date = date . add ( number , "d" ) ;
}
else if ( unitAbbr == "星" || unitAbbr == "礼" ) {
date = date . add ( number * 7 , "d" ) ;
}
else if ( unitAbbr == "月" ) {
date = date . add ( number , "month" ) ;
}
else if ( unitAbbr == "年" ) {
date = date . add ( number , "year" ) ;
}
result . start . assign ( "year" , date . year ( ) ) ;
result . start . assign ( "month" , date . month ( ) + 1 ) ;
result . start . assign ( "day" , date . date ( ) ) ;
return result ;
}
if ( unitAbbr == "秒" ) {
date = date . add ( number , "second" ) ;
}
else if ( unitAbbr == "分" ) {
date = date . add ( number , "minute" ) ;
}
else if ( unitAbbr == "小" || unitAbbr == "钟" ) {
date = date . add ( number , "hour" ) ;
}
result . start . imply ( "year" , date . year ( ) ) ;
result . start . imply ( "month" , date . month ( ) + 1 ) ;
result . start . imply ( "day" , date . date ( ) ) ;
result . start . assign ( "hour" , date . hour ( ) ) ;
result . start . assign ( "minute" , date . minute ( ) ) ;
result . start . assign ( "second" , date . second ( ) ) ;
return result ;
}
}
ZHHansDeadlineFormatParser$1 . default = ZHHansDeadlineFormatParser ;
var ZHHansRelationWeekdayParser$1 = { } ;
var _ _importDefault$4 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansRelationWeekdayParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$2 = _ _importDefault$4 ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$2 = AbstractParserWithWordBoundary ;
const constants _1$2 = constants ;
const PATTERN$1 = new RegExp ( "(?<prefix>上|下|这)(?:个)?(?:星期|礼拜|周)(?<weekday>" + Object . keys ( constants _1$2 . WEEKDAY _OFFSET ) . join ( "|" ) + ")" ) ;
class ZHHansRelationWeekdayParser extends AbstractParserWithWordBoundary _1$2 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN$1 ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const dayOfWeek = match . groups . weekday ;
const offset = constants _1$2 . WEEKDAY _OFFSET [ dayOfWeek ] ;
if ( offset === undefined )
return null ;
let modifier = null ;
const prefix = match . groups . prefix ;
if ( prefix == "上" ) {
modifier = "last" ;
}
else if ( prefix == "下" ) {
modifier = "next" ;
}
else if ( prefix == "这" ) {
modifier = "this" ;
}
let startMoment = ( 0 , dayjs _1$2 . default ) ( context . refDate ) ;
let startMomentFixed = false ;
const refOffset = startMoment . day ( ) ;
if ( modifier == "last" || modifier == "past" ) {
startMoment = startMoment . day ( offset - 7 ) ;
startMomentFixed = true ;
}
else if ( modifier == "next" ) {
startMoment = startMoment . day ( offset + 7 ) ;
startMomentFixed = true ;
}
else if ( modifier == "this" ) {
startMoment = startMoment . day ( offset ) ;
}
else {
if ( Math . abs ( offset - 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset - 7 ) ;
}
else if ( Math . abs ( offset + 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset + 7 ) ;
}
else {
startMoment = startMoment . day ( offset ) ;
}
}
result . start . assign ( "weekday" , offset ) ;
if ( startMomentFixed ) {
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
}
else {
result . start . imply ( "day" , startMoment . date ( ) ) ;
result . start . imply ( "month" , startMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
return result ;
}
}
ZHHansRelationWeekdayParser$1 . default = ZHHansRelationWeekdayParser ;
var ZHHansTimeExpressionParser$1 = { } ;
var _ _importDefault$3 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansTimeExpressionParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1$1 = _ _importDefault$3 ( require$$0 ) ;
const AbstractParserWithWordBoundary _1$1 = AbstractParserWithWordBoundary ;
const constants _1$1 = constants ;
const FIRST _REG _PATTERN = new RegExp ( "(?:从|自)?" +
"(?:" +
"(今|明|前|大前|后|大后|昨)(早|朝|晚)|" +
"(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
"(今|明|前|大前|后|大后|昨)(?:日|天)" +
"(?:[\\s,， +
"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" +
")?" +
"(?:[\\s,， +
"(?:(\\d+|[" +
Object . keys ( constants _1$1 . NUMBER ) . join ( "" ) +
"]+)(?:\\s*)(?:点|时|:|： +
"(?:\\s*)" +
"(\\d+|半|正|整|[" +
Object . keys ( constants _1$1 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:分|:|： +
"(?:\\s*)" +
"(\\d+|[" +
Object . keys ( constants _1$1 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:秒)?)" +
"(?:\\s*(A.M.|P.M.|AM?|PM?))?" , "i" ) ;
const SECOND _REG _PATTERN = new RegExp ( "(?:^\\s*(?:到|至|\\-|\\– +
"(?:" +
"(今|明|前|大前|后|大后|昨)(早|朝|晚)|" +
"(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
"(今|明|前|大前|后|大后|昨)(?:日|天)" +
"(?:[\\s,， +
"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" +
")?" +
"(?:[\\s,， +
"(?:(\\d+|[" +
Object . keys ( constants _1$1 . NUMBER ) . join ( "" ) +
"]+)(?:\\s*)(?:点|时|:|： +
"(?:\\s*)" +
"(\\d+|半|正|整|[" +
Object . keys ( constants _1$1 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:分|:|： +
"(?:\\s*)" +
"(\\d+|[" +
Object . keys ( constants _1$1 . NUMBER ) . join ( "" ) +
"]+)?(?:\\s*)(?:秒)?)" +
"(?:\\s*(A.M.|P.M.|AM?|PM?))?" , "i" ) ;
const DAY _GROUP _1 = 1 ;
const ZH _AM _PM _HOUR _GROUP _1 = 2 ;
const ZH _AM _PM _HOUR _GROUP _2 = 3 ;
const DAY _GROUP _3 = 4 ;
const ZH _AM _PM _HOUR _GROUP _3 = 5 ;
const HOUR _GROUP = 6 ;
const MINUTE _GROUP = 7 ;
const SECOND _GROUP = 8 ;
const AM _PM _HOUR _GROUP = 9 ;
class ZHHansTimeExpressionParser extends AbstractParserWithWordBoundary _1$1 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return FIRST _REG _PATTERN ;
}
innerExtract ( context , match ) {
if ( match . index > 0 && context . text [ match . index - 1 ] . match ( /\w/ ) ) {
return null ;
}
const refMoment = ( 0 , dayjs _1$1 . default ) ( context . refDate ) ;
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const startMoment = refMoment . clone ( ) ;
if ( match [ DAY _GROUP _1 ] ) {
const day1 = match [ DAY _GROUP _1 ] ;
if ( day1 == "明" ) {
if ( refMoment . hour ( ) > 1 ) {
startMoment . add ( 1 , "day" ) ;
}
}
else if ( day1 == "昨" ) {
startMoment . add ( - 1 , "day" ) ;
}
else if ( day1 == "前" ) {
startMoment . add ( - 2 , "day" ) ;
}
else if ( day1 == "大前" ) {
startMoment . add ( - 3 , "day" ) ;
}
else if ( day1 == "后" ) {
startMoment . add ( 2 , "day" ) ;
}
else if ( day1 == "大后" ) {
startMoment . add ( 3 , "day" ) ;
}
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
}
else if ( match [ DAY _GROUP _3 ] ) {
const day3 = match [ DAY _GROUP _3 ] ;
if ( day3 == "明" ) {
startMoment . add ( 1 , "day" ) ;
}
else if ( day3 == "昨" ) {
startMoment . add ( - 1 , "day" ) ;
}
else if ( day3 == "前" ) {
startMoment . add ( - 2 , "day" ) ;
}
else if ( day3 == "大前" ) {
startMoment . add ( - 3 , "day" ) ;
}
else if ( day3 == "后" ) {
startMoment . add ( 2 , "day" ) ;
}
else if ( day3 == "大后" ) {
startMoment . add ( 3 , "day" ) ;
}
result . start . assign ( "day" , startMoment . date ( ) ) ;
result . start . assign ( "month" , startMoment . month ( ) + 1 ) ;
result . start . assign ( "year" , startMoment . year ( ) ) ;
}
else {
result . start . imply ( "day" , startMoment . date ( ) ) ;
result . start . imply ( "month" , startMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
let hour = 0 ;
let minute = 0 ;
let meridiem = - 1 ;
if ( match [ SECOND _GROUP ] ) {
let second = parseInt ( match [ SECOND _GROUP ] ) ;
if ( isNaN ( second ) ) {
second = ( 0 , constants _1$1 . zhStringToNumber ) ( match [ SECOND _GROUP ] ) ;
}
if ( second >= 60 )
return null ;
result . start . assign ( "second" , second ) ;
}
hour = parseInt ( match [ HOUR _GROUP ] ) ;
if ( isNaN ( hour ) ) {
hour = ( 0 , constants _1$1 . zhStringToNumber ) ( match [ HOUR _GROUP ] ) ;
}
if ( match [ MINUTE _GROUP ] ) {
if ( match [ MINUTE _GROUP ] == "半" ) {
minute = 30 ;
}
else if ( match [ MINUTE _GROUP ] == "正" || match [ MINUTE _GROUP ] == "整" ) {
minute = 0 ;
}
else {
minute = parseInt ( match [ MINUTE _GROUP ] ) ;
if ( isNaN ( minute ) ) {
minute = ( 0 , constants _1$1 . zhStringToNumber ) ( match [ MINUTE _GROUP ] ) ;
}
}
}
else if ( hour > 100 ) {
minute = hour % 100 ;
hour = Math . floor ( hour / 100 ) ;
}
if ( minute >= 60 ) {
return null ;
}
if ( hour > 24 ) {
return null ;
}
if ( hour >= 12 ) {
meridiem = 1 ;
}
if ( match [ AM _PM _HOUR _GROUP ] ) {
if ( hour > 12 )
return null ;
const ampm = match [ AM _PM _HOUR _GROUP ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
if ( ampm == "p" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _1 ] ) {
const zhAMPMString1 = match [ ZH _AM _PM _HOUR _GROUP _1 ] ;
const zhAMPM1 = zhAMPMString1 [ 0 ] ;
if ( zhAMPM1 == "早" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM1 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _2 ] ) {
const zhAMPMString2 = match [ ZH _AM _PM _HOUR _GROUP _2 ] ;
const zhAMPM2 = zhAMPMString2 [ 0 ] ;
if ( zhAMPM2 == "上" || zhAMPM2 == "早" || zhAMPM2 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM2 == "下" || zhAMPM2 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _3 ] ) {
const zhAMPMString3 = match [ ZH _AM _PM _HOUR _GROUP _3 ] ;
const zhAMPM3 = zhAMPMString3 [ 0 ] ;
if ( zhAMPM3 == "上" || zhAMPM3 == "早" || zhAMPM3 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM3 == "下" || zhAMPM3 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
result . start . assign ( "hour" , hour ) ;
result . start . assign ( "minute" , minute ) ;
if ( meridiem >= 0 ) {
result . start . assign ( "meridiem" , meridiem ) ;
}
else {
if ( hour < 12 ) {
result . start . imply ( "meridiem" , 0 ) ;
}
else {
result . start . imply ( "meridiem" , 1 ) ;
}
}
match = SECOND _REG _PATTERN . exec ( context . text . substring ( result . index + result . text . length ) ) ;
if ( ! match ) {
if ( result . text . match ( /^\d+$/ ) ) {
return null ;
}
return result ;
}
const endMoment = startMoment . clone ( ) ;
result . end = context . createParsingComponents ( ) ;
if ( match [ DAY _GROUP _1 ] ) {
const day1 = match [ DAY _GROUP _1 ] ;
if ( day1 == "明" ) {
if ( refMoment . hour ( ) > 1 ) {
endMoment . add ( 1 , "day" ) ;
}
}
else if ( day1 == "昨" ) {
endMoment . add ( - 1 , "day" ) ;
}
else if ( day1 == "前" ) {
endMoment . add ( - 2 , "day" ) ;
}
else if ( day1 == "大前" ) {
endMoment . add ( - 3 , "day" ) ;
}
else if ( day1 == "后" ) {
endMoment . add ( 2 , "day" ) ;
}
else if ( day1 == "大后" ) {
endMoment . add ( 3 , "day" ) ;
}
result . end . assign ( "day" , endMoment . date ( ) ) ;
result . end . assign ( "month" , endMoment . month ( ) + 1 ) ;
result . end . assign ( "year" , endMoment . year ( ) ) ;
}
else if ( match [ DAY _GROUP _3 ] ) {
const day3 = match [ DAY _GROUP _3 ] ;
if ( day3 == "明" ) {
endMoment . add ( 1 , "day" ) ;
}
else if ( day3 == "昨" ) {
endMoment . add ( - 1 , "day" ) ;
}
else if ( day3 == "前" ) {
endMoment . add ( - 2 , "day" ) ;
}
else if ( day3 == "大前" ) {
endMoment . add ( - 3 , "day" ) ;
}
else if ( day3 == "后" ) {
endMoment . add ( 2 , "day" ) ;
}
else if ( day3 == "大后" ) {
endMoment . add ( 3 , "day" ) ;
}
result . end . assign ( "day" , endMoment . date ( ) ) ;
result . end . assign ( "month" , endMoment . month ( ) + 1 ) ;
result . end . assign ( "year" , endMoment . year ( ) ) ;
}
else {
result . end . imply ( "day" , endMoment . date ( ) ) ;
result . end . imply ( "month" , endMoment . month ( ) + 1 ) ;
result . end . imply ( "year" , endMoment . year ( ) ) ;
}
hour = 0 ;
minute = 0 ;
meridiem = - 1 ;
if ( match [ SECOND _GROUP ] ) {
let second = parseInt ( match [ SECOND _GROUP ] ) ;
if ( isNaN ( second ) ) {
second = ( 0 , constants _1$1 . zhStringToNumber ) ( match [ SECOND _GROUP ] ) ;
}
if ( second >= 60 )
return null ;
result . end . assign ( "second" , second ) ;
}
hour = parseInt ( match [ HOUR _GROUP ] ) ;
if ( isNaN ( hour ) ) {
hour = ( 0 , constants _1$1 . zhStringToNumber ) ( match [ HOUR _GROUP ] ) ;
}
if ( match [ MINUTE _GROUP ] ) {
if ( match [ MINUTE _GROUP ] == "半" ) {
minute = 30 ;
}
else if ( match [ MINUTE _GROUP ] == "正" || match [ MINUTE _GROUP ] == "整" ) {
minute = 0 ;
}
else {
minute = parseInt ( match [ MINUTE _GROUP ] ) ;
if ( isNaN ( minute ) ) {
minute = ( 0 , constants _1$1 . zhStringToNumber ) ( match [ MINUTE _GROUP ] ) ;
}
}
}
else if ( hour > 100 ) {
minute = hour % 100 ;
hour = Math . floor ( hour / 100 ) ;
}
if ( minute >= 60 ) {
return null ;
}
if ( hour > 24 ) {
return null ;
}
if ( hour >= 12 ) {
meridiem = 1 ;
}
if ( match [ AM _PM _HOUR _GROUP ] ) {
if ( hour > 12 )
return null ;
const ampm = match [ AM _PM _HOUR _GROUP ] [ 0 ] . toLowerCase ( ) ;
if ( ampm == "a" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
if ( ampm == "p" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
if ( ! result . start . isCertain ( "meridiem" ) ) {
if ( meridiem == 0 ) {
result . start . imply ( "meridiem" , 0 ) ;
if ( result . start . get ( "hour" ) == 12 ) {
result . start . assign ( "hour" , 0 ) ;
}
}
else {
result . start . imply ( "meridiem" , 1 ) ;
if ( result . start . get ( "hour" ) != 12 ) {
result . start . assign ( "hour" , result . start . get ( "hour" ) + 12 ) ;
}
}
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _1 ] ) {
const zhAMPMString1 = match [ ZH _AM _PM _HOUR _GROUP _1 ] ;
const zhAMPM1 = zhAMPMString1 [ 0 ] ;
if ( zhAMPM1 == "早" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM1 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _2 ] ) {
const zhAMPMString2 = match [ ZH _AM _PM _HOUR _GROUP _2 ] ;
const zhAMPM2 = zhAMPMString2 [ 0 ] ;
if ( zhAMPM2 == "上" || zhAMPM2 == "早" || zhAMPM2 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM2 == "下" || zhAMPM2 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
else if ( match [ ZH _AM _PM _HOUR _GROUP _3 ] ) {
const zhAMPMString3 = match [ ZH _AM _PM _HOUR _GROUP _3 ] ;
const zhAMPM3 = zhAMPMString3 [ 0 ] ;
if ( zhAMPM3 == "上" || zhAMPM3 == "早" || zhAMPM3 == "凌" ) {
meridiem = 0 ;
if ( hour == 12 )
hour = 0 ;
}
else if ( zhAMPM3 == "下" || zhAMPM3 == "晚" ) {
meridiem = 1 ;
if ( hour != 12 )
hour += 12 ;
}
}
result . text = result . text + match [ 0 ] ;
result . end . assign ( "hour" , hour ) ;
result . end . assign ( "minute" , minute ) ;
if ( meridiem >= 0 ) {
result . end . assign ( "meridiem" , meridiem ) ;
}
else {
const startAtPM = result . start . isCertain ( "meridiem" ) && result . start . get ( "meridiem" ) == 1 ;
if ( startAtPM && result . start . get ( "hour" ) > hour ) {
result . end . imply ( "meridiem" , 0 ) ;
}
else if ( hour > 12 ) {
result . end . imply ( "meridiem" , 1 ) ;
}
}
if ( result . end . date ( ) . getTime ( ) < result . start . date ( ) . getTime ( ) ) {
result . end . imply ( "day" , result . end . get ( "day" ) + 1 ) ;
}
return result ;
}
}
ZHHansTimeExpressionParser$1 . default = ZHHansTimeExpressionParser ;
var ZHHansWeekdayParser$1 = { } ;
var _ _importDefault$2 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansWeekdayParser$1 , "__esModule" , { value : true } ) ;
const dayjs _1 = _ _importDefault$2 ( require$$0 ) ;
const AbstractParserWithWordBoundary _1 = AbstractParserWithWordBoundary ;
const constants _1 = constants ;
const PATTERN = new RegExp ( "(?:星期|礼拜|周)(?<weekday>" + Object . keys ( constants _1 . WEEKDAY _OFFSET ) . join ( "|" ) + ")" ) ;
class ZHHansWeekdayParser extends AbstractParserWithWordBoundary _1 . AbstractParserWithWordBoundaryChecking {
innerPattern ( ) {
return PATTERN ;
}
innerExtract ( context , match ) {
const result = context . createParsingResult ( match . index , match [ 0 ] ) ;
const dayOfWeek = match . groups . weekday ;
const offset = constants _1 . WEEKDAY _OFFSET [ dayOfWeek ] ;
if ( offset === undefined )
return null ;
let startMoment = ( 0 , dayjs _1 . default ) ( context . refDate ) ;
const refOffset = startMoment . day ( ) ;
if ( Math . abs ( offset - 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset - 7 ) ;
}
else if ( Math . abs ( offset + 7 - refOffset ) < Math . abs ( offset - refOffset ) ) {
startMoment = startMoment . day ( offset + 7 ) ;
}
else {
startMoment = startMoment . day ( offset ) ;
}
result . start . assign ( "weekday" , offset ) ;
{
result . start . imply ( "day" , startMoment . date ( ) ) ;
result . start . imply ( "month" , startMoment . month ( ) + 1 ) ;
result . start . imply ( "year" , startMoment . year ( ) ) ;
}
return result ;
}
}
ZHHansWeekdayParser$1 . default = ZHHansWeekdayParser ;
var ZHHansMergeDateRangeRefiner$1 = { } ;
var _ _importDefault$1 = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansMergeDateRangeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateRangeRefiner _1 = _ _importDefault$1 ( AbstractMergeDateRangeRefiner$1 ) ;
class ZHHansMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner _1 . default {
patternBetween ( ) {
return /^\s*(至|到|-|~|～ － ;
}
}
ZHHansMergeDateRangeRefiner$1 . default = ZHHansMergeDateRangeRefiner ;
var ZHHansMergeDateTimeRefiner$1 = { } ;
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( ZHHansMergeDateTimeRefiner$1 , "__esModule" , { value : true } ) ;
const AbstractMergeDateTimeRefiner _1 = _ _importDefault ( AbstractMergeDateTimeRefiner ) ;
class ZHHansMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner _1 . default {
patternBetween ( ) {
return /^\s*$/i ;
}
}
ZHHansMergeDateTimeRefiner$1 . default = ZHHansMergeDateTimeRefiner ;
( function ( exports ) {
var _ _importDefault = ( commonjsGlobal && commonjsGlobal . _ _importDefault ) || function ( mod ) {
return ( mod && mod . _ _esModule ) ? mod : { "default" : mod } ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . createConfiguration = exports . createCasualConfiguration = exports . parseDate = exports . parse = exports . strict = exports . casual = exports . hans = void 0 ;
const chrono _1 = chrono$1 ;
const ExtractTimezoneOffsetRefiner _1 = _ _importDefault ( ExtractTimezoneOffsetRefiner$1 ) ;
const configurations _1 = configurations ;
const ZHHansCasualDateParser _1 = _ _importDefault ( ZHHansCasualDateParser$1 ) ;
const ZHHansDateParser _1 = _ _importDefault ( ZHHansDateParser$1 ) ;
const ZHHansDeadlineFormatParser _1 = _ _importDefault ( ZHHansDeadlineFormatParser$1 ) ;
const ZHHansRelationWeekdayParser _1 = _ _importDefault ( ZHHansRelationWeekdayParser$1 ) ;
const ZHHansTimeExpressionParser _1 = _ _importDefault ( ZHHansTimeExpressionParser$1 ) ;
const ZHHansWeekdayParser _1 = _ _importDefault ( ZHHansWeekdayParser$1 ) ;
const ZHHansMergeDateRangeRefiner _1 = _ _importDefault ( ZHHansMergeDateRangeRefiner$1 ) ;
const ZHHansMergeDateTimeRefiner _1 = _ _importDefault ( ZHHansMergeDateTimeRefiner$1 ) ;
exports . hans = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . casual = new chrono _1 . Chrono ( createCasualConfiguration ( ) ) ;
exports . strict = new chrono _1 . Chrono ( createConfiguration ( ) ) ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
function createCasualConfiguration ( ) {
const option = createConfiguration ( ) ;
option . parsers . unshift ( new ZHHansCasualDateParser _1 . default ( ) ) ;
return option ;
}
exports . createCasualConfiguration = createCasualConfiguration ;
function createConfiguration ( ) {
const configuration = ( 0 , configurations _1 . includeCommonConfiguration ) ( {
parsers : [
new ZHHansDateParser _1 . default ( ) ,
new ZHHansRelationWeekdayParser _1 . default ( ) ,
new ZHHansWeekdayParser _1 . default ( ) ,
new ZHHansTimeExpressionParser _1 . default ( ) ,
new ZHHansDeadlineFormatParser _1 . default ( ) ,
] ,
refiners : [ new ZHHansMergeDateRangeRefiner _1 . default ( ) , new ZHHansMergeDateTimeRefiner _1 . default ( ) ] ,
} ) ;
configuration . refiners = configuration . refiners . filter ( ( refiner ) => ! ( refiner instanceof ExtractTimezoneOffsetRefiner _1 . default ) ) ;
return configuration ;
}
exports . createConfiguration = createConfiguration ;
} ( hans ) ) ;
( function ( exports ) {
var _ _createBinding = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _exportStar = ( commonjsGlobal && commonjsGlobal . _ _exportStar ) || function ( m , exports ) {
for ( var p in m ) if ( p !== "default" && ! Object . prototype . hasOwnProperty . call ( exports , p ) ) _ _createBinding ( exports , m , p ) ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . hans = void 0 ;
_ _exportStar ( hant , exports ) ;
var hans _1 = hans ;
Object . defineProperty ( exports , "hans" , { enumerable : true , get : function ( ) { return hans _1 . hans ; } } ) ;
} ( zh ) ) ;
( function ( exports ) {
var _ _createBinding = ( commonjsGlobal && commonjsGlobal . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
var desc = Object . getOwnPropertyDescriptor ( m , k ) ;
if ( ! desc || ( "get" in desc ? ! m . _ _esModule : desc . writable || desc . configurable ) ) {
desc = { enumerable : true , get : function ( ) { return m [ k ] ; } } ;
}
Object . defineProperty ( o , k2 , desc ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( commonjsGlobal && commonjsGlobal . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( commonjsGlobal && commonjsGlobal . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , { value : true } ) ;
exports . parseDate = exports . parse = exports . casual = exports . strict = exports . zh = exports . nl = exports . pt = exports . ja = exports . fr = exports . de = exports . Meridiem = exports . Chrono = exports . en = void 0 ;
const en = _ _importStar ( en$1 ) ;
exports . en = en ;
const chrono _1 = chrono$1 ;
Object . defineProperty ( exports , "Chrono" , { enumerable : true , get : function ( ) { return chrono _1 . Chrono ; } } ) ;
( function ( Meridiem ) {
Meridiem [ Meridiem [ "AM" ] = 0 ] = "AM" ;
Meridiem [ Meridiem [ "PM" ] = 1 ] = "PM" ;
} ) ( exports . Meridiem || ( exports . Meridiem = { } ) ) ;
const de$1 = _ _importStar ( de ) ;
exports . de = de$1 ;
const fr$1 = _ _importStar ( fr ) ;
exports . fr = fr$1 ;
const ja$1 = _ _importStar ( ja ) ;
exports . ja = ja$1 ;
const pt$1 = _ _importStar ( pt ) ;
exports . pt = pt$1 ;
const nl$1 = _ _importStar ( nl ) ;
exports . nl = nl$1 ;
const zh$1 = _ _importStar ( zh ) ;
exports . zh = zh$1 ;
exports . strict = en . strict ;
exports . casual = en . casual ;
function parse ( text , ref , option ) {
return exports . casual . parse ( text , ref , option ) ;
}
exports . parse = parse ;
function parseDate ( text , ref , option ) {
return exports . casual . parseDate ( text , ref , option ) ;
}
exports . parseDate = parseDate ;
} ( dist ) ) ;
var chrono = /*@__PURE__*/ getDefaultExportFromCjs ( dist ) ;
function getLocalizedChrono ( ) {
const locale = window . moment . locale ( ) ;
switch ( locale ) {
case "en-gb" :
return new dist . Chrono ( chrono . en . createCasualConfiguration ( true ) ) ;
default :
return new dist . Chrono ( chrono . en . createCasualConfiguration ( false ) ) ;
}
}
function getConfiguredChrono ( ) {
const localizedChrono = getLocalizedChrono ( ) ;
localizedChrono . parsers . push ( {
pattern : ( ) => {
return /\bChristmas\b/i ;
} ,
extract : ( ) => {
return {
day : 25 ,
month : 12 ,
} ;
} ,
} ) ;
localizedChrono . parsers . push ( {
pattern : ( ) => new RegExp ( ORDINAL _NUMBER _PATTERN ) ,
extract : ( _context , match ) => {
return {
day : parseOrdinalNumberPattern ( match [ 0 ] ) ,
month : window . moment ( ) . month ( ) ,
} ;
} ,
} ) ;
return localizedChrono ;
}
class NLDParser {
constructor ( ) {
this . chrono = getConfiguredChrono ( ) ;
}
getParsedDate ( selectedText , weekStartPreference ) {
var _a ;
const parser = this . chrono ;
const initialParse = parser . parse ( selectedText ) ;
const weekdayIsCertain = ( _a = initialParse [ 0 ] ) === null || _a === void 0 ? void 0 : _a . start . isCertain ( "weekday" ) ;
const weekStart = weekStartPreference === "locale-default"
? getLocaleWeekStart ( )
: weekStartPreference ;
const locale = {
weekStart : getWeekNumber ( weekStart ) ,
} ;
const thisDateMatch = selectedText . match ( /this\s([\w]+)/i ) ;
const nextDateMatch = selectedText . match ( /next\s([\w]+)/i ) ;
const lastDayOfMatch = selectedText . match ( /(last day of|end of)\s*([^\n\r]*)/i ) ;
const midOf = selectedText . match ( /mid\s([\w]+)/i ) ;
const referenceDate = weekdayIsCertain
? window . moment ( ) . weekday ( 0 ) . toDate ( )
: new Date ( ) ;
if ( thisDateMatch && thisDateMatch [ 1 ] === "week" ) {
return parser . parseDate ( ` this ${ weekStart } ` , referenceDate ) ;
}
if ( nextDateMatch && nextDateMatch [ 1 ] === "week" ) {
return parser . parseDate ( ` next ${ weekStart } ` , referenceDate , {
forwardDate : true ,
} ) ;
}
if ( nextDateMatch && nextDateMatch [ 1 ] === "month" ) {
const thisMonth = parser . parseDate ( "this month" , new Date ( ) , {
forwardDate : true ,
} ) ;
return parser . parseDate ( selectedText , thisMonth , {
forwardDate : true ,
} ) ;
}
if ( nextDateMatch && nextDateMatch [ 1 ] === "year" ) {
const thisYear = parser . parseDate ( "this year" , new Date ( ) , {
forwardDate : true ,
} ) ;
return parser . parseDate ( selectedText , thisYear , {
forwardDate : true ,
} ) ;
}
if ( lastDayOfMatch ) {
const tempDate = parser . parse ( lastDayOfMatch [ 2 ] ) ;
const year = tempDate [ 0 ] . start . get ( "year" ) ;
const month = tempDate [ 0 ] . start . get ( "month" ) ;
const lastDay = getLastDayOfMonth ( year , month ) ;
return parser . parseDate ( ` ${ year } - ${ month } - ${ lastDay } ` , new Date ( ) , {
forwardDate : true ,
} ) ;
}
if ( midOf ) {
return parser . parseDate ( ` ${ midOf [ 1 ] } 15th ` , new Date ( ) , {
forwardDate : true ,
} ) ;
}
return parser . parseDate ( selectedText , referenceDate , { locale } ) ;
}
}
const DEFAULT _SETTINGS = {
autosuggestToggleLink : true ,
autocompleteTriggerPhrase : "@" ,
isAutosuggestEnabled : true ,
format : "YYYY-MM-DD" ,
timeFormat : "HH:mm" ,
separator : " " ,
weekStart : "locale-default" ,
modalToggleTime : false ,
modalToggleLink : false ,
modalMomentFormat : "YYYY-MM-DD HH:mm" ,
} ;
const weekdays = [
"sunday" ,
"monday" ,
"tuesday" ,
"wednesday" ,
"thursday" ,
"friday" ,
"saturday" ,
] ;
class NLDSettingsTab extends require$$0$1 . PluginSettingTab {
constructor ( app , plugin ) {
super ( app , plugin ) ;
this . plugin = plugin ;
}
display ( ) {
const { containerEl } = this ;
const localizedWeekdays = window . moment . weekdays ( ) ;
const localeWeekStart = getLocaleWeekStart ( ) ;
containerEl . empty ( ) ;
containerEl . createEl ( "h2" , {
text : "Natural Language Dates" ,
} ) ;
containerEl . createEl ( "h3" , {
text : "Parser settings" ,
} ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Date format" )
. setDesc ( "Output format for parsed dates" )
. addMomentFormat ( ( text ) => text
. setDefaultFormat ( "YYYY-MM-DD" )
. setValue ( this . plugin . settings . format )
. onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . format = value || "YYYY-MM-DD" ;
yield this . plugin . saveSettings ( ) ;
} ) ) ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Week starts on" )
. setDesc ( "Which day to consider as the start of the week" )
. addDropdown ( ( dropdown ) => {
dropdown . addOption ( "locale-default" , ` Locale default ( ${ localeWeekStart } ) ` ) ;
localizedWeekdays . forEach ( ( day , i ) => {
dropdown . addOption ( weekdays [ i ] , day ) ;
} ) ;
dropdown . setValue ( this . plugin . settings . weekStart . toLowerCase ( ) ) ;
dropdown . onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . weekStart = value ;
yield this . plugin . saveSettings ( ) ;
} ) ) ;
} ) ;
containerEl . createEl ( "h3" , {
text : "Hotkey formatting settings" ,
} ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Time format" )
. setDesc ( "Format for the hotkeys that include the current time" )
. addMomentFormat ( ( text ) => text
. setDefaultFormat ( "HH:mm" )
. setValue ( this . plugin . settings . timeFormat )
. onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . timeFormat = value || "HH:mm" ;
yield this . plugin . saveSettings ( ) ;
} ) ) ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Separator" )
. setDesc ( "Separator between date and time for entries that have both" )
. addText ( ( text ) => text
. setPlaceholder ( "Separator is empty" )
. setValue ( this . plugin . settings . separator )
. onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . separator = value ;
yield this . plugin . saveSettings ( ) ;
} ) ) ) ;
containerEl . createEl ( "h3" , {
text : "Date Autosuggest" ,
} ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Enable date autosuggest" )
. setDesc ( ` Input dates with natural language. Open the suggest menu with ${ this . plugin . settings . autocompleteTriggerPhrase } ` )
. addToggle ( ( toggle ) => toggle
. setValue ( this . plugin . settings . isAutosuggestEnabled )
. onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . isAutosuggestEnabled = value ;
yield this . plugin . saveSettings ( ) ;
} ) ) ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Add dates as link?" )
. setDesc ( "If enabled, dates created via autosuggest will be wrapped in [[wikilinks]]" )
. addToggle ( ( toggle ) => toggle
. setValue ( this . plugin . settings . autosuggestToggleLink )
. onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . autosuggestToggleLink = value ;
yield this . plugin . saveSettings ( ) ;
} ) ) ) ;
new require$$0$1 . Setting ( containerEl )
. setName ( "Trigger phrase" )
. setDesc ( "Character(s) that will cause the date autosuggest to open" )
. addMomentFormat ( ( text ) => text
. setPlaceholder ( DEFAULT _SETTINGS . autocompleteTriggerPhrase )
. setValue ( this . plugin . settings . autocompleteTriggerPhrase || "@" )
. onChange ( ( value ) => _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . plugin . settings . autocompleteTriggerPhrase = value . trim ( ) ;
yield this . plugin . saveSettings ( ) ;
} ) ) ) ;
}
}
class DateSuggest extends require$$0$1 . EditorSuggest {
constructor ( app , plugin ) {
super ( app ) ;
this . app = app ;
this . plugin = plugin ;
// @ts-ignore
this . scope . register ( [ "Shift" ] , "Enter" , ( evt ) => {
// @ts-ignore
this . suggestions . useSelectedItem ( evt ) ;
return false ;
} ) ;
if ( this . plugin . settings . autosuggestToggleLink ) {
this . setInstructions ( [ { command : "Shift" , purpose : "Keep text as alias" } ] ) ;
}
}
getSuggestions ( context ) {
const suggestions = this . getDateSuggestions ( context ) ;
if ( suggestions . length ) {
return suggestions ;
}
// catch-all if there are no matches
return [ { label : context . query } ] ;
}
getDateSuggestions ( context ) {
if ( context . query . match ( /^time/ ) ) {
return [ "now" , "+15 minutes" , "+1 hour" , "-15 minutes" , "-1 hour" ]
. map ( ( val ) => ( { label : ` time: ${ val } ` } ) )
. filter ( ( item ) => item . label . toLowerCase ( ) . startsWith ( context . query ) ) ;
}
if ( context . query . match ( /(next|last|this)/i ) ) {
const reference = context . query . match ( /(next|last|this)/i ) [ 1 ] ;
return [
"week" ,
"month" ,
"year" ,
"Sunday" ,
"Monday" ,
"Tuesday" ,
"Wednesday" ,
"Thursday" ,
"Friday" ,
"Saturday" ,
]
. map ( ( val ) => ( { label : ` ${ reference } ${ val } ` } ) )
. filter ( ( items ) => items . label . toLowerCase ( ) . startsWith ( context . query ) ) ;
}
const relativeDate = context . query . match ( /^in ([+-]?\d+)/i ) || context . query . match ( /^([+-]?\d+)/i ) ;
if ( relativeDate ) {
const timeDelta = relativeDate [ 1 ] ;
return [
{ label : ` in ${ timeDelta } minutes ` } ,
{ label : ` in ${ timeDelta } hours ` } ,
{ label : ` in ${ timeDelta } days ` } ,
{ label : ` in ${ timeDelta } weeks ` } ,
{ label : ` in ${ timeDelta } months ` } ,
{ label : ` ${ timeDelta } days ago ` } ,
{ label : ` ${ timeDelta } weeks ago ` } ,
{ label : ` ${ timeDelta } months ago ` } ,
] . filter ( ( items ) => items . label . toLowerCase ( ) . startsWith ( context . query ) ) ;
}
return [ { label : "Today" } , { label : "Yesterday" } , { label : "Tomorrow" } ] . filter ( ( items ) => items . label . toLowerCase ( ) . startsWith ( context . query ) ) ;
}
renderSuggestion ( suggestion , el ) {
el . setText ( suggestion . label ) ;
}
selectSuggestion ( suggestion , event ) {
const { editor } = this . context ;
const includeAlias = event . shiftKey ;
let dateStr = "" ;
let makeIntoLink = this . plugin . settings . autosuggestToggleLink ;
if ( suggestion . label . startsWith ( "time:" ) ) {
const timePart = suggestion . label . substring ( 5 ) ;
dateStr = this . plugin . parseTime ( timePart ) . formattedString ;
makeIntoLink = false ;
}
else {
dateStr = this . plugin . parseDate ( suggestion . label ) . formattedString ;
}
if ( makeIntoLink ) {
dateStr = generateMarkdownLink ( this . app , dateStr , includeAlias ? suggestion . label : undefined ) ;
}
editor . replaceRange ( dateStr , this . context . start , this . context . end ) ;
}
onTrigger ( cursor , editor , file ) {
var _a ;
if ( ! this . plugin . settings . isAutosuggestEnabled ) {
return null ;
}
const triggerPhrase = this . plugin . settings . autocompleteTriggerPhrase ;
const startPos = ( ( _a = this . context ) === null || _a === void 0 ? void 0 : _a . start ) || {
line : cursor . line ,
ch : cursor . ch - triggerPhrase . length ,
} ;
if ( ! editor . getRange ( startPos , cursor ) . startsWith ( triggerPhrase ) ) {
return null ;
}
const precedingChar = editor . getRange ( {
line : startPos . line ,
ch : startPos . ch - 1 ,
} , startPos ) ;
// Short-circuit if `@` as a part of a word (e.g. part of an email address)
if ( precedingChar && /[`a-zA-Z0-9]/ . test ( precedingChar ) ) {
return null ;
}
return {
start : startPos ,
end : cursor ,
query : editor . getRange ( startPos , cursor ) . substring ( triggerPhrase . length ) ,
} ;
}
}
function getParseCommand ( plugin , mode ) {
const { workspace } = plugin . app ;
const activeView = workspace . getActiveViewOfType ( require$$0$1 . MarkdownView ) ;
// The active view might not be a markdown view
if ( ! activeView ) {
return ;
}
const editor = activeView . editor ;
const cursor = editor . getCursor ( ) ;
const selectedText = getSelectedText ( editor ) ;
const date = plugin . parseDate ( selectedText ) ;
if ( ! date . moment . isValid ( ) ) {
// Do nothing
editor . setCursor ( {
line : cursor . line ,
ch : cursor . ch ,
} ) ;
return ;
}
//mode == "replace"
let newStr = ` [[ ${ date . formattedString } ]] ` ;
if ( mode == "link" ) {
newStr = ` [ ${ selectedText } ]( ${ date . formattedString } ) ` ;
}
else if ( mode == "clean" ) {
newStr = ` ${ date . formattedString } ` ;
}
else if ( mode == "time" ) {
const time = plugin . parseTime ( selectedText ) ;
newStr = ` ${ time . formattedString } ` ;
}
editor . replaceSelection ( newStr ) ;
adjustCursor ( editor , cursor , newStr , selectedText ) ;
editor . focus ( ) ;
}
function insertMomentCommand ( plugin , date , format ) {
const { workspace } = plugin . app ;
const activeView = workspace . getActiveViewOfType ( require$$0$1 . MarkdownView ) ;
if ( activeView ) {
// The active view might not be a markdown view
const editor = activeView . editor ;
editor . replaceSelection ( window . moment ( date ) . format ( format ) ) ;
}
}
function getNowCommand ( plugin ) {
const format = ` ${ plugin . settings . format } ${ plugin . settings . separator } ${ plugin . settings . timeFormat } ` ;
const date = new Date ( ) ;
insertMomentCommand ( plugin , date , format ) ;
}
function getCurrentDateCommand ( plugin ) {
const format = plugin . settings . format ;
const date = new Date ( ) ;
insertMomentCommand ( plugin , date , format ) ;
}
function getCurrentTimeCommand ( plugin ) {
const format = plugin . settings . timeFormat ;
const date = new Date ( ) ;
insertMomentCommand ( plugin , date , format ) ;
}
class NaturalLanguageDates extends require$$0$1 . Plugin {
onload ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
yield this . loadSettings ( ) ;
this . addCommand ( {
id : "nlp-dates" ,
name : "Parse natural language date" ,
callback : ( ) => getParseCommand ( this , "replace" ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-dates-link" ,
name : "Parse natural language date (as link)" ,
callback : ( ) => getParseCommand ( this , "link" ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-date-clean" ,
name : "Parse natural language date (as plain text)" ,
callback : ( ) => getParseCommand ( this , "clean" ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-parse-time" ,
name : "Parse natural language time" ,
callback : ( ) => getParseCommand ( this , "time" ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-now" ,
name : "Insert the current date and time" ,
callback : ( ) => getNowCommand ( this ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-today" ,
name : "Insert the current date" ,
callback : ( ) => getCurrentDateCommand ( this ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-time" ,
name : "Insert the current time" ,
callback : ( ) => getCurrentTimeCommand ( this ) ,
hotkeys : [ ] ,
} ) ;
this . addCommand ( {
id : "nlp-picker" ,
name : "Date picker" ,
checkCallback : ( checking ) => {
if ( checking ) {
return ! ! this . app . workspace . getActiveViewOfType ( require$$0$1 . MarkdownView ) ;
}
new DatePickerModal ( this . app , this ) . open ( ) ;
} ,
hotkeys : [ ] ,
} ) ;
this . addSettingTab ( new NLDSettingsTab ( this . app , this ) ) ;
this . registerObsidianProtocolHandler ( "nldates" , this . actionHandler . bind ( this ) ) ;
this . registerEditorSuggest ( new DateSuggest ( this . app , this ) ) ;
this . app . workspace . onLayoutReady ( ( ) => {
// initialize the parser when layout is ready so that the correct locale is used
this . parser = new NLDParser ( ) ;
} ) ;
} ) ;
}
onunload ( ) {
console . log ( "Unloading natural language date parser plugin" ) ;
}
loadSettings ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
this . settings = Object . assign ( { } , DEFAULT _SETTINGS , yield this . loadData ( ) ) ;
} ) ;
}
saveSettings ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
yield this . saveData ( this . settings ) ;
} ) ;
}
/ *
@ param dateString : A string that contains a date in natural language , e . g . today , tomorrow , next week
@ param format : A string that contains the formatting string for a Moment
@ returns NLDResult : An object containing the date , a cloned Moment and the formatted string .
* /
parse ( dateString , format ) {
const date = this . parser . getParsedDate ( dateString , this . settings . weekStart ) ;
const formattedString = getFormattedDate ( date , format ) ;
if ( formattedString === "Invalid date" ) {
console . debug ( "Input date " + dateString + " can't be parsed by nldates" ) ;
}
return {
formattedString ,
date ,
moment : window . moment ( date ) ,
} ;
}
/ *
@ param dateString : A string that contains a date in natural language , e . g . today , tomorrow , next week
@ returns NLDResult : An object containing the date , a cloned Moment and the formatted string .
* /
parseDate ( dateString ) {
return this . parse ( dateString , this . settings . format ) ;
}
parseTime ( dateString ) {
return this . parse ( dateString , this . settings . timeFormat ) ;
}
actionHandler ( params ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const { workspace } = this . app ;
const date = this . parseDate ( params . day ) ;
const newPane = parseTruthy ( params . newPane || "yes" ) ;
if ( date . moment . isValid ( ) ) {
const dailyNote = yield getOrCreateDailyNote ( date . moment ) ;
workspace . getLeaf ( newPane ) . openFile ( dailyNote ) ;
}
} ) ;
}
}
module . exports = NaturalLanguageDates ;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
