|
|
'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|\\-|\\–|until|through|till)?\\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*(?:\\-|\\–|\\~|\\〜|to|\\?)\\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("(?:(?:\\,|\\(|\\（)\\s*)?" +
|
|
|
"(?: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*(?:\\-|\\–|\\~|\\〜|bis)\\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("(?:(?:\\,|\\(|\\（)\\s*)?" +
|
|
|
"(?: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*(?:\\-|\\–|\\~|\\〜|[àa]|\\?)\\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("(?:(?:\\,|\\(|\\（)\\s*)?" +
|
|
|
"(?:(?: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*(\\-|\\–|\\~|\\〜|[àa]|\\?)\\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|\\-|\\–|jusqu'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０-９]{1,4}|元)))年\s*)?([0-9０-９]{1,2})月\s*([0-9０-９]{1,2})日/i;
|
|
|
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("(?:(?:\\,|\\(|\\（)\\s*)?" +
|
|
|
"(?:(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*(?:\\-|\\–|\\~|\\〜|a(?:o)?|\\?)\\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|\\-|\\–|ao?|\\s)\\s*([0-9]{1,2})(?:º|ª|°)?)?\\s*(?:de)?\\s*" +
|
|
|
`(?:-|/|\\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("(?:(?:\\,|\\(|\\（)\\s*)?" +
|
|
|
"(?: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|\\-|\\–|until|through|till|\\s)\\s*" +
|
|
|
`(${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*(?:\\-|\\–|\\~|\\〜|om|\\?)\\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,，]*)" +
|
|
|
"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" +
|
|
|
")?" +
|
|
|
"(?:[\\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*(至|到|\-|\~|～|－|ー)\s*$/i;
|
|
|
}
|
|
|
}
|
|
|
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,，]*)" +
|
|
|
"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?" +
|
|
|
")?" +
|
|
|
"(?:[\\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*(至|到|-|~|～|－|ー)\s*$/i;
|
|
|
}
|
|
|
}
|
|
|
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,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","node_modules/obsidian-daily-notes-interface/dist/main.js","src/utils.ts","src/modals/date-picker.ts","node_modules/chrono-node/dist/utils/pattern.js","node_modules/dayjs/esm/constant.js","node_modules/dayjs/esm/locale/en.js","node_modules/dayjs/esm/utils.js","node_modules/dayjs/esm/index.js","node_modules/chrono-node/dist/calculation/years.js","node_modules/chrono-node/dist/locales/en/constants.js","node_modules/dayjs/plugin/quarterOfYear.js","node_modules/dayjs/plugin/weekday.js","node_modules/chrono-node/dist/utils/dayjs.js","node_modules/chrono-node/dist/timezone.js","node_modules/chrono-node/dist/results.js","node_modules/chrono-node/dist/common/parsers/AbstractParserWithWordBoundary.js","node_modules/chrono-node/dist/locales/en/parsers/ENTimeUnitWithinFormatParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENMonthNameLittleEndianParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENMonthNameMiddleEndianParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENMonthNameParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENCasualYearMonthDayParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENSlashMonthFormatParser.js","node_modules/chrono-node/dist/common/parsers/AbstractTimeExpressionParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENTimeExpressionParser.js","node_modules/chrono-node/dist/utils/timeunits.js","node_modules/chrono-node/dist/locales/en/parsers/ENTimeUnitAgoFormatParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENTimeUnitLaterFormatParser.js","node_modules/chrono-node/dist/common/abstractRefiners.js","node_modules/chrono-node/dist/common/refiners/AbstractMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/en/refiners/ENMergeDateRangeRefiner.js","node_modules/chrono-node/dist/calculation/mergingCalculation.js","node_modules/chrono-node/dist/common/refiners/AbstractMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/en/refiners/ENMergeDateTimeRefiner.js","node_modules/chrono-node/dist/common/refiners/ExtractTimezoneAbbrRefiner.js","node_modules/chrono-node/dist/common/refiners/ExtractTimezoneOffsetRefiner.js","node_modules/chrono-node/dist/common/refiners/OverlapRemovalRefiner.js","node_modules/chrono-node/dist/common/refiners/ForwardDateRefiner.js","node_modules/chrono-node/dist/common/refiners/UnlikelyFormatFilter.js","node_modules/chrono-node/dist/common/parsers/ISOFormatParser.js","node_modules/chrono-node/dist/common/refiners/MergeWeekdayComponentRefiner.js","node_modules/chrono-node/dist/configurations.js","node_modules/chrono-node/dist/common/casualReferences.js","node_modules/chrono-node/dist/locales/en/parsers/ENCasualDateParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENCasualTimeParser.js","node_modules/chrono-node/dist/calculation/weeks.js","node_modules/chrono-node/dist/locales/en/parsers/ENWeekdayParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENRelativeDateFormatParser.js","node_modules/chrono-node/dist/chrono.js","node_modules/chrono-node/dist/common/parsers/SlashDateFormatParser.js","node_modules/chrono-node/dist/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.js","node_modules/chrono-node/dist/locales/en/index.js","node_modules/chrono-node/dist/locales/de/parsers/DETimeExpressionParser.js","node_modules/chrono-node/dist/locales/de/constants.js","node_modules/chrono-node/dist/locales/de/parsers/DEWeekdayParser.js","node_modules/chrono-node/dist/locales/de/refiners/DEMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/de/refiners/DEMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/de/parsers/DECasualTimeParser.js","node_modules/chrono-node/dist/locales/de/parsers/DECasualDateParser.js","node_modules/chrono-node/dist/locales/de/parsers/DEMonthNameLittleEndianParser.js","node_modules/chrono-node/dist/locales/de/index.js","node_modules/chrono-node/dist/locales/fr/parsers/FRCasualDateParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRCasualTimeParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRTimeExpressionParser.js","node_modules/chrono-node/dist/locales/fr/refiners/FRMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/fr/refiners/FRMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/fr/constants.js","node_modules/chrono-node/dist/locales/fr/parsers/FRWeekdayParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRSpecificTimeExpressionParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRMonthNameLittleEndianParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRTimeUnitAgoFormatParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRTimeUnitWithinFormatParser.js","node_modules/chrono-node/dist/locales/fr/parsers/FRTimeUnitRelativeFormatParser.js","node_modules/chrono-node/dist/locales/fr/index.js","node_modules/chrono-node/dist/locales/ja/constants.js","node_modules/chrono-node/dist/locales/ja/parsers/JPStandardParser.js","node_modules/chrono-node/dist/locales/ja/refiners/JPMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/ja/parsers/JPCasualDateParser.js","node_modules/chrono-node/dist/locales/ja/index.js","node_modules/chrono-node/dist/locales/pt/constants.js","node_modules/chrono-node/dist/locales/pt/parsers/PTWeekdayParser.js","node_modules/chrono-node/dist/locales/pt/parsers/PTTimeExpressionParser.js","node_modules/chrono-node/dist/locales/pt/refiners/PTMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/pt/refiners/PTMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/pt/parsers/PTMonthNameLittleEndianParser.js","node_modules/chrono-node/dist/locales/pt/parsers/PTCasualDateParser.js","node_modules/chrono-node/dist/locales/pt/parsers/PTCasualTimeParser.js","node_modules/chrono-node/dist/locales/pt/index.js","node_modules/chrono-node/dist/locales/nl/refiners/NLMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/nl/refiners/NLMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/nl/parsers/NLCasualDateParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLCasualTimeParser.js","node_modules/chrono-node/dist/locales/nl/constants.js","node_modules/chrono-node/dist/locales/nl/parsers/NLTimeUnitWithinFormatParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLWeekdayParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLMonthNameMiddleEndianParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLMonthNameParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLSlashMonthFormatParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLTimeExpressionParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLCasualYearMonthDayParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLCasualDateTimeParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLTimeUnitCasualRelativeFormatParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLRelativeDateFormatParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLTimeUnitAgoFormatParser.js","node_modules/chrono-node/dist/locales/nl/parsers/NLTimeUnitLaterFormatParser.js","node_modules/chrono-node/dist/locales/nl/index.js","node_modules/chrono-node/dist/locales/zh/hant/parsers/ZHHantCasualDateParser.js","node_modules/chrono-node/dist/locales/zh/hant/constants.js","node_modules/chrono-node/dist/locales/zh/hant/parsers/ZHHantDateParser.js","node_modules/chrono-node/dist/locales/zh/hant/parsers/ZHHantDeadlineFormatParser.js","node_modules/chrono-node/dist/locales/zh/hant/parsers/ZHHantRelationWeekdayParser.js","node_modules/chrono-node/dist/locales/zh/hant/parsers/ZHHantTimeExpressionParser.js","node_modules/chrono-node/dist/locales/zh/hant/parsers/ZHHantWeekdayParser.js","node_modules/chrono-node/dist/locales/zh/hant/refiners/ZHHantMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/zh/hant/refiners/ZHHantMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/zh/hant/index.js","node_modules/chrono-node/dist/locales/zh/hans/parsers/ZHHansCasualDateParser.js","node_modules/chrono-node/dist/locales/zh/hans/constants.js","node_modules/chrono-node/dist/locales/zh/hans/parsers/ZHHansDateParser.js","node_modules/chrono-node/dist/locales/zh/hans/parsers/ZHHansDeadlineFormatParser.js","node_modules/chrono-node/dist/locales/zh/hans/parsers/ZHHansRelationWeekdayParser.js","node_modules/chrono-node/dist/locales/zh/hans/parsers/ZHHansTimeExpressionParser.js","node_modules/chrono-node/dist/locales/zh/hans/parsers/ZHHansWeekdayParser.js","node_modules/chrono-node/dist/locales/zh/hans/refiners/ZHHansMergeDateRangeRefiner.js","node_modules/chrono-node/dist/locales/zh/hans/refiners/ZHHansMergeDateTimeRefiner.js","node_modules/chrono-node/dist/locales/zh/hans/index.js","node_modules/chrono-node/dist/locales/zh/index.js","node_modules/chrono-node/dist/index.js","src/parser.ts","src/settings.ts","src/suggest/date-suggest.ts","src/commands.ts","src/main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar obsidian = require('obsidian');\n\nconst DEFAULT_DAILY_NOTE_FORMAT = \"YYYY-MM-DD\";\nconst DEFAULT_WEEKLY_NOTE_FORMAT = \"gggg-[W]ww\";\nconst DEFAULT_MONTHLY_NOTE_FORMAT = \"YYYY-MM\";\nconst DEFAULT_QUARTERLY_NOTE_FORMAT = \"YYYY-[Q]Q\";\nconst DEFAULT_YEARLY_NOTE_FORMAT = \"YYYY\";\n\nfunction shouldUsePeriodicNotesSettings(periodicity) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = window.app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.[periodicity]?.enabled;\n}\n/**\n * Read the user settings for the `daily-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getDailyNoteSettings() {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const { internalPlugins, plugins } = window.app;\n        if (shouldUsePeriodicNotesSettings(\"daily\")) {\n            const { format, folder, template } = plugins.getPlugin(\"periodic-notes\")?.settings?.daily || {};\n            return {\n                format: format || DEFAULT_DAILY_NOTE_FORMAT,\n                folder: folder?.trim() || \"\",\n                template: template?.trim() || \"\",\n            };\n        }\n        const { folder, format, template } = internalPlugins.getPluginById(\"daily-notes\")?.instance?.options || {};\n        return {\n            format: format || DEFAULT_DAILY_NOTE_FORMAT,\n            folder: folder?.trim() || \"\",\n            template: template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom daily note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `weekly-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getWeeklyNoteSettings() {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const pluginManager = window.app.plugins;\n        const calendarSettings = pluginManager.getPlugin(\"calendar\")?.options;\n        const periodicNotesSettings = pluginManager.getPlugin(\"periodic-notes\")?.settings?.weekly;\n        if (shouldUsePeriodicNotesSettings(\"weekly\")) {\n            return {\n                format: periodicNotesSettings.format || DEFAULT_WEEKLY_NOTE_FORMAT,\n                folder: periodicNotesSettings.folder?.trim() || \"\",\n                template: periodicNotesSettings.template?.trim() || \"\",\n            };\n        }\n        const settings = calendarSettings || {};\n        return {\n            format: settings.weeklyNoteFormat || DEFAULT_WEEKLY_NOTE_FORMAT,\n            folder: settings.weeklyNoteFolder?.trim() || \"\",\n            template: settings.weeklyNoteTemplate?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom weekly note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `periodic-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getMonthlyNoteSettings() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pluginManager = window.app.plugins;\n    try {\n        const settings = (shouldUsePeriodicNotesSettings(\"monthly\") &&\n            pluginManager.getPlugin(\"periodic-notes\")?.settings?.monthly) ||\n            {};\n        return {\n            format: settings.format || DEFAULT_MONTHLY_NOTE_FORMAT,\n            folder: settings.folder?.trim() || \"\",\n            template: settings.template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom monthly note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `periodic-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getQuarterlyNoteSettings() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pluginManager = window.app.plugins;\n    try {\n        const settings = (shouldUsePeriodicNotesSettings(\"quarterly\") &&\n            pluginManager.getPlugin(\"periodic-notes\")?.settings?.quarterly) ||\n            {};\n        return {\n            format: settings.format || DEFAULT_QUARTERLY_NOTE_FORMAT,\n            folder: settings.folder?.trim() || \"\",\n            template: settings.template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom quarterly note settings found!\", err);\n    }\n}\n/**\n * Read the user settings for the `periodic-notes` plugin\n * to keep behavior of creating a new note in-sync.\n */\nfunction getYearlyNoteSettings() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pluginManager = window.app.plugins;\n    try {\n        const settings = (shouldUsePeriodicNotesSettings(\"yearly\") &&\n            pluginManager.getPlugin(\"periodic-notes\")?.settings?.yearly) ||\n            {};\n        return {\n            format: settings.format || DEFAULT_YEARLY_NOTE_FORMAT,\n            folder: settings.folder?.trim() || \"\",\n            template: settings.template?.trim() || \"\",\n        };\n    }\n    catch (err) {\n        console.info(\"No custom yearly note settings found!\", err);\n    }\n}\n\n// Credit: @creationix/path.js\nfunction join(...partSegments) {\n    // Split the inputs into a list of path commands.\n    let parts = [];\n    for (let i = 0, l = partSegments.length; i < l; i++) {\n        parts = parts.concat(partSegments[i].split(\"/\"));\n    }\n    // Interpret the path commands to get the new resolved path.\n    const newParts = [];\n    for (let i = 0, l = parts.length; i < l; i++) {\n        const part = parts[i];\n        // Remove leading and trailing slashes\n        // Also remove \".\" segments\n        if (!part || part === \".\")\n            continue;\n        // Push new path segments.\n        else\n            newParts.push(part);\n    }\n    // Preserve the initial slash if there was one.\n    if (parts[0] === \"\")\n        newParts.unshift(\"\");\n    // Turn back into a single string path.\n    return newParts.join(\"/\");\n}\nfunction basename(fullPath) {\n    let base = fullPath.substring(fullPath.lastIndexOf(\"/\") + 1);\n    if (base.lastIndexOf(\".\") != -1)\n        base = base.substring(0, base.lastIndexOf(\".\"));\n    return base;\n}\nasync function ensureFolderExists(path) {\n    const dirs = path.replace(/\\\\/g, \"/\").split(\"/\");\n    dirs.pop(); // remove basename\n    if (dirs.length) {\n        const dir = join(...dirs);\n        if (!window.app.vault.getAbstractFileByPath(dir)) {\n            await window.app.vault.createFolder(dir);\n        }\n    }\n}\nasync function getNotePath(directory, filename) {\n    if (!filename.endsWith(\".md\")) {\n        filename += \".md\";\n    }\n    const path = obsidian.normalizePath(join(directory, filename));\n    await ensureFolderExists(path);\n    return path;\n}\nasync function getTemplateInfo(template) {\n    const { metadataCache, vault } = window.app;\n    const templatePath = obsidian.normalizePath(template);\n    if (templatePath === \"/\") {\n        return Promise.resolve([\"\", null]);\n    }\n    try {\n        const templateFile = metadataCache.getFirstLinkpathDest(templatePath, \"\");\n        const contents = await vault.cachedRead(templateFile);\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const IFoldInfo = window.app.foldManager.load(templateFile);\n        return [contents, IFoldInfo];\n    }\n    catch (err) {\n        console.error(`Failed to read the daily note template '${templatePath}'`, err);\n        new obsidian.Notice(\"Failed to read the daily note template\");\n        return [\"\", null];\n    }\n}\n\n/**\n * dateUID is a way of weekly identifying daily/weekly/monthly notes.\n * They are prefixed with the granularity to avoid ambiguity.\n */\nfunction getDateUID(date, granularity = \"day\") {\n    const ts = date.clone().startOf(granularity).format();\n    return `${granularity}-${ts}`;\n}\nfunction removeEscapedCharacters(format) {\n    return format.replace(/\\[[^\\]]*\\]/g, \"\"); // remove everything within brackets\n}\n/**\n * XXX: When parsing dates that contain both week numbers and months,\n * Moment choses to ignore the week numbers. For the week dateUID, we\n * want the opposite behavior. Strip the MMM from the format to patch.\n */\nfunction isFormatAmbiguous(format, granularity) {\n    if (granularity === \"week\") {\n        const cleanFormat = removeEscapedCharacters(format);\n        return (/w{1,2}/i.test(cleanFormat) &&\n            (/M{1,4}/.test(cleanFormat) || /D{1,4}/.test(cleanFormat)));\n    }\n    return false;\n}\nfunction getDateFromFile(file, granularity) {\n    return getDateFromFilename(file.basename, granularity);\n}\nfunction getDateFromPath(path, granularity) {\n    return getDateFromFilename(basename(path), granularity);\n}\nfunction getDateFromFilename(filename, granularity) {\n    const getSettings = {\n        day: getDailyNoteSettings,\n        week: getWeeklyNoteSettings,\n        month: getMonthlyNoteSettings,\n        quarter: getQuarterlyNoteSettings,\n        year: getYearlyNoteSettings,\n    };\n    const format = getSettings[granularity]().format.split(\"/\").pop();\n    const noteDate = window.moment(filename, format, true);\n    if (!noteDate.isValid()) {\n        return null;\n    }\n    if (isFormatAmbiguous(format, granularity)) {\n        if (granularity === \"week\") {\n            const cleanFormat = removeEscapedCharacters(format);\n            if (/w{1,2}/i.test(cleanFormat)) {\n                return window.moment(filename, \n                // If format contains week, remove day & month formatting\n                format.replace(/M{1,4}/g, \"\").replace(/D{1,4}/g, \"\"), false);\n            }\n        }\n    }\n    return noteDate;\n}\n\nclass DailyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createDailyNote(date) {\n    const app = window.app;\n    const { vault } = app;\n    const moment = window.moment;\n    const { template, format, folder } = getDailyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename)\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*yesterday\\s*}}/gi, date.clone().subtract(1, \"day\").format(format))\n            .replace(/{{\\s*tomorrow\\s*}}/gi, date.clone().add(1, \"d\").format(format)));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getDailyNote(date, dailyNotes) {\n    return dailyNotes[getDateUID(date, \"day\")] ?? null;\n}\nfunction getAllDailyNotes() {\n    /**\n     * Find all daily notes in the daily note folder\n     */\n    const { vault } = window.app;\n    const { folder } = getDailyNoteSettings();\n    const dailyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!dailyNotesFolder) {\n        throw new DailyNotesFolderMissingError(\"Failed to find daily notes folder\");\n    }\n    const dailyNotes = {};\n    obsidian.Vault.recurseChildren(dailyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"day\");\n            if (date) {\n                const dateString = getDateUID(date, \"day\");\n                dailyNotes[dateString] = note;\n            }\n        }\n    });\n    return dailyNotes;\n}\n\nclass WeeklyNotesFolderMissingError extends Error {\n}\nfunction getDaysOfWeek() {\n    const { moment } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let weekStart = moment.localeData()._week.dow;\n    const daysOfWeek = [\n        \"sunday\",\n        \"monday\",\n        \"tuesday\",\n        \"wednesday\",\n        \"thursday\",\n        \"friday\",\n        \"saturday\",\n    ];\n    while (weekStart) {\n        daysOfWeek.push(daysOfWeek.shift());\n        weekStart--;\n    }\n    return daysOfWeek;\n}\nfunction getDayOfWeekNumericalValue(dayOfWeekName) {\n    return getDaysOfWeek().indexOf(dayOfWeekName.toLowerCase());\n}\nasync function createWeeklyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getWeeklyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*title\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\\s*:(.*?)}}/gi, (_, dayOfWeek, momentFormat) => {\n            const day = getDayOfWeekNumericalValue(dayOfWeek);\n            return date.weekday(day).format(momentFormat.trim());\n        }));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getWeeklyNote(date, weeklyNotes) {\n    return weeklyNotes[getDateUID(date, \"week\")] ?? null;\n}\nfunction getAllWeeklyNotes() {\n    const weeklyNotes = {};\n    if (!appHasWeeklyNotesPluginLoaded()) {\n        return weeklyNotes;\n    }\n    const { vault } = window.app;\n    const { folder } = getWeeklyNoteSettings();\n    const weeklyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!weeklyNotesFolder) {\n        throw new WeeklyNotesFolderMissingError(\"Failed to find weekly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(weeklyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"week\");\n            if (date) {\n                const dateString = getDateUID(date, \"week\");\n                weeklyNotes[dateString] = note;\n            }\n        }\n    });\n    return weeklyNotes;\n}\n\nclass MonthlyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createMonthlyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getMonthlyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getMonthlyNote(date, monthlyNotes) {\n    return monthlyNotes[getDateUID(date, \"month\")] ?? null;\n}\nfunction getAllMonthlyNotes() {\n    const monthlyNotes = {};\n    if (!appHasMonthlyNotesPluginLoaded()) {\n        return monthlyNotes;\n    }\n    const { vault } = window.app;\n    const { folder } = getMonthlyNoteSettings();\n    const monthlyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!monthlyNotesFolder) {\n        throw new MonthlyNotesFolderMissingError(\"Failed to find monthly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(monthlyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"month\");\n            if (date) {\n                const dateString = getDateUID(date, \"month\");\n                monthlyNotes[dateString] = note;\n            }\n        }\n    });\n    return monthlyNotes;\n}\n\nclass QuarterlyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createQuarterlyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getQuarterlyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getQuarterlyNote(date, quarterly) {\n    return quarterly[getDateUID(date, \"quarter\")] ?? null;\n}\nfunction getAllQuarterlyNotes() {\n    const quarterly = {};\n    if (!appHasQuarterlyNotesPluginLoaded()) {\n        return quarterly;\n    }\n    const { vault } = window.app;\n    const { folder } = getQuarterlyNoteSettings();\n    const quarterlyFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!quarterlyFolder) {\n        throw new QuarterlyNotesFolderMissingError(\"Failed to find quarterly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(quarterlyFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"quarter\");\n            if (date) {\n                const dateString = getDateUID(date, \"quarter\");\n                quarterly[dateString] = note;\n            }\n        }\n    });\n    return quarterly;\n}\n\nclass YearlyNotesFolderMissingError extends Error {\n}\n/**\n * This function mimics the behavior of the daily-notes plugin\n * so it will replace {{date}}, {{title}}, and {{time}} with the\n * formatted timestamp.\n *\n * Note: it has an added bonus that it's not 'today' specific.\n */\nasync function createYearlyNote(date) {\n    const { vault } = window.app;\n    const { template, format, folder } = getYearlyNoteSettings();\n    const [templateContents, IFoldInfo] = await getTemplateInfo(template);\n    const filename = date.format(format);\n    const normalizedPath = await getNotePath(folder, filename);\n    try {\n        const createdFile = await vault.create(normalizedPath, templateContents\n            .replace(/{{\\s*(date|time)\\s*(([+-]\\d+)([yqmwdhs]))?\\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {\n            const now = window.moment();\n            const currentDate = date.clone().set({\n                hour: now.get(\"hour\"),\n                minute: now.get(\"minute\"),\n                second: now.get(\"second\"),\n            });\n            if (calc) {\n                currentDate.add(parseInt(timeDelta, 10), unit);\n            }\n            if (momentFormat) {\n                return currentDate.format(momentFormat.substring(1).trim());\n            }\n            return currentDate.format(format);\n        })\n            .replace(/{{\\s*date\\s*}}/gi, filename)\n            .replace(/{{\\s*time\\s*}}/gi, window.moment().format(\"HH:mm\"))\n            .replace(/{{\\s*title\\s*}}/gi, filename));\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        window.app.foldManager.save(createdFile, IFoldInfo);\n        return createdFile;\n    }\n    catch (err) {\n        console.error(`Failed to create file: '${normalizedPath}'`, err);\n        new obsidian.Notice(\"Unable to create new file.\");\n    }\n}\nfunction getYearlyNote(date, yearlyNotes) {\n    return yearlyNotes[getDateUID(date, \"year\")] ?? null;\n}\nfunction getAllYearlyNotes() {\n    const yearlyNotes = {};\n    if (!appHasYearlyNotesPluginLoaded()) {\n        return yearlyNotes;\n    }\n    const { vault } = window.app;\n    const { folder } = getYearlyNoteSettings();\n    const yearlyNotesFolder = vault.getAbstractFileByPath(obsidian.normalizePath(folder));\n    if (!yearlyNotesFolder) {\n        throw new YearlyNotesFolderMissingError(\"Failed to find yearly notes folder\");\n    }\n    obsidian.Vault.recurseChildren(yearlyNotesFolder, (note) => {\n        if (note instanceof obsidian.TFile) {\n            const date = getDateFromFile(note, \"year\");\n            if (date) {\n                const dateString = getDateUID(date, \"year\");\n                yearlyNotes[dateString] = note;\n            }\n        }\n    });\n    return yearlyNotes;\n}\n\nfunction appHasDailyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const dailyNotesPlugin = app.internalPlugins.plugins[\"daily-notes\"];\n    if (dailyNotesPlugin && dailyNotesPlugin.enabled) {\n        return true;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.daily?.enabled;\n}\n/**\n * XXX: \"Weekly Notes\" live in either the Calendar plugin or the periodic-notes plugin.\n * Check both until the weekly notes feature is removed from the Calendar plugin.\n */\nfunction appHasWeeklyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    if (app.plugins.getPlugin(\"calendar\")) {\n        return true;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.weekly?.enabled;\n}\nfunction appHasMonthlyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.monthly?.enabled;\n}\nfunction appHasQuarterlyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.quarterly?.enabled;\n}\nfunction appHasYearlyNotesPluginLoaded() {\n    const { app } = window;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const periodicNotes = app.plugins.getPlugin(\"periodic-notes\");\n    return periodicNotes && periodicNotes.settings?.yearly?.enabled;\n}\nfunction getPeriodicNoteSettings(granularity) {\n    const getSettings = {\n        day: getDailyNoteSettings,\n        week: getWeeklyNoteSettings,\n        month: getMonthlyNoteSettings,\n        quarter: getQuarterlyNoteSettings,\n        year: getYearlyNoteSettings,\n    }[granularity];\n    return getSettings();\n}\nfunction createPeriodicNote(granularity, date) {\n    const createFn = {\n        day: createDailyNote,\n        month: createMonthlyNote,\n        week: createWeeklyNote,\n    };\n    return createFn[granularity](date);\n}\n\nexports.DEFAULT_DAILY_NOTE_FORMAT = DEFAULT_DAILY_NOTE_FORMAT;\nexports.DEFAULT_MONTHLY_NOTE_FORMAT = DEFAULT_MONTHLY_NOTE_FORMAT;\nexports.DEFAULT_QUARTERLY_NOTE_FORMAT = DEFAULT_QUARTERLY_NOTE_FORMAT;\nexports.DEFAULT_WEEKLY_NOTE_FORMAT = DEFAULT_WEEKLY_NOTE_FORMAT;\nexports.DEFAULT_YEARLY_NOTE_FORMAT = DEFAULT_YEARLY_NOTE_FORMAT;\nexports.appHasDailyNotesPluginLoaded = appHasDailyNotesPluginLoaded;\nexports.appHasMonthlyNotesPluginLoaded = appHasMonthlyNotesPluginLoaded;\nexports.appHasQuarterlyNotesPluginLoaded = appHasQuarterlyNotesPluginLoaded;\nexports.appHasWeeklyNotesPluginLoaded = appHasWeeklyNotesPluginLoaded;\nexports.appHasYearlyNotesPluginLoaded = appHasYearlyNotesPluginLoaded;\nexports.createDailyNote = createDailyNote;\nexports.createMonthlyNote = createMonthlyNote;\nexports.createPeriodicNote = createPeriodicNote;\nexports.createQuarterlyNote = createQuarterlyNote;\nexports.createWeeklyNote = createWeeklyNote;\nexports.createYearlyNote = createYearlyNote;\nexports.getAllDailyNotes = getAllDailyNotes;\nexports.getAllMonthlyNotes = getAllMonthlyNotes;\nexports.getAllQuarterlyNotes = getAllQuarterlyNotes;\nexports.getAllWeeklyNotes = getAllWeeklyNotes;\nexports.getAllYearlyNotes = getAllYearlyNotes;\nexports.getDailyNote = getDailyNote;\nexports.getDailyNoteSettings = getDailyNoteSettings;\nexports.getDateFromFile = getDateFromFile;\nexports.getDateFromPath = getDateFromPath;\nexports.getDateUID = getDateUID;\nexports.getMonthlyNote = getMonthlyNote;\nexports.getMonthlyNoteSettings = getMonthlyNoteSettings;\nexports.getPeriodicNoteSettings = getPeriodicNoteSettings;\nexports.getQuarterlyNote = getQuarterlyNote;\nexports.getQuarterlyNoteSettings = getQuarterlyNoteSettings;\nexports.getTemplateInfo = getTemplateInfo;\nexports.getWeeklyNote = getWeeklyNote;\nexports.getWeeklyNoteSettings = getWeeklyNoteSettings;\nexports.getYearlyNote = getYearlyNote;\nexports.getYearlyNoteSettings = getYearlyNoteSettings;\n","import { Moment } from \"moment\";\nimport { App, Editor, EditorRange, EditorPosition, normalizePath, TFile } from \"obsidian\";\nimport {\n  createDailyNote,\n  getAllDailyNotes,\n  getDailyNote,\n} from \"obsidian-daily-notes-interface\";\n\nimport { DayOfWeek } from \"./settings\";\n\nconst daysOfWeek: Omit<DayOfWeek, \"locale-default\">[] = [\n  \"sunday\",\n  \"monday\",\n  \"tuesday\",\n  \"wednesday\",\n  \"thursday\",\n  \"friday\",\n  \"saturday\",\n];\n\nexport default function getWordBoundaries(editor: Editor): EditorRange {\n  const cursor = editor.getCursor();\n\n    const pos = editor.posToOffset(cursor);\n    const word = (editor as any).cm.state.wordAt(pos);\n    const wordStart = editor.offsetToPos(word.from);\n    const wordEnd = editor.offsetToPos(word.to);\n    return {\n      from: wordStart,\n      to: wordEnd,\n    };\n}\n\nexport function getSelectedText(editor: Editor): string {\n  if (editor.somethingSelected()) {\n    return editor.getSelection();\n  } else {\n    const wordBoundaries = getWordBoundaries(editor);\n    editor.setSelection(wordBoundaries.from, wordBoundaries.to); // TODO check if this needs to be updated/improved\n    return editor.getSelection();\n  }\n}\n\nexport function adjustCursor(\n  editor: Editor,\n  cursor: EditorPosition,\n  newStr: string,\n  oldStr: string\n): void {\n  const cursorOffset = newStr.length - oldStr.length;\n  editor.setCursor({\n    line: cursor.line,\n    ch: cursor.ch + cursorOffset,\n  });\n}\n\nexport function getFormattedDate(date: Date, format: string): string {\n  return window.moment(date).format(format);\n}\n\nexport function getLastDayOfMonth(year: number, month: number) {\n  return new Date(year, month, 0).getDate();\n}\n\nexport function parseTruthy(flag: string): boolean {\n  return [\"y\", \"yes\", \"1\", \"t\", \"true\"].indexOf(flag.toLowerCase()) >= 0;\n}\n\nexport function getWeekNumber(dayOfWeek: Omit<DayOfWeek, \"locale-default\">): number {\n  return daysOfWeek.indexOf(dayOfWeek);\n}\n\nexport function getLocaleWeekStart(): Omit<DayOfWeek, \"locale-default\"> {\n  // @ts-ignore\n  const startOfWeek = window.moment.localeData()._week.dow;\n  return daysOfWeek[startOfWeek];\n}\n\nexport function generateMarkdownLink(app: App, subpath: string, alias?: string) {\n  const useMarkdownLinks = (app.vault as any).getConfig(\"useMarkdownLinks\");\n  const path = normalizePath(subpath);\n\n  if (useMarkdownLinks) {\n    if (alias) {\n      return `[${alias}](${path.replace(/ /g, \"%20\")})`;\n    } else {\n      return `[${subpath}](${path})`;\n    }\n  } else {\n    if (alias) {\n      return `[[${path}|${alias}]]`;\n    } else {\n      return `[[${path}]]`;\n    }\n  }\n}\n\nexport async function getOrCreateDailyNote(date: Moment): Promise<TFile | null> {\n  // Borrowed from the Slated plugin:\n  // https://github.com/tgrosinger/slated-obsidian/blob/main/src/vault.ts#L17\n  const desiredNote = getDailyNote(date, getAllDailyNotes());\n  if (desiredNote) {\n    return Promise.resolve(desiredNote);\n  }\n  return createDailyNote(date);\n}\n\n// Source `chrono`:\n// https://github.com/wanasit/chrono/blob/47f11da6b656cd5cb61f246e8cca706983208ded/src/utils/pattern.ts#L8\n// Copyright (c) 2014, Wanasit Tanakitrungruang\ntype DictionaryLike = string[] | { [word: string]: unknown } | Map<string, unknown>;\n\nfunction extractTerms(dictionary: DictionaryLike): string[] {\n  let keys: string[];\n  if (dictionary instanceof Array) {\n    keys = [...dictionary];\n  } else if (dictionary instanceof Map) {\n    keys = Array.from((dictionary as Map<string, unknown>).keys());\n  } else {\n    keys = Object.keys(dictionary);\n  }\n\n  return keys;\n}\nfunction matchAnyPattern(dictionary: DictionaryLike): string {\n  const joinedTerms = extractTerms(dictionary)\n    .sort((a, b) => b.length - a.length)\n    .join(\"|\")\n    .replace(/\\./g, \"\\\\.\");\n\n  return `(?:${joinedTerms})`;\n}\n\nconst ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {\n  first: 1,\n  second: 2,\n  third: 3,\n  fourth: 4,\n  fifth: 5,\n  sixth: 6,\n  seventh: 7,\n  eighth: 8,\n  ninth: 9,\n  tenth: 10,\n  eleventh: 11,\n  twelfth: 12,\n  thirteenth: 13,\n  fourteenth: 14,\n  fifteenth: 15,\n  sixteenth: 16,\n  seventeenth: 17,\n  eighteenth: 18,\n  nineteenth: 19,\n  twentieth: 20,\n  \"twenty first\": 21,\n  \"twenty-first\": 21,\n  \"twenty second\": 22,\n  \"twenty-second\": 22,\n  \"twenty third\": 23,\n  \"twenty-third\": 23,\n  \"twenty fourth\": 24,\n  \"twenty-fourth\": 24,\n  \"twenty fifth\": 25,\n  \"twenty-fifth\": 25,\n  \"twenty sixth\": 26,\n  \"twenty-sixth\": 26,\n  \"twenty seventh\": 27,\n  \"twenty-seventh\": 27,\n  \"twenty eighth\": 28,\n  \"twenty-eighth\": 28,\n  \"twenty ninth\": 29,\n  \"twenty-ninth\": 29,\n  thirtieth: 30,\n  \"thirty first\": 31,\n  \"thirty-first\": 31,\n};\n\nexport const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(\n  ORDINAL_WORD_DICTIONARY\n)}|[0-9]{1,2}(?:st|nd|rd|th)?)`;\n\nexport function parseOrdinalNumberPattern(match: string): number {\n  let num = match.toLowerCase();\n  if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {\n    return ORDINAL_WORD_DICTIONARY[num];\n  }\n\n  num = num.replace(/(?:st|nd|rd|th)$/i, \"\");\n  return parseInt(num);\n}\n","import { App, MarkdownView, Modal, Setting } from \"obsidian\";\nimport { generateMarkdownLink } from \"src/utils\";\nimport type NaturalLanguageDates from \"../main\";\n\nexport default class DatePickerModal extends Modal {\n  plugin: NaturalLanguageDates;\n\n  constructor(app: App, plugin: NaturalLanguageDates) {\n    super(app);\n    this.plugin = plugin;\n  }\n\n  onOpen(): void {\n    let previewEl: HTMLElement;\n\n    let dateInput = \"\";\n    let momentFormat = this.plugin.settings.modalMomentFormat;\n    let insertAsLink = this.plugin.settings.modalToggleLink;\n\n    const getDateStr = () => {\n      let cleanDateInput = dateInput;\n      let shouldIncludeAlias = false;\n\n      if (dateInput.endsWith(\"|\")) {\n        shouldIncludeAlias = true;\n        cleanDateInput = dateInput.slice(0, -1);\n      }\n\n      const parsedDate = this.plugin.parseDate(cleanDateInput || \"today\");\n      let parsedDateString = parsedDate.moment.isValid()\n        ? parsedDate.moment.format(momentFormat)\n        : \"\";\n\n      if (insertAsLink) {\n        parsedDateString = generateMarkdownLink(\n          this.app,\n          parsedDateString,\n          shouldIncludeAlias ? cleanDateInput : undefined\n        );\n      }\n\n      return parsedDateString;\n    };\n\n    this.contentEl.createEl(\"form\", {}, (formEl) => {\n      const dateInputEl = new Setting(formEl)\n        .setName(\"Date\")\n        .setDesc(getDateStr())\n        .addText((textEl) => {\n          textEl.setPlaceholder(\"Today\");\n\n          textEl.onChange((value) => {\n            dateInput = value;\n            previewEl.setText(getDateStr());\n          });\n\n          window.setTimeout(() => textEl.inputEl.focus(), 10);\n        });\n      previewEl = dateInputEl.descEl;\n\n      new Setting(formEl)\n        .setName(\"Date Format\")\n        .setDesc(\"Moment format to be used\")\n        .addMomentFormat((momentEl) => {\n          momentEl.setPlaceholder(\"YYYY-MM-DD HH:mm\");\n          momentEl.setValue(momentFormat);\n          momentEl.onChange((value) => {\n            momentFormat = value.trim() || \"YYYY-MM-DD HH:mm\";\n            this.plugin.settings.modalMomentFormat = momentFormat;\n            this.plugin.saveSettings();\n\n            previewEl.setText(getDateStr());\n          });\n        });\n      new Setting(formEl).setName(\"Add as link?\").addToggle((toggleEl) => {\n        toggleEl.setValue(this.plugin.settings.modalToggleLink).onChange((value) => {\n          insertAsLink = value;\n          this.plugin.settings.modalToggleLink = insertAsLink;\n          this.plugin.saveSettings();\n\n          previewEl.setText(getDateStr());\n        });\n      });\n\n      formEl.createDiv(\"modal-button-container\", (buttonContainerEl) => {\n        buttonContainerEl\n          .createEl(\"button\", { attr: { type: \"button\" }, text: \"Never mind\" })\n          .addEventListener(\"click\", () => this.close());\n        buttonContainerEl.createEl(\"button\", {\n          attr: { type: \"submit\" },\n          cls: \"mod-cta\",\n          text: \"Insert Date\",\n        });\n      });\n\n      const activeView = this.app.workspace.getActiveViewOfType(MarkdownView);\n      const activeEditor = activeView.editor;\n      formEl.addEventListener(\"submit\", (e: Event) => {\n        e.preventDefault();\n        this.close();\n        activeEditor.replaceSelection(getDateStr());\n      });\n    });\n  }\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.matchAnyPattern = exports.extractTerms = exports.repeatedTimeunitPattern = void 0;\nfunction repeatedTimeunitPattern(prefix, singleTimeunitPattern) {\n    const singleTimeunitPatternNoCapture = singleTimeunitPattern.replace(/\\((?!\\?)/g, \"(?:\");\n    return `${prefix}${singleTimeunitPatternNoCapture}\\\\s{0,5}(?:,?\\\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;\n}\nexports.repeatedTimeunitPattern = repeatedTimeunitPattern;\nfunction extractTerms(dictionary) {\n    let keys;\n    if (dictionary instanceof Array) {\n        keys = [...dictionary];\n    }\n    else if (dictionary instanceof Map) {\n        keys = Array.from(dictionary.keys());\n    }\n    else {\n        keys = Object.keys(dictionary);\n    }\n    return keys;\n}\nexports.extractTerms = extractTerms;\nfunction matchAnyPattern(dictionary) {\n    const joinedTerms = extractTerms(dictionary)\n        .sort((a, b) => b.length - a.length)\n        .join(\"|\")\n        .replace(/\\./g, \"\\\\.\");\n    return `(?:${joinedTerms})`;\n}\nexports.matchAnyPattern = matchAnyPattern;\n","export var SECONDS_A_MINUTE = 60;\nexport var SECONDS_A_HOUR = SECONDS_A_MINUTE * 60;\nexport var SECONDS_A_DAY = SECONDS_A_HOUR * 24;\nexport var SECONDS_A_WEEK = SECONDS_A_DAY * 7;\nexport var MILLISECONDS_A_SECOND = 1e3;\nexport var MILLISECONDS_A_MINUTE = SECONDS_A_MINUTE * MILLISECONDS_A_SECOND;\nexport var MILLISECONDS_A_HOUR = SECONDS_A_HOUR * MILLISECONDS_A_SECOND;\nexport var MILLISECONDS_A_DAY = SECONDS_A_DAY * MILLISECONDS_A_SECOND;\nexport var MILLISECONDS_A_WEEK = SECONDS_A_WEEK * MILLISECONDS_A_SECOND; // English locales\n\nexport var MS = 'millisecond';\nexport var S = 'second';\nexport var MIN = 'minute';\nexport var H = 'hour';\nexport var D = 'day';\nexport var W = 'week';\nexport var M = 'month';\nexport var Q = 'quarter';\nexport var Y = 'year';\nexport var DATE = 'date';\nexport var FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ';\nexport var INVALID_DATE_STRING = 'Invalid Date'; // regex\n\nexport var REGEX_PARSE = /^(\\d{4})[-/]?(\\d{1,2})?[-/]?(\\d{0,2})[^0-9]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?\\.?(\\d+)?$/;\nexport 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]\n// We don't need weekdaysShort, weekdaysMin, monthsShort in en.js locale\nexport default {\n  name: 'en',\n  weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),\n  months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_')\n};","import * as C from './constant';\n\nvar padStart = function padStart(string, length, pad) {\n  var s = String(string);\n  if (!s || s.length >= length) return string;\n  return \"\" + Array(length + 1 - s.length).join(pad) + string;\n};\n\nvar padZoneStr = function padZoneStr(instance) {\n  var negMinutes = -instance.utcOffset();\n  var minutes = Math.abs(negMinutes);\n  var hourOffset = Math.floor(minutes / 60);\n  var minuteOffset = minutes % 60;\n  return \"\" + (negMinutes <= 0 ? '+' : '-') + padStart(hourOffset, 2, '0') + \":\" + padStart(minuteOffset, 2, '0');\n};\n\nvar monthDiff = function monthDiff(a, b) {\n  // function from moment.js in order to keep the same result\n  if (a.date() < b.date()) return -monthDiff(b, a);\n  var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month());\n  var anchor = a.clone().add(wholeMonthDiff, C.M);\n  var c = b - anchor < 0;\n  var anchor2 = a.clone().add(wholeMonthDiff + (c ? -1 : 1), C.M);\n  return +(-(wholeMonthDiff + (b - anchor) / (c ? anchor - anchor2 : anchor2 - anchor)) || 0);\n};\n\nvar absFloor = function absFloor(n) {\n  return n < 0 ? Math.ceil(n) || 0 : Math.floor(n);\n};\n\nvar prettyUnit = function prettyUnit(u) {\n  var special = {\n    M: C.M,\n    y: C.Y,\n    w: C.W,\n    d: C.D,\n    D: C.DATE,\n    h: C.H,\n    m: C.MIN,\n    s: C.S,\n    ms: C.MS,\n    Q: C.Q\n  };\n  return special[u] || String(u || '').toLowerCase().replace(/s$/, '');\n};\n\nvar isUndefined = function isUndefined(s) {\n  return s === undefined;\n};\n\nexport default {\n  s: padStart,\n  z: padZoneStr,\n  m: monthDiff,\n  a: absFloor,\n  p: prettyUnit,\n  u: isUndefined\n};","import * as C from './constant';\nimport en from './locale/en';\nimport U from './utils';\nvar L = 'en'; // global locale\n\nvar Ls = {}; // global loaded locale\n\nLs[L] = en;\n\nvar isDayjs = function isDayjs(d) {\n  return d instanceof Dayjs;\n}; // eslint-disable-line no-use-before-define\n\n\nvar parseLocale = function parseLocale(preset, object, isLocal) {\n  var l;\n  if (!preset) return L;\n\n  if (typeof preset === 'string') {\n    if (Ls[preset]) {\n      l = preset;\n    }\n\n    if (object) {\n      Ls[preset] = object;\n      l = preset;\n    }\n  } else {\n    var name = preset.name;\n    Ls[name] = preset;\n    l = name;\n  }\n\n  if (!isLocal && l) L = l;\n  return l || !isLocal && L;\n};\n\nvar dayjs = function dayjs(date, c) {\n  if (isDayjs(date)) {\n    return date.clone();\n  } // eslint-disable-next-line no-nested-ternary\n\n\n  var cfg = typeof c === 'object' ? c : {};\n  cfg.date = date;\n  cfg.args = arguments; // eslint-disable-line prefer-rest-params\n\n  return new Dayjs(cfg); // eslint-disable-line no-use-before-define\n};\n\nvar wrapper = function wrapper(date, instance) {\n  return dayjs(date, {\n    locale: instance.$L,\n    utc: instance.$u,\n    x: instance.$x,\n    $offset: instance.$offset // todo: refactor; do not use this.$offset in you code\n\n  });\n};\n\nvar Utils = U; // for plugin use\n\nUtils.l = parseLocale;\nUtils.i = isDayjs;\nUtils.w = wrapper;\n\nvar parseDate = function parseDate(cfg) {\n  var date = cfg.date,\n      utc = cfg.utc;\n  if (date === null) return new Date(NaN); // null is invalid\n\n  if (Utils.u(date)) return new Date(); // today\n\n  if (date instanceof Date) return new Date(date);\n\n  if (typeof date === 'string' && !/Z$/i.test(date)) {\n    var d = date.match(C.REGEX_PARSE);\n\n    if (d) {\n      var m = d[2] - 1 || 0;\n      var ms = (d[7] || '0').substring(0, 3);\n\n      if (utc) {\n        return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));\n      }\n\n      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);\n    }\n  }\n\n  return new Date(date); // everything else\n};\n\nvar Dayjs = /*#__PURE__*/function () {\n  function Dayjs(cfg) {\n    this.$L = parseLocale(cfg.locale, null, true);\n    this.parse(cfg); // for plugin\n  }\n\n  var _proto = Dayjs.prototype;\n\n  _proto.parse = function parse(cfg) {\n    this.$d = parseDate(cfg);\n    this.$x = cfg.x || {};\n    this.init();\n  };\n\n  _proto.init = function init() {\n    var $d = this.$d;\n    this.$y = $d.getFullYear();\n    this.$M = $d.getMonth();\n    this.$D = $d.getDate();\n    this.$W = $d.getDay();\n    this.$H = $d.getHours();\n    this.$m = $d.getMinutes();\n    this.$s = $d.getSeconds();\n    this.$ms = $d.getMilliseconds();\n  } // eslint-disable-next-line class-methods-use-this\n  ;\n\n  _proto.$utils = function $utils() {\n    return Utils;\n  };\n\n  _proto.isValid = function isValid() {\n    return !(this.$d.toString() === C.INVALID_DATE_STRING);\n  };\n\n  _proto.isSame = function isSame(that, units) {\n    var other = dayjs(that);\n    return this.startOf(units) <= other && other <= this.endOf(units);\n  };\n\n  _proto.isAfter = function isAfter(that, units) {\n    return dayjs(that) < this.startOf(units);\n  };\n\n  _proto.isBefore = function isBefore(that, units) {\n    return this.endOf(units) < dayjs(that);\n  };\n\n  _proto.$g = function $g(input, get, set) {\n    if (Utils.u(input)) return this[get];\n    return this.set(set, input);\n  };\n\n  _proto.unix = function unix() {\n    return Math.floor(this.valueOf() / 1000);\n  };\n\n  _proto.valueOf = function valueOf() {\n    // timezone(hour) * 60 * 60 * 1000 => ms\n    return this.$d.getTime();\n  };\n\n  _proto.startOf = function startOf(units, _startOf) {\n    var _this = this;\n\n    // startOf -> endOf\n    var isStartOf = !Utils.u(_startOf) ? _startOf : true;\n    var unit = Utils.p(units);\n\n    var instanceFactory = function instanceFactory(d, m) {\n      var ins = Utils.w(_this.$u ? Date.UTC(_this.$y, m, d) : new Date(_this.$y, m, d), _this);\n      return isStartOf ? ins : ins.endOf(C.D);\n    };\n\n    var instanceFactorySet = function instanceFactorySet(method, slice) {\n      var argumentStart = [0, 0, 0, 0];\n      var argumentEnd = [23, 59, 59, 999];\n      return Utils.w(_this.toDate()[method].apply( // eslint-disable-line prefer-spread\n      _this.toDate('s'), (isStartOf ? argumentStart : argumentEnd).slice(slice)), _this);\n    };\n\n    var $W = this.$W,\n        $M = this.$M,\n        $D = this.$D;\n    var utcPad = \"set\" + (this.$u ? 'UTC' : '');\n\n    switch (unit) {\n      case C.Y:\n        return isStartOf ? instanceFactory(1, 0) : instanceFactory(31, 11);\n\n      case C.M:\n        return isStartOf ? instanceFactory(1, $M) : instanceFactory(0, $M + 1);\n\n      case C.W:\n        {\n          var weekStart = this.$locale().weekStart || 0;\n          var gap = ($W < weekStart ? $W + 7 : $W) - weekStart;\n          return instanceFactory(isStartOf ? $D - gap : $D + (6 - gap), $M);\n        }\n\n      case C.D:\n      case C.DATE:\n        return instanceFactorySet(utcPad + \"Hours\", 0);\n\n      case C.H:\n        return instanceFactorySet(utcPad + \"Minutes\", 1);\n\n      case C.MIN:\n        return instanceFactorySet(utcPad + \"Seconds\", 2);\n\n      case C.S:\n        return instanceFactorySet(utcPad + \"Milliseconds\", 3);\n\n      default:\n        return this.clone();\n    }\n  };\n\n  _proto.endOf = function endOf(arg) {\n    return this.startOf(arg, false);\n  };\n\n  _proto.$set = function $set(units, _int) {\n    var _C$D$C$DATE$C$M$C$Y$C;\n\n    // private set\n    var unit = Utils.p(units);\n    var utcPad = \"set\" + (this.$u ? 'UTC' : '');\n    var name = (_C$D$C$DATE$C$M$C$Y$C = {}, _C$D$C$DATE$C$M$C$Y$C[C.D] = utcPad + \"Date\", _C$D$C$DATE$C$M$C$Y$C[C.DATE] = utcPad + \"Date\", _C$D$C$DATE$C$M$C$Y$C[C.M] = utcPad + \"Month\", _C$D$C$DATE$C$M$C$Y$C[C.Y] = utcPad + \"FullYear\", _C$D$C$DATE$C$M$C$Y$C[C.H] = utcPad + \"Hours\", _C$D$C$DATE$C$M$C$Y$C[C.MIN] = utcPad + \"Minutes\", _C$D$C$DATE$C$M$C$Y$C[C.S] = utcPad + \"Seconds\", _C$D$C$DATE$C$M$C$Y$C[C.MS] = utcPad + \"Milliseconds\", _C$D$C$DATE$C$M$C$Y$C)[unit];\n    var arg = unit === C.D ? this.$D + (_int - this.$W) : _int;\n\n    if (unit === C.M || unit === C.Y) {\n      // clone is for badMutable plugin\n      var date = this.clone().set(C.DATE, 1);\n      date.$d[name](arg);\n      date.init();\n      this.$d = date.set(C.DATE, Math.min(this.$D, date.daysInMonth())).$d;\n    } else if (name) this.$d[name](arg);\n\n    this.init();\n    return this;\n  };\n\n  _proto.set = function set(string, _int2) {\n    return this.clone().$set(string, _int2);\n  };\n\n  _proto.get = function get(unit) {\n    return this[Utils.p(unit)]();\n  };\n\n  _proto.add = function add(number, units) {\n    var _this2 = this,\n        _C$MIN$C$H$C$S$unit;\n\n    number = Number(number); // eslint-disable-line no-param-reassign\n\n    var unit = Utils.p(units);\n\n    var instanceFactorySet = function instanceFactorySet(n) {\n      var d = dayjs(_this2);\n      return Utils.w(d.date(d.date() + Math.round(n * number)), _this2);\n    };\n\n    if (unit === C.M) {\n      return this.set(C.M, this.$M + number);\n    }\n\n    if (unit === C.Y) {\n      return this.set(C.Y, this.$y + number);\n    }\n\n    if (unit === C.D) {\n      return instanceFactorySet(1);\n    }\n\n    if (unit === C.W) {\n      return instanceFactorySet(7);\n    }\n\n    var step = (_C$MIN$C$H$C$S$unit = {}, _C$MIN$C$H$C$S$unit[C.MIN] = C.MILLISECONDS_A_MINUTE, _C$MIN$C$H$C$S$unit[C.H] = C.MILLISECONDS_A_HOUR, _C$MIN$C$H$C$S$unit[C.S] = C.MILLISECONDS_A_SECOND, _C$MIN$C$H$C$S$unit)[unit] || 1; // ms\n\n    var nextTimeStamp = this.$d.getTime() + number * step;\n    return Utils.w(nextTimeStamp, this);\n  };\n\n  _proto.subtract = function subtract(number, string) {\n    return this.add(number * -1, string);\n  };\n\n  _proto.format = function format(formatStr) {\n    var _this3 = this;\n\n    if (!this.isValid()) return C.INVALID_DATE_STRING;\n    var str = formatStr || C.FORMAT_DEFAULT;\n    var zoneStr = Utils.z(this);\n    var locale = this.$locale();\n    var $H = this.$H,\n        $m = this.$m,\n        $M = this.$M;\n    var weekdays = locale.weekdays,\n        months = locale.months,\n        meridiem = locale.meridiem;\n\n    var getShort = function getShort(arr, index, full, length) {\n      return arr && (arr[index] || arr(_this3, str)) || full[index].substr(0, length);\n    };\n\n    var get$H = function get$H(num) {\n      return Utils.s($H % 12 || 12, num, '0');\n    };\n\n    var meridiemFunc = meridiem || function (hour, minute, isLowercase) {\n      var m = hour < 12 ? 'AM' : 'PM';\n      return isLowercase ? m.toLowerCase() : m;\n    };\n\n    var matches = {\n      YY: String(this.$y).slice(-2),\n      YYYY: this.$y,\n      M: $M + 1,\n      MM: Utils.s($M + 1, 2, '0'),\n      MMM: getShort(locale.monthsShort, $M, months, 3),\n      MMMM: getShort(months, $M),\n      D: this.$D,\n      DD: Utils.s(this.$D, 2, '0'),\n      d: String(this.$W),\n      dd: getShort(locale.weekdaysMin, this.$W, weekdays, 2),\n      ddd: getShort(locale.weekdaysShort, this.$W, weekdays, 3),\n      dddd: weekdays[this.$W],\n      H: String($H),\n      HH: Utils.s($H, 2, '0'),\n      h: get$H(1),\n      hh: get$H(2),\n      a: meridiemFunc($H, $m, true),\n      A: meridiemFunc($H, $m, false),\n      m: String($m),\n      mm: Utils.s($m, 2, '0'),\n      s: String(this.$s),\n      ss: Utils.s(this.$s, 2, '0'),\n      SSS: Utils.s(this.$ms, 3, '0'),\n      Z: zoneStr // 'ZZ' logic below\n\n    };\n    return str.replace(C.REGEX_FORMAT, function (match, $1) {\n      return $1 || matches[match] || zoneStr.replace(':', '');\n    }); // 'ZZ'\n  };\n\n  _proto.utcOffset = function utcOffset() {\n    // Because a bug at FF24, we're rounding the timezone offset around 15 minutes\n    // https://github.com/moment/moment/pull/1871\n    return -Math.round(this.$d.getTimezoneOffset() / 15) * 15;\n  };\n\n  _proto.diff = function diff(input, units, _float) {\n    var _C$Y$C$M$C$Q$C$W$C$D$;\n\n    var unit = Utils.p(units);\n    var that = dayjs(input);\n    var zoneDelta = (that.utcOffset() - this.utcOffset()) * C.MILLISECONDS_A_MINUTE;\n    var diff = this - that;\n    var result = Utils.m(this, that);\n    result = (_C$Y$C$M$C$Q$C$W$C$D$ = {}, _C$Y$C$M$C$Q$C$W$C$D$[C.Y] = result / 12, _C$Y$C$M$C$Q$C$W$C$D$[C.M] = result, _C$Y$C$M$C$Q$C$W$C$D$[C.Q] = result / 3, _C$Y$C$M$C$Q$C$W$C$D$[C.W] = (diff - zoneDelta) / C.MILLISECONDS_A_WEEK, _C$Y$C$M$C$Q$C$W$C$D$[C.D] = (diff - zoneDelta) / C.MILLISECONDS_A_DAY, _C$Y$C$M$C$Q$C$W$C$D$[C.H] = diff / C.MILLISECONDS_A_HOUR, _C$Y$C$M$C$Q$C$W$C$D$[C.MIN] = diff / C.MILLISECONDS_A_MINUTE, _C$Y$C$M$C$Q$C$W$C$D$[C.S] = diff / C.MILLISECONDS_A_SECOND, _C$Y$C$M$C$Q$C$W$C$D$)[unit] || diff; // milliseconds\n\n    return _float ? result : Utils.a(result);\n  };\n\n  _proto.daysInMonth = function daysInMonth() {\n    return this.endOf(C.M).$D;\n  };\n\n  _proto.$locale = function $locale() {\n    // get locale object\n    return Ls[this.$L];\n  };\n\n  _proto.locale = function locale(preset, object) {\n    if (!preset) return this.$L;\n    var that = this.clone();\n    var nextLocaleName = parseLocale(preset, object, true);\n    if (nextLocaleName) that.$L = nextLocaleName;\n    return that;\n  };\n\n  _proto.clone = function clone() {\n    return Utils.w(this.$d, this);\n  };\n\n  _proto.toDate = function toDate() {\n    return new Date(this.valueOf());\n  };\n\n  _proto.toJSON = function toJSON() {\n    return this.isValid() ? this.toISOString() : null;\n  };\n\n  _proto.toISOString = function toISOString() {\n    // ie 8 return\n    // new Dayjs(this.valueOf() + this.$d.getTimezoneOffset() * 60000)\n    // .format('YYYY-MM-DDTHH:mm:ss.SSS[Z]')\n    return this.$d.toISOString();\n  };\n\n  _proto.toString = function toString() {\n    return this.$d.toUTCString();\n  };\n\n  return Dayjs;\n}();\n\nvar proto = Dayjs.prototype;\ndayjs.prototype = proto;\n[['$ms', C.MS], ['$s', C.S], ['$m', C.MIN], ['$H', C.H], ['$W', C.D], ['$M', C.M], ['$y', C.Y], ['$D', C.DATE]].forEach(function (g) {\n  proto[g[1]] = function (input) {\n    return this.$g(input, g[0], g[1]);\n  };\n});\n\ndayjs.extend = function (plugin, option) {\n  if (!plugin.$i) {\n    // install plugin only once\n    plugin(option, Dayjs, dayjs);\n    plugin.$i = true;\n  }\n\n  return dayjs;\n};\n\ndayjs.locale = parseLocale;\ndayjs.isDayjs = isDayjs;\n\ndayjs.unix = function (timestamp) {\n  return dayjs(timestamp * 1e3);\n};\n\ndayjs.en = Ls[L];\ndayjs.Ls = Ls;\ndayjs.p = {};\nexport default dayjs;","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.findYearClosestToRef = exports.findMostLikelyADYear = void 0;\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nfunction findMostLikelyADYear(yearNumber) {\n    if (yearNumber < 100) {\n        if (yearNumber > 50) {\n            yearNumber = yearNumber + 1900;\n        }\n        else {\n            yearNumber = yearNumber + 2000;\n        }\n    }\n    return yearNumber;\n}\nexports.findMostLikelyADYear = findMostLikelyADYear;\nfunction findYearClosestToRef(refDate, day, month) {\n    const refMoment = (0, dayjs_1.default)(refDate);\n    let dateMoment = refMoment;\n    dateMoment = dateMoment.month(month - 1);\n    dateMoment = dateMoment.date(day);\n    dateMoment = dateMoment.year(refMoment.year());\n    const nextYear = dateMoment.add(1, \"y\");\n    const lastYear = dateMoment.add(-1, \"y\");\n    if (Math.abs(nextYear.diff(refMoment)) < Math.abs(dateMoment.diff(refMoment))) {\n        dateMoment = nextYear;\n    }\n    else if (Math.abs(lastYear.diff(refMoment)) < Math.abs(dateMoment.diff(refMoment))) {\n        dateMoment = lastYear;\n    }\n    return dateMoment.year();\n}\nexports.findYearClosestToRef = findYearClosestToRef;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst pattern_1 = require(\"../../utils/pattern\");\nconst years_1 = require(\"../../calculation/years\");\nexports.WEEKDAY_DICTIONARY = {\n    sunday: 0,\n    sun: 0,\n    \"sun.\": 0,\n    monday: 1,\n    mon: 1,\n    \"mon.\": 1,\n    tuesday: 2,\n    tue: 2,\n    \"tue.\": 2,\n    wednesday: 3,\n    wed: 3,\n    \"wed.\": 3,\n    thursday: 4,\n    thurs: 4,\n    \"thurs.\": 4,\n    thur: 4,\n    \"thur.\": 4,\n    thu: 4,\n    \"thu.\": 4,\n    friday: 5,\n    fri: 5,\n    \"fri.\": 5,\n    saturday: 6,\n    sat: 6,\n    \"sat.\": 6,\n};\nexports.FULL_MONTH_NAME_DICTIONARY = {\n    january: 1,\n    february: 2,\n    march: 3,\n    april: 4,\n    may: 5,\n    june: 6,\n    july: 7,\n    august: 8,\n    september: 9,\n    october: 10,\n    november: 11,\n    december: 12,\n};\nexports.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 });\nexports.INTEGER_WORD_DICTIONARY = {\n    one: 1,\n    two: 2,\n    three: 3,\n    four: 4,\n    five: 5,\n    six: 6,\n    seven: 7,\n    eight: 8,\n    nine: 9,\n    ten: 10,\n    eleven: 11,\n    twelve: 12,\n};\nexports.ORDINAL_WORD_DICTIONARY = {\n    first: 1,\n    second: 2,\n    third: 3,\n    fourth: 4,\n    fifth: 5,\n    sixth: 6,\n    seventh: 7,\n    eighth: 8,\n    ninth: 9,\n    tenth: 10,\n    eleventh: 11,\n    twelfth: 12,\n    thirteenth: 13,\n    fourteenth: 14,\n    fifteenth: 15,\n    sixteenth: 16,\n    seventeenth: 17,\n    eighteenth: 18,\n    nineteenth: 19,\n    twentieth: 20,\n    \"twenty first\": 21,\n    \"twenty-first\": 21,\n    \"twenty second\": 22,\n    \"twenty-second\": 22,\n    \"twenty third\": 23,\n    \"twenty-third\": 23,\n    \"twenty fourth\": 24,\n    \"twenty-fourth\": 24,\n    \"twenty fifth\": 25,\n    \"twenty-fifth\": 25,\n    \"twenty sixth\": 26,\n    \"twenty-sixth\": 26,\n    \"twenty seventh\": 27,\n    \"twenty-seventh\": 27,\n    \"twenty eighth\": 28,\n    \"twenty-eighth\": 28,\n    \"twenty ninth\": 29,\n    \"twenty-ninth\": 29,\n    \"thirtieth\": 30,\n    \"thirty first\": 31,\n    \"thirty-first\": 31,\n};\nexports.TIME_UNIT_DICTIONARY = {\n    sec: \"second\",\n    second: \"second\",\n    seconds: \"second\",\n    min: \"minute\",\n    mins: \"minute\",\n    minute: \"minute\",\n    minutes: \"minute\",\n    h: \"hour\",\n    hr: \"hour\",\n    hrs: \"hour\",\n    hour: \"hour\",\n    hours: \"hour\",\n    day: \"d\",\n    days: \"d\",\n    week: \"week\",\n    weeks: \"week\",\n    month: \"month\",\n    months: \"month\",\n    y: \"year\",\n    yr: \"year\",\n    year: \"year\",\n    years: \"year\",\n};\nexports.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)?)`;\nfunction parseNumberPattern(match) {\n    const num = match.toLowerCase();\n    if (exports.INTEGER_WORD_DICTIONARY[num] !== undefined) {\n        return exports.INTEGER_WORD_DICTIONARY[num];\n    }\n    else if (num === \"a\" || num === \"an\") {\n        return 1;\n    }\n    else if (num.match(/few/)) {\n        return 3;\n    }\n    else if (num.match(/half/)) {\n        return 0.5;\n    }\n    else if (num.match(/couple/)) {\n        return 2;\n    }\n    else if (num.match(/several/)) {\n        return 7;\n    }\n    return parseFloat(num);\n}\nexports.parseNumberPattern = parseNumberPattern;\nexports.ORDINAL_NUMBER_PATTERN = `(?:${(0, pattern_1.matchAnyPattern)(exports.ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:st|nd|rd|th)?)`;\nfunction parseOrdinalNumberPattern(match) {\n    let num = match.toLowerCase();\n    if (exports.ORDINAL_WORD_DICTIONARY[num] !== undefined) {\n        return exports.ORDINAL_WORD_DICTIONARY[num];\n    }\n    num = num.replace(/(?:st|nd|rd|th)$/i, \"\");\n    return parseInt(num);\n}\nexports.parseOrdinalNumberPattern = parseOrdinalNumberPattern;\nexports.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])`;\nfunction parseYear(match) {\n    if (/BE/i.test(match)) {\n        match = match.replace(/BE/i, \"\");\n        return parseInt(match) - 543;\n    }\n    if (/BCE?/i.test(match)) {\n        match = match.replace(/BCE?/i, \"\");\n        return -parseInt(match);\n    }\n    if (/(AD|CE)/i.test(match)) {\n        match = match.replace(/(AD|CE)/i, \"\");\n        return parseInt(match);\n    }\n    const rawYearNumber = parseInt(match);\n    return (0, years_1.findMostLikelyADYear)(rawYearNumber);\n}\nexports.parseYear = parseYear;\nconst SINGLE_TIME_UNIT_PATTERN = `(${exports.NUMBER_PATTERN})\\\\s{0,3}(${(0, pattern_1.matchAnyPattern)(exports.TIME_UNIT_DICTIONARY)})`;\nconst SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, \"i\");\nexports.TIME_UNITS_PATTERN = (0, pattern_1.repeatedTimeunitPattern)(`(?:(?:about|around)\\\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);\nfunction parseTimeUnits(timeunitText) {\n    const fragments = {};\n    let remainingText = timeunitText;\n    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    while (match) {\n        collectDateTimeFragment(fragments, match);\n        remainingText = remainingText.substring(match[0].length).trim();\n        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    }\n    return fragments;\n}\nexports.parseTimeUnits = parseTimeUnits;\nfunction collectDateTimeFragment(fragments, match) {\n    const num = parseNumberPattern(match[1]);\n    const unit = exports.TIME_UNIT_DICTIONARY[match[2].toLowerCase()];\n    fragments[unit] = num;\n}\n","!function(t,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=n():\"function\"==typeof define&&define.amd?define(n):t.dayjs_plugin_quarterOfYear=n()}(this,function(){\"use strict\";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)}}});\n","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):e.dayjs_plugin_weekday=t()}(this,function(){\"use strict\";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\")}}});\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.implySimilarTime = exports.assignSimilarTime = exports.assignSimilarDate = exports.assignTheNextDay = void 0;\nconst index_1 = require(\"../index\");\nfunction assignTheNextDay(component, targetDayJs) {\n    targetDayJs = targetDayJs.add(1, \"day\");\n    assignSimilarDate(component, targetDayJs);\n    implySimilarTime(component, targetDayJs);\n}\nexports.assignTheNextDay = assignTheNextDay;\nfunction assignSimilarDate(component, targetDayJs) {\n    component.assign(\"day\", targetDayJs.date());\n    component.assign(\"month\", targetDayJs.month() + 1);\n    component.assign(\"year\", targetDayJs.year());\n}\nexports.assignSimilarDate = assignSimilarDate;\nfunction assignSimilarTime(component, targetDayJs) {\n    component.assign(\"hour\", targetDayJs.hour());\n    component.assign(\"minute\", targetDayJs.minute());\n    component.assign(\"second\", targetDayJs.second());\n    component.assign(\"millisecond\", targetDayJs.millisecond());\n    if (component.get(\"hour\") < 12) {\n        component.assign(\"meridiem\", index_1.Meridiem.AM);\n    }\n    else {\n        component.assign(\"meridiem\", index_1.Meridiem.PM);\n    }\n}\nexports.assignSimilarTime = assignSimilarTime;\nfunction implySimilarTime(component, targetDayJs) {\n    component.imply(\"hour\", targetDayJs.hour());\n    component.imply(\"minute\", targetDayJs.minute());\n    component.imply(\"second\", targetDayJs.second());\n    component.imply(\"millisecond\", targetDayJs.millisecond());\n}\nexports.implySimilarTime = implySimilarTime;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.toTimezoneOffset = exports.TIMEZONE_ABBR_MAP = void 0;\nexports.TIMEZONE_ABBR_MAP = {\n    ACDT: 630,\n    ACST: 570,\n    ADT: -180,\n    AEDT: 660,\n    AEST: 600,\n    AFT: 270,\n    AKDT: -480,\n    AKST: -540,\n    ALMT: 360,\n    AMST: -180,\n    AMT: -240,\n    ANAST: 720,\n    ANAT: 720,\n    AQTT: 300,\n    ART: -180,\n    AST: -240,\n    AWDT: 540,\n    AWST: 480,\n    AZOST: 0,\n    AZOT: -60,\n    AZST: 300,\n    AZT: 240,\n    BNT: 480,\n    BOT: -240,\n    BRST: -120,\n    BRT: -180,\n    BST: 60,\n    BTT: 360,\n    CAST: 480,\n    CAT: 120,\n    CCT: 390,\n    CDT: -300,\n    CEST: 120,\n    CET: 60,\n    CHADT: 825,\n    CHAST: 765,\n    CKT: -600,\n    CLST: -180,\n    CLT: -240,\n    COT: -300,\n    CST: -360,\n    CVT: -60,\n    CXT: 420,\n    ChST: 600,\n    DAVT: 420,\n    EASST: -300,\n    EAST: -360,\n    EAT: 180,\n    ECT: -300,\n    EDT: -240,\n    EEST: 180,\n    EET: 120,\n    EGST: 0,\n    EGT: -60,\n    EST: -300,\n    ET: -300,\n    FJST: 780,\n    FJT: 720,\n    FKST: -180,\n    FKT: -240,\n    FNT: -120,\n    GALT: -360,\n    GAMT: -540,\n    GET: 240,\n    GFT: -180,\n    GILT: 720,\n    GMT: 0,\n    GST: 240,\n    GYT: -240,\n    HAA: -180,\n    HAC: -300,\n    HADT: -540,\n    HAE: -240,\n    HAP: -420,\n    HAR: -360,\n    HAST: -600,\n    HAT: -90,\n    HAY: -480,\n    HKT: 480,\n    HLV: -210,\n    HNA: -240,\n    HNC: -360,\n    HNE: -300,\n    HNP: -480,\n    HNR: -420,\n    HNT: -150,\n    HNY: -540,\n    HOVT: 420,\n    ICT: 420,\n    IDT: 180,\n    IOT: 360,\n    IRDT: 270,\n    IRKST: 540,\n    IRKT: 540,\n    IRST: 210,\n    IST: 330,\n    JST: 540,\n    KGT: 360,\n    KRAST: 480,\n    KRAT: 480,\n    KST: 540,\n    KUYT: 240,\n    LHDT: 660,\n    LHST: 630,\n    LINT: 840,\n    MAGST: 720,\n    MAGT: 720,\n    MART: -510,\n    MAWT: 300,\n    MDT: -360,\n    MESZ: 120,\n    MEZ: 60,\n    MHT: 720,\n    MMT: 390,\n    MSD: 240,\n    MSK: 180,\n    MST: -420,\n    MUT: 240,\n    MVT: 300,\n    MYT: 480,\n    NCT: 660,\n    NDT: -90,\n    NFT: 690,\n    NOVST: 420,\n    NOVT: 360,\n    NPT: 345,\n    NST: -150,\n    NUT: -660,\n    NZDT: 780,\n    NZST: 720,\n    OMSST: 420,\n    OMST: 420,\n    PDT: -420,\n    PET: -300,\n    PETST: 720,\n    PETT: 720,\n    PGT: 600,\n    PHOT: 780,\n    PHT: 480,\n    PKT: 300,\n    PMDT: -120,\n    PMST: -180,\n    PONT: 660,\n    PST: -480,\n    PT: -480,\n    PWT: 540,\n    PYST: -180,\n    PYT: -240,\n    RET: 240,\n    SAMT: 240,\n    SAST: 120,\n    SBT: 660,\n    SCT: 240,\n    SGT: 480,\n    SRT: -180,\n    SST: -660,\n    TAHT: -600,\n    TFT: 300,\n    TJT: 300,\n    TKT: 780,\n    TLT: 540,\n    TMT: 300,\n    TVT: 720,\n    ULAT: 480,\n    UTC: 0,\n    UYST: -120,\n    UYT: -180,\n    UZT: 300,\n    VET: -210,\n    VLAST: 660,\n    VLAT: 660,\n    VUT: 660,\n    WAST: 120,\n    WAT: 60,\n    WEST: 60,\n    WESZ: 60,\n    WET: 0,\n    WEZ: 0,\n    WFT: 720,\n    WGST: -120,\n    WGT: -180,\n    WIB: 420,\n    WIT: 540,\n    WITA: 480,\n    WST: 780,\n    WT: 0,\n    YAKST: 600,\n    YAKT: 600,\n    YAPT: 600,\n    YEKST: 360,\n    YEKT: 360,\n};\nfunction toTimezoneOffset(timezoneInput) {\n    var _a;\n    if (timezoneInput === null) {\n        return null;\n    }\n    if (typeof timezoneInput === \"number\") {\n        return timezoneInput;\n    }\n    return (_a = exports.TIMEZONE_ABBR_MAP[timezoneInput]) !== null && _a !== void 0 ? _a : 0;\n}\nexports.toTimezoneOffset = toTimezoneOffset;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ParsingResult = exports.ParsingComponents = exports.ReferenceWithTimezone = void 0;\nconst quarterOfYear_1 = __importDefault(require(\"dayjs/plugin/quarterOfYear\"));\nconst weekday_1 = __importDefault(require(\"dayjs/plugin/weekday\"));\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst dayjs_2 = require(\"./utils/dayjs\");\nconst timezone_1 = require(\"./timezone\");\ndayjs_1.default.extend(quarterOfYear_1.default);\ndayjs_1.default.extend(weekday_1.default);\nclass ReferenceWithTimezone {\n    constructor(input) {\n        var _a;\n        input = input !== null && input !== void 0 ? input : new Date();\n        if (input instanceof Date) {\n            this.instant = input;\n            this.timezoneOffset = -input.getTimezoneOffset();\n        }\n        else {\n            this.instant = (_a = input.instant) !== null && _a !== void 0 ? _a : new Date();\n            this.timezoneOffset = (0, timezone_1.toTimezoneOffset)(input.timezone);\n        }\n    }\n}\nexports.ReferenceWithTimezone = ReferenceWithTimezone;\nclass ParsingComponents {\n    constructor(reference, knownComponents) {\n        this.reference = reference;\n        this.knownValues = {};\n        this.impliedValues = {};\n        if (knownComponents) {\n            for (const key in knownComponents) {\n                this.knownValues[key] = knownComponents[key];\n            }\n        }\n        const refDayJs = (0, dayjs_1.default)(reference.instant);\n        this.imply(\"day\", refDayJs.date());\n        this.imply(\"month\", refDayJs.month() + 1);\n        this.imply(\"year\", refDayJs.year());\n        this.imply(\"hour\", 12);\n        this.imply(\"minute\", 0);\n        this.imply(\"second\", 0);\n        this.imply(\"millisecond\", 0);\n    }\n    get(component) {\n        if (component in this.knownValues) {\n            return this.knownValues[component];\n        }\n        if (component in this.impliedValues) {\n            return this.impliedValues[component];\n        }\n        return null;\n    }\n    isCertain(component) {\n        return component in this.knownValues;\n    }\n    getCertainComponents() {\n        return Object.keys(this.knownValues);\n    }\n    imply(component, value) {\n        if (component in this.knownValues) {\n            return this;\n        }\n        this.impliedValues[component] = value;\n        return this;\n    }\n    assign(component, value) {\n        this.knownValues[component] = value;\n        delete this.impliedValues[component];\n        return this;\n    }\n    delete(component) {\n        delete this.knownValues[component];\n        delete this.impliedValues[component];\n    }\n    clone() {\n        const component = new ParsingComponents(this.reference);\n        component.knownValues = {};\n        component.impliedValues = {};\n        for (const key in this.knownValues) {\n            component.knownValues[key] = this.knownValues[key];\n        }\n        for (const key in this.impliedValues) {\n            component.impliedValues[key] = this.impliedValues[key];\n        }\n        return component;\n    }\n    isOnlyDate() {\n        return !this.isCertain(\"hour\") && !this.isCertain(\"minute\") && !this.isCertain(\"second\");\n    }\n    isOnlyTime() {\n        return !this.isCertain(\"weekday\") && !this.isCertain(\"day\") && !this.isCertain(\"month\");\n    }\n    isOnlyWeekdayComponent() {\n        return this.isCertain(\"weekday\") && !this.isCertain(\"day\") && !this.isCertain(\"month\");\n    }\n    isOnlyDayMonthComponent() {\n        return this.isCertain(\"day\") && this.isCertain(\"month\") && !this.isCertain(\"year\");\n    }\n    isValidDate() {\n        const date = this.dateWithoutTimezoneAdjustment();\n        if (date.getFullYear() !== this.get(\"year\"))\n            return false;\n        if (date.getMonth() !== this.get(\"month\") - 1)\n            return false;\n        if (date.getDate() !== this.get(\"day\"))\n            return false;\n        if (this.get(\"hour\") != null && date.getHours() != this.get(\"hour\"))\n            return false;\n        if (this.get(\"minute\") != null && date.getMinutes() != this.get(\"minute\"))\n            return false;\n        return true;\n    }\n    toString() {\n        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(this.impliedValues)}}]`;\n    }\n    dayjs() {\n        return (0, dayjs_1.default)(this.date());\n    }\n    date() {\n        const date = this.dateWithoutTimezoneAdjustment();\n        return new Date(date.getTime() + this.getSystemTimezoneAdjustmentMinute(date) * 60000);\n    }\n    dateWithoutTimezoneAdjustment() {\n        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\"));\n        date.setFullYear(this.get(\"year\"));\n        return date;\n    }\n    getSystemTimezoneAdjustmentMinute(date) {\n        var _a, _b;\n        if (!date || date.getTime() < 0) {\n            date = new Date();\n        }\n        const currentTimezoneOffset = -date.getTimezoneOffset();\n        const targetTimezoneOffset = (_b = (_a = this.get(\"timezoneOffset\")) !== null && _a !== void 0 ? _a : this.reference.timezoneOffset) !== null && _b !== void 0 ? _b : currentTimezoneOffset;\n        return currentTimezoneOffset - targetTimezoneOffset;\n    }\n    static createRelativeFromReference(reference, fragments) {\n        let date = (0, dayjs_1.default)(reference.instant);\n        for (const key in fragments) {\n            date = date.add(fragments[key], key);\n        }\n        const components = new ParsingComponents(reference);\n        if (fragments[\"hour\"] || fragments[\"minute\"] || fragments[\"second\"]) {\n            (0, dayjs_2.assignSimilarTime)(components, date);\n            (0, dayjs_2.assignSimilarDate)(components, date);\n            if (reference.timezoneOffset !== null) {\n                components.assign(\"timezoneOffset\", -reference.instant.getTimezoneOffset());\n            }\n        }\n        else {\n            (0, dayjs_2.implySimilarTime)(components, date);\n            if (reference.timezoneOffset !== null) {\n                components.imply(\"timezoneOffset\", -reference.instant.getTimezoneOffset());\n            }\n            if (fragments[\"d\"]) {\n                components.assign(\"day\", date.date());\n                components.assign(\"month\", date.month() + 1);\n                components.assign(\"year\", date.year());\n            }\n            else {\n                if (fragments[\"week\"]) {\n                    components.imply(\"weekday\", date.day());\n                }\n                components.imply(\"day\", date.date());\n                if (fragments[\"month\"]) {\n                    components.assign(\"month\", date.month() + 1);\n                    components.assign(\"year\", date.year());\n                }\n                else {\n                    components.imply(\"month\", date.month() + 1);\n                    if (fragments[\"year\"]) {\n                        components.assign(\"year\", date.year());\n                    }\n                    else {\n                        components.imply(\"year\", date.year());\n                    }\n                }\n            }\n        }\n        return components;\n    }\n}\nexports.ParsingComponents = ParsingComponents;\nclass ParsingResult {\n    constructor(reference, index, text, start, end) {\n        this.reference = reference;\n        this.refDate = reference.instant;\n        this.index = index;\n        this.text = text;\n        this.start = start || new ParsingComponents(reference);\n        this.end = end;\n    }\n    clone() {\n        const result = new ParsingResult(this.reference, this.index, this.text);\n        result.start = this.start ? this.start.clone() : null;\n        result.end = this.end ? this.end.clone() : null;\n        return result;\n    }\n    date() {\n        return this.start.date();\n    }\n    toString() {\n        return `[ParsingResult {index: ${this.index}, text: '${this.text}', ...}]`;\n    }\n}\nexports.ParsingResult = ParsingResult;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AbstractParserWithWordBoundaryChecking = void 0;\nclass AbstractParserWithWordBoundaryChecking {\n    constructor() {\n        this.cachedInnerPattern = null;\n        this.cachedPattern = null;\n    }\n    pattern(context) {\n        const innerPattern = this.innerPattern(context);\n        if (innerPattern == this.cachedInnerPattern) {\n            return this.cachedPattern;\n        }\n        this.cachedPattern = new RegExp(`(\\\\W|^)${innerPattern.source}`, innerPattern.flags);\n        this.cachedInnerPattern = innerPattern;\n        return this.cachedPattern;\n    }\n    extract(context, match) {\n        var _a;\n        const header = (_a = match[1]) !== null && _a !== void 0 ? _a : \"\";\n        match.index = match.index + header.length;\n        match[0] = match[0].substring(header.length);\n        for (let i = 2; i < match.length; i++) {\n            match[i - 1] = match[i];\n        }\n        return this.innerExtract(context, match);\n    }\n}\nexports.AbstractParserWithWordBoundaryChecking = AbstractParserWithWordBoundaryChecking;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN_WITH_PREFIX = new RegExp(`(?:within|in|for)\\\\s*` +\n    `(?:(?:about|around|roughly|approximately|just)\\\\s*(?:~\\\\s*)?)?(${constants_1.TIME_UNITS_PATTERN})(?=\\\\W|$)`, \"i\");\nconst PATTERN_WITHOUT_PREFIX = new RegExp(`(?:(?:about|around|roughly|approximately|just)\\\\s*(?:~\\\\s*)?)?(${constants_1.TIME_UNITS_PATTERN})(?=\\\\W|$)`, \"i\");\nclass ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;\n    }\n    innerExtract(context, match) {\n        const timeUnits = (0, constants_1.parseTimeUnits)(match[1]);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n    }\n}\nexports.default = ENTimeUnitWithinFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../../calculation/years\");\nconst constants_1 = require(\"../constants\");\nconst constants_2 = require(\"../constants\");\nconst constants_3 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`(?:on\\\\s{0,3})?` +\n    `(${constants_3.ORDINAL_NUMBER_PATTERN})` +\n    `(?:` +\n    `\\\\s{0,3}(?:to|\\\\-|\\\\–|until|through|till)?\\\\s{0,3}` +\n    `(${constants_3.ORDINAL_NUMBER_PATTERN})` +\n    \")?\" +\n    `(?:-|/|\\\\s{0,3}(?:of)?\\\\s{0,3})` +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    \"(?:\" +\n    `(?:-|/|,?\\\\s{0,3})` +\n    `(${constants_2.YEAR_PATTERN}(?![^\\\\s]\\\\d))` +\n    \")?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst DATE_GROUP = 1;\nconst DATE_TO_GROUP = 2;\nconst MONTH_NAME_GROUP = 3;\nconst YEAR_GROUP = 4;\nclass ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const month = constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        const day = (0, constants_3.parseOrdinalNumberPattern)(match[DATE_GROUP]);\n        if (day > 31) {\n            match.index = match.index + match[DATE_GROUP].length;\n            return null;\n        }\n        result.start.assign(\"month\", month);\n        result.start.assign(\"day\", day);\n        if (match[YEAR_GROUP]) {\n            const yearNumber = (0, constants_2.parseYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", yearNumber);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            result.start.imply(\"year\", year);\n        }\n        if (match[DATE_TO_GROUP]) {\n            const endDate = (0, constants_3.parseOrdinalNumberPattern)(match[DATE_TO_GROUP]);\n            result.end = result.start.clone();\n            result.end.assign(\"day\", endDate);\n        }\n        return result;\n    }\n}\nexports.default = ENMonthNameLittleEndianParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../../calculation/years\");\nconst constants_1 = require(\"../constants\");\nconst constants_2 = require(\"../constants\");\nconst constants_3 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    \"(?:-|/|\\\\s*,?\\\\s*)\" +\n    `(${constants_2.ORDINAL_NUMBER_PATTERN})(?!\\\\s*(?:am|pm))\\\\s*` +\n    \"(?:\" +\n    \"(?:to|\\\\-)\\\\s*\" +\n    `(${constants_2.ORDINAL_NUMBER_PATTERN})\\\\s*` +\n    \")?\" +\n    \"(?:\" +\n    \"(?:-|/|\\\\s*,?\\\\s*)\" +\n    `(${constants_3.YEAR_PATTERN})` +\n    \")?\" +\n    \"(?=\\\\W|$)(?!\\\\:\\\\d)\", \"i\");\nconst MONTH_NAME_GROUP = 1;\nconst DATE_GROUP = 2;\nconst DATE_TO_GROUP = 3;\nconst YEAR_GROUP = 4;\nclass ENMonthNameMiddleEndianParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const month = constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        const day = (0, constants_2.parseOrdinalNumberPattern)(match[DATE_GROUP]);\n        if (day > 31) {\n            return null;\n        }\n        const components = context.createParsingComponents({\n            day: day,\n            month: month,\n        });\n        if (match[YEAR_GROUP]) {\n            const year = (0, constants_3.parseYear)(match[YEAR_GROUP]);\n            components.assign(\"year\", year);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            components.imply(\"year\", year);\n        }\n        if (!match[DATE_TO_GROUP]) {\n            return components;\n        }\n        const endDate = (0, constants_2.parseOrdinalNumberPattern)(match[DATE_TO_GROUP]);\n        const result = context.createParsingResult(match.index, match[0]);\n        result.start = components;\n        result.end = components.clone();\n        result.end.assign(\"day\", endDate);\n        return result;\n    }\n}\nexports.default = ENMonthNameMiddleEndianParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst years_1 = require(\"../../../calculation/years\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst constants_2 = require(\"../constants\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`((?:in)\\\\s*)?` +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    `\\\\s*` +\n    `(?:` +\n    `[,-]?\\\\s*(${constants_2.YEAR_PATTERN})?` +\n    \")?\" +\n    \"(?=[^\\\\s\\\\w]|\\\\s+[^0-9]|\\\\s+$|$)\", \"i\");\nconst PREFIX_GROUP = 1;\nconst MONTH_NAME_GROUP = 2;\nconst YEAR_GROUP = 3;\nclass ENMonthNameParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const monthName = match[MONTH_NAME_GROUP].toLowerCase();\n        if (match[0].length <= 3 && !constants_1.FULL_MONTH_NAME_DICTIONARY[monthName]) {\n            return null;\n        }\n        const result = context.createParsingResult(match.index + (match[PREFIX_GROUP] || \"\").length, match.index + match[0].length);\n        result.start.imply(\"day\", 1);\n        const month = constants_1.MONTH_DICTIONARY[monthName];\n        result.start.assign(\"month\", month);\n        if (match[YEAR_GROUP]) {\n            const year = (0, constants_2.parseYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", year);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, 1, month);\n            result.start.imply(\"year\", year);\n        }\n        return result;\n    }\n}\nexports.default = ENMonthNameParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`([0-9]{4})[\\\\.\\\\/\\\\s]` +\n    `(?:(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})|([0-9]{1,2}))[\\\\.\\\\/\\\\s]` +\n    `([0-9]{1,2})` +\n    \"(?=\\\\W|$)\", \"i\");\nconst YEAR_NUMBER_GROUP = 1;\nconst MONTH_NAME_GROUP = 2;\nconst MONTH_NUMBER_GROUP = 3;\nconst DATE_NUMBER_GROUP = 4;\nclass ENCasualYearMonthDayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const month = match[MONTH_NUMBER_GROUP]\n            ? parseInt(match[MONTH_NUMBER_GROUP])\n            : constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        if (month < 1 || month > 12) {\n            return null;\n        }\n        const year = parseInt(match[YEAR_NUMBER_GROUP]);\n        const day = parseInt(match[DATE_NUMBER_GROUP]);\n        return {\n            day: day,\n            month: month,\n            year: year,\n        };\n    }\n}\nexports.default = ENCasualYearMonthDayParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"([0-9]|0[1-9]|1[012])/([0-9]{4})\" + \"\", \"i\");\nconst MONTH_GROUP = 1;\nconst YEAR_GROUP = 2;\nclass ENSlashMonthFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const year = parseInt(match[YEAR_GROUP]);\n        const month = parseInt(match[MONTH_GROUP]);\n        return context.createParsingComponents().imply(\"day\", 1).assign(\"month\", month).assign(\"year\", year);\n    }\n}\nexports.default = ENSlashMonthFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AbstractTimeExpressionParser = void 0;\nconst index_1 = require(\"../../index\");\nfunction primaryTimePattern(primaryPrefix, primarySuffix) {\n    return new RegExp(\"(^|\\\\s|T|\\\\b)\" +\n        `${primaryPrefix}` +\n        \"(\\\\d{1,4})\" +\n        \"(?:\" +\n        \"(?:\\\\.|\\\\:|\\\\：)\" +\n        \"(\\\\d{1,2})\" +\n        \"(?:\" +\n        \"(?:\\\\:|\\\\：)\" +\n        \"(\\\\d{2})\" +\n        \"(?:\\\\.(\\\\d{1,6}))?\" +\n        \")?\" +\n        \")?\" +\n        \"(?:\\\\s*(a\\\\.m\\\\.|p\\\\.m\\\\.|am?|pm?))?\" +\n        `${primarySuffix}`, \"i\");\n}\nfunction followingTimePatten(followingPhase, followingSuffix) {\n    return new RegExp(`^(${followingPhase})` +\n        \"(\\\\d{1,4})\" +\n        \"(?:\" +\n        \"(?:\\\\.|\\\\:|\\\\：)\" +\n        \"(\\\\d{1,2})\" +\n        \"(?:\" +\n        \"(?:\\\\.|\\\\:|\\\\：)\" +\n        \"(\\\\d{1,2})(?:\\\\.(\\\\d{1,6}))?\" +\n        \")?\" +\n        \")?\" +\n        \"(?:\\\\s*(a\\\\.m\\\\.|p\\\\.m\\\\.|am?|pm?))?\" +\n        `${followingSuffix}`, \"i\");\n}\nconst HOUR_GROUP = 2;\nconst MINUTE_GROUP = 3;\nconst SECOND_GROUP = 4;\nconst MILLI_SECOND_GROUP = 5;\nconst AM_PM_HOUR_GROUP = 6;\nclass AbstractTimeExpressionParser {\n    constructor(strictMode = false) {\n        this.cachedPrimaryPrefix = null;\n        this.cachedPrimarySuffix = null;\n        this.cachedPrimaryTimePattern = null;\n        this.cachedFollowingPhase = null;\n        this.cachedFollowingSuffix = null;\n        this.cachedFollowingTimePatten = null;\n        this.strictMode = strictMode;\n    }\n    primarySuffix() {\n        return \"(?=\\\\W|$)\";\n    }\n    followingSuffix() {\n        return \"(?=\\\\W|$)\";\n    }\n    pattern(context) {\n        return this.getPrimaryTimePatternThroughCache();\n    }\n    extract(context, match) {\n        const startComponents = this.extractPrimaryTimeComponents(context, match);\n        if (!startComponents) {\n            match.index += match[0].length;\n            return null;\n        }\n        const index = match.index + match[1].length;\n        const text = match[0].substring(match[1].length);\n        const result = context.createParsingResult(index, text, startComponents);\n        match.index += match[0].length;\n        const remainingText = context.text.substring(match.index);\n        const followingPattern = this.getFollowingTimePatternThroughCache();\n        const followingMatch = followingPattern.exec(remainingText);\n        if (!followingMatch ||\n            followingMatch[0].match(/^\\s*([+-])\\s*\\d{3,4}$/)) {\n            return this.checkAndReturnWithoutFollowingPattern(result);\n        }\n        result.end = this.extractFollowingTimeComponents(context, followingMatch, result);\n        if (result.end) {\n            result.text += followingMatch[0];\n        }\n        return this.checkAndReturnWithFollowingPattern(result);\n    }\n    extractPrimaryTimeComponents(context, match, strict = false) {\n        const components = context.createParsingComponents();\n        let minute = 0;\n        let meridiem = null;\n        let hour = parseInt(match[HOUR_GROUP]);\n        if (hour > 100) {\n            if (this.strictMode || match[MINUTE_GROUP] != null) {\n                return null;\n            }\n            minute = hour % 100;\n            hour = Math.floor(hour / 100);\n        }\n        if (hour > 24) {\n            return null;\n        }\n        if (match[MINUTE_GROUP] != null) {\n            if (match[MINUTE_GROUP].length == 1 && !match[AM_PM_HOUR_GROUP]) {\n                return null;\n            }\n            minute = parseInt(match[MINUTE_GROUP]);\n        }\n        if (minute >= 60) {\n            return null;\n        }\n        if (hour > 12) {\n            meridiem = index_1.Meridiem.PM;\n        }\n        if (match[AM_PM_HOUR_GROUP] != null) {\n            if (hour > 12)\n                return null;\n            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = index_1.Meridiem.AM;\n                if (hour == 12) {\n                    hour = 0;\n                }\n            }\n            if (ampm == \"p\") {\n                meridiem = index_1.Meridiem.PM;\n                if (hour != 12) {\n                    hour += 12;\n                }\n            }\n        }\n        components.assign(\"hour\", hour);\n        components.assign(\"minute\", minute);\n        if (meridiem !== null) {\n            components.assign(\"meridiem\", meridiem);\n        }\n        else {\n            if (hour < 12) {\n                components.imply(\"meridiem\", index_1.Meridiem.AM);\n            }\n            else {\n                components.imply(\"meridiem\", index_1.Meridiem.PM);\n            }\n        }\n        if (match[MILLI_SECOND_GROUP] != null) {\n            const millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));\n            if (millisecond >= 1000)\n                return null;\n            components.assign(\"millisecond\", millisecond);\n        }\n        if (match[SECOND_GROUP] != null) {\n            const second = parseInt(match[SECOND_GROUP]);\n            if (second >= 60)\n                return null;\n            components.assign(\"second\", second);\n        }\n        return components;\n    }\n    extractFollowingTimeComponents(context, match, result) {\n        const components = context.createParsingComponents();\n        if (match[MILLI_SECOND_GROUP] != null) {\n            const millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));\n            if (millisecond >= 1000)\n                return null;\n            components.assign(\"millisecond\", millisecond);\n        }\n        if (match[SECOND_GROUP] != null) {\n            const second = parseInt(match[SECOND_GROUP]);\n            if (second >= 60)\n                return null;\n            components.assign(\"second\", second);\n        }\n        let hour = parseInt(match[HOUR_GROUP]);\n        let minute = 0;\n        let meridiem = -1;\n        if (match[MINUTE_GROUP] != null) {\n            minute = parseInt(match[MINUTE_GROUP]);\n        }\n        else if (hour > 100) {\n            minute = hour % 100;\n            hour = Math.floor(hour / 100);\n        }\n        if (minute >= 60 || hour > 24) {\n            return null;\n        }\n        if (hour >= 12) {\n            meridiem = index_1.Meridiem.PM;\n        }\n        if (match[AM_PM_HOUR_GROUP] != null) {\n            if (hour > 12) {\n                return null;\n            }\n            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = index_1.Meridiem.AM;\n                if (hour == 12) {\n                    hour = 0;\n                    if (!components.isCertain(\"day\")) {\n                        components.imply(\"day\", components.get(\"day\") + 1);\n                    }\n                }\n            }\n            if (ampm == \"p\") {\n                meridiem = index_1.Meridiem.PM;\n                if (hour != 12)\n                    hour += 12;\n            }\n            if (!result.start.isCertain(\"meridiem\")) {\n                if (meridiem == index_1.Meridiem.AM) {\n                    result.start.imply(\"meridiem\", index_1.Meridiem.AM);\n                    if (result.start.get(\"hour\") == 12) {\n                        result.start.assign(\"hour\", 0);\n                    }\n                }\n                else {\n                    result.start.imply(\"meridiem\", index_1.Meridiem.PM);\n                    if (result.start.get(\"hour\") != 12) {\n                        result.start.assign(\"hour\", result.start.get(\"hour\") + 12);\n                    }\n                }\n            }\n        }\n        components.assign(\"hour\", hour);\n        components.assign(\"minute\", minute);\n        if (meridiem >= 0) {\n            components.assign(\"meridiem\", meridiem);\n        }\n        else {\n            const startAtPM = result.start.isCertain(\"meridiem\") && result.start.get(\"hour\") > 12;\n            if (startAtPM) {\n                if (result.start.get(\"hour\") - 12 > hour) {\n                    components.imply(\"meridiem\", index_1.Meridiem.AM);\n                }\n                else if (hour <= 12) {\n                    components.assign(\"hour\", hour + 12);\n                    components.assign(\"meridiem\", index_1.Meridiem.PM);\n                }\n            }\n            else if (hour > 12) {\n                components.imply(\"meridiem\", index_1.Meridiem.PM);\n            }\n            else if (hour <= 12) {\n                components.imply(\"meridiem\", index_1.Meridiem.AM);\n            }\n        }\n        if (components.date().getTime() < result.start.date().getTime()) {\n            components.imply(\"day\", components.get(\"day\") + 1);\n        }\n        return components;\n    }\n    checkAndReturnWithoutFollowingPattern(result) {\n        if (result.text.match(/^\\d$/)) {\n            return null;\n        }\n        if (result.text.match(/\\d[apAP]$/)) {\n            return null;\n        }\n        const endingWithNumbers = result.text.match(/[^\\d:.](\\d[\\d.]+)$/);\n        if (endingWithNumbers) {\n            const endingNumbers = endingWithNumbers[1];\n            if (this.strictMode) {\n                return null;\n            }\n            if (endingNumbers.includes(\".\") && !endingNumbers.match(/\\d(\\.\\d{2})+$/)) {\n                return null;\n            }\n            const endingNumberVal = parseInt(endingNumbers);\n            if (endingNumberVal > 24) {\n                return null;\n            }\n        }\n        return result;\n    }\n    checkAndReturnWithFollowingPattern(result) {\n        if (result.text.match(/^\\d+-\\d+$/)) {\n            return null;\n        }\n        const endingWithNumbers = result.text.match(/[^\\d:.](\\d[\\d.]+)\\s*-\\s*(\\d[\\d.]+)$/);\n        if (endingWithNumbers) {\n            if (this.strictMode) {\n                return null;\n            }\n            const startingNumbers = endingWithNumbers[1];\n            const endingNumbers = endingWithNumbers[2];\n            if (endingNumbers.includes(\".\") && !endingNumbers.match(/\\d(\\.\\d{2})+$/)) {\n                return null;\n            }\n            const endingNumberVal = parseInt(endingNumbers);\n            const startingNumberVal = parseInt(startingNumbers);\n            if (endingNumberVal > 24 || startingNumberVal > 24) {\n                return null;\n            }\n        }\n        return result;\n    }\n    getPrimaryTimePatternThroughCache() {\n        const primaryPrefix = this.primaryPrefix();\n        const primarySuffix = this.primarySuffix();\n        if (this.cachedPrimaryPrefix === primaryPrefix && this.cachedPrimarySuffix === primarySuffix) {\n            return this.cachedPrimaryTimePattern;\n        }\n        this.cachedPrimaryTimePattern = primaryTimePattern(primaryPrefix, primarySuffix);\n        this.cachedPrimaryPrefix = primaryPrefix;\n        this.cachedPrimarySuffix = primarySuffix;\n        return this.cachedPrimaryTimePattern;\n    }\n    getFollowingTimePatternThroughCache() {\n        const followingPhase = this.followingPhase();\n        const followingSuffix = this.followingSuffix();\n        if (this.cachedFollowingPhase === followingPhase && this.cachedFollowingSuffix === followingSuffix) {\n            return this.cachedFollowingTimePatten;\n        }\n        this.cachedFollowingTimePatten = followingTimePatten(followingPhase, followingSuffix);\n        this.cachedFollowingPhase = followingPhase;\n        this.cachedFollowingSuffix = followingSuffix;\n        return this.cachedFollowingTimePatten;\n    }\n}\nexports.AbstractTimeExpressionParser = AbstractTimeExpressionParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst index_1 = require(\"../../../index\");\nconst AbstractTimeExpressionParser_1 = require(\"../../../common/parsers/AbstractTimeExpressionParser\");\nclass ENTimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {\n    constructor(strictMode) {\n        super(strictMode);\n    }\n    followingPhase() {\n        return \"\\\\s*(?:\\\\-|\\\\–|\\\\~|\\\\〜|to|\\\\?)\\\\s*\";\n    }\n    primaryPrefix() {\n        return \"(?:(?:at|from)\\\\s*)??\";\n    }\n    primarySuffix() {\n        return \"(?:\\\\s*(?:o\\\\W*clock|at\\\\s*night|in\\\\s*the\\\\s*(?:morning|afternoon)))?(?!/)(?=\\\\W|$)\";\n    }\n    extractPrimaryTimeComponents(context, match) {\n        const components = super.extractPrimaryTimeComponents(context, match);\n        if (components) {\n            if (match[0].endsWith(\"night\")) {\n                const hour = components.get(\"hour\");\n                if (hour >= 6 && hour < 12) {\n                    components.assign(\"hour\", components.get(\"hour\") + 12);\n                    components.assign(\"meridiem\", index_1.Meridiem.PM);\n                }\n                else if (hour < 6) {\n                    components.assign(\"meridiem\", index_1.Meridiem.AM);\n                }\n            }\n            if (match[0].endsWith(\"afternoon\")) {\n                components.assign(\"meridiem\", index_1.Meridiem.PM);\n                const hour = components.get(\"hour\");\n                if (hour >= 0 && hour <= 6) {\n                    components.assign(\"hour\", components.get(\"hour\") + 12);\n                }\n            }\n            if (match[0].endsWith(\"morning\")) {\n                components.assign(\"meridiem\", index_1.Meridiem.AM);\n                const hour = components.get(\"hour\");\n                if (hour < 12) {\n                    components.assign(\"hour\", components.get(\"hour\"));\n                }\n            }\n        }\n        return components;\n    }\n}\nexports.default = ENTimeExpressionParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.addImpliedTimeUnits = exports.reverseTimeUnits = void 0;\nfunction reverseTimeUnits(timeUnits) {\n    const reversed = {};\n    for (const key in timeUnits) {\n        reversed[key] = -timeUnits[key];\n    }\n    return reversed;\n}\nexports.reverseTimeUnits = reverseTimeUnits;\nfunction addImpliedTimeUnits(components, timeUnits) {\n    const output = components.clone();\n    let date = components.dayjs();\n    for (const key in timeUnits) {\n        date = date.add(timeUnits[key], key);\n    }\n    if (\"day\" in timeUnits || \"d\" in timeUnits || \"week\" in timeUnits || \"month\" in timeUnits || \"year\" in timeUnits) {\n        output.imply(\"day\", date.date());\n        output.imply(\"month\", date.month() + 1);\n        output.imply(\"year\", date.year());\n    }\n    if (\"second\" in timeUnits || \"minute\" in timeUnits || \"hour\" in timeUnits) {\n        output.imply(\"second\", date.second());\n        output.imply(\"minute\", date.minute());\n        output.imply(\"hour\", date.hour());\n    }\n    return output;\n}\nexports.addImpliedTimeUnits = addImpliedTimeUnits;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nconst PATTERN = new RegExp(`(${constants_1.TIME_UNITS_PATTERN})\\\\s{0,5}(?:ago|before|earlier)(?=(?:\\\\W|$))`, \"i\");\nconst STRICT_PATTERN = new RegExp(`(${constants_1.TIME_UNITS_PATTERN})\\\\s{0,5}ago(?=(?:\\\\W|$))`, \"i\");\nclass ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    constructor(strictMode) {\n        super();\n        this.strictMode = strictMode;\n    }\n    innerPattern() {\n        return this.strictMode ? STRICT_PATTERN : PATTERN;\n    }\n    innerExtract(context, match) {\n        const timeUnits = (0, constants_1.parseTimeUnits)(match[1]);\n        const outputTimeUnits = (0, timeunits_1.reverseTimeUnits)(timeUnits);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);\n    }\n}\nexports.default = ENTimeUnitAgoFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`(${constants_1.TIME_UNITS_PATTERN})\\\\s{0,5}(?:later|after|from now|henceforth|forward|out)` + \"(?=(?:\\\\W|$))\", \"i\");\nconst STRICT_PATTERN = new RegExp(\"\" + \"(\" + constants_1.TIME_UNITS_PATTERN + \")\" + \"(later|from now)\" + \"(?=(?:\\\\W|$))\", \"i\");\nconst GROUP_NUM_TIMEUNITS = 1;\nclass ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    constructor(strictMode) {\n        super();\n        this.strictMode = strictMode;\n    }\n    innerPattern() {\n        return this.strictMode ? STRICT_PATTERN : PATTERN;\n    }\n    innerExtract(context, match) {\n        const fragments = (0, constants_1.parseTimeUnits)(match[GROUP_NUM_TIMEUNITS]);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, fragments);\n    }\n}\nexports.default = ENTimeUnitLaterFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.MergingRefiner = exports.Filter = void 0;\nclass Filter {\n    refine(context, results) {\n        return results.filter((r) => this.isValid(context, r));\n    }\n}\nexports.Filter = Filter;\nclass MergingRefiner {\n    refine(context, results) {\n        if (results.length < 2) {\n            return results;\n        }\n        const mergedResults = [];\n        let curResult = results[0];\n        let nextResult = null;\n        for (let i = 1; i < results.length; i++) {\n            nextResult = results[i];\n            const textBetween = context.text.substring(curResult.index + curResult.text.length, nextResult.index);\n            if (!this.shouldMergeResults(textBetween, curResult, nextResult, context)) {\n                mergedResults.push(curResult);\n                curResult = nextResult;\n            }\n            else {\n                const left = curResult;\n                const right = nextResult;\n                const mergedResult = this.mergeResults(textBetween, left, right, context);\n                context.debug(() => {\n                    console.log(`${this.constructor.name} merged ${left} and ${right} into ${mergedResult}`);\n                });\n                curResult = mergedResult;\n            }\n        }\n        if (curResult != null) {\n            mergedResults.push(curResult);\n        }\n        return mergedResults;\n    }\n}\nexports.MergingRefiner = MergingRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst abstractRefiners_1 = require(\"../abstractRefiners\");\nclass AbstractMergeDateRangeRefiner extends abstractRefiners_1.MergingRefiner {\n    shouldMergeResults(textBetween, currentResult, nextResult) {\n        return !currentResult.end && !nextResult.end && textBetween.match(this.patternBetween()) != null;\n    }\n    mergeResults(textBetween, fromResult, toResult) {\n        if (!fromResult.start.isOnlyWeekdayComponent() && !toResult.start.isOnlyWeekdayComponent()) {\n            toResult.start.getCertainComponents().forEach((key) => {\n                if (!fromResult.start.isCertain(key)) {\n                    fromResult.start.assign(key, toResult.start.get(key));\n                }\n            });\n            fromResult.start.getCertainComponents().forEach((key) => {\n                if (!toResult.start.isCertain(key)) {\n                    toResult.start.assign(key, fromResult.start.get(key));\n                }\n            });\n        }\n        if (fromResult.start.date().getTime() > toResult.start.date().getTime()) {\n            let fromMoment = fromResult.start.dayjs();\n            let toMoment = toResult.start.dayjs();\n            if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, \"days\").isBefore(toMoment)) {\n                fromMoment = fromMoment.add(-7, \"days\");\n                fromResult.start.imply(\"day\", fromMoment.date());\n                fromResult.start.imply(\"month\", fromMoment.month() + 1);\n                fromResult.start.imply(\"year\", fromMoment.year());\n            }\n            else if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, \"days\").isAfter(fromMoment)) {\n                toMoment = toMoment.add(7, \"days\");\n                toResult.start.imply(\"day\", toMoment.date());\n                toResult.start.imply(\"month\", toMoment.month() + 1);\n                toResult.start.imply(\"year\", toMoment.year());\n            }\n            else {\n                [toResult, fromResult] = [fromResult, toResult];\n            }\n        }\n        const result = fromResult.clone();\n        result.start = fromResult.start;\n        result.end = toResult.start;\n        result.index = Math.min(fromResult.index, toResult.index);\n        if (fromResult.index < toResult.index) {\n            result.text = fromResult.text + textBetween + toResult.text;\n        }\n        else {\n            result.text = toResult.text + textBetween + fromResult.text;\n        }\n        return result;\n    }\n}\nexports.default = AbstractMergeDateRangeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(to|-)\\s*$/i;\n    }\n}\nexports.default = ENMergeDateRangeRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.mergeDateTimeComponent = exports.mergeDateTimeResult = void 0;\nconst index_1 = require(\"../index\");\nfunction mergeDateTimeResult(dateResult, timeResult) {\n    const result = dateResult.clone();\n    const beginDate = dateResult.start;\n    const beginTime = timeResult.start;\n    result.start = mergeDateTimeComponent(beginDate, beginTime);\n    if (dateResult.end != null || timeResult.end != null) {\n        const endDate = dateResult.end == null ? dateResult.start : dateResult.end;\n        const endTime = timeResult.end == null ? timeResult.start : timeResult.end;\n        const endDateTime = mergeDateTimeComponent(endDate, endTime);\n        if (dateResult.end == null && endDateTime.date().getTime() < result.start.date().getTime()) {\n            if (endDateTime.isCertain(\"day\")) {\n                endDateTime.assign(\"day\", endDateTime.get(\"day\") + 1);\n            }\n            else {\n                endDateTime.imply(\"day\", endDateTime.get(\"day\") + 1);\n            }\n        }\n        result.end = endDateTime;\n    }\n    return result;\n}\nexports.mergeDateTimeResult = mergeDateTimeResult;\nfunction mergeDateTimeComponent(dateComponent, timeComponent) {\n    const dateTimeComponent = dateComponent.clone();\n    if (timeComponent.isCertain(\"hour\")) {\n        dateTimeComponent.assign(\"hour\", timeComponent.get(\"hour\"));\n        dateTimeComponent.assign(\"minute\", timeComponent.get(\"minute\"));\n        if (timeComponent.isCertain(\"second\")) {\n            dateTimeComponent.assign(\"second\", timeComponent.get(\"second\"));\n            if (timeComponent.isCertain(\"millisecond\")) {\n                dateTimeComponent.assign(\"millisecond\", timeComponent.get(\"millisecond\"));\n            }\n            else {\n                dateTimeComponent.imply(\"millisecond\", timeComponent.get(\"millisecond\"));\n            }\n        }\n        else {\n            dateTimeComponent.imply(\"second\", timeComponent.get(\"second\"));\n            dateTimeComponent.imply(\"millisecond\", timeComponent.get(\"millisecond\"));\n        }\n    }\n    else {\n        dateTimeComponent.imply(\"hour\", timeComponent.get(\"hour\"));\n        dateTimeComponent.imply(\"minute\", timeComponent.get(\"minute\"));\n        dateTimeComponent.imply(\"second\", timeComponent.get(\"second\"));\n        dateTimeComponent.imply(\"millisecond\", timeComponent.get(\"millisecond\"));\n    }\n    if (timeComponent.isCertain(\"timezoneOffset\")) {\n        dateTimeComponent.assign(\"timezoneOffset\", timeComponent.get(\"timezoneOffset\"));\n    }\n    if (timeComponent.isCertain(\"meridiem\")) {\n        dateTimeComponent.assign(\"meridiem\", timeComponent.get(\"meridiem\"));\n    }\n    else if (timeComponent.get(\"meridiem\") != null && dateTimeComponent.get(\"meridiem\") == null) {\n        dateTimeComponent.imply(\"meridiem\", timeComponent.get(\"meridiem\"));\n    }\n    if (dateTimeComponent.get(\"meridiem\") == index_1.Meridiem.PM && dateTimeComponent.get(\"hour\") < 12) {\n        if (timeComponent.isCertain(\"hour\")) {\n            dateTimeComponent.assign(\"hour\", dateTimeComponent.get(\"hour\") + 12);\n        }\n        else {\n            dateTimeComponent.imply(\"hour\", dateTimeComponent.get(\"hour\") + 12);\n        }\n    }\n    return dateTimeComponent;\n}\nexports.mergeDateTimeComponent = mergeDateTimeComponent;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst abstractRefiners_1 = require(\"../abstractRefiners\");\nconst mergingCalculation_1 = require(\"../../calculation/mergingCalculation\");\nclass ENMergeDateTimeRefiner extends abstractRefiners_1.MergingRefiner {\n    shouldMergeResults(textBetween, currentResult, nextResult) {\n        return (((currentResult.start.isOnlyDate() && nextResult.start.isOnlyTime()) ||\n            (nextResult.start.isOnlyDate() && currentResult.start.isOnlyTime())) &&\n            textBetween.match(this.patternBetween()) != null);\n    }\n    mergeResults(textBetween, currentResult, nextResult) {\n        const result = currentResult.start.isOnlyDate()\n            ? (0, mergingCalculation_1.mergeDateTimeResult)(currentResult, nextResult)\n            : (0, mergingCalculation_1.mergeDateTimeResult)(nextResult, currentResult);\n        result.index = currentResult.index;\n        result.text = currentResult.text + textBetween + nextResult.text;\n        return result;\n    }\n}\nexports.default = ENMergeDateTimeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return new RegExp(\"^\\\\s*(T|at|after|before|on|of|,|-)?\\\\s*$\");\n    }\n}\nexports.default = ENMergeDateTimeRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst TIMEZONE_NAME_PATTERN = new RegExp(\"^\\\\s*,?\\\\s*\\\\(?([A-Z]{2,4})\\\\)?(?=\\\\W|$)\", \"i\");\nconst DEFAULT_TIMEZONE_ABBR_MAP = {\n    ACDT: 630,\n    ACST: 570,\n    ADT: -180,\n    AEDT: 660,\n    AEST: 600,\n    AFT: 270,\n    AKDT: -480,\n    AKST: -540,\n    ALMT: 360,\n    AMST: -180,\n    AMT: -240,\n    ANAST: 720,\n    ANAT: 720,\n    AQTT: 300,\n    ART: -180,\n    AST: -240,\n    AWDT: 540,\n    AWST: 480,\n    AZOST: 0,\n    AZOT: -60,\n    AZST: 300,\n    AZT: 240,\n    BNT: 480,\n    BOT: -240,\n    BRST: -120,\n    BRT: -180,\n    BST: 60,\n    BTT: 360,\n    CAST: 480,\n    CAT: 120,\n    CCT: 390,\n    CDT: -300,\n    CEST: 120,\n    CET: 60,\n    CHADT: 825,\n    CHAST: 765,\n    CKT: -600,\n    CLST: -180,\n    CLT: -240,\n    COT: -300,\n    CST: -360,\n    CVT: -60,\n    CXT: 420,\n    ChST: 600,\n    DAVT: 420,\n    EASST: -300,\n    EAST: -360,\n    EAT: 180,\n    ECT: -300,\n    EDT: -240,\n    EEST: 180,\n    EET: 120,\n    EGST: 0,\n    EGT: -60,\n    EST: -300,\n    ET: -300,\n    FJST: 780,\n    FJT: 720,\n    FKST: -180,\n    FKT: -240,\n    FNT: -120,\n    GALT: -360,\n    GAMT: -540,\n    GET: 240,\n    GFT: -180,\n    GILT: 720,\n    GMT: 0,\n    GST: 240,\n    GYT: -240,\n    HAA: -180,\n    HAC: -300,\n    HADT: -540,\n    HAE: -240,\n    HAP: -420,\n    HAR: -360,\n    HAST: -600,\n    HAT: -90,\n    HAY: -480,\n    HKT: 480,\n    HLV: -210,\n    HNA: -240,\n    HNC: -360,\n    HNE: -300,\n    HNP: -480,\n    HNR: -420,\n    HNT: -150,\n    HNY: -540,\n    HOVT: 420,\n    ICT: 420,\n    IDT: 180,\n    IOT: 360,\n    IRDT: 270,\n    IRKST: 540,\n    IRKT: 540,\n    IRST: 210,\n    IST: 330,\n    JST: 540,\n    KGT: 360,\n    KRAST: 480,\n    KRAT: 480,\n    KST: 540,\n    KUYT: 240,\n    LHDT: 660,\n    LHST: 630,\n    LINT: 840,\n    MAGST: 720,\n    MAGT: 720,\n    MART: -510,\n    MAWT: 300,\n    MDT: -360,\n    MESZ: 120,\n    MEZ: 60,\n    MHT: 720,\n    MMT: 390,\n    MSD: 240,\n    MSK: 240,\n    MST: -420,\n    MUT: 240,\n    MVT: 300,\n    MYT: 480,\n    NCT: 660,\n    NDT: -90,\n    NFT: 690,\n    NOVST: 420,\n    NOVT: 360,\n    NPT: 345,\n    NST: -150,\n    NUT: -660,\n    NZDT: 780,\n    NZST: 720,\n    OMSST: 420,\n    OMST: 420,\n    PDT: -420,\n    PET: -300,\n    PETST: 720,\n    PETT: 720,\n    PGT: 600,\n    PHOT: 780,\n    PHT: 480,\n    PKT: 300,\n    PMDT: -120,\n    PMST: -180,\n    PONT: 660,\n    PST: -480,\n    PT: -480,\n    PWT: 540,\n    PYST: -180,\n    PYT: -240,\n    RET: 240,\n    SAMT: 240,\n    SAST: 120,\n    SBT: 660,\n    SCT: 240,\n    SGT: 480,\n    SRT: -180,\n    SST: -660,\n    TAHT: -600,\n    TFT: 300,\n    TJT: 300,\n    TKT: 780,\n    TLT: 540,\n    TMT: 300,\n    TVT: 720,\n    ULAT: 480,\n    UTC: 0,\n    UYST: -120,\n    UYT: -180,\n    UZT: 300,\n    VET: -210,\n    VLAST: 660,\n    VLAT: 660,\n    VUT: 660,\n    WAST: 120,\n    WAT: 60,\n    WEST: 60,\n    WESZ: 60,\n    WET: 0,\n    WEZ: 0,\n    WFT: 720,\n    WGST: -120,\n    WGT: -180,\n    WIB: 420,\n    WIT: 540,\n    WITA: 480,\n    WST: 780,\n    WT: 0,\n    YAKST: 600,\n    YAKT: 600,\n    YAPT: 600,\n    YEKST: 360,\n    YEKT: 360,\n};\nclass ExtractTimezoneAbbrRefiner {\n    constructor(timezoneOverrides) {\n        this.timezone = Object.assign(Object.assign({}, DEFAULT_TIMEZONE_ABBR_MAP), timezoneOverrides);\n    }\n    refine(context, results) {\n        var _a;\n        const timezoneOverrides = (_a = context.option.timezones) !== null && _a !== void 0 ? _a : {};\n        results.forEach((result) => {\n            var _a, _b;\n            const suffix = context.text.substring(result.index + result.text.length);\n            const match = TIMEZONE_NAME_PATTERN.exec(suffix);\n            if (!match) {\n                return;\n            }\n            const timezoneAbbr = match[1].toUpperCase();\n            const extractedTimezoneOffset = (_b = (_a = timezoneOverrides[timezoneAbbr]) !== null && _a !== void 0 ? _a : this.timezone[timezoneAbbr]) !== null && _b !== void 0 ? _b : null;\n            if (extractedTimezoneOffset === null) {\n                return;\n            }\n            context.debug(() => {\n                console.log(`Extracting timezone: '${timezoneAbbr}' into : ${extractedTimezoneOffset}`);\n            });\n            const currentTimezoneOffset = result.start.get(\"timezoneOffset\");\n            if (currentTimezoneOffset !== null && extractedTimezoneOffset != currentTimezoneOffset) {\n                if (result.start.isCertain(\"timezoneOffset\")) {\n                    return;\n                }\n                if (timezoneAbbr != match[1]) {\n                    return;\n                }\n            }\n            if (result.start.isOnlyDate()) {\n                if (timezoneAbbr != match[1]) {\n                    return;\n                }\n            }\n            result.text += match[0];\n            if (!result.start.isCertain(\"timezoneOffset\")) {\n                result.start.assign(\"timezoneOffset\", extractedTimezoneOffset);\n            }\n            if (result.end != null && !result.end.isCertain(\"timezoneOffset\")) {\n                result.end.assign(\"timezoneOffset\", extractedTimezoneOffset);\n            }\n        });\n        return results;\n    }\n}\nexports.default = ExtractTimezoneAbbrRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst TIMEZONE_OFFSET_PATTERN = new RegExp(\"^\\\\s*(?:(?:GMT|UTC)\\\\s?)?([+-])(\\\\d{1,2})(?::?(\\\\d{2}))?\", \"i\");\nconst TIMEZONE_OFFSET_SIGN_GROUP = 1;\nconst TIMEZONE_OFFSET_HOUR_OFFSET_GROUP = 2;\nconst TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP = 3;\nclass ExtractTimezoneOffsetRefiner {\n    refine(context, results) {\n        results.forEach(function (result) {\n            if (result.start.isCertain(\"timezoneOffset\")) {\n                return;\n            }\n            const suffix = context.text.substring(result.index + result.text.length);\n            const match = TIMEZONE_OFFSET_PATTERN.exec(suffix);\n            if (!match) {\n                return;\n            }\n            context.debug(() => {\n                console.log(`Extracting timezone: '${match[0]}' into : ${result}`);\n            });\n            const hourOffset = parseInt(match[TIMEZONE_OFFSET_HOUR_OFFSET_GROUP]);\n            const minuteOffset = parseInt(match[TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP] || \"0\");\n            let timezoneOffset = hourOffset * 60 + minuteOffset;\n            if (match[TIMEZONE_OFFSET_SIGN_GROUP] === \"-\") {\n                timezoneOffset = -timezoneOffset;\n            }\n            if (result.end != null) {\n                result.end.assign(\"timezoneOffset\", timezoneOffset);\n            }\n            result.start.assign(\"timezoneOffset\", timezoneOffset);\n            result.text += match[0];\n        });\n        return results;\n    }\n}\nexports.default = ExtractTimezoneOffsetRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nclass OverlapRemovalRefiner {\n    refine(context, results) {\n        if (results.length < 2) {\n            return results;\n        }\n        const filteredResults = [];\n        let prevResult = results[0];\n        for (let i = 1; i < results.length; i++) {\n            const result = results[i];\n            if (result.index < prevResult.index + prevResult.text.length) {\n                if (result.text.length > prevResult.text.length) {\n                    prevResult = result;\n                }\n            }\n            else {\n                filteredResults.push(prevResult);\n                prevResult = result;\n            }\n        }\n        if (prevResult != null) {\n            filteredResults.push(prevResult);\n        }\n        return filteredResults;\n    }\n}\nexports.default = OverlapRemovalRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nclass ForwardDateRefiner {\n    refine(context, results) {\n        if (!context.option.forwardDate) {\n            return results;\n        }\n        results.forEach(function (result) {\n            let refMoment = (0, dayjs_1.default)(context.refDate);\n            if (result.start.isOnlyDayMonthComponent() && refMoment.isAfter(result.start.dayjs())) {\n                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {\n                    result.start.imply(\"year\", result.start.get(\"year\") + 1);\n                    context.debug(() => {\n                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);\n                    });\n                    if (result.end && !result.end.isCertain(\"year\")) {\n                        result.end.imply(\"year\", result.end.get(\"year\") + 1);\n                        context.debug(() => {\n                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);\n                        });\n                    }\n                }\n            }\n            if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {\n                if (refMoment.day() >= result.start.get(\"weekday\")) {\n                    refMoment = refMoment.day(result.start.get(\"weekday\") + 7);\n                }\n                else {\n                    refMoment = refMoment.day(result.start.get(\"weekday\"));\n                }\n                result.start.imply(\"day\", refMoment.date());\n                result.start.imply(\"month\", refMoment.month() + 1);\n                result.start.imply(\"year\", refMoment.year());\n                context.debug(() => {\n                    console.log(`Forward weekly adjusted for ${result} (${result.start})`);\n                });\n                if (result.end && result.end.isOnlyWeekdayComponent()) {\n                    if (refMoment.day() > result.end.get(\"weekday\")) {\n                        refMoment = refMoment.day(result.end.get(\"weekday\") + 7);\n                    }\n                    else {\n                        refMoment = refMoment.day(result.end.get(\"weekday\"));\n                    }\n                    result.end.imply(\"day\", refMoment.date());\n                    result.end.imply(\"month\", refMoment.month() + 1);\n                    result.end.imply(\"year\", refMoment.year());\n                    context.debug(() => {\n                        console.log(`Forward weekly adjusted for ${result} (${result.end})`);\n                    });\n                }\n            }\n        });\n        return results;\n    }\n}\nexports.default = ForwardDateRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst abstractRefiners_1 = require(\"../abstractRefiners\");\nclass UnlikelyFormatFilter extends abstractRefiners_1.Filter {\n    constructor(strictMode) {\n        super();\n        this.strictMode = strictMode;\n    }\n    isValid(context, result) {\n        if (result.text.replace(\" \", \"\").match(/^\\d*(\\.\\d*)?$/)) {\n            context.debug(() => {\n                console.log(`Removing unlikely result '${result.text}'`);\n            });\n            return false;\n        }\n        if (!result.start.isValidDate()) {\n            context.debug(() => {\n                console.log(`Removing invalid result: ${result} (${result.start})`);\n            });\n            return false;\n        }\n        if (result.end && !result.end.isValidDate()) {\n            context.debug(() => {\n                console.log(`Removing invalid result: ${result} (${result.end})`);\n            });\n            return false;\n        }\n        if (this.strictMode) {\n            return this.isStrictModeValid(context, result);\n        }\n        return true;\n    }\n    isStrictModeValid(context, result) {\n        if (result.start.isOnlyWeekdayComponent()) {\n            context.debug(() => {\n                console.log(`(Strict) Removing weekday only component: ${result} (${result.end})`);\n            });\n            return false;\n        }\n        if (result.start.isOnlyTime() && (!result.start.isCertain(\"hour\") || !result.start.isCertain(\"minute\"))) {\n            context.debug(() => {\n                console.log(`(Strict) Removing uncertain time component: ${result} (${result.end})`);\n            });\n            return false;\n        }\n        return true;\n    }\n}\nexports.default = UnlikelyFormatFilter;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractParserWithWordBoundary_1 = require(\"./AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"([0-9]{4})\\\\-([0-9]{1,2})\\\\-([0-9]{1,2})\" +\n    \"(?:T\" +\n    \"([0-9]{1,2}):([0-9]{1,2})\" +\n    \"(?:\" +\n    \":([0-9]{1,2})(?:\\\\.(\\\\d{1,4}))?\" +\n    \")?\" +\n    \"(?:\" +\n    \"Z|([+-]\\\\d{2}):?(\\\\d{2})?\" +\n    \")?\" +\n    \")?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst YEAR_NUMBER_GROUP = 1;\nconst MONTH_NUMBER_GROUP = 2;\nconst DATE_NUMBER_GROUP = 3;\nconst HOUR_NUMBER_GROUP = 4;\nconst MINUTE_NUMBER_GROUP = 5;\nconst SECOND_NUMBER_GROUP = 6;\nconst MILLISECOND_NUMBER_GROUP = 7;\nconst TZD_HOUR_OFFSET_GROUP = 8;\nconst TZD_MINUTE_OFFSET_GROUP = 9;\nclass ISOFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const components = {};\n        components[\"year\"] = parseInt(match[YEAR_NUMBER_GROUP]);\n        components[\"month\"] = parseInt(match[MONTH_NUMBER_GROUP]);\n        components[\"day\"] = parseInt(match[DATE_NUMBER_GROUP]);\n        if (match[HOUR_NUMBER_GROUP] != null) {\n            components[\"hour\"] = parseInt(match[HOUR_NUMBER_GROUP]);\n            components[\"minute\"] = parseInt(match[MINUTE_NUMBER_GROUP]);\n            if (match[SECOND_NUMBER_GROUP] != null) {\n                components[\"second\"] = parseInt(match[SECOND_NUMBER_GROUP]);\n            }\n            if (match[MILLISECOND_NUMBER_GROUP] != null) {\n                components[\"millisecond\"] = parseInt(match[MILLISECOND_NUMBER_GROUP]);\n            }\n            if (match[TZD_HOUR_OFFSET_GROUP] == null) {\n                components[\"timezoneOffset\"] = 0;\n            }\n            else {\n                const hourOffset = parseInt(match[TZD_HOUR_OFFSET_GROUP]);\n                let minuteOffset = 0;\n                if (match[TZD_MINUTE_OFFSET_GROUP] != null) {\n                    minuteOffset = parseInt(match[TZD_MINUTE_OFFSET_GROUP]);\n                }\n                let offset = hourOffset * 60;\n                if (offset < 0) {\n                    offset -= minuteOffset;\n                }\n                else {\n                    offset += minuteOffset;\n                }\n                components[\"timezoneOffset\"] = offset;\n            }\n        }\n        return components;\n    }\n}\nexports.default = ISOFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst abstractRefiners_1 = require(\"../abstractRefiners\");\nclass MergeWeekdayComponentRefiner extends abstractRefiners_1.MergingRefiner {\n    mergeResults(textBetween, currentResult, nextResult) {\n        const newResult = nextResult.clone();\n        newResult.index = currentResult.index;\n        newResult.text = currentResult.text + textBetween + newResult.text;\n        newResult.start.assign(\"weekday\", currentResult.start.get(\"weekday\"));\n        if (newResult.end) {\n            newResult.end.assign(\"weekday\", currentResult.start.get(\"weekday\"));\n        }\n        return newResult;\n    }\n    shouldMergeResults(textBetween, currentResult, nextResult) {\n        const weekdayThenNormalDate = currentResult.start.isOnlyWeekdayComponent() &&\n            !currentResult.start.isCertain(\"hour\") &&\n            nextResult.start.isCertain(\"day\");\n        return weekdayThenNormalDate && textBetween.match(/^,?\\s*$/) != null;\n    }\n}\nexports.default = MergeWeekdayComponentRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.includeCommonConfiguration = void 0;\nconst ExtractTimezoneAbbrRefiner_1 = __importDefault(require(\"./common/refiners/ExtractTimezoneAbbrRefiner\"));\nconst ExtractTimezoneOffsetRefiner_1 = __importDefault(require(\"./common/refiners/ExtractTimezoneOffsetRefiner\"));\nconst OverlapRemovalRefiner_1 = __importDefault(require(\"./common/refiners/OverlapRemovalRefiner\"));\nconst ForwardDateRefiner_1 = __importDefault(require(\"./common/refiners/ForwardDateRefiner\"));\nconst UnlikelyFormatFilter_1 = __importDefault(require(\"./common/refiners/UnlikelyFormatFilter\"));\nconst ISOFormatParser_1 = __importDefault(require(\"./common/parsers/ISOFormatParser\"));\nconst MergeWeekdayComponentRefiner_1 = __importDefault(require(\"./common/refiners/MergeWeekdayComponentRefiner\"));\nfunction includeCommonConfiguration(configuration, strictMode = false) {\n    configuration.parsers.unshift(new ISOFormatParser_1.default());\n    configuration.refiners.unshift(new MergeWeekdayComponentRefiner_1.default());\n    configuration.refiners.unshift(new ExtractTimezoneAbbrRefiner_1.default());\n    configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner_1.default());\n    configuration.refiners.unshift(new OverlapRemovalRefiner_1.default());\n    configuration.refiners.push(new OverlapRemovalRefiner_1.default());\n    configuration.refiners.push(new ForwardDateRefiner_1.default());\n    configuration.refiners.push(new UnlikelyFormatFilter_1.default(strictMode));\n    return configuration;\n}\nexports.includeCommonConfiguration = includeCommonConfiguration;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.tonight = exports.tomorrow = exports.yesterday = exports.today = exports.now = void 0;\nconst results_1 = require(\"../results\");\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst dayjs_2 = require(\"../utils/dayjs\");\nconst index_1 = require(\"../index\");\nfunction now(reference) {\n    const targetDate = (0, dayjs_1.default)(reference.instant);\n    const component = new results_1.ParsingComponents(reference, {});\n    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n    (0, dayjs_2.assignSimilarTime)(component, targetDate);\n    if (reference.timezoneOffset !== null) {\n        component.assign(\"timezoneOffset\", targetDate.utcOffset());\n    }\n    return component;\n}\nexports.now = now;\nfunction today(reference) {\n    const targetDate = (0, dayjs_1.default)(reference.instant);\n    const component = new results_1.ParsingComponents(reference, {});\n    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n    (0, dayjs_2.implySimilarTime)(component, targetDate);\n    return component;\n}\nexports.today = today;\nfunction yesterday(reference) {\n    let targetDate = (0, dayjs_1.default)(reference.instant);\n    const component = new results_1.ParsingComponents(reference, {});\n    targetDate = targetDate.add(-1, \"day\");\n    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n    (0, dayjs_2.implySimilarTime)(component, targetDate);\n    return component;\n}\nexports.yesterday = yesterday;\nfunction tomorrow(reference) {\n    const targetDate = (0, dayjs_1.default)(reference.instant);\n    const component = new results_1.ParsingComponents(reference, {});\n    (0, dayjs_2.assignTheNextDay)(component, targetDate);\n    return component;\n}\nexports.tomorrow = tomorrow;\nfunction tonight(reference, implyHour = 22) {\n    const targetDate = (0, dayjs_1.default)(reference.instant);\n    const component = new results_1.ParsingComponents(reference, {});\n    component.imply(\"hour\", implyHour);\n    component.imply(\"meridiem\", index_1.Meridiem.PM);\n    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n    return component;\n}\nexports.tonight = tonight;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_2 = require(\"../../../utils/dayjs\");\nconst references = __importStar(require(\"../../../common/casualReferences\"));\nconst PATTERN = /(now|today|tonight|tomorrow|tmr|tmrw|yesterday|last\\s*night)(?=\\W|$)/i;\nclass ENCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        let targetDate = (0, dayjs_1.default)(context.refDate);\n        const lowerText = match[0].toLowerCase();\n        const component = context.createParsingComponents();\n        switch (lowerText) {\n            case \"now\":\n                return references.now(context.reference);\n            case \"today\":\n                return references.today(context.reference);\n            case \"yesterday\":\n                return references.yesterday(context.reference);\n            case \"tomorrow\":\n            case \"tmr\":\n            case \"tmrw\":\n                return references.tomorrow(context.reference);\n            case \"tonight\":\n                return references.tonight(context.reference);\n            default:\n                if (lowerText.match(/last\\s*night/)) {\n                    if (targetDate.hour() > 6) {\n                        targetDate = targetDate.add(-1, \"day\");\n                    }\n                    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n                    component.imply(\"hour\", 0);\n                }\n                break;\n        }\n        return component;\n    }\n}\nexports.default = ENCasualDateParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst index_1 = require(\"../../../index\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst dayjs_2 = require(\"../../../utils/dayjs\");\nconst PATTERN = /(?:this)?\\s{0,3}(morning|afternoon|evening|night|midnight|noon)(?=\\W|$)/i;\nclass ENCasualTimeParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const targetDate = (0, dayjs_1.default)(context.refDate);\n        const component = context.createParsingComponents();\n        switch (match[1].toLowerCase()) {\n            case \"afternoon\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 15);\n                break;\n            case \"evening\":\n            case \"night\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 20);\n                break;\n            case \"midnight\":\n                (0, dayjs_2.assignTheNextDay)(component, targetDate);\n                component.imply(\"hour\", 0);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                break;\n            case \"morning\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 6);\n                break;\n            case \"noon\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 12);\n                break;\n        }\n        return component;\n    }\n}\nexports.default = ENCasualTimeParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.toDayJSClosestWeekday = exports.toDayJSWeekday = void 0;\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nfunction toDayJSWeekday(refDate, offset, modifier, locale) {\n    var _a;\n    if (!modifier) {\n        return toDayJSClosestWeekday(refDate, offset, locale);\n    }\n    let date = (0, dayjs_1.default)(refDate).locale(\"en\", locale);\n    const weekStart = (_a = locale === null || locale === void 0 ? void 0 : locale.weekStart) !== null && _a !== void 0 ? _a : 0;\n    const weekdayOffset = (7 + offset - weekStart) % 7;\n    switch (modifier) {\n        case \"this\":\n            date = date.weekday(weekdayOffset);\n            break;\n        case \"next\":\n            date = date.weekday(weekdayOffset + 7);\n            break;\n        case \"last\":\n            date = date.weekday(weekdayOffset - 7);\n            break;\n    }\n    return date;\n}\nexports.toDayJSWeekday = toDayJSWeekday;\nfunction toDayJSClosestWeekday(refDate, offset, locale) {\n    var _a;\n    let date = (0, dayjs_1.default)(refDate).locale(\"en\", locale);\n    const refOffset = date.weekday();\n    const weekStart = (_a = locale === null || locale === void 0 ? void 0 : locale.weekStart) !== null && _a !== void 0 ? _a : 0;\n    const weekdayOffset = (7 + offset - weekStart) % 7;\n    if (Math.abs(weekdayOffset - 7 - refOffset) < Math.abs(weekdayOffset - refOffset)) {\n        date = date.weekday(weekdayOffset - 7);\n    }\n    else if (Math.abs(weekdayOffset + 7 - refOffset) < Math.abs(weekdayOffset - refOffset)) {\n        date = date.weekday(weekdayOffset + 7);\n    }\n    else {\n        date = date.weekday(weekdayOffset);\n    }\n    return date;\n}\nexports.toDayJSClosestWeekday = toDayJSClosestWeekday;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst weeks_1 = require(\"../../../calculation/weeks\");\nconst PATTERN = new RegExp(\"(?:(?:\\\\,|\\\\(|\\\\（)\\\\s*)?\" +\n    \"(?:on\\\\s*?)?\" +\n    \"(?:(this|last|past|next)\\\\s*)?\" +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.WEEKDAY_DICTIONARY)})` +\n    \"(?:\\\\s*(?:\\\\,|\\\\)|\\\\）))?\" +\n    \"(?:\\\\s*(this|last|past|next)\\\\s*week)?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst PREFIX_GROUP = 1;\nconst WEEKDAY_GROUP = 2;\nconst POSTFIX_GROUP = 3;\nclass ENWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();\n        const offset = constants_1.WEEKDAY_DICTIONARY[dayOfWeek];\n        const prefix = match[PREFIX_GROUP];\n        const postfix = match[POSTFIX_GROUP];\n        let modifierWord = prefix || postfix;\n        modifierWord = modifierWord || \"\";\n        modifierWord = modifierWord.toLowerCase();\n        let modifier = null;\n        if (modifierWord == \"last\" || modifierWord == \"past\") {\n            modifier = \"last\";\n        }\n        else if (modifierWord == \"next\") {\n            modifier = \"next\";\n        }\n        else if (modifierWord == \"this\") {\n            modifier = \"this\";\n        }\n        const date = (0, weeks_1.toDayJSWeekday)(context.refDate, offset, modifier, context.option.locale);\n        return context\n            .createParsingComponents()\n            .assign(\"weekday\", offset)\n            .imply(\"day\", date.date())\n            .imply(\"month\", date.month() + 1)\n            .imply(\"year\", date.year());\n    }\n}\nexports.default = ENWeekdayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst PATTERN = new RegExp(`(this|next|last|past)\\\\s*(${(0, pattern_1.matchAnyPattern)(constants_1.TIME_UNIT_DICTIONARY)})(?=\\\\s*)` + \"(?=\\\\W|$)\", \"i\");\nconst MODIFIER_WORD_GROUP = 1;\nconst RELATIVE_WORD_GROUP = 2;\nclass ENRelativeDateFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();\n        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();\n        const timeunit = constants_1.TIME_UNIT_DICTIONARY[unitWord];\n        if (modifier == \"next\") {\n            const timeUnits = {};\n            timeUnits[timeunit] = 1;\n            return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n        }\n        if (modifier == \"last\" || modifier == \"past\") {\n            const timeUnits = {};\n            timeUnits[timeunit] = -1;\n            return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n        }\n        const components = context.createParsingComponents();\n        let date = (0, dayjs_1.default)(context.reference.instant);\n        if (unitWord.match(/week/i)) {\n            date = date.add(-date.get(\"d\"), \"d\");\n            components.imply(\"day\", date.date());\n            components.imply(\"month\", date.month() + 1);\n            components.imply(\"year\", date.year());\n        }\n        else if (unitWord.match(/month/i)) {\n            date = date.add(-date.date() + 1, \"d\");\n            components.imply(\"day\", date.date());\n            components.assign(\"year\", date.year());\n            components.assign(\"month\", date.month() + 1);\n        }\n        else if (unitWord.match(/year/i)) {\n            date = date.add(-date.date() + 1, \"d\");\n            date = date.add(-date.month(), \"month\");\n            components.imply(\"day\", date.date());\n            components.imply(\"month\", date.month() + 1);\n            components.assign(\"year\", date.year());\n        }\n        return components;\n    }\n}\nexports.default = ENRelativeDateFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ParsingContext = exports.Chrono = void 0;\nconst results_1 = require(\"./results\");\nconst en_1 = require(\"./locales/en\");\nclass Chrono {\n    constructor(configuration) {\n        configuration = configuration || (0, en_1.createCasualConfiguration)();\n        this.parsers = [...configuration.parsers];\n        this.refiners = [...configuration.refiners];\n    }\n    clone() {\n        return new Chrono({\n            parsers: [...this.parsers],\n            refiners: [...this.refiners],\n        });\n    }\n    parseDate(text, referenceDate, option) {\n        const results = this.parse(text, referenceDate, option);\n        return results.length > 0 ? results[0].start.date() : null;\n    }\n    parse(text, referenceDate, option) {\n        const context = new ParsingContext(text, referenceDate, option);\n        let results = [];\n        this.parsers.forEach((parser) => {\n            const parsedResults = Chrono.executeParser(context, parser);\n            results = results.concat(parsedResults);\n        });\n        results.sort((a, b) => {\n            return a.index - b.index;\n        });\n        this.refiners.forEach(function (refiner) {\n            results = refiner.refine(context, results);\n        });\n        return results;\n    }\n    static executeParser(context, parser) {\n        const results = [];\n        const pattern = parser.pattern(context);\n        const originalText = context.text;\n        let remainingText = context.text;\n        let match = pattern.exec(remainingText);\n        while (match) {\n            const index = match.index + originalText.length - remainingText.length;\n            match.index = index;\n            const result = parser.extract(context, match);\n            if (!result) {\n                remainingText = originalText.substring(match.index + 1);\n                match = pattern.exec(remainingText);\n                continue;\n            }\n            let parsedResult = null;\n            if (result instanceof results_1.ParsingResult) {\n                parsedResult = result;\n            }\n            else if (result instanceof results_1.ParsingComponents) {\n                parsedResult = context.createParsingResult(match.index, match[0]);\n                parsedResult.start = result;\n            }\n            else {\n                parsedResult = context.createParsingResult(match.index, match[0], result);\n            }\n            context.debug(() => console.log(`${parser.constructor.name} extracted result ${parsedResult}`));\n            results.push(parsedResult);\n            remainingText = originalText.substring(index + parsedResult.text.length);\n            match = pattern.exec(remainingText);\n        }\n        return results;\n    }\n}\nexports.Chrono = Chrono;\nclass ParsingContext {\n    constructor(text, refDate, option) {\n        this.text = text;\n        this.reference = new results_1.ReferenceWithTimezone(refDate);\n        this.option = option !== null && option !== void 0 ? option : {};\n        this.refDate = this.reference.instant;\n    }\n    createParsingComponents(components) {\n        if (components instanceof results_1.ParsingComponents) {\n            return components;\n        }\n        return new results_1.ParsingComponents(this.reference, components);\n    }\n    createParsingResult(index, textOrEndIndex, startComponents, endComponents) {\n        const text = typeof textOrEndIndex === \"string\" ? textOrEndIndex : this.text.substring(index, textOrEndIndex);\n        const start = startComponents ? this.createParsingComponents(startComponents) : null;\n        const end = endComponents ? this.createParsingComponents(endComponents) : null;\n        return new results_1.ParsingResult(this.reference, index, text, start, end);\n    }\n    debug(block) {\n        if (this.option.debug) {\n            if (this.option.debug instanceof Function) {\n                this.option.debug(block);\n            }\n            else {\n                const handler = this.option.debug;\n                handler.debug(block);\n            }\n        }\n    }\n}\nexports.ParsingContext = ParsingContext;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../calculation/years\");\nconst PATTERN = new RegExp(\"([^\\\\d]|^)\" +\n    \"([0-3]{0,1}[0-9]{1})[\\\\/\\\\.\\\\-]([0-3]{0,1}[0-9]{1})\" +\n    \"(?:[\\\\/\\\\.\\\\-]([0-9]{4}|[0-9]{2}))?\" +\n    \"(\\\\W|$)\", \"i\");\nconst OPENING_GROUP = 1;\nconst ENDING_GROUP = 5;\nconst FIRST_NUMBERS_GROUP = 2;\nconst SECOND_NUMBERS_GROUP = 3;\nconst YEAR_GROUP = 4;\nclass SlashDateFormatParser {\n    constructor(littleEndian) {\n        this.groupNumberMonth = littleEndian ? SECOND_NUMBERS_GROUP : FIRST_NUMBERS_GROUP;\n        this.groupNumberDay = littleEndian ? FIRST_NUMBERS_GROUP : SECOND_NUMBERS_GROUP;\n    }\n    pattern() {\n        return PATTERN;\n    }\n    extract(context, match) {\n        if (match[OPENING_GROUP] == \"/\" || match[ENDING_GROUP] == \"/\") {\n            match.index += match[0].length;\n            return;\n        }\n        const index = match.index + match[OPENING_GROUP].length;\n        const text = match[0].substr(match[OPENING_GROUP].length, match[0].length - match[OPENING_GROUP].length - match[ENDING_GROUP].length);\n        if (text.match(/^\\d\\.\\d$/) || text.match(/^\\d\\.\\d{1,2}\\.\\d{1,2}\\s*$/)) {\n            return;\n        }\n        if (!match[YEAR_GROUP] && match[0].indexOf(\"/\") < 0) {\n            return;\n        }\n        const result = context.createParsingResult(index, text);\n        let month = parseInt(match[this.groupNumberMonth]);\n        let day = parseInt(match[this.groupNumberDay]);\n        if (month < 1 || month > 12) {\n            if (month > 12) {\n                if (day >= 1 && day <= 12 && month <= 31) {\n                    [day, month] = [month, day];\n                }\n                else {\n                    return null;\n                }\n            }\n        }\n        if (day < 1 || day > 31) {\n            return null;\n        }\n        result.start.assign(\"day\", day);\n        result.start.assign(\"month\", month);\n        if (match[YEAR_GROUP]) {\n            const rawYearNumber = parseInt(match[YEAR_GROUP]);\n            const year = (0, years_1.findMostLikelyADYear)(rawYearNumber);\n            result.start.assign(\"year\", year);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            result.start.imply(\"year\", year);\n        }\n        return result;\n    }\n}\nexports.default = SlashDateFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nconst PATTERN = new RegExp(`(this|last|past|next|\\\\+|-)\\\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\\\W|$)`, \"i\");\nclass ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const prefix = match[1].toLowerCase();\n        let timeUnits = (0, constants_1.parseTimeUnits)(match[2]);\n        switch (prefix) {\n            case \"last\":\n            case \"past\":\n            case \"-\":\n                timeUnits = (0, timeunits_1.reverseTimeUnits)(timeUnits);\n                break;\n        }\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n    }\n}\nexports.default = ENTimeUnitCasualRelativeFormatParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.GB = exports.strict = exports.casual = void 0;\nconst ENTimeUnitWithinFormatParser_1 = __importDefault(require(\"./parsers/ENTimeUnitWithinFormatParser\"));\nconst ENMonthNameLittleEndianParser_1 = __importDefault(require(\"./parsers/ENMonthNameLittleEndianParser\"));\nconst ENMonthNameMiddleEndianParser_1 = __importDefault(require(\"./parsers/ENMonthNameMiddleEndianParser\"));\nconst ENMonthNameParser_1 = __importDefault(require(\"./parsers/ENMonthNameParser\"));\nconst ENCasualYearMonthDayParser_1 = __importDefault(require(\"./parsers/ENCasualYearMonthDayParser\"));\nconst ENSlashMonthFormatParser_1 = __importDefault(require(\"./parsers/ENSlashMonthFormatParser\"));\nconst ENTimeExpressionParser_1 = __importDefault(require(\"./parsers/ENTimeExpressionParser\"));\nconst ENTimeUnitAgoFormatParser_1 = __importDefault(require(\"./parsers/ENTimeUnitAgoFormatParser\"));\nconst ENTimeUnitLaterFormatParser_1 = __importDefault(require(\"./parsers/ENTimeUnitLaterFormatParser\"));\nconst ENMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/ENMergeDateRangeRefiner\"));\nconst ENMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/ENMergeDateTimeRefiner\"));\nconst configurations_1 = require(\"../../configurations\");\nconst ENCasualDateParser_1 = __importDefault(require(\"./parsers/ENCasualDateParser\"));\nconst ENCasualTimeParser_1 = __importDefault(require(\"./parsers/ENCasualTimeParser\"));\nconst ENWeekdayParser_1 = __importDefault(require(\"./parsers/ENWeekdayParser\"));\nconst ENRelativeDateFormatParser_1 = __importDefault(require(\"./parsers/ENRelativeDateFormatParser\"));\nconst chrono_1 = require(\"../../chrono\");\nconst SlashDateFormatParser_1 = __importDefault(require(\"../../common/parsers/SlashDateFormatParser\"));\nconst ENTimeUnitCasualRelativeFormatParser_1 = __importDefault(require(\"./parsers/ENTimeUnitCasualRelativeFormatParser\"));\nexports.casual = new chrono_1.Chrono(createCasualConfiguration(false));\nexports.strict = new chrono_1.Chrono(createConfiguration(true, false));\nexports.GB = new chrono_1.Chrono(createConfiguration(false, true));\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration(littleEndian = false) {\n    const option = createConfiguration(false, littleEndian);\n    option.parsers.unshift(new ENCasualDateParser_1.default());\n    option.parsers.unshift(new ENCasualTimeParser_1.default());\n    option.parsers.unshift(new ENMonthNameParser_1.default());\n    option.parsers.unshift(new ENRelativeDateFormatParser_1.default());\n    option.parsers.unshift(new ENTimeUnitCasualRelativeFormatParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration(strictMode = true, littleEndian = false) {\n    return (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new SlashDateFormatParser_1.default(littleEndian),\n            new ENTimeUnitWithinFormatParser_1.default(),\n            new ENMonthNameLittleEndianParser_1.default(),\n            new ENMonthNameMiddleEndianParser_1.default(),\n            new ENWeekdayParser_1.default(),\n            new ENCasualYearMonthDayParser_1.default(),\n            new ENSlashMonthFormatParser_1.default(),\n            new ENTimeExpressionParser_1.default(strictMode),\n            new ENTimeUnitAgoFormatParser_1.default(strictMode),\n            new ENTimeUnitLaterFormatParser_1.default(strictMode),\n        ],\n        refiners: [new ENMergeDateTimeRefiner_1.default(), new ENMergeDateRangeRefiner_1.default()],\n    }, strictMode);\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractTimeExpressionParser_1 = require(\"../../../common/parsers/AbstractTimeExpressionParser\");\nconst index_1 = require(\"../../../index\");\nclass DETimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {\n    primaryPrefix() {\n        return \"(?:(?:um|von)\\\\s*)?\";\n    }\n    followingPhase() {\n        return \"\\\\s*(?:\\\\-|\\\\–|\\\\~|\\\\〜|bis)\\\\s*\";\n    }\n    primarySuffix() {\n        return \"(?:\\\\s*uhr)?(?:\\\\s*(?:morgens|vormittags|nachmittags|abends|nachts))?(?=\\\\W|$)\";\n    }\n    extractPrimaryTimeComponents(context, match) {\n        const components = super.extractPrimaryTimeComponents(context, match);\n        if (components) {\n            if (match[0].endsWith(\"morgens\") || match[0].endsWith(\"vormittags\")) {\n                components.assign(\"meridiem\", index_1.Meridiem.AM);\n                const hour = components.get(\"hour\");\n                if (hour < 12) {\n                    components.assign(\"hour\", components.get(\"hour\"));\n                }\n            }\n            if (match[0].endsWith(\"nachmittags\") || match[0].endsWith(\"abends\") || match[0].endsWith(\"nachts\")) {\n                components.assign(\"meridiem\", index_1.Meridiem.PM);\n                const hour = components.get(\"hour\");\n                if (hour < 12) {\n                    components.assign(\"hour\", components.get(\"hour\") + 12);\n                }\n            }\n        }\n        return components;\n    }\n}\nexports.default = DETimeExpressionParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst pattern_1 = require(\"../../utils/pattern\");\nconst years_1 = require(\"../../calculation/years\");\nexports.WEEKDAY_DICTIONARY = {\n    \"sonntag\": 0,\n    \"so\": 0,\n    \"montag\": 1,\n    \"mo\": 1,\n    \"dienstag\": 2,\n    \"di\": 2,\n    \"mittwoch\": 3,\n    \"mi\": 3,\n    \"donnerstag\": 4,\n    \"do\": 4,\n    \"freitag\": 5,\n    \"fr\": 5,\n    \"samstag\": 6,\n    \"sa\": 6,\n};\nexports.MONTH_DICTIONARY = {\n    \"januar\": 1,\n    \"jan\": 1,\n    \"jan.\": 1,\n    \"februar\": 2,\n    \"feb\": 2,\n    \"feb.\": 2,\n    \"märz\": 3,\n    \"maerz\": 3,\n    \"mär\": 3,\n    \"mär.\": 3,\n    \"mrz\": 3,\n    \"mrz.\": 3,\n    \"april\": 4,\n    \"apr\": 4,\n    \"apr.\": 4,\n    \"mai\": 5,\n    \"juni\": 6,\n    \"jun\": 6,\n    \"jun.\": 6,\n    \"juli\": 7,\n    \"jul\": 7,\n    \"jul.\": 7,\n    \"august\": 8,\n    \"aug\": 8,\n    \"aug.\": 8,\n    \"september\": 9,\n    \"sep\": 9,\n    \"sep.\": 9,\n    \"sept\": 9,\n    \"sept.\": 9,\n    \"oktober\": 10,\n    \"okt\": 10,\n    \"okt.\": 10,\n    \"november\": 11,\n    \"nov\": 11,\n    \"nov.\": 11,\n    \"dezember\": 12,\n    \"dez\": 12,\n    \"dez.\": 12,\n};\nexports.INTEGER_WORD_DICTIONARY = {\n    \"eins\": 1,\n    \"zwei\": 2,\n    \"drei\": 3,\n    \"vier\": 4,\n    \"fünf\": 5,\n    \"fuenf\": 5,\n    \"sechs\": 6,\n    \"sieben\": 7,\n    \"acht\": 8,\n    \"neun\": 9,\n    \"zehn\": 10,\n    \"elf\": 11,\n    \"zwölf\": 12,\n    \"zwoelf\": 12,\n};\nexports.TIME_UNIT_DICTIONARY = {\n    sec: \"second\",\n    second: \"second\",\n    seconds: \"second\",\n    min: \"minute\",\n    mins: \"minute\",\n    minute: \"minute\",\n    minutes: \"minute\",\n    h: \"hour\",\n    hr: \"hour\",\n    hrs: \"hour\",\n    hour: \"hour\",\n    hours: \"hour\",\n    day: \"d\",\n    days: \"d\",\n    week: \"week\",\n    weeks: \"week\",\n    month: \"month\",\n    months: \"month\",\n    y: \"year\",\n    yr: \"year\",\n    year: \"year\",\n    years: \"year\",\n};\nexports.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)?)`;\nfunction parseNumberPattern(match) {\n    const num = match.toLowerCase();\n    if (exports.INTEGER_WORD_DICTIONARY[num] !== undefined) {\n        return exports.INTEGER_WORD_DICTIONARY[num];\n    }\n    else if (num === \"a\" || num === \"an\") {\n        return 1;\n    }\n    else if (num.match(/few/)) {\n        return 3;\n    }\n    else if (num.match(/half/)) {\n        return 0.5;\n    }\n    else if (num.match(/couple/)) {\n        return 2;\n    }\n    else if (num.match(/several/)) {\n        return 7;\n    }\n    return parseFloat(num);\n}\nexports.parseNumberPattern = parseNumberPattern;\nexports.YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\\\s*[vn]\\\\.?\\\\s*C(?:hr)?\\\\.?)?)`;\nfunction parseYear(match) {\n    if (/v/i.test(match)) {\n        return -parseInt(match.replace(/[^0-9]+/gi, \"\"));\n    }\n    if (/n/i.test(match)) {\n        return parseInt(match.replace(/[^0-9]+/gi, \"\"));\n    }\n    const rawYearNumber = parseInt(match);\n    return (0, years_1.findMostLikelyADYear)(rawYearNumber);\n}\nexports.parseYear = parseYear;\nconst SINGLE_TIME_UNIT_PATTERN = `(${exports.NUMBER_PATTERN})\\\\s{0,5}(${(0, pattern_1.matchAnyPattern)(exports.TIME_UNIT_DICTIONARY)})\\\\s{0,5}`;\nconst SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, \"i\");\nexports.TIME_UNITS_PATTERN = (0, pattern_1.repeatedTimeunitPattern)(\"\", SINGLE_TIME_UNIT_PATTERN);\nfunction parseTimeUnits(timeunitText) {\n    const fragments = {};\n    let remainingText = timeunitText;\n    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    while (match) {\n        collectDateTimeFragment(fragments, match);\n        remainingText = remainingText.substring(match[0].length);\n        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    }\n    return fragments;\n}\nexports.parseTimeUnits = parseTimeUnits;\nfunction collectDateTimeFragment(fragments, match) {\n    const num = parseNumberPattern(match[1]);\n    const unit = exports.TIME_UNIT_DICTIONARY[match[2].toLowerCase()];\n    fragments[unit] = num;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst weeks_1 = require(\"../../../calculation/weeks\");\nconst PATTERN = new RegExp(\"(?:(?:\\\\,|\\\\(|\\\\（)\\\\s*)?\" +\n    \"(?:a[mn]\\\\s*?)?\" +\n    \"(?:(diese[mn]|letzte[mn]|n(?:ä|ae)chste[mn])\\\\s*)?\" +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.WEEKDAY_DICTIONARY)})` +\n    \"(?:\\\\s*(?:\\\\,|\\\\)|\\\\）))?\" +\n    \"(?:\\\\s*(diese|letzte|n(?:ä|ae)chste)\\\\s*woche)?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst PREFIX_GROUP = 1;\nconst SUFFIX_GROUP = 3;\nconst WEEKDAY_GROUP = 2;\nclass DEWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();\n        const offset = constants_1.WEEKDAY_DICTIONARY[dayOfWeek];\n        const prefix = match[PREFIX_GROUP];\n        const postfix = match[SUFFIX_GROUP];\n        let modifierWord = prefix || postfix;\n        modifierWord = modifierWord || \"\";\n        modifierWord = modifierWord.toLowerCase();\n        let modifier = null;\n        if (modifierWord.match(/letzte/)) {\n            modifier = \"last\";\n        }\n        else if (modifierWord.match(/chste/)) {\n            modifier = \"next\";\n        }\n        else if (modifierWord.match(/diese/)) {\n            modifier = \"this\";\n        }\n        const date = (0, weeks_1.toDayJSWeekday)(context.refDate, offset, modifier);\n        return context\n            .createParsingComponents()\n            .assign(\"weekday\", offset)\n            .imply(\"day\", date.date())\n            .imply(\"month\", date.month() + 1)\n            .imply(\"year\", date.year());\n    }\n}\nexports.default = DEWeekdayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass DEMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(bis(?:\\s*(?:am|zum))?|-)\\s*$/i;\n    }\n}\nexports.default = DEMergeDateRangeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass DEMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return new RegExp(\"^\\\\s*(T|um|am|,|-)?\\\\s*$\");\n    }\n}\nexports.default = DEMergeDateTimeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst index_1 = require(\"../../../index\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_2 = require(\"../../../utils/dayjs\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nclass DECasualTimeParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return /(diesen)?\\s*(morgen|vormittag|mittags?|nachmittag|abend|nacht|mitternacht)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const targetDate = (0, dayjs_1.default)(context.refDate);\n        const timeKeywordPattern = match[2].toLowerCase();\n        const component = context.createParsingComponents();\n        (0, dayjs_2.implySimilarTime)(component, targetDate);\n        return DECasualTimeParser.extractTimeComponents(component, timeKeywordPattern);\n    }\n    static extractTimeComponents(component, timeKeywordPattern) {\n        switch (timeKeywordPattern) {\n            case \"morgen\":\n                component.imply(\"hour\", 6);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n            case \"vormittag\":\n                component.imply(\"hour\", 9);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n            case \"mittag\":\n            case \"mittags\":\n                component.imply(\"hour\", 12);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n            case \"nachmittag\":\n                component.imply(\"hour\", 15);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                break;\n            case \"abend\":\n                component.imply(\"hour\", 18);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                break;\n            case \"nacht\":\n                component.imply(\"hour\", 22);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                break;\n            case \"mitternacht\":\n                if (component.get(\"hour\") > 1) {\n                    component = (0, timeunits_1.addImpliedTimeUnits)(component, { \"day\": 1 });\n                }\n                component.imply(\"hour\", 0);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n        }\n        return component;\n    }\n}\nexports.default = DECasualTimeParser;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_2 = require(\"../../../utils/dayjs\");\nconst DECasualTimeParser_1 = __importDefault(require(\"./DECasualTimeParser\"));\nconst references = __importStar(require(\"../../../common/casualReferences\"));\nconst PATTERN = new RegExp(`(jetzt|heute|morgen|übermorgen|uebermorgen|gestern|vorgestern|letzte\\\\s*nacht)` +\n    `(?:\\\\s*(morgen|vormittag|mittags?|nachmittag|abend|nacht|mitternacht))?` +\n    `(?=\\\\W|$)`, \"i\");\nconst DATE_GROUP = 1;\nconst TIME_GROUP = 2;\nclass DECasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        let targetDate = (0, dayjs_1.default)(context.refDate);\n        const dateKeyword = (match[DATE_GROUP] || \"\").toLowerCase();\n        const timeKeyword = (match[TIME_GROUP] || \"\").toLowerCase();\n        let component = context.createParsingComponents();\n        switch (dateKeyword) {\n            case \"jetzt\":\n                component = references.now(context.reference);\n                break;\n            case \"heute\":\n                component = references.today(context.reference);\n                break;\n            case \"morgen\":\n                (0, dayjs_2.assignTheNextDay)(component, targetDate);\n                break;\n            case \"übermorgen\":\n            case \"uebermorgen\":\n                targetDate = targetDate.add(1, \"day\");\n                (0, dayjs_2.assignTheNextDay)(component, targetDate);\n                break;\n            case \"gestern\":\n                targetDate = targetDate.add(-1, \"day\");\n                (0, dayjs_2.assignSimilarDate)(component, targetDate);\n                (0, dayjs_2.implySimilarTime)(component, targetDate);\n                break;\n            case \"vorgestern\":\n                targetDate = targetDate.add(-2, \"day\");\n                (0, dayjs_2.assignSimilarDate)(component, targetDate);\n                (0, dayjs_2.implySimilarTime)(component, targetDate);\n                break;\n            default:\n                if (dateKeyword.match(/letzte\\s*nacht/)) {\n                    if (targetDate.hour() > 6) {\n                        targetDate = targetDate.add(-1, \"day\");\n                    }\n                    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n                    component.imply(\"hour\", 0);\n                }\n                break;\n        }\n        if (timeKeyword) {\n            component = DECasualTimeParser_1.default.extractTimeComponents(component, timeKeyword);\n        }\n        return component;\n    }\n}\nexports.default = DECasualDateParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../../calculation/years\");\nconst constants_1 = require(\"../constants\");\nconst constants_2 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"(?:am\\\\s*?)?\" +\n    \"(?:den\\\\s*?)?\" +\n    `([0-9]{1,2})\\\\.` +\n    `(?:\\\\s*(?:bis(?:\\\\s*(?:am|zum))?|\\\\-|\\\\–|\\\\s)\\\\s*([0-9]{1,2})\\\\.?)?\\\\s*` +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    `(?:(?:-|/|,?\\\\s*)(${constants_2.YEAR_PATTERN}(?![^\\\\s]\\\\d)))?` +\n    `(?=\\\\W|$)`, \"i\");\nconst DATE_GROUP = 1;\nconst DATE_TO_GROUP = 2;\nconst MONTH_NAME_GROUP = 3;\nconst YEAR_GROUP = 4;\nclass DEMonthNameLittleEndianParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const month = constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        const day = parseInt(match[DATE_GROUP]);\n        if (day > 31) {\n            match.index = match.index + match[DATE_GROUP].length;\n            return null;\n        }\n        result.start.assign(\"month\", month);\n        result.start.assign(\"day\", day);\n        if (match[YEAR_GROUP]) {\n            const yearNumber = (0, constants_2.parseYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", yearNumber);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            result.start.imply(\"year\", year);\n        }\n        if (match[DATE_TO_GROUP]) {\n            const endDate = parseInt(match[DATE_TO_GROUP]);\n            result.end = result.start.clone();\n            result.end.assign(\"day\", endDate);\n        }\n        return result;\n    }\n}\nexports.default = DEMonthNameLittleEndianParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = void 0;\nconst configurations_1 = require(\"../../configurations\");\nconst chrono_1 = require(\"../../chrono\");\nconst SlashDateFormatParser_1 = __importDefault(require(\"../../common/parsers/SlashDateFormatParser\"));\nconst ISOFormatParser_1 = __importDefault(require(\"../../common/parsers/ISOFormatParser\"));\nconst DETimeExpressionParser_1 = __importDefault(require(\"./parsers/DETimeExpressionParser\"));\nconst DEWeekdayParser_1 = __importDefault(require(\"./parsers/DEWeekdayParser\"));\nconst DEMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/DEMergeDateRangeRefiner\"));\nconst DEMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/DEMergeDateTimeRefiner\"));\nconst DECasualDateParser_1 = __importDefault(require(\"./parsers/DECasualDateParser\"));\nconst DECasualTimeParser_1 = __importDefault(require(\"./parsers/DECasualTimeParser\"));\nconst DEMonthNameLittleEndianParser_1 = __importDefault(require(\"./parsers/DEMonthNameLittleEndianParser\"));\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration(true));\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration(littleEndian = true) {\n    const option = createConfiguration(false, littleEndian);\n    option.parsers.unshift(new DECasualTimeParser_1.default());\n    option.parsers.unshift(new DECasualDateParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration(strictMode = true, littleEndian = true) {\n    return (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new ISOFormatParser_1.default(),\n            new SlashDateFormatParser_1.default(littleEndian),\n            new DETimeExpressionParser_1.default(),\n            new DEMonthNameLittleEndianParser_1.default(),\n            new DEWeekdayParser_1.default(),\n        ],\n        refiners: [new DEMergeDateRangeRefiner_1.default(), new DEMergeDateTimeRefiner_1.default()],\n    }, strictMode);\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst index_1 = require(\"../../../index\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_2 = require(\"../../../utils/dayjs\");\nconst references = __importStar(require(\"../../../common/casualReferences\"));\nclass FRCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return /(maintenant|aujourd'hui|demain|hier|cette\\s*nuit|la\\s*veille)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        let targetDate = (0, dayjs_1.default)(context.refDate);\n        const lowerText = match[0].toLowerCase();\n        const component = context.createParsingComponents();\n        switch (lowerText) {\n            case \"maintenant\":\n                return references.now(context.reference);\n            case \"aujourd'hui\":\n                return references.today(context.reference);\n            case \"hier\":\n                return references.yesterday(context.reference);\n            case \"demain\":\n                return references.tomorrow(context.reference);\n            default:\n                if (lowerText.match(/cette\\s*nuit/)) {\n                    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n                    component.imply(\"hour\", 22);\n                    component.imply(\"meridiem\", index_1.Meridiem.PM);\n                }\n                else if (lowerText.match(/la\\s*veille/)) {\n                    targetDate = targetDate.add(-1, \"day\");\n                    (0, dayjs_2.assignSimilarDate)(component, targetDate);\n                    component.imply(\"hour\", 0);\n                }\n        }\n        return component;\n    }\n}\nexports.default = FRCasualDateParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst index_1 = require(\"../../../index\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nclass FRCasualTimeParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return /(cet?)?\\s*(matin|soir|après-midi|aprem|a midi|à minuit)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const suffixLower = match[2].toLowerCase();\n        const component = context.createParsingComponents();\n        switch (suffixLower) {\n            case \"après-midi\":\n            case \"aprem\":\n                component.imply(\"hour\", 14);\n                component.imply(\"minute\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                break;\n            case \"soir\":\n                component.imply(\"hour\", 18);\n                component.imply(\"minute\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                break;\n            case \"matin\":\n                component.imply(\"hour\", 8);\n                component.imply(\"minute\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n            case \"a midi\":\n                component.imply(\"hour\", 12);\n                component.imply(\"minute\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n            case \"à minuit\":\n                component.imply(\"hour\", 0);\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                break;\n        }\n        return component;\n    }\n}\nexports.default = FRCasualTimeParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractTimeExpressionParser_1 = require(\"../../../common/parsers/AbstractTimeExpressionParser\");\nclass FRTimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {\n    primaryPrefix() {\n        return \"(?:(?:[àa])\\\\s*)?\";\n    }\n    followingPhase() {\n        return \"\\\\s*(?:\\\\-|\\\\–|\\\\~|\\\\〜|[àa]|\\\\?)\\\\s*\";\n    }\n    extractPrimaryTimeComponents(context, match) {\n        if (match[0].match(/^\\s*\\d{4}\\s*$/)) {\n            return null;\n        }\n        return super.extractPrimaryTimeComponents(context, match);\n    }\n}\nexports.default = FRTimeExpressionParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass FRMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return new RegExp(\"^\\\\s*(T|à|a|vers|de|,|-)?\\\\s*$\");\n    }\n}\nexports.default = FRMergeDateTimeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass FRMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(à|a|-)\\s*$/i;\n    }\n}\nexports.default = FRMergeDateRangeRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst pattern_1 = require(\"../../utils/pattern\");\nexports.WEEKDAY_DICTIONARY = {\n    \"dimanche\": 0,\n    \"dim\": 0,\n    \"lundi\": 1,\n    \"lun\": 1,\n    \"mardi\": 2,\n    \"mar\": 2,\n    \"mercredi\": 3,\n    \"mer\": 3,\n    \"jeudi\": 4,\n    \"jeu\": 4,\n    \"vendredi\": 5,\n    \"ven\": 5,\n    \"samedi\": 6,\n    \"sam\": 6,\n};\nexports.MONTH_DICTIONARY = {\n    \"janvier\": 1,\n    \"jan\": 1,\n    \"jan.\": 1,\n    \"février\": 2,\n    \"fév\": 2,\n    \"fév.\": 2,\n    \"fevrier\": 2,\n    \"fev\": 2,\n    \"fev.\": 2,\n    \"mars\": 3,\n    \"mar\": 3,\n    \"mar.\": 3,\n    \"avril\": 4,\n    \"avr\": 4,\n    \"avr.\": 4,\n    \"mai\": 5,\n    \"juin\": 6,\n    \"jun\": 6,\n    \"juillet\": 7,\n    \"juil\": 7,\n    \"jul\": 7,\n    \"jul.\": 7,\n    \"août\": 8,\n    \"aout\": 8,\n    \"septembre\": 9,\n    \"sep\": 9,\n    \"sep.\": 9,\n    \"sept\": 9,\n    \"sept.\": 9,\n    \"octobre\": 10,\n    \"oct\": 10,\n    \"oct.\": 10,\n    \"novembre\": 11,\n    \"nov\": 11,\n    \"nov.\": 11,\n    \"décembre\": 12,\n    \"decembre\": 12,\n    \"dec\": 12,\n    \"dec.\": 12,\n};\nexports.INTEGER_WORD_DICTIONARY = {\n    \"un\": 1,\n    \"deux\": 2,\n    \"trois\": 3,\n    \"quatre\": 4,\n    \"cinq\": 5,\n    \"six\": 6,\n    \"sept\": 7,\n    \"huit\": 8,\n    \"neuf\": 9,\n    \"dix\": 10,\n    \"onze\": 11,\n    \"douze\": 12,\n    \"treize\": 13,\n};\nexports.TIME_UNIT_DICTIONARY = {\n    \"sec\": \"second\",\n    \"seconde\": \"second\",\n    \"secondes\": \"second\",\n    \"min\": \"minute\",\n    \"mins\": \"minute\",\n    \"minute\": \"minute\",\n    \"minutes\": \"minute\",\n    \"h\": \"hour\",\n    \"hr\": \"hour\",\n    \"hrs\": \"hour\",\n    \"heure\": \"hour\",\n    \"heures\": \"hour\",\n    \"jour\": \"d\",\n    \"jours\": \"d\",\n    \"semaine\": \"week\",\n    \"semaines\": \"week\",\n    \"mois\": \"month\",\n    \"trimestre\": \"quarter\",\n    \"trimestres\": \"quarter\",\n    \"ans\": \"year\",\n    \"année\": \"year\",\n    \"années\": \"year\",\n};\nexports.NUMBER_PATTERN = `(?:${(0, pattern_1.matchAnyPattern)(exports.INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\\\.[0-9]+|une?\\\\b|quelques?|demi-?)`;\nfunction parseNumberPattern(match) {\n    const num = match.toLowerCase();\n    if (exports.INTEGER_WORD_DICTIONARY[num] !== undefined) {\n        return exports.INTEGER_WORD_DICTIONARY[num];\n    }\n    else if (num === \"une\" || num === \"un\") {\n        return 1;\n    }\n    else if (num.match(/quelques?/)) {\n        return 3;\n    }\n    else if (num.match(/demi-?/)) {\n        return 0.5;\n    }\n    return parseFloat(num);\n}\nexports.parseNumberPattern = parseNumberPattern;\nexports.ORDINAL_NUMBER_PATTERN = `(?:[0-9]{1,2}(?:er)?)`;\nfunction parseOrdinalNumberPattern(match) {\n    let num = match.toLowerCase();\n    num = num.replace(/(?:er)$/i, \"\");\n    return parseInt(num);\n}\nexports.parseOrdinalNumberPattern = parseOrdinalNumberPattern;\nexports.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])`;\nfunction parseYear(match) {\n    if (/AC/i.test(match)) {\n        match = match.replace(/BC/i, \"\");\n        return -parseInt(match);\n    }\n    if (/AD/i.test(match) || /C/i.test(match)) {\n        match = match.replace(/[^\\d]+/i, \"\");\n        return parseInt(match);\n    }\n    let yearNumber = parseInt(match);\n    if (yearNumber < 100) {\n        if (yearNumber > 50) {\n            yearNumber = yearNumber + 1900;\n        }\n        else {\n            yearNumber = yearNumber + 2000;\n        }\n    }\n    return yearNumber;\n}\nexports.parseYear = parseYear;\nconst SINGLE_TIME_UNIT_PATTERN = `(${exports.NUMBER_PATTERN})\\\\s{0,5}(${(0, pattern_1.matchAnyPattern)(exports.TIME_UNIT_DICTIONARY)})\\\\s{0,5}`;\nconst SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, \"i\");\nexports.TIME_UNITS_PATTERN = (0, pattern_1.repeatedTimeunitPattern)(\"\", SINGLE_TIME_UNIT_PATTERN);\nfunction parseTimeUnits(timeunitText) {\n    const fragments = {};\n    let remainingText = timeunitText;\n    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    while (match) {\n        collectDateTimeFragment(fragments, match);\n        remainingText = remainingText.substring(match[0].length);\n        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    }\n    return fragments;\n}\nexports.parseTimeUnits = parseTimeUnits;\nfunction collectDateTimeFragment(fragments, match) {\n    const num = parseNumberPattern(match[1]);\n    const unit = exports.TIME_UNIT_DICTIONARY[match[2].toLowerCase()];\n    fragments[unit] = num;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst weeks_1 = require(\"../../../calculation/weeks\");\nconst PATTERN = new RegExp(\"(?:(?:\\\\,|\\\\(|\\\\（)\\\\s*)?\" +\n    \"(?:(?:ce)\\\\s*)?\" +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.WEEKDAY_DICTIONARY)})` +\n    \"(?:\\\\s*(?:\\\\,|\\\\)|\\\\）))?\" +\n    \"(?:\\\\s*(dernier|prochain)\\\\s*)?\" +\n    \"(?=\\\\W|\\\\d|$)\", \"i\");\nconst WEEKDAY_GROUP = 1;\nconst POSTFIX_GROUP = 2;\nclass FRWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();\n        const offset = constants_1.WEEKDAY_DICTIONARY[dayOfWeek];\n        if (offset === undefined) {\n            return null;\n        }\n        let suffix = match[POSTFIX_GROUP];\n        suffix = suffix || \"\";\n        suffix = suffix.toLowerCase();\n        let modifier = null;\n        if (suffix == \"dernier\") {\n            modifier = \"last\";\n        }\n        else if (suffix == \"prochain\") {\n            modifier = \"next\";\n        }\n        const date = (0, weeks_1.toDayJSWeekday)(context.refDate, offset, modifier);\n        return context\n            .createParsingComponents()\n            .assign(\"weekday\", offset)\n            .imply(\"day\", date.date())\n            .imply(\"month\", date.month() + 1)\n            .imply(\"year\", date.year());\n    }\n}\nexports.default = FRWeekdayParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst index_1 = require(\"../../../index\");\nconst FIRST_REG_PATTERN = new RegExp(\"(^|\\\\s|T)\" +\n    \"(?:(?:[àa])\\\\s*)?\" +\n    \"(\\\\d{1,2})(?:h|:)?\" +\n    \"(?:(\\\\d{1,2})(?:m|:)?)?\" +\n    \"(?:(\\\\d{1,2})(?:s|:)?)?\" +\n    \"(?:\\\\s*(A\\\\.M\\\\.|P\\\\.M\\\\.|AM?|PM?))?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst SECOND_REG_PATTERN = new RegExp(\"^\\\\s*(\\\\-|\\\\–|\\\\~|\\\\〜|[àa]|\\\\?)\\\\s*\" +\n    \"(\\\\d{1,2})(?:h|:)?\" +\n    \"(?:(\\\\d{1,2})(?:m|:)?)?\" +\n    \"(?:(\\\\d{1,2})(?:s|:)?)?\" +\n    \"(?:\\\\s*(A\\\\.M\\\\.|P\\\\.M\\\\.|AM?|PM?))?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst HOUR_GROUP = 2;\nconst MINUTE_GROUP = 3;\nconst SECOND_GROUP = 4;\nconst AM_PM_HOUR_GROUP = 5;\nclass FRSpecificTimeExpressionParser {\n    pattern(context) {\n        return FIRST_REG_PATTERN;\n    }\n    extract(context, match) {\n        const result = context.createParsingResult(match.index + match[1].length, match[0].substring(match[1].length));\n        if (result.text.match(/^\\d{4}$/)) {\n            match.index += match[0].length;\n            return null;\n        }\n        result.start = FRSpecificTimeExpressionParser.extractTimeComponent(result.start.clone(), match);\n        if (!result.start) {\n            match.index += match[0].length;\n            return null;\n        }\n        const remainingText = context.text.substring(match.index + match[0].length);\n        const secondMatch = SECOND_REG_PATTERN.exec(remainingText);\n        if (secondMatch) {\n            result.end = FRSpecificTimeExpressionParser.extractTimeComponent(result.start.clone(), secondMatch);\n            if (result.end) {\n                result.text += secondMatch[0];\n            }\n        }\n        return result;\n    }\n    static extractTimeComponent(extractingComponents, match) {\n        let hour = 0;\n        let minute = 0;\n        let meridiem = null;\n        hour = parseInt(match[HOUR_GROUP]);\n        if (match[MINUTE_GROUP] != null) {\n            minute = parseInt(match[MINUTE_GROUP]);\n        }\n        if (minute >= 60 || hour > 24) {\n            return null;\n        }\n        if (hour >= 12) {\n            meridiem = index_1.Meridiem.PM;\n        }\n        if (match[AM_PM_HOUR_GROUP] != null) {\n            if (hour > 12)\n                return null;\n            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = index_1.Meridiem.AM;\n                if (hour == 12) {\n                    hour = 0;\n                }\n            }\n            if (ampm == \"p\") {\n                meridiem = index_1.Meridiem.PM;\n                if (hour != 12) {\n                    hour += 12;\n                }\n            }\n        }\n        extractingComponents.assign(\"hour\", hour);\n        extractingComponents.assign(\"minute\", minute);\n        if (meridiem !== null) {\n            extractingComponents.assign(\"meridiem\", meridiem);\n        }\n        else {\n            if (hour < 12) {\n                extractingComponents.imply(\"meridiem\", index_1.Meridiem.AM);\n            }\n            else {\n                extractingComponents.imply(\"meridiem\", index_1.Meridiem.PM);\n            }\n        }\n        if (match[SECOND_GROUP] != null) {\n            const second = parseInt(match[SECOND_GROUP]);\n            if (second >= 60)\n                return null;\n            extractingComponents.assign(\"second\", second);\n        }\n        return extractingComponents;\n    }\n}\nexports.default = FRSpecificTimeExpressionParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../../calculation/years\");\nconst constants_1 = require(\"../constants\");\nconst constants_2 = require(\"../constants\");\nconst constants_3 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"(?:on\\\\s*?)?\" +\n    `(${constants_3.ORDINAL_NUMBER_PATTERN})` +\n    `(?:\\\\s*(?:au|\\\\-|\\\\–|jusqu'au?|\\\\s)\\\\s*(${constants_3.ORDINAL_NUMBER_PATTERN}))?` +\n    `(?:-|/|\\\\s*(?:de)?\\\\s*)` +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    `(?:(?:-|/|,?\\\\s*)(${constants_2.YEAR_PATTERN}(?![^\\\\s]\\\\d)))?` +\n    `(?=\\\\W|$)`, \"i\");\nconst DATE_GROUP = 1;\nconst DATE_TO_GROUP = 2;\nconst MONTH_NAME_GROUP = 3;\nconst YEAR_GROUP = 4;\nclass FRMonthNameLittleEndianParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const month = constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        const day = (0, constants_3.parseOrdinalNumberPattern)(match[DATE_GROUP]);\n        if (day > 31) {\n            match.index = match.index + match[DATE_GROUP].length;\n            return null;\n        }\n        result.start.assign(\"month\", month);\n        result.start.assign(\"day\", day);\n        if (match[YEAR_GROUP]) {\n            const yearNumber = (0, constants_2.parseYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", yearNumber);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            result.start.imply(\"year\", year);\n        }\n        if (match[DATE_TO_GROUP]) {\n            const endDate = (0, constants_3.parseOrdinalNumberPattern)(match[DATE_TO_GROUP]);\n            result.end = result.start.clone();\n            result.end.assign(\"day\", endDate);\n        }\n        return result;\n    }\n}\nexports.default = FRMonthNameLittleEndianParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nclass FRTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    constructor() {\n        super();\n    }\n    innerPattern() {\n        return new RegExp(`il y a\\\\s*(${constants_1.TIME_UNITS_PATTERN})(?=(?:\\\\W|$))`, \"i\");\n    }\n    innerExtract(context, match) {\n        const timeUnits = (0, constants_1.parseTimeUnits)(match[1]);\n        const outputTimeUnits = (0, timeunits_1.reverseTimeUnits)(timeUnits);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);\n    }\n}\nexports.default = FRTimeUnitAgoFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nclass FRTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return new RegExp(`(?:dans|en|pour|pendant)\\\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\\\W|$)`, \"i\");\n    }\n    innerExtract(context, match) {\n        const timeUnits = (0, constants_1.parseTimeUnits)(match[1]);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n    }\n}\nexports.default = FRTimeUnitWithinFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nclass FRTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    constructor() {\n        super();\n    }\n    innerPattern() {\n        return new RegExp(`(?:les?|la|l'|du|des?)\\\\s*` +\n            `(${constants_1.NUMBER_PATTERN})?` +\n            `(?:\\\\s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))?` +\n            `\\\\s*(${(0, pattern_1.matchAnyPattern)(constants_1.TIME_UNIT_DICTIONARY)})` +\n            `(?:\\\\s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))?`, \"i\");\n    }\n    innerExtract(context, match) {\n        const num = match[1] ? (0, constants_1.parseNumberPattern)(match[1]) : 1;\n        const unit = constants_1.TIME_UNIT_DICTIONARY[match[3].toLowerCase()];\n        let timeUnits = {};\n        timeUnits[unit] = num;\n        let modifier = match[2] || match[4] || \"\";\n        modifier = modifier.toLowerCase();\n        if (!modifier) {\n            return;\n        }\n        if (/derni[eè]re?s?/.test(modifier) || /pass[ée]e?s?/.test(modifier) || /pr[ée]c[ée]dents?/.test(modifier)) {\n            timeUnits = (0, timeunits_1.reverseTimeUnits)(timeUnits);\n        }\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n    }\n}\nexports.default = FRTimeUnitAgoFormatParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = void 0;\nconst configurations_1 = require(\"../../configurations\");\nconst chrono_1 = require(\"../../chrono\");\nconst FRCasualDateParser_1 = __importDefault(require(\"./parsers/FRCasualDateParser\"));\nconst FRCasualTimeParser_1 = __importDefault(require(\"./parsers/FRCasualTimeParser\"));\nconst SlashDateFormatParser_1 = __importDefault(require(\"../../common/parsers/SlashDateFormatParser\"));\nconst FRTimeExpressionParser_1 = __importDefault(require(\"./parsers/FRTimeExpressionParser\"));\nconst FRMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/FRMergeDateTimeRefiner\"));\nconst FRMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/FRMergeDateRangeRefiner\"));\nconst FRWeekdayParser_1 = __importDefault(require(\"./parsers/FRWeekdayParser\"));\nconst FRSpecificTimeExpressionParser_1 = __importDefault(require(\"./parsers/FRSpecificTimeExpressionParser\"));\nconst FRMonthNameLittleEndianParser_1 = __importDefault(require(\"./parsers/FRMonthNameLittleEndianParser\"));\nconst FRTimeUnitAgoFormatParser_1 = __importDefault(require(\"./parsers/FRTimeUnitAgoFormatParser\"));\nconst FRTimeUnitWithinFormatParser_1 = __importDefault(require(\"./parsers/FRTimeUnitWithinFormatParser\"));\nconst FRTimeUnitRelativeFormatParser_1 = __importDefault(require(\"./parsers/FRTimeUnitRelativeFormatParser\"));\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration(true));\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration(littleEndian = true) {\n    const option = createConfiguration(false, littleEndian);\n    option.parsers.unshift(new FRCasualDateParser_1.default());\n    option.parsers.unshift(new FRCasualTimeParser_1.default());\n    option.parsers.unshift(new FRTimeUnitRelativeFormatParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration(strictMode = true, littleEndian = true) {\n    return (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new SlashDateFormatParser_1.default(littleEndian),\n            new FRMonthNameLittleEndianParser_1.default(),\n            new FRTimeExpressionParser_1.default(),\n            new FRSpecificTimeExpressionParser_1.default(),\n            new FRTimeUnitAgoFormatParser_1.default(),\n            new FRTimeUnitWithinFormatParser_1.default(),\n            new FRWeekdayParser_1.default(),\n        ],\n        refiners: [new FRMergeDateTimeRefiner_1.default(), new FRMergeDateRangeRefiner_1.default()],\n    }, strictMode);\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.toHankaku = void 0;\nfunction toHankaku(text) {\n    return String(text)\n        .replace(/\\u2019/g, \"\\u0027\")\n        .replace(/\\u201D/g, \"\\u0022\")\n        .replace(/\\u3000/g, \"\\u0020\")\n        .replace(/\\uFFE5/g, \"\\u00A5\")\n        .replace(/[\\uFF01\\uFF03-\\uFF06\\uFF08\\uFF09\\uFF0C-\\uFF19\\uFF1C-\\uFF1F\\uFF21-\\uFF3B\\uFF3D\\uFF3F\\uFF41-\\uFF5B\\uFF5D\\uFF5E]/g, alphaNum);\n}\nexports.toHankaku = toHankaku;\nfunction alphaNum(token) {\n    return String.fromCharCode(token.charCodeAt(0) - 65248);\n}\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst years_1 = require(\"../../../calculation/years\");\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst PATTERN = /(?:(?:([同今本])|((昭和|平成|令和)?([0-9０-９]{1,4}|元)))年\\s*)?([0-9０-９]{1,2})月\\s*([0-9０-９]{1,2})日/i;\nconst SPECIAL_YEAR_GROUP = 1;\nconst TYPICAL_YEAR_GROUP = 2;\nconst ERA_GROUP = 3;\nconst YEAR_NUMBER_GROUP = 4;\nconst MONTH_GROUP = 5;\nconst DAY_GROUP = 6;\nclass JPStandardParser {\n    pattern() {\n        return PATTERN;\n    }\n    extract(context, match) {\n        const month = parseInt((0, constants_1.toHankaku)(match[MONTH_GROUP]));\n        const day = parseInt((0, constants_1.toHankaku)(match[DAY_GROUP]));\n        const components = context.createParsingComponents({\n            day: day,\n            month: month,\n        });\n        if (match[SPECIAL_YEAR_GROUP] && match[SPECIAL_YEAR_GROUP].match(\"同|今|本\")) {\n            const moment = (0, dayjs_1.default)(context.refDate);\n            components.assign(\"year\", moment.year());\n        }\n        if (match[TYPICAL_YEAR_GROUP]) {\n            const yearNumText = match[YEAR_NUMBER_GROUP];\n            let year = yearNumText == \"元\" ? 1 : parseInt((0, constants_1.toHankaku)(yearNumText));\n            if (match[ERA_GROUP] == \"令和\") {\n                year += 2018;\n            }\n            else if (match[ERA_GROUP] == \"平成\") {\n                year += 1988;\n            }\n            else if (match[ERA_GROUP] == \"昭和\") {\n                year += 1925;\n            }\n            components.assign(\"year\", year);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            components.imply(\"year\", year);\n        }\n        return components;\n    }\n}\nexports.default = JPStandardParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass JPMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(から|ー|-)\\s*$/i;\n    }\n}\nexports.default = JPMergeDateRangeRefiner;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst index_1 = require(\"../../../index\");\nconst references = __importStar(require(\"../../../common/casualReferences\"));\nconst PATTERN = /今日|当日|昨日|明日|今夜|今夕|今晩|今朝/i;\nclass JPCasualDateParser {\n    pattern() {\n        return PATTERN;\n    }\n    extract(context, match) {\n        const text = match[0];\n        const date = (0, dayjs_1.default)(context.refDate);\n        const components = context.createParsingComponents();\n        switch (text) {\n            case \"昨日\":\n                return references.yesterday(context.reference);\n            case \"明日\":\n                return references.tomorrow(context.reference);\n            case \"今日\":\n            case \"当日\":\n                return references.today(context.reference);\n        }\n        if (text == \"今夜\" || text == \"今夕\" || text == \"今晩\") {\n            components.imply(\"hour\", 22);\n            components.assign(\"meridiem\", index_1.Meridiem.PM);\n        }\n        else if (text.match(\"今朝\")) {\n            components.imply(\"hour\", 6);\n            components.assign(\"meridiem\", index_1.Meridiem.AM);\n        }\n        components.assign(\"day\", date.date());\n        components.assign(\"month\", date.month() + 1);\n        components.assign(\"year\", date.year());\n        return components;\n    }\n}\nexports.default = JPCasualDateParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = void 0;\nconst JPStandardParser_1 = __importDefault(require(\"./parsers/JPStandardParser\"));\nconst JPMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/JPMergeDateRangeRefiner\"));\nconst JPCasualDateParser_1 = __importDefault(require(\"./parsers/JPCasualDateParser\"));\nconst chrono_1 = require(\"../../chrono\");\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration());\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration() {\n    const option = createConfiguration();\n    option.parsers.unshift(new JPCasualDateParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration() {\n    return {\n        parsers: [new JPStandardParser_1.default()],\n        refiners: [new JPMergeDateRangeRefiner_1.default()],\n    };\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseYear = exports.YEAR_PATTERN = exports.MONTH_DICTIONARY = exports.WEEKDAY_DICTIONARY = void 0;\nexports.WEEKDAY_DICTIONARY = {\n    \"domingo\": 0,\n    \"dom\": 0,\n    \"segunda\": 1,\n    \"segunda-feira\": 1,\n    \"seg\": 1,\n    \"terça\": 2,\n    \"terça-feira\": 2,\n    \"ter\": 2,\n    \"quarta\": 3,\n    \"quarta-feira\": 3,\n    \"qua\": 3,\n    \"quinta\": 4,\n    \"quinta-feira\": 4,\n    \"qui\": 4,\n    \"sexta\": 5,\n    \"sexta-feira\": 5,\n    \"sex\": 5,\n    \"sábado\": 6,\n    \"sabado\": 6,\n    \"sab\": 6,\n};\nexports.MONTH_DICTIONARY = {\n    \"janeiro\": 1,\n    \"jan\": 1,\n    \"jan.\": 1,\n    \"fevereiro\": 2,\n    \"fev\": 2,\n    \"fev.\": 2,\n    \"março\": 3,\n    \"mar\": 3,\n    \"mar.\": 3,\n    \"abril\": 4,\n    \"abr\": 4,\n    \"abr.\": 4,\n    \"maio\": 5,\n    \"mai\": 5,\n    \"mai.\": 5,\n    \"junho\": 6,\n    \"jun\": 6,\n    \"jun.\": 6,\n    \"julho\": 7,\n    \"jul\": 7,\n    \"jul.\": 7,\n    \"agosto\": 8,\n    \"ago\": 8,\n    \"ago.\": 8,\n    \"setembro\": 9,\n    \"set\": 9,\n    \"set.\": 9,\n    \"outubro\": 10,\n    \"out\": 10,\n    \"out.\": 10,\n    \"novembro\": 11,\n    \"nov\": 11,\n    \"nov.\": 11,\n    \"dezembro\": 12,\n    \"dez\": 12,\n    \"dez.\": 12,\n};\nexports.YEAR_PATTERN = \"[0-9]{1,4}(?![^\\\\s]\\\\d)(?:\\\\s*[a|d]\\\\.?\\\\s*c\\\\.?|\\\\s*a\\\\.?\\\\s*d\\\\.?)?\";\nfunction parseYear(match) {\n    if (match.match(/^[0-9]{1,4}$/)) {\n        let yearNumber = parseInt(match);\n        if (yearNumber < 100) {\n            if (yearNumber > 50) {\n                yearNumber = yearNumber + 1900;\n            }\n            else {\n                yearNumber = yearNumber + 2000;\n            }\n        }\n        return yearNumber;\n    }\n    if (match.match(/a\\.?\\s*c\\.?/i)) {\n        match = match.replace(/a\\.?\\s*c\\.?/i, \"\");\n        return -parseInt(match);\n    }\n    return parseInt(match);\n}\nexports.parseYear = parseYear;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst weeks_1 = require(\"../../../calculation/weeks\");\nconst PATTERN = new RegExp(\"(?:(?:\\\\,|\\\\(|\\\\（)\\\\s*)?\" +\n    \"(?:(este|esta|passado|pr[oó]ximo)\\\\s*)?\" +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.WEEKDAY_DICTIONARY)})` +\n    \"(?:\\\\s*(?:\\\\,|\\\\)|\\\\）))?\" +\n    \"(?:\\\\s*(este|esta|passado|pr[óo]ximo)\\\\s*semana)?\" +\n    \"(?=\\\\W|\\\\d|$)\", \"i\");\nconst PREFIX_GROUP = 1;\nconst WEEKDAY_GROUP = 2;\nconst POSTFIX_GROUP = 3;\nclass PTWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();\n        const offset = constants_1.WEEKDAY_DICTIONARY[dayOfWeek];\n        if (offset === undefined) {\n            return null;\n        }\n        const prefix = match[PREFIX_GROUP];\n        const postfix = match[POSTFIX_GROUP];\n        let norm = prefix || postfix || \"\";\n        norm = norm.toLowerCase();\n        let modifier = null;\n        if (norm == \"passado\") {\n            modifier = \"this\";\n        }\n        else if (norm == \"próximo\" || norm == \"proximo\") {\n            modifier = \"next\";\n        }\n        else if (norm == \"este\") {\n            modifier = \"this\";\n        }\n        const date = (0, weeks_1.toDayJSWeekday)(context.refDate, offset, modifier);\n        return context\n            .createParsingComponents()\n            .assign(\"weekday\", offset)\n            .imply(\"day\", date.date())\n            .imply(\"month\", date.month() + 1)\n            .imply(\"year\", date.year());\n    }\n}\nexports.default = PTWeekdayParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractTimeExpressionParser_1 = require(\"../../../common/parsers/AbstractTimeExpressionParser\");\nclass PTTimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {\n    primaryPrefix() {\n        return \"(?:(?:ao?|às?|das|da|de|do)\\\\s*)?\";\n    }\n    followingPhase() {\n        return \"\\\\s*(?:\\\\-|\\\\–|\\\\~|\\\\〜|a(?:o)?|\\\\?)\\\\s*\";\n    }\n}\nexports.default = PTTimeExpressionParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass PTMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return new RegExp(\"^\\\\s*(?:,|à)?\\\\s*$\");\n    }\n}\nexports.default = PTMergeDateTimeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass PTMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(?:-)\\s*$/i;\n    }\n}\nexports.default = PTMergeDateRangeRefiner;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../../calculation/years\");\nconst constants_1 = require(\"../constants\");\nconst constants_2 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`([0-9]{1,2})(?:º|ª|°)?` +\n    \"(?:\\\\s*(?:desde|de|\\\\-|\\\\–|ao?|\\\\s)\\\\s*([0-9]{1,2})(?:º|ª|°)?)?\\\\s*(?:de)?\\\\s*\" +\n    `(?:-|/|\\\\s*(?:de|,)?\\\\s*)` +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    `(?:\\\\s*(?:de|,)?\\\\s*(${constants_2.YEAR_PATTERN}))?` +\n    `(?=\\\\W|$)`, \"i\");\nconst DATE_GROUP = 1;\nconst DATE_TO_GROUP = 2;\nconst MONTH_NAME_GROUP = 3;\nconst YEAR_GROUP = 4;\nclass PTMonthNameLittleEndianParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const month = constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        const day = parseInt(match[DATE_GROUP]);\n        if (day > 31) {\n            match.index = match.index + match[DATE_GROUP].length;\n            return null;\n        }\n        result.start.assign(\"month\", month);\n        result.start.assign(\"day\", day);\n        if (match[YEAR_GROUP]) {\n            const yearNumber = (0, constants_2.parseYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", yearNumber);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            result.start.imply(\"year\", year);\n        }\n        if (match[DATE_TO_GROUP]) {\n            const endDate = parseInt(match[DATE_TO_GROUP]);\n            result.end = result.start.clone();\n            result.end.assign(\"day\", endDate);\n        }\n        return result;\n    }\n}\nexports.default = PTMonthNameLittleEndianParser;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst references = __importStar(require(\"../../../common/casualReferences\"));\nclass PTCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return /(agora|hoje|amanha|amanhã|ontem)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const lowerText = match[0].toLowerCase();\n        const component = context.createParsingComponents();\n        switch (lowerText) {\n            case \"agora\":\n                return references.now(context.reference);\n            case \"hoje\":\n                return references.today(context.reference);\n            case \"amanha\":\n            case \"amanhã\":\n                return references.tomorrow(context.reference);\n            case \"ontem\":\n                return references.yesterday(context.reference);\n        }\n        return component;\n    }\n}\nexports.default = PTCasualDateParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst index_1 = require(\"../../../index\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_1 = require(\"../../../utils/dayjs\");\nconst dayjs_2 = __importDefault(require(\"dayjs\"));\nclass PTCasualTimeParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return /(?:esta\\s*)?(manha|manhã|tarde|meia-noite|meio-dia|noite)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const targetDate = (0, dayjs_2.default)(context.refDate);\n        const component = context.createParsingComponents();\n        switch (match[1].toLowerCase()) {\n            case \"tarde\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 15);\n                break;\n            case \"noite\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 22);\n                break;\n            case \"manha\":\n            case \"manhã\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 6);\n                break;\n            case \"meia-noite\":\n                (0, dayjs_1.assignTheNextDay)(component, targetDate);\n                component.imply(\"hour\", 0);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                break;\n            case \"meio-dia\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 12);\n                break;\n        }\n        return component;\n    }\n}\nexports.default = PTCasualTimeParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = void 0;\nconst configurations_1 = require(\"../../configurations\");\nconst chrono_1 = require(\"../../chrono\");\nconst SlashDateFormatParser_1 = __importDefault(require(\"../../common/parsers/SlashDateFormatParser\"));\nconst PTWeekdayParser_1 = __importDefault(require(\"./parsers/PTWeekdayParser\"));\nconst PTTimeExpressionParser_1 = __importDefault(require(\"./parsers/PTTimeExpressionParser\"));\nconst PTMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/PTMergeDateTimeRefiner\"));\nconst PTMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/PTMergeDateRangeRefiner\"));\nconst PTMonthNameLittleEndianParser_1 = __importDefault(require(\"./parsers/PTMonthNameLittleEndianParser\"));\nconst PTCasualDateParser_1 = __importDefault(require(\"./parsers/PTCasualDateParser\"));\nconst PTCasualTimeParser_1 = __importDefault(require(\"./parsers/PTCasualTimeParser\"));\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration(true));\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration(littleEndian = true) {\n    const option = createConfiguration(false, littleEndian);\n    option.parsers.push(new PTCasualDateParser_1.default());\n    option.parsers.push(new PTCasualTimeParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration(strictMode = true, littleEndian = true) {\n    return (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new SlashDateFormatParser_1.default(littleEndian),\n            new PTWeekdayParser_1.default(),\n            new PTTimeExpressionParser_1.default(),\n            new PTMonthNameLittleEndianParser_1.default(),\n        ],\n        refiners: [new PTMergeDateTimeRefiner_1.default(), new PTMergeDateRangeRefiner_1.default()],\n    }, strictMode);\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass NLMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(tot|-)\\s*$/i;\n    }\n}\nexports.default = NLMergeDateRangeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass NLMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return new RegExp(\"^\\\\s*(om|na|voor|in de|,|-)?\\\\s*$\");\n    }\n}\nexports.default = NLMergeDateTimeRefiner;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst references = __importStar(require(\"../../../common/casualReferences\"));\nclass NLCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return /(nu|vandaag|morgen|morgend|gisteren)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const lowerText = match[0].toLowerCase();\n        const component = context.createParsingComponents();\n        switch (lowerText) {\n            case \"nu\":\n                return references.now(context.reference);\n            case \"vandaag\":\n                return references.today(context.reference);\n            case \"morgen\":\n            case \"morgend\":\n                return references.tomorrow(context.reference);\n            case \"gisteren\":\n                return references.yesterday(context.reference);\n        }\n        return component;\n    }\n}\nexports.default = NLCasualDateParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst index_1 = require(\"../../../index\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst dayjs_2 = require(\"../../../utils/dayjs\");\nconst DAY_GROUP = 1;\nconst MOMENT_GROUP = 2;\nclass NLCasualTimeParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return /(deze)?\\s*(namiddag|avond|middernacht|ochtend|middag|'s middags|'s avonds|'s ochtends)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const targetDate = (0, dayjs_1.default)(context.refDate);\n        const component = context.createParsingComponents();\n        if (match[DAY_GROUP] === \"deze\") {\n            component.assign(\"day\", context.refDate.getDate());\n            component.assign(\"month\", context.refDate.getMonth() + 1);\n            component.assign(\"year\", context.refDate.getFullYear());\n        }\n        switch (match[MOMENT_GROUP].toLowerCase()) {\n            case \"namiddag\":\n            case \"'s namiddags\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 15);\n                break;\n            case \"avond\":\n            case \"'s avonds'\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 20);\n                break;\n            case \"middernacht\":\n                (0, dayjs_2.assignTheNextDay)(component, targetDate);\n                component.imply(\"hour\", 0);\n                component.imply(\"minute\", 0);\n                component.imply(\"second\", 0);\n                break;\n            case \"ochtend\":\n            case \"'s ochtends\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 6);\n                break;\n            case \"middag\":\n            case \"'s middags\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 12);\n                break;\n        }\n        return component;\n    }\n}\nexports.default = NLCasualTimeParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst pattern_1 = require(\"../../utils/pattern\");\nconst years_1 = require(\"../../calculation/years\");\nexports.WEEKDAY_DICTIONARY = {\n    zondag: 0,\n    zon: 0,\n    \"zon.\": 0,\n    zo: 0,\n    \"zo.\": 0,\n    maandag: 1,\n    ma: 1,\n    \"ma.\": 1,\n    dinsdag: 2,\n    din: 2,\n    \"din.\": 2,\n    di: 2,\n    \"di.\": 2,\n    woensdag: 3,\n    woe: 3,\n    \"woe.\": 3,\n    wo: 3,\n    \"wo.\": 3,\n    donderdag: 4,\n    dond: 4,\n    \"dond.\": 4,\n    do: 4,\n    \"do.\": 4,\n    vrijdag: 5,\n    vrij: 5,\n    \"vrij.\": 5,\n    vr: 5,\n    \"vr.\": 5,\n    zaterdag: 6,\n    zat: 6,\n    \"zat.\": 6,\n    \"za\": 6,\n    \"za.\": 6,\n};\nexports.MONTH_DICTIONARY = {\n    januari: 1,\n    jan: 1,\n    \"jan.\": 1,\n    februari: 2,\n    feb: 2,\n    \"feb.\": 2,\n    maart: 3,\n    mar: 3,\n    \"mar.\": 3,\n    april: 4,\n    apr: 4,\n    \"apr.\": 4,\n    mei: 5,\n    juni: 6,\n    jun: 6,\n    \"jun.\": 6,\n    juli: 7,\n    jul: 7,\n    \"jul.\": 7,\n    augustus: 8,\n    aug: 8,\n    \"aug.\": 8,\n    september: 9,\n    sep: 9,\n    \"sep.\": 9,\n    sept: 9,\n    \"sept.\": 9,\n    oktober: 10,\n    okt: 10,\n    \"okt.\": 10,\n    november: 11,\n    nov: 11,\n    \"nov.\": 11,\n    december: 12,\n    dec: 12,\n    \"dec.\": 12,\n};\nexports.INTEGER_WORD_DICTIONARY = {\n    een: 1,\n    twee: 2,\n    drie: 3,\n    vier: 4,\n    vijf: 5,\n    zes: 6,\n    zeven: 7,\n    acht: 8,\n    negen: 9,\n    tien: 10,\n    elf: 11,\n    twaalf: 12,\n};\nexports.ORDINAL_WORD_DICTIONARY = {\n    eerste: 1,\n    tweede: 2,\n    derde: 3,\n    vierde: 4,\n    vijfde: 5,\n    zesde: 6,\n    zevende: 7,\n    achtste: 8,\n    negende: 9,\n    tiende: 10,\n    elfde: 11,\n    twaalfde: 12,\n    dertiende: 13,\n    veertiende: 14,\n    vijftiende: 15,\n    zestiende: 16,\n    zeventiende: 17,\n    achttiende: 18,\n    negentiende: 19,\n    twintigste: 20,\n    \"eenentwintigste\": 21,\n    \"tweeëntwintigste\": 22,\n    \"drieentwintigste\": 23,\n    \"vierentwintigste\": 24,\n    \"vijfentwintigste\": 25,\n    \"zesentwintigste\": 26,\n    \"zevenentwintigste\": 27,\n    \"achtentwintig\": 28,\n    \"negenentwintig\": 29,\n    \"dertigste\": 30,\n    \"eenendertigste\": 31,\n};\nexports.TIME_UNIT_DICTIONARY = {\n    sec: \"second\",\n    second: \"second\",\n    seconden: \"second\",\n    min: \"minute\",\n    mins: \"minute\",\n    minute: \"minute\",\n    minuut: \"minute\",\n    minuten: \"minute\",\n    minuutje: \"minute\",\n    h: \"hour\",\n    hr: \"hour\",\n    hrs: \"hour\",\n    uur: \"hour\",\n    u: \"hour\",\n    uren: \"hour\",\n    dag: \"d\",\n    dagen: \"d\",\n    week: \"week\",\n    weken: \"week\",\n    maand: \"month\",\n    maanden: \"month\",\n    jaar: \"year\",\n    jr: \"year\",\n    jaren: \"year\",\n};\nexports.NUMBER_PATTERN = `(?:${(0, pattern_1.matchAnyPattern)(exports.INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+[\\\\.,][0-9]+|halve?|half|paar)`;\nfunction parseNumberPattern(match) {\n    const num = match.toLowerCase();\n    if (exports.INTEGER_WORD_DICTIONARY[num] !== undefined) {\n        return exports.INTEGER_WORD_DICTIONARY[num];\n    }\n    else if (num === \"paar\") {\n        return 2;\n    }\n    else if (num === \"half\" || num.match(/halve?/)) {\n        return 0.5;\n    }\n    return parseFloat(num.replace(\",\", \".\"));\n}\nexports.parseNumberPattern = parseNumberPattern;\nexports.ORDINAL_NUMBER_PATTERN = `(?:${(0, pattern_1.matchAnyPattern)(exports.ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:ste|de)?)`;\nfunction parseOrdinalNumberPattern(match) {\n    let num = match.toLowerCase();\n    if (exports.ORDINAL_WORD_DICTIONARY[num] !== undefined) {\n        return exports.ORDINAL_WORD_DICTIONARY[num];\n    }\n    num = num.replace(/(?:ste|de)$/i, \"\");\n    return parseInt(num);\n}\nexports.parseOrdinalNumberPattern = parseOrdinalNumberPattern;\nexports.YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\\\s*(?:voor Christus|na Christus)|[1-2][0-9]{3}|[5-9][0-9])`;\nfunction parseYear(match) {\n    if (/voor Christus/i.test(match)) {\n        match = match.replace(/voor Christus/i, \"\");\n        return -parseInt(match);\n    }\n    if (/na Christus/i.test(match)) {\n        match = match.replace(/na Christus/i, \"\");\n        return parseInt(match);\n    }\n    const rawYearNumber = parseInt(match);\n    return (0, years_1.findMostLikelyADYear)(rawYearNumber);\n}\nexports.parseYear = parseYear;\nconst SINGLE_TIME_UNIT_PATTERN = `(${exports.NUMBER_PATTERN})\\\\s{0,5}(${(0, pattern_1.matchAnyPattern)(exports.TIME_UNIT_DICTIONARY)})\\\\s{0,5}`;\nconst SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, \"i\");\nexports.TIME_UNITS_PATTERN = (0, pattern_1.repeatedTimeunitPattern)(`(?:(?:binnen|in)\\\\s*)?`, SINGLE_TIME_UNIT_PATTERN);\nfunction parseTimeUnits(timeunitText) {\n    const fragments = {};\n    let remainingText = timeunitText;\n    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    while (match) {\n        collectDateTimeFragment(fragments, match);\n        remainingText = remainingText.substring(match[0].length);\n        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);\n    }\n    return fragments;\n}\nexports.parseTimeUnits = parseTimeUnits;\nfunction collectDateTimeFragment(fragments, match) {\n    const num = parseNumberPattern(match[1]);\n    const unit = exports.TIME_UNIT_DICTIONARY[match[2].toLowerCase()];\n    fragments[unit] = num;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nclass NLTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return new RegExp(`(?:binnen|in|binnen de|voor)\\\\s*` + \"(\" + constants_1.TIME_UNITS_PATTERN + \")\" + `(?=\\\\W|$)`, \"i\");\n    }\n    innerExtract(context, match) {\n        const timeUnits = (0, constants_1.parseTimeUnits)(match[1]);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n    }\n}\nexports.default = NLTimeUnitWithinFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../../nl/constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst weeks_1 = require(\"../../../calculation/weeks\");\nconst PATTERN = new RegExp(\"(?:(?:\\\\,|\\\\(|\\\\（)\\\\s*)?\" +\n    \"(?:op\\\\s*?)?\" +\n    \"(?:(deze|vorige|volgende)\\\\s*(?:week\\\\s*)?)?\" +\n    `(${(0, pattern_1.matchAnyPattern)(constants_1.WEEKDAY_DICTIONARY)})` +\n    \"(?=\\\\W|$)\", \"i\");\nconst PREFIX_GROUP = 1;\nconst WEEKDAY_GROUP = 2;\nconst POSTFIX_GROUP = 3;\nclass NLWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();\n        const offset = constants_1.WEEKDAY_DICTIONARY[dayOfWeek];\n        const prefix = match[PREFIX_GROUP];\n        const postfix = match[POSTFIX_GROUP];\n        let modifierWord = prefix || postfix;\n        modifierWord = modifierWord || \"\";\n        modifierWord = modifierWord.toLowerCase();\n        let modifier = null;\n        if (modifierWord == \"vorige\") {\n            modifier = \"last\";\n        }\n        else if (modifierWord == \"volgende\") {\n            modifier = \"next\";\n        }\n        else if (modifierWord == \"deze\") {\n            modifier = \"this\";\n        }\n        const date = (0, weeks_1.toDayJSWeekday)(context.refDate, offset, modifier);\n        return context\n            .createParsingComponents()\n            .assign(\"weekday\", offset)\n            .imply(\"day\", date.date())\n            .imply(\"month\", date.month() + 1)\n            .imply(\"year\", date.year());\n    }\n}\nexports.default = NLWeekdayParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst years_1 = require(\"../../../calculation/years\");\nconst constants_1 = require(\"../constants\");\nconst constants_2 = require(\"../constants\");\nconst constants_3 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"(?:on\\\\s*?)?\" +\n    `(${constants_2.ORDINAL_NUMBER_PATTERN})` +\n    \"(?:\\\\s*\" +\n    \"(?:tot|\\\\-|\\\\–|until|through|till|\\\\s)\\\\s*\" +\n    `(${constants_2.ORDINAL_NUMBER_PATTERN})` +\n    \")?\" +\n    \"(?:-|/|\\\\s*(?:of)?\\\\s*)\" +\n    \"(\" +\n    (0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY) +\n    \")\" +\n    \"(?:\" +\n    \"(?:-|/|,?\\\\s*)\" +\n    `(${constants_3.YEAR_PATTERN}(?![^\\\\s]\\\\d))` +\n    \")?\" +\n    \"(?=\\\\W|$)\", \"i\");\nconst MONTH_NAME_GROUP = 3;\nconst DATE_GROUP = 1;\nconst DATE_TO_GROUP = 2;\nconst YEAR_GROUP = 4;\nclass NLMonthNameMiddleEndianParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const month = constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        const day = (0, constants_2.parseOrdinalNumberPattern)(match[DATE_GROUP]);\n        if (day > 31) {\n            match.index = match.index + match[DATE_GROUP].length;\n            return null;\n        }\n        const components = context.createParsingComponents({\n            day: day,\n            month: month,\n        });\n        if (match[YEAR_GROUP]) {\n            const year = (0, constants_3.parseYear)(match[YEAR_GROUP]);\n            components.assign(\"year\", year);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, day, month);\n            components.imply(\"year\", year);\n        }\n        if (!match[DATE_TO_GROUP]) {\n            return components;\n        }\n        const endDate = (0, constants_2.parseOrdinalNumberPattern)(match[DATE_TO_GROUP]);\n        const result = context.createParsingResult(match.index, match[0]);\n        result.start = components;\n        result.end = components.clone();\n        result.end.assign(\"day\", endDate);\n        return result;\n    }\n}\nexports.default = NLMonthNameMiddleEndianParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst years_1 = require(\"../../../calculation/years\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst constants_2 = require(\"../constants\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})` +\n    `\\\\s*` +\n    `(?:` +\n    `[,-]?\\\\s*(${constants_2.YEAR_PATTERN})?` +\n    \")?\" +\n    \"(?=[^\\\\s\\\\w]|\\\\s+[^0-9]|\\\\s+$|$)\", \"i\");\nconst MONTH_NAME_GROUP = 1;\nconst YEAR_GROUP = 2;\nclass NLMonthNameParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const components = context.createParsingComponents();\n        components.imply(\"day\", 1);\n        const monthName = match[MONTH_NAME_GROUP];\n        const month = constants_1.MONTH_DICTIONARY[monthName.toLowerCase()];\n        components.assign(\"month\", month);\n        if (match[YEAR_GROUP]) {\n            const year = (0, constants_2.parseYear)(match[YEAR_GROUP]);\n            components.assign(\"year\", year);\n        }\n        else {\n            const year = (0, years_1.findYearClosestToRef)(context.refDate, 1, month);\n            components.imply(\"year\", year);\n        }\n        return components;\n    }\n}\nexports.default = NLMonthNameParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"([0-9]|0[1-9]|1[012])/([0-9]{4})\" + \"\", \"i\");\nconst MONTH_GROUP = 1;\nconst YEAR_GROUP = 2;\nclass NLSlashMonthFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const year = parseInt(match[YEAR_GROUP]);\n        const month = parseInt(match[MONTH_GROUP]);\n        return context.createParsingComponents().imply(\"day\", 1).assign(\"month\", month).assign(\"year\", year);\n    }\n}\nexports.default = NLSlashMonthFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractTimeExpressionParser_1 = require(\"../../../common/parsers/AbstractTimeExpressionParser\");\nclass NLTimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {\n    primaryPrefix() {\n        return \"(?:(?:om)\\\\s*)?\";\n    }\n    followingPhase() {\n        return \"\\\\s*(?:\\\\-|\\\\–|\\\\~|\\\\〜|om|\\\\?)\\\\s*\";\n    }\n    primarySuffix() {\n        return \"(?:\\\\s*(?:uur))?(?!/)(?=\\\\W|$)\";\n    }\n    extractPrimaryTimeComponents(context, match) {\n        if (match[0].match(/^\\s*\\d{4}\\s*$/)) {\n            return null;\n        }\n        return super.extractPrimaryTimeComponents(context, match);\n    }\n}\nexports.default = NLTimeExpressionParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(`([0-9]{4})[\\\\.\\\\/\\\\s]` +\n    `(?:(${(0, pattern_1.matchAnyPattern)(constants_1.MONTH_DICTIONARY)})|([0-9]{1,2}))[\\\\.\\\\/\\\\s]` +\n    `([0-9]{1,2})` +\n    \"(?=\\\\W|$)\", \"i\");\nconst YEAR_NUMBER_GROUP = 1;\nconst MONTH_NAME_GROUP = 2;\nconst MONTH_NUMBER_GROUP = 3;\nconst DATE_NUMBER_GROUP = 4;\nclass NLCasualYearMonthDayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const month = match[MONTH_NUMBER_GROUP]\n            ? parseInt(match[MONTH_NUMBER_GROUP])\n            : constants_1.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];\n        if (month < 1 || month > 12) {\n            return null;\n        }\n        const year = parseInt(match[YEAR_NUMBER_GROUP]);\n        const day = parseInt(match[DATE_NUMBER_GROUP]);\n        return {\n            day: day,\n            month: month,\n            year: year,\n        };\n    }\n}\nexports.default = NLCasualYearMonthDayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst index_1 = require(\"../../../index\");\nconst dayjs_1 = require(\"../../../utils/dayjs\");\nconst dayjs_2 = __importDefault(require(\"dayjs\"));\nconst DATE_GROUP = 1;\nconst TIME_OF_DAY_GROUP = 2;\nclass NLCasualDateTimeParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return /(gisteren|morgen|van)(ochtend|middag|namiddag|avond|nacht)(?=\\W|$)/i;\n    }\n    innerExtract(context, match) {\n        const dateText = match[DATE_GROUP].toLowerCase();\n        const timeText = match[TIME_OF_DAY_GROUP].toLowerCase();\n        const component = context.createParsingComponents();\n        const targetDate = (0, dayjs_2.default)(context.refDate);\n        switch (dateText) {\n            case \"gisteren\":\n                (0, dayjs_1.assignSimilarDate)(component, targetDate.add(-1, \"day\"));\n                break;\n            case \"van\":\n                (0, dayjs_1.assignSimilarDate)(component, targetDate);\n                break;\n            case \"morgen\":\n                (0, dayjs_1.assignTheNextDay)(component, targetDate);\n                break;\n        }\n        switch (timeText) {\n            case \"ochtend\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 6);\n                break;\n            case \"middag\":\n                component.imply(\"meridiem\", index_1.Meridiem.AM);\n                component.imply(\"hour\", 12);\n                break;\n            case \"namiddag\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 15);\n                break;\n            case \"avond\":\n                component.imply(\"meridiem\", index_1.Meridiem.PM);\n                component.imply(\"hour\", 20);\n                break;\n        }\n        return component;\n    }\n}\nexports.default = NLCasualDateTimeParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nconst PATTERN = new RegExp(`(deze|vorige|afgelopen|komende|over|\\\\+|-)\\\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\\\W|$)`, \"i\");\nclass NLTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const prefix = match[1].toLowerCase();\n        let timeUnits = (0, constants_1.parseTimeUnits)(match[2]);\n        switch (prefix) {\n            case \"vorige\":\n            case \"afgelopen\":\n            case \"-\":\n                timeUnits = (0, timeunits_1.reverseTimeUnits)(timeUnits);\n                break;\n        }\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n    }\n}\nexports.default = NLTimeUnitCasualRelativeFormatParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst pattern_1 = require(\"../../../utils/pattern\");\nconst PATTERN = new RegExp(`(dit|deze|komende|volgend|volgende|afgelopen|vorige)\\\\s*(${(0, pattern_1.matchAnyPattern)(constants_1.TIME_UNIT_DICTIONARY)})(?=\\\\s*)` +\n    \"(?=\\\\W|$)\", \"i\");\nconst MODIFIER_WORD_GROUP = 1;\nconst RELATIVE_WORD_GROUP = 2;\nclass NLRelativeDateFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();\n        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();\n        const timeunit = constants_1.TIME_UNIT_DICTIONARY[unitWord];\n        if (modifier == \"volgend\" || modifier == \"volgende\" || modifier == \"komende\") {\n            const timeUnits = {};\n            timeUnits[timeunit] = 1;\n            return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n        }\n        if (modifier == \"afgelopen\" || modifier == \"vorige\") {\n            const timeUnits = {};\n            timeUnits[timeunit] = -1;\n            return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);\n        }\n        const components = context.createParsingComponents();\n        let date = (0, dayjs_1.default)(context.reference.instant);\n        if (unitWord.match(/week/i)) {\n            date = date.add(-date.get(\"d\"), \"d\");\n            components.imply(\"day\", date.date());\n            components.imply(\"month\", date.month() + 1);\n            components.imply(\"year\", date.year());\n        }\n        else if (unitWord.match(/maand/i)) {\n            date = date.add(-date.date() + 1, \"d\");\n            components.imply(\"day\", date.date());\n            components.assign(\"year\", date.year());\n            components.assign(\"month\", date.month() + 1);\n        }\n        else if (unitWord.match(/jaar/i)) {\n            date = date.add(-date.date() + 1, \"d\");\n            date = date.add(-date.month(), \"month\");\n            components.imply(\"day\", date.date());\n            components.imply(\"month\", date.month() + 1);\n            components.assign(\"year\", date.year());\n        }\n        return components;\n    }\n}\nexports.default = NLRelativeDateFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst timeunits_1 = require(\"../../../utils/timeunits\");\nconst PATTERN = new RegExp(\"\" + \"(\" + constants_1.TIME_UNITS_PATTERN + \")\" + \"(?:geleden|voor|eerder)(?=(?:\\\\W|$))\", \"i\");\nconst STRICT_PATTERN = new RegExp(\"\" + \"(\" + constants_1.TIME_UNITS_PATTERN + \")\" + \"geleden(?=(?:\\\\W|$))\", \"i\");\nclass NLTimeUnitAgoFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    constructor(strictMode) {\n        super();\n        this.strictMode = strictMode;\n    }\n    innerPattern() {\n        return this.strictMode ? STRICT_PATTERN : PATTERN;\n    }\n    innerExtract(context, match) {\n        const timeUnits = (0, constants_1.parseTimeUnits)(match[1]);\n        const outputTimeUnits = (0, timeunits_1.reverseTimeUnits)(timeUnits);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);\n    }\n}\nexports.default = NLTimeUnitAgoFormatParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst constants_1 = require(\"../constants\");\nconst results_1 = require(\"../../../results\");\nconst AbstractParserWithWordBoundary_1 = require(\"../../../common/parsers/AbstractParserWithWordBoundary\");\nconst PATTERN = new RegExp(\"\" + \"(\" + constants_1.TIME_UNITS_PATTERN + \")\" + \"(later|na|vanaf nu|voortaan|vooruit|uit)\" + \"(?=(?:\\\\W|$))\", \"i\");\nconst STRICT_PATTERN = new RegExp(\"\" + \"(\" + constants_1.TIME_UNITS_PATTERN + \")\" + \"(later|vanaf nu)\" + \"(?=(?:\\\\W|$))\", \"i\");\nconst GROUP_NUM_TIMEUNITS = 1;\nclass NLTimeUnitLaterFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    constructor(strictMode) {\n        super();\n        this.strictMode = strictMode;\n    }\n    innerPattern() {\n        return this.strictMode ? STRICT_PATTERN : PATTERN;\n    }\n    innerExtract(context, match) {\n        const fragments = (0, constants_1.parseTimeUnits)(match[GROUP_NUM_TIMEUNITS]);\n        return results_1.ParsingComponents.createRelativeFromReference(context.reference, fragments);\n    }\n}\nexports.default = NLTimeUnitLaterFormatParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = void 0;\nconst configurations_1 = require(\"../../configurations\");\nconst chrono_1 = require(\"../../chrono\");\nconst NLMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/NLMergeDateRangeRefiner\"));\nconst NLMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/NLMergeDateTimeRefiner\"));\nconst NLCasualDateParser_1 = __importDefault(require(\"./parsers/NLCasualDateParser\"));\nconst NLCasualTimeParser_1 = __importDefault(require(\"./parsers/NLCasualTimeParser\"));\nconst SlashDateFormatParser_1 = __importDefault(require(\"../../common/parsers/SlashDateFormatParser\"));\nconst NLTimeUnitWithinFormatParser_1 = __importDefault(require(\"./parsers/NLTimeUnitWithinFormatParser\"));\nconst NLWeekdayParser_1 = __importDefault(require(\"./parsers/NLWeekdayParser\"));\nconst NLMonthNameMiddleEndianParser_1 = __importDefault(require(\"./parsers/NLMonthNameMiddleEndianParser\"));\nconst NLMonthNameParser_1 = __importDefault(require(\"./parsers/NLMonthNameParser\"));\nconst NLSlashMonthFormatParser_1 = __importDefault(require(\"./parsers/NLSlashMonthFormatParser\"));\nconst NLTimeExpressionParser_1 = __importDefault(require(\"./parsers/NLTimeExpressionParser\"));\nconst NLCasualYearMonthDayParser_1 = __importDefault(require(\"./parsers/NLCasualYearMonthDayParser\"));\nconst NLCasualDateTimeParser_1 = __importDefault(require(\"./parsers/NLCasualDateTimeParser\"));\nconst NLTimeUnitCasualRelativeFormatParser_1 = __importDefault(require(\"./parsers/NLTimeUnitCasualRelativeFormatParser\"));\nconst NLRelativeDateFormatParser_1 = __importDefault(require(\"./parsers/NLRelativeDateFormatParser\"));\nconst NLTimeUnitAgoFormatParser_1 = __importDefault(require(\"./parsers/NLTimeUnitAgoFormatParser\"));\nconst NLTimeUnitLaterFormatParser_1 = __importDefault(require(\"./parsers/NLTimeUnitLaterFormatParser\"));\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration(true));\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration(littleEndian = true) {\n    const option = createConfiguration(false, littleEndian);\n    option.parsers.unshift(new NLCasualDateParser_1.default());\n    option.parsers.unshift(new NLCasualTimeParser_1.default());\n    option.parsers.unshift(new NLCasualDateTimeParser_1.default());\n    option.parsers.unshift(new NLMonthNameParser_1.default());\n    option.parsers.unshift(new NLRelativeDateFormatParser_1.default());\n    option.parsers.unshift(new NLTimeUnitCasualRelativeFormatParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration(strictMode = true, littleEndian = true) {\n    return (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new SlashDateFormatParser_1.default(littleEndian),\n            new NLTimeUnitWithinFormatParser_1.default(),\n            new NLMonthNameMiddleEndianParser_1.default(),\n            new NLMonthNameParser_1.default(),\n            new NLWeekdayParser_1.default(),\n            new NLCasualYearMonthDayParser_1.default(),\n            new NLSlashMonthFormatParser_1.default(),\n            new NLTimeExpressionParser_1.default(strictMode),\n            new NLTimeUnitAgoFormatParser_1.default(strictMode),\n            new NLTimeUnitLaterFormatParser_1.default(strictMode),\n        ],\n        refiners: [new NLMergeDateTimeRefiner_1.default(), new NLMergeDateRangeRefiner_1.default()],\n    }, strictMode);\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst NOW_GROUP = 1;\nconst DAY_GROUP_1 = 2;\nconst TIME_GROUP_1 = 3;\nconst TIME_GROUP_2 = 4;\nconst DAY_GROUP_3 = 5;\nconst TIME_GROUP_3 = 6;\nclass ZHHantCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return new RegExp(\"(而家|立(?:刻|即)|即刻)|\" +\n            \"(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|\" +\n            \"(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|\" +\n            \"(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)\" +\n            \"(?:[\\\\s|,|，]*)\" +\n            \"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?\", \"i\");\n    }\n    innerExtract(context, match) {\n        const index = match.index;\n        const result = context.createParsingResult(index, match[0]);\n        const refMoment = (0, dayjs_1.default)(context.refDate);\n        let startMoment = refMoment;\n        if (match[NOW_GROUP]) {\n            result.start.imply(\"hour\", refMoment.hour());\n            result.start.imply(\"minute\", refMoment.minute());\n            result.start.imply(\"second\", refMoment.second());\n            result.start.imply(\"millisecond\", refMoment.millisecond());\n        }\n        else if (match[DAY_GROUP_1]) {\n            const day1 = match[DAY_GROUP_1];\n            const time1 = match[TIME_GROUP_1];\n            if (day1 == \"明\" || day1 == \"聽\") {\n                if (refMoment.hour() > 1) {\n                    startMoment = startMoment.add(1, \"day\");\n                }\n            }\n            else if (day1 == \"昨\" || day1 == \"尋\" || day1 == \"琴\") {\n                startMoment = startMoment.add(-1, \"day\");\n            }\n            else if (day1 == \"前\") {\n                startMoment = startMoment.add(-2, \"day\");\n            }\n            else if (day1 == \"大前\") {\n                startMoment = startMoment.add(-3, \"day\");\n            }\n            else if (day1 == \"後\") {\n                startMoment = startMoment.add(2, \"day\");\n            }\n            else if (day1 == \"大後\") {\n                startMoment = startMoment.add(3, \"day\");\n            }\n            if (time1 == \"早\" || time1 == \"朝\") {\n                result.start.imply(\"hour\", 6);\n            }\n            else if (time1 == \"晚\") {\n                result.start.imply(\"hour\", 22);\n                result.start.imply(\"meridiem\", 1);\n            }\n        }\n        else if (match[TIME_GROUP_2]) {\n            const timeString2 = match[TIME_GROUP_2];\n            const time2 = timeString2[0];\n            if (time2 == \"早\" || time2 == \"朝\" || time2 == \"上\") {\n                result.start.imply(\"hour\", 6);\n            }\n            else if (time2 == \"下\" || time2 == \"晏\") {\n                result.start.imply(\"hour\", 15);\n                result.start.imply(\"meridiem\", 1);\n            }\n            else if (time2 == \"中\") {\n                result.start.imply(\"hour\", 12);\n                result.start.imply(\"meridiem\", 1);\n            }\n            else if (time2 == \"夜\" || time2 == \"晚\") {\n                result.start.imply(\"hour\", 22);\n                result.start.imply(\"meridiem\", 1);\n            }\n            else if (time2 == \"凌\") {\n                result.start.imply(\"hour\", 0);\n            }\n        }\n        else if (match[DAY_GROUP_3]) {\n            const day3 = match[DAY_GROUP_3];\n            if (day3 == \"明\" || day3 == \"聽\") {\n                if (refMoment.hour() > 1) {\n                    startMoment = startMoment.add(1, \"day\");\n                }\n            }\n            else if (day3 == \"昨\" || day3 == \"尋\" || day3 == \"琴\") {\n                startMoment = startMoment.add(-1, \"day\");\n            }\n            else if (day3 == \"前\") {\n                startMoment = startMoment.add(-2, \"day\");\n            }\n            else if (day3 == \"大前\") {\n                startMoment = startMoment.add(-3, \"day\");\n            }\n            else if (day3 == \"後\") {\n                startMoment = startMoment.add(2, \"day\");\n            }\n            else if (day3 == \"大後\") {\n                startMoment = startMoment.add(3, \"day\");\n            }\n            const timeString3 = match[TIME_GROUP_3];\n            if (timeString3) {\n                const time3 = timeString3[0];\n                if (time3 == \"早\" || time3 == \"朝\" || time3 == \"上\") {\n                    result.start.imply(\"hour\", 6);\n                }\n                else if (time3 == \"下\" || time3 == \"晏\") {\n                    result.start.imply(\"hour\", 15);\n                    result.start.imply(\"meridiem\", 1);\n                }\n                else if (time3 == \"中\") {\n                    result.start.imply(\"hour\", 12);\n                    result.start.imply(\"meridiem\", 1);\n                }\n                else if (time3 == \"夜\" || time3 == \"晚\") {\n                    result.start.imply(\"hour\", 22);\n                    result.start.imply(\"meridiem\", 1);\n                }\n                else if (time3 == \"凌\") {\n                    result.start.imply(\"hour\", 0);\n                }\n            }\n        }\n        result.start.assign(\"day\", startMoment.date());\n        result.start.assign(\"month\", startMoment.month() + 1);\n        result.start.assign(\"year\", startMoment.year());\n        return result;\n    }\n}\nexports.default = ZHHantCasualDateParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.zhStringToYear = exports.zhStringToNumber = exports.WEEKDAY_OFFSET = exports.NUMBER = void 0;\nexports.NUMBER = {\n    \"零\": 0,\n    \"一\": 1,\n    \"二\": 2,\n    \"兩\": 2,\n    \"三\": 3,\n    \"四\": 4,\n    \"五\": 5,\n    \"六\": 6,\n    \"七\": 7,\n    \"八\": 8,\n    \"九\": 9,\n    \"十\": 10,\n    \"廿\": 20,\n    \"卅\": 30,\n};\nexports.WEEKDAY_OFFSET = {\n    \"天\": 0,\n    \"日\": 0,\n    \"一\": 1,\n    \"二\": 2,\n    \"三\": 3,\n    \"四\": 4,\n    \"五\": 5,\n    \"六\": 6,\n};\nfunction zhStringToNumber(text) {\n    let number = 0;\n    for (let i = 0; i < text.length; i++) {\n        const char = text[i];\n        if (char === \"十\") {\n            number = number === 0 ? exports.NUMBER[char] : number * exports.NUMBER[char];\n        }\n        else {\n            number += exports.NUMBER[char];\n        }\n    }\n    return number;\n}\nexports.zhStringToNumber = zhStringToNumber;\nfunction zhStringToYear(text) {\n    let string = \"\";\n    for (let i = 0; i < text.length; i++) {\n        const char = text[i];\n        string = string + exports.NUMBER[char];\n    }\n    return parseInt(string);\n}\nexports.zhStringToYear = zhStringToYear;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst YEAR_GROUP = 1;\nconst MONTH_GROUP = 2;\nconst DAY_GROUP = 3;\nclass ZHHantDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return new RegExp(\"(\" +\n            \"\\\\d{2,4}|\" +\n            \"[\" + Object.keys(constants_1.NUMBER).join(\"\") + \"]{4}|\" +\n            \"[\" + Object.keys(constants_1.NUMBER).join(\"\") + \"]{2}\" +\n            \")?\" +\n            \"(?:\\\\s*)\" +\n            \"(?:年)?\" +\n            \"(?:[\\\\s|,|，]*)\" +\n            \"(\" +\n            \"\\\\d{1,2}|\" +\n            \"[\" + Object.keys(constants_1.NUMBER).join(\"\") + \"]{1,2}\" +\n            \")\" +\n            \"(?:\\\\s*)\" +\n            \"(?:月)\" +\n            \"(?:\\\\s*)\" +\n            \"(\" +\n            \"\\\\d{1,2}|\" +\n            \"[\" + Object.keys(constants_1.NUMBER).join(\"\") + \"]{1,2}\" +\n            \")?\" +\n            \"(?:\\\\s*)\" +\n            \"(?:日|號)?\");\n    }\n    innerExtract(context, match) {\n        const startMoment = (0, dayjs_1.default)(context.refDate);\n        const result = context.createParsingResult(match.index, match[0]);\n        let month = parseInt(match[MONTH_GROUP]);\n        if (isNaN(month))\n            month = (0, constants_1.zhStringToNumber)(match[MONTH_GROUP]);\n        result.start.assign(\"month\", month);\n        if (match[DAY_GROUP]) {\n            let day = parseInt(match[DAY_GROUP]);\n            if (isNaN(day))\n                day = (0, constants_1.zhStringToNumber)(match[DAY_GROUP]);\n            result.start.assign(\"day\", day);\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n        }\n        if (match[YEAR_GROUP]) {\n            let year = parseInt(match[YEAR_GROUP]);\n            if (isNaN(year))\n                year = (0, constants_1.zhStringToYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", year);\n        }\n        else {\n            result.start.imply(\"year\", startMoment.year());\n        }\n        return result;\n    }\n}\nexports.default = ZHHantDateParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst PATTERN = new RegExp(\"(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+|半|幾)(?:\\\\s*)\" +\n    \"(?:個)?\" +\n    \"(秒(?:鐘)?|分鐘|小時|鐘|日|天|星期|禮拜|月|年)\" +\n    \"(?:(?:之|過)?後|(?:之)?內)\", \"i\");\nconst NUMBER_GROUP = 1;\nconst UNIT_GROUP = 2;\nclass ZHHantDeadlineFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        let number = parseInt(match[NUMBER_GROUP]);\n        if (isNaN(number)) {\n            number = (0, constants_1.zhStringToNumber)(match[NUMBER_GROUP]);\n        }\n        if (isNaN(number)) {\n            const string = match[NUMBER_GROUP];\n            if (string === \"幾\") {\n                number = 3;\n            }\n            else if (string === \"半\") {\n                number = 0.5;\n            }\n            else {\n                return null;\n            }\n        }\n        let date = (0, dayjs_1.default)(context.refDate);\n        const unit = match[UNIT_GROUP];\n        const unitAbbr = unit[0];\n        if (unitAbbr.match(/[日天星禮月年]/)) {\n            if (unitAbbr == \"日\" || unitAbbr == \"天\") {\n                date = date.add(number, \"d\");\n            }\n            else if (unitAbbr == \"星\" || unitAbbr == \"禮\") {\n                date = date.add(number * 7, \"d\");\n            }\n            else if (unitAbbr == \"月\") {\n                date = date.add(number, \"month\");\n            }\n            else if (unitAbbr == \"年\") {\n                date = date.add(number, \"year\");\n            }\n            result.start.assign(\"year\", date.year());\n            result.start.assign(\"month\", date.month() + 1);\n            result.start.assign(\"day\", date.date());\n            return result;\n        }\n        if (unitAbbr == \"秒\") {\n            date = date.add(number, \"second\");\n        }\n        else if (unitAbbr == \"分\") {\n            date = date.add(number, \"minute\");\n        }\n        else if (unitAbbr == \"小\" || unitAbbr == \"鐘\") {\n            date = date.add(number, \"hour\");\n        }\n        result.start.imply(\"year\", date.year());\n        result.start.imply(\"month\", date.month() + 1);\n        result.start.imply(\"day\", date.date());\n        result.start.assign(\"hour\", date.hour());\n        result.start.assign(\"minute\", date.minute());\n        result.start.assign(\"second\", date.second());\n        return result;\n    }\n}\nexports.default = ZHHantDeadlineFormatParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst PATTERN = new RegExp(\"(?<prefix>上|今|下|這|呢)(?:個)?(?:星期|禮拜|週)(?<weekday>\" + Object.keys(constants_1.WEEKDAY_OFFSET).join(\"|\") + \")\");\nclass ZHHantRelationWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const dayOfWeek = match.groups.weekday;\n        const offset = constants_1.WEEKDAY_OFFSET[dayOfWeek];\n        if (offset === undefined)\n            return null;\n        let modifier = null;\n        const prefix = match.groups.prefix;\n        if (prefix == \"上\") {\n            modifier = \"last\";\n        }\n        else if (prefix == \"下\") {\n            modifier = \"next\";\n        }\n        else if (prefix == \"今\" || prefix == \"這\" || prefix == \"呢\") {\n            modifier = \"this\";\n        }\n        let startMoment = (0, dayjs_1.default)(context.refDate);\n        let startMomentFixed = false;\n        const refOffset = startMoment.day();\n        if (modifier == \"last\" || modifier == \"past\") {\n            startMoment = startMoment.day(offset - 7);\n            startMomentFixed = true;\n        }\n        else if (modifier == \"next\") {\n            startMoment = startMoment.day(offset + 7);\n            startMomentFixed = true;\n        }\n        else if (modifier == \"this\") {\n            startMoment = startMoment.day(offset);\n        }\n        else {\n            if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {\n                startMoment = startMoment.day(offset - 7);\n            }\n            else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {\n                startMoment = startMoment.day(offset + 7);\n            }\n            else {\n                startMoment = startMoment.day(offset);\n            }\n        }\n        result.start.assign(\"weekday\", offset);\n        if (startMomentFixed) {\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n            result.start.imply(\"month\", startMoment.month() + 1);\n            result.start.imply(\"year\", startMoment.year());\n        }\n        return result;\n    }\n}\nexports.default = ZHHantRelationWeekdayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst FIRST_REG_PATTERN = new RegExp(\"(?:由|從|自)?\" +\n    \"(?:\" +\n    \"(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|\" +\n    \"(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|\" +\n    \"(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?\" +\n    \")?\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)(?:\\\\s*)(?:點|時|:|：)\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|半|正|整|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:分|:|：)?\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:秒)?)\" +\n    \"(?:\\\\s*(A.M.|P.M.|AM?|PM?))?\", \"i\");\nconst SECOND_REG_PATTERN = new RegExp(\"(?:^\\\\s*(?:到|至|\\\\-|\\\\–|\\\\~|\\\\〜)\\\\s*)\" +\n    \"(?:\" +\n    \"(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|\" +\n    \"(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|\" +\n    \"(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?\" +\n    \")?\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)(?:\\\\s*)(?:點|時|:|：)\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|半|正|整|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:分|:|：)?\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:秒)?)\" +\n    \"(?:\\\\s*(A.M.|P.M.|AM?|PM?))?\", \"i\");\nconst DAY_GROUP_1 = 1;\nconst ZH_AM_PM_HOUR_GROUP_1 = 2;\nconst ZH_AM_PM_HOUR_GROUP_2 = 3;\nconst DAY_GROUP_3 = 4;\nconst ZH_AM_PM_HOUR_GROUP_3 = 5;\nconst HOUR_GROUP = 6;\nconst MINUTE_GROUP = 7;\nconst SECOND_GROUP = 8;\nconst AM_PM_HOUR_GROUP = 9;\nclass ZHHantTimeExpressionParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return FIRST_REG_PATTERN;\n    }\n    innerExtract(context, match) {\n        if (match.index > 0 && context.text[match.index - 1].match(/\\w/)) {\n            return null;\n        }\n        const refMoment = (0, dayjs_1.default)(context.refDate);\n        const result = context.createParsingResult(match.index, match[0]);\n        const startMoment = refMoment.clone();\n        if (match[DAY_GROUP_1]) {\n            var day1 = match[DAY_GROUP_1];\n            if (day1 == \"明\" || day1 == \"聽\") {\n                if (refMoment.hour() > 1) {\n                    startMoment.add(1, \"day\");\n                }\n            }\n            else if (day1 == \"昨\" || day1 == \"尋\" || day1 == \"琴\") {\n                startMoment.add(-1, \"day\");\n            }\n            else if (day1 == \"前\") {\n                startMoment.add(-2, \"day\");\n            }\n            else if (day1 == \"大前\") {\n                startMoment.add(-3, \"day\");\n            }\n            else if (day1 == \"後\") {\n                startMoment.add(2, \"day\");\n            }\n            else if (day1 == \"大後\") {\n                startMoment.add(3, \"day\");\n            }\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else if (match[DAY_GROUP_3]) {\n            var day3 = match[DAY_GROUP_3];\n            if (day3 == \"明\" || day3 == \"聽\") {\n                startMoment.add(1, \"day\");\n            }\n            else if (day3 == \"昨\" || day3 == \"尋\" || day3 == \"琴\") {\n                startMoment.add(-1, \"day\");\n            }\n            else if (day3 == \"前\") {\n                startMoment.add(-2, \"day\");\n            }\n            else if (day3 == \"大前\") {\n                startMoment.add(-3, \"day\");\n            }\n            else if (day3 == \"後\") {\n                startMoment.add(2, \"day\");\n            }\n            else if (day3 == \"大後\") {\n                startMoment.add(3, \"day\");\n            }\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n            result.start.imply(\"month\", startMoment.month() + 1);\n            result.start.imply(\"year\", startMoment.year());\n        }\n        let hour = 0;\n        let minute = 0;\n        let meridiem = -1;\n        if (match[SECOND_GROUP]) {\n            var second = parseInt(match[SECOND_GROUP]);\n            if (isNaN(second)) {\n                second = (0, constants_1.zhStringToNumber)(match[SECOND_GROUP]);\n            }\n            if (second >= 60)\n                return null;\n            result.start.assign(\"second\", second);\n        }\n        hour = parseInt(match[HOUR_GROUP]);\n        if (isNaN(hour)) {\n            hour = (0, constants_1.zhStringToNumber)(match[HOUR_GROUP]);\n        }\n        if (match[MINUTE_GROUP]) {\n            if (match[MINUTE_GROUP] == \"半\") {\n                minute = 30;\n            }\n            else if (match[MINUTE_GROUP] == \"正\" || match[MINUTE_GROUP] == \"整\") {\n                minute = 0;\n            }\n            else {\n                minute = parseInt(match[MINUTE_GROUP]);\n                if (isNaN(minute)) {\n                    minute = (0, constants_1.zhStringToNumber)(match[MINUTE_GROUP]);\n                }\n            }\n        }\n        else if (hour > 100) {\n            minute = hour % 100;\n            hour = Math.floor(hour / 100);\n        }\n        if (minute >= 60) {\n            return null;\n        }\n        if (hour > 24) {\n            return null;\n        }\n        if (hour >= 12) {\n            meridiem = 1;\n        }\n        if (match[AM_PM_HOUR_GROUP]) {\n            if (hour > 12)\n                return null;\n            var ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            if (ampm == \"p\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_1]) {\n            var zhAMPMString1 = match[ZH_AM_PM_HOUR_GROUP_1];\n            var zhAMPM1 = zhAMPMString1[0];\n            if (zhAMPM1 == \"朝\" || zhAMPM1 == \"早\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM1 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_2]) {\n            var zhAMPMString2 = match[ZH_AM_PM_HOUR_GROUP_2];\n            var zhAMPM2 = zhAMPMString2[0];\n            if (zhAMPM2 == \"上\" || zhAMPM2 == \"朝\" || zhAMPM2 == \"早\" || zhAMPM2 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM2 == \"下\" || zhAMPM2 == \"晏\" || zhAMPM2 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_3]) {\n            var zhAMPMString3 = match[ZH_AM_PM_HOUR_GROUP_3];\n            var zhAMPM3 = zhAMPMString3[0];\n            if (zhAMPM3 == \"上\" || zhAMPM3 == \"朝\" || zhAMPM3 == \"早\" || zhAMPM3 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM3 == \"下\" || zhAMPM3 == \"晏\" || zhAMPM3 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        result.start.assign(\"hour\", hour);\n        result.start.assign(\"minute\", minute);\n        if (meridiem >= 0) {\n            result.start.assign(\"meridiem\", meridiem);\n        }\n        else {\n            if (hour < 12) {\n                result.start.imply(\"meridiem\", 0);\n            }\n            else {\n                result.start.imply(\"meridiem\", 1);\n            }\n        }\n        match = SECOND_REG_PATTERN.exec(context.text.substring(result.index + result.text.length));\n        if (!match) {\n            if (result.text.match(/^\\d+$/)) {\n                return null;\n            }\n            return result;\n        }\n        const endMoment = startMoment.clone();\n        result.end = context.createParsingComponents();\n        if (match[DAY_GROUP_1]) {\n            var day1 = match[DAY_GROUP_1];\n            if (day1 == \"明\" || day1 == \"聽\") {\n                if (refMoment.hour() > 1) {\n                    endMoment.add(1, \"day\");\n                }\n            }\n            else if (day1 == \"昨\" || day1 == \"尋\" || day1 == \"琴\") {\n                endMoment.add(-1, \"day\");\n            }\n            else if (day1 == \"前\") {\n                endMoment.add(-2, \"day\");\n            }\n            else if (day1 == \"大前\") {\n                endMoment.add(-3, \"day\");\n            }\n            else if (day1 == \"後\") {\n                endMoment.add(2, \"day\");\n            }\n            else if (day1 == \"大後\") {\n                endMoment.add(3, \"day\");\n            }\n            result.end.assign(\"day\", endMoment.date());\n            result.end.assign(\"month\", endMoment.month() + 1);\n            result.end.assign(\"year\", endMoment.year());\n        }\n        else if (match[DAY_GROUP_3]) {\n            var day3 = match[DAY_GROUP_3];\n            if (day3 == \"明\" || day3 == \"聽\") {\n                endMoment.add(1, \"day\");\n            }\n            else if (day3 == \"昨\" || day3 == \"尋\" || day3 == \"琴\") {\n                endMoment.add(-1, \"day\");\n            }\n            else if (day3 == \"前\") {\n                endMoment.add(-2, \"day\");\n            }\n            else if (day3 == \"大前\") {\n                endMoment.add(-3, \"day\");\n            }\n            else if (day3 == \"後\") {\n                endMoment.add(2, \"day\");\n            }\n            else if (day3 == \"大後\") {\n                endMoment.add(3, \"day\");\n            }\n            result.end.assign(\"day\", endMoment.date());\n            result.end.assign(\"month\", endMoment.month() + 1);\n            result.end.assign(\"year\", endMoment.year());\n        }\n        else {\n            result.end.imply(\"day\", endMoment.date());\n            result.end.imply(\"month\", endMoment.month() + 1);\n            result.end.imply(\"year\", endMoment.year());\n        }\n        hour = 0;\n        minute = 0;\n        meridiem = -1;\n        if (match[SECOND_GROUP]) {\n            var second = parseInt(match[SECOND_GROUP]);\n            if (isNaN(second)) {\n                second = (0, constants_1.zhStringToNumber)(match[SECOND_GROUP]);\n            }\n            if (second >= 60)\n                return null;\n            result.end.assign(\"second\", second);\n        }\n        hour = parseInt(match[HOUR_GROUP]);\n        if (isNaN(hour)) {\n            hour = (0, constants_1.zhStringToNumber)(match[HOUR_GROUP]);\n        }\n        if (match[MINUTE_GROUP]) {\n            if (match[MINUTE_GROUP] == \"半\") {\n                minute = 30;\n            }\n            else if (match[MINUTE_GROUP] == \"正\" || match[MINUTE_GROUP] == \"整\") {\n                minute = 0;\n            }\n            else {\n                minute = parseInt(match[MINUTE_GROUP]);\n                if (isNaN(minute)) {\n                    minute = (0, constants_1.zhStringToNumber)(match[MINUTE_GROUP]);\n                }\n            }\n        }\n        else if (hour > 100) {\n            minute = hour % 100;\n            hour = Math.floor(hour / 100);\n        }\n        if (minute >= 60) {\n            return null;\n        }\n        if (hour > 24) {\n            return null;\n        }\n        if (hour >= 12) {\n            meridiem = 1;\n        }\n        if (match[AM_PM_HOUR_GROUP]) {\n            if (hour > 12)\n                return null;\n            var ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            if (ampm == \"p\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n            if (!result.start.isCertain(\"meridiem\")) {\n                if (meridiem == 0) {\n                    result.start.imply(\"meridiem\", 0);\n                    if (result.start.get(\"hour\") == 12) {\n                        result.start.assign(\"hour\", 0);\n                    }\n                }\n                else {\n                    result.start.imply(\"meridiem\", 1);\n                    if (result.start.get(\"hour\") != 12) {\n                        result.start.assign(\"hour\", result.start.get(\"hour\") + 12);\n                    }\n                }\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_1]) {\n            var zhAMPMString1 = match[ZH_AM_PM_HOUR_GROUP_1];\n            var zhAMPM1 = zhAMPMString1[0];\n            if (zhAMPM1 == \"朝\" || zhAMPM1 == \"早\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM1 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_2]) {\n            var zhAMPMString2 = match[ZH_AM_PM_HOUR_GROUP_2];\n            var zhAMPM2 = zhAMPMString2[0];\n            if (zhAMPM2 == \"上\" || zhAMPM2 == \"朝\" || zhAMPM2 == \"早\" || zhAMPM2 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM2 == \"下\" || zhAMPM2 == \"晏\" || zhAMPM2 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_3]) {\n            var zhAMPMString3 = match[ZH_AM_PM_HOUR_GROUP_3];\n            var zhAMPM3 = zhAMPMString3[0];\n            if (zhAMPM3 == \"上\" || zhAMPM3 == \"朝\" || zhAMPM3 == \"早\" || zhAMPM3 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM3 == \"下\" || zhAMPM3 == \"晏\" || zhAMPM3 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        result.text = result.text + match[0];\n        result.end.assign(\"hour\", hour);\n        result.end.assign(\"minute\", minute);\n        if (meridiem >= 0) {\n            result.end.assign(\"meridiem\", meridiem);\n        }\n        else {\n            const startAtPM = result.start.isCertain(\"meridiem\") && result.start.get(\"meridiem\") == 1;\n            if (startAtPM && result.start.get(\"hour\") > hour) {\n                result.end.imply(\"meridiem\", 0);\n            }\n            else if (hour > 12) {\n                result.end.imply(\"meridiem\", 1);\n            }\n        }\n        if (result.end.date().getTime() < result.start.date().getTime()) {\n            result.end.imply(\"day\", result.end.get(\"day\") + 1);\n        }\n        return result;\n    }\n}\nexports.default = ZHHantTimeExpressionParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst PATTERN = new RegExp(\"(?:星期|禮拜|週)(?<weekday>\" + Object.keys(constants_1.WEEKDAY_OFFSET).join(\"|\") + \")\");\nclass ZHHantWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const dayOfWeek = match.groups.weekday;\n        const offset = constants_1.WEEKDAY_OFFSET[dayOfWeek];\n        if (offset === undefined)\n            return null;\n        let startMoment = (0, dayjs_1.default)(context.refDate);\n        const startMomentFixed = false;\n        const refOffset = startMoment.day();\n        if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {\n            startMoment = startMoment.day(offset - 7);\n        }\n        else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {\n            startMoment = startMoment.day(offset + 7);\n        }\n        else {\n            startMoment = startMoment.day(offset);\n        }\n        result.start.assign(\"weekday\", offset);\n        if (startMomentFixed) {\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n            result.start.imply(\"month\", startMoment.month() + 1);\n            result.start.imply(\"year\", startMoment.year());\n        }\n        return result;\n    }\n}\nexports.default = ZHHantWeekdayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass ZHHantMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(至|到|\\-|\\~|～|－|ー)\\s*$/i;\n    }\n}\nexports.default = ZHHantMergeDateRangeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass ZHHantMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*$/i;\n    }\n}\nexports.default = ZHHantMergeDateTimeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = exports.hant = void 0;\nconst chrono_1 = require(\"../../../chrono\");\nconst ExtractTimezoneOffsetRefiner_1 = __importDefault(require(\"../../../common/refiners/ExtractTimezoneOffsetRefiner\"));\nconst configurations_1 = require(\"../../../configurations\");\nconst ZHHantCasualDateParser_1 = __importDefault(require(\"./parsers/ZHHantCasualDateParser\"));\nconst ZHHantDateParser_1 = __importDefault(require(\"./parsers/ZHHantDateParser\"));\nconst ZHHantDeadlineFormatParser_1 = __importDefault(require(\"./parsers/ZHHantDeadlineFormatParser\"));\nconst ZHHantRelationWeekdayParser_1 = __importDefault(require(\"./parsers/ZHHantRelationWeekdayParser\"));\nconst ZHHantTimeExpressionParser_1 = __importDefault(require(\"./parsers/ZHHantTimeExpressionParser\"));\nconst ZHHantWeekdayParser_1 = __importDefault(require(\"./parsers/ZHHantWeekdayParser\"));\nconst ZHHantMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/ZHHantMergeDateRangeRefiner\"));\nconst ZHHantMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/ZHHantMergeDateTimeRefiner\"));\nexports.hant = new chrono_1.Chrono(createCasualConfiguration());\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration());\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration() {\n    const option = createConfiguration();\n    option.parsers.unshift(new ZHHantCasualDateParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration() {\n    const configuration = (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new ZHHantDateParser_1.default(),\n            new ZHHantRelationWeekdayParser_1.default(),\n            new ZHHantWeekdayParser_1.default(),\n            new ZHHantTimeExpressionParser_1.default(),\n            new ZHHantDeadlineFormatParser_1.default(),\n        ],\n        refiners: [new ZHHantMergeDateRangeRefiner_1.default(), new ZHHantMergeDateTimeRefiner_1.default()],\n    });\n    configuration.refiners = configuration.refiners.filter((refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner_1.default));\n    return configuration;\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst NOW_GROUP = 1;\nconst DAY_GROUP_1 = 2;\nconst TIME_GROUP_1 = 3;\nconst TIME_GROUP_2 = 4;\nconst DAY_GROUP_3 = 5;\nconst TIME_GROUP_3 = 6;\nclass ZHHansCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern(context) {\n        return new RegExp(\"(现在|立(?:刻|即)|即刻)|\" +\n            \"(今|明|前|大前|后|大后|昨)(早|晚)|\" +\n            \"(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|\" +\n            \"(今|明|前|大前|后|大后|昨)(?:日|天)\" +\n            \"(?:[\\\\s|,|，]*)\" +\n            \"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?\", \"i\");\n    }\n    innerExtract(context, match) {\n        const index = match.index;\n        const result = context.createParsingResult(index, match[0]);\n        const refMoment = (0, dayjs_1.default)(context.refDate);\n        let startMoment = refMoment;\n        if (match[NOW_GROUP]) {\n            result.start.imply(\"hour\", refMoment.hour());\n            result.start.imply(\"minute\", refMoment.minute());\n            result.start.imply(\"second\", refMoment.second());\n            result.start.imply(\"millisecond\", refMoment.millisecond());\n        }\n        else if (match[DAY_GROUP_1]) {\n            const day1 = match[DAY_GROUP_1];\n            const time1 = match[TIME_GROUP_1];\n            if (day1 == \"明\") {\n                if (refMoment.hour() > 1) {\n                    startMoment = startMoment.add(1, \"day\");\n                }\n            }\n            else if (day1 == \"昨\") {\n                startMoment = startMoment.add(-1, \"day\");\n            }\n            else if (day1 == \"前\") {\n                startMoment = startMoment.add(-2, \"day\");\n            }\n            else if (day1 == \"大前\") {\n                startMoment = startMoment.add(-3, \"day\");\n            }\n            else if (day1 == \"后\") {\n                startMoment = startMoment.add(2, \"day\");\n            }\n            else if (day1 == \"大后\") {\n                startMoment = startMoment.add(3, \"day\");\n            }\n            if (time1 == \"早\") {\n                result.start.imply(\"hour\", 6);\n            }\n            else if (time1 == \"晚\") {\n                result.start.imply(\"hour\", 22);\n                result.start.imply(\"meridiem\", 1);\n            }\n        }\n        else if (match[TIME_GROUP_2]) {\n            const timeString2 = match[TIME_GROUP_2];\n            const time2 = timeString2[0];\n            if (time2 == \"早\" || time2 == \"上\") {\n                result.start.imply(\"hour\", 6);\n            }\n            else if (time2 == \"下\") {\n                result.start.imply(\"hour\", 15);\n                result.start.imply(\"meridiem\", 1);\n            }\n            else if (time2 == \"中\") {\n                result.start.imply(\"hour\", 12);\n                result.start.imply(\"meridiem\", 1);\n            }\n            else if (time2 == \"夜\" || time2 == \"晚\") {\n                result.start.imply(\"hour\", 22);\n                result.start.imply(\"meridiem\", 1);\n            }\n            else if (time2 == \"凌\") {\n                result.start.imply(\"hour\", 0);\n            }\n        }\n        else if (match[DAY_GROUP_3]) {\n            const day3 = match[DAY_GROUP_3];\n            if (day3 == \"明\") {\n                if (refMoment.hour() > 1) {\n                    startMoment = startMoment.add(1, \"day\");\n                }\n            }\n            else if (day3 == \"昨\") {\n                startMoment = startMoment.add(-1, \"day\");\n            }\n            else if (day3 == \"前\") {\n                startMoment = startMoment.add(-2, \"day\");\n            }\n            else if (day3 == \"大前\") {\n                startMoment = startMoment.add(-3, \"day\");\n            }\n            else if (day3 == \"后\") {\n                startMoment = startMoment.add(2, \"day\");\n            }\n            else if (day3 == \"大后\") {\n                startMoment = startMoment.add(3, \"day\");\n            }\n            const timeString3 = match[TIME_GROUP_3];\n            if (timeString3) {\n                const time3 = timeString3[0];\n                if (time3 == \"早\" || time3 == \"上\") {\n                    result.start.imply(\"hour\", 6);\n                }\n                else if (time3 == \"下\") {\n                    result.start.imply(\"hour\", 15);\n                    result.start.imply(\"meridiem\", 1);\n                }\n                else if (time3 == \"中\") {\n                    result.start.imply(\"hour\", 12);\n                    result.start.imply(\"meridiem\", 1);\n                }\n                else if (time3 == \"夜\" || time3 == \"晚\") {\n                    result.start.imply(\"hour\", 22);\n                    result.start.imply(\"meridiem\", 1);\n                }\n                else if (time3 == \"凌\") {\n                    result.start.imply(\"hour\", 0);\n                }\n            }\n        }\n        result.start.assign(\"day\", startMoment.date());\n        result.start.assign(\"month\", startMoment.month() + 1);\n        result.start.assign(\"year\", startMoment.year());\n        return result;\n    }\n}\nexports.default = ZHHansCasualDateParser;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.zhStringToYear = exports.zhStringToNumber = exports.WEEKDAY_OFFSET = exports.NUMBER = void 0;\nexports.NUMBER = {\n    \"零\": 0,\n    \"〇\": 0,\n    \"一\": 1,\n    \"二\": 2,\n    \"两\": 2,\n    \"三\": 3,\n    \"四\": 4,\n    \"五\": 5,\n    \"六\": 6,\n    \"七\": 7,\n    \"八\": 8,\n    \"九\": 9,\n    \"十\": 10,\n};\nexports.WEEKDAY_OFFSET = {\n    \"天\": 0,\n    \"日\": 0,\n    \"一\": 1,\n    \"二\": 2,\n    \"三\": 3,\n    \"四\": 4,\n    \"五\": 5,\n    \"六\": 6,\n};\nfunction zhStringToNumber(text) {\n    let number = 0;\n    for (let i = 0; i < text.length; i++) {\n        const char = text[i];\n        if (char === \"十\") {\n            number = number === 0 ? exports.NUMBER[char] : number * exports.NUMBER[char];\n        }\n        else {\n            number += exports.NUMBER[char];\n        }\n    }\n    return number;\n}\nexports.zhStringToNumber = zhStringToNumber;\nfunction zhStringToYear(text) {\n    let string = \"\";\n    for (let i = 0; i < text.length; i++) {\n        const char = text[i];\n        string = string + exports.NUMBER[char];\n    }\n    return parseInt(string);\n}\nexports.zhStringToYear = zhStringToYear;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst YEAR_GROUP = 1;\nconst MONTH_GROUP = 2;\nconst DAY_GROUP = 3;\nclass ZHHansDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return new RegExp(\"(\" +\n            \"\\\\d{2,4}|\" +\n            \"[\" +\n            Object.keys(constants_1.NUMBER).join(\"\") +\n            \"]{4}|\" +\n            \"[\" +\n            Object.keys(constants_1.NUMBER).join(\"\") +\n            \"]{2}\" +\n            \")?\" +\n            \"(?:\\\\s*)\" +\n            \"(?:年)?\" +\n            \"(?:[\\\\s|,|，]*)\" +\n            \"(\" +\n            \"\\\\d{1,2}|\" +\n            \"[\" +\n            Object.keys(constants_1.NUMBER).join(\"\") +\n            \"]{1,3}\" +\n            \")\" +\n            \"(?:\\\\s*)\" +\n            \"(?:月)\" +\n            \"(?:\\\\s*)\" +\n            \"(\" +\n            \"\\\\d{1,2}|\" +\n            \"[\" +\n            Object.keys(constants_1.NUMBER).join(\"\") +\n            \"]{1,3}\" +\n            \")?\" +\n            \"(?:\\\\s*)\" +\n            \"(?:日|号)?\");\n    }\n    innerExtract(context, match) {\n        const startMoment = (0, dayjs_1.default)(context.refDate);\n        const result = context.createParsingResult(match.index, match[0]);\n        let month = parseInt(match[MONTH_GROUP]);\n        if (isNaN(month))\n            month = (0, constants_1.zhStringToNumber)(match[MONTH_GROUP]);\n        result.start.assign(\"month\", month);\n        if (match[DAY_GROUP]) {\n            let day = parseInt(match[DAY_GROUP]);\n            if (isNaN(day))\n                day = (0, constants_1.zhStringToNumber)(match[DAY_GROUP]);\n            result.start.assign(\"day\", day);\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n        }\n        if (match[YEAR_GROUP]) {\n            let year = parseInt(match[YEAR_GROUP]);\n            if (isNaN(year))\n                year = (0, constants_1.zhStringToYear)(match[YEAR_GROUP]);\n            result.start.assign(\"year\", year);\n        }\n        else {\n            result.start.imply(\"year\", startMoment.year());\n        }\n        return result;\n    }\n}\nexports.default = ZHHansDateParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst PATTERN = new RegExp(\"(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+|半|几)(?:\\\\s*)\" +\n    \"(?:个)?\" +\n    \"(秒(?:钟)?|分钟|小时|钟|日|天|星期|礼拜|月|年)\" +\n    \"(?:(?:之|过)?后|(?:之)?内)\", \"i\");\nconst NUMBER_GROUP = 1;\nconst UNIT_GROUP = 2;\nclass ZHHansDeadlineFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        let number = parseInt(match[NUMBER_GROUP]);\n        if (isNaN(number)) {\n            number = (0, constants_1.zhStringToNumber)(match[NUMBER_GROUP]);\n        }\n        if (isNaN(number)) {\n            const string = match[NUMBER_GROUP];\n            if (string === \"几\") {\n                number = 3;\n            }\n            else if (string === \"半\") {\n                number = 0.5;\n            }\n            else {\n                return null;\n            }\n        }\n        let date = (0, dayjs_1.default)(context.refDate);\n        const unit = match[UNIT_GROUP];\n        const unitAbbr = unit[0];\n        if (unitAbbr.match(/[日天星礼月年]/)) {\n            if (unitAbbr == \"日\" || unitAbbr == \"天\") {\n                date = date.add(number, \"d\");\n            }\n            else if (unitAbbr == \"星\" || unitAbbr == \"礼\") {\n                date = date.add(number * 7, \"d\");\n            }\n            else if (unitAbbr == \"月\") {\n                date = date.add(number, \"month\");\n            }\n            else if (unitAbbr == \"年\") {\n                date = date.add(number, \"year\");\n            }\n            result.start.assign(\"year\", date.year());\n            result.start.assign(\"month\", date.month() + 1);\n            result.start.assign(\"day\", date.date());\n            return result;\n        }\n        if (unitAbbr == \"秒\") {\n            date = date.add(number, \"second\");\n        }\n        else if (unitAbbr == \"分\") {\n            date = date.add(number, \"minute\");\n        }\n        else if (unitAbbr == \"小\" || unitAbbr == \"钟\") {\n            date = date.add(number, \"hour\");\n        }\n        result.start.imply(\"year\", date.year());\n        result.start.imply(\"month\", date.month() + 1);\n        result.start.imply(\"day\", date.date());\n        result.start.assign(\"hour\", date.hour());\n        result.start.assign(\"minute\", date.minute());\n        result.start.assign(\"second\", date.second());\n        return result;\n    }\n}\nexports.default = ZHHansDeadlineFormatParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst PATTERN = new RegExp(\"(?<prefix>上|下|这)(?:个)?(?:星期|礼拜|周)(?<weekday>\" + Object.keys(constants_1.WEEKDAY_OFFSET).join(\"|\") + \")\");\nclass ZHHansRelationWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const dayOfWeek = match.groups.weekday;\n        const offset = constants_1.WEEKDAY_OFFSET[dayOfWeek];\n        if (offset === undefined)\n            return null;\n        let modifier = null;\n        const prefix = match.groups.prefix;\n        if (prefix == \"上\") {\n            modifier = \"last\";\n        }\n        else if (prefix == \"下\") {\n            modifier = \"next\";\n        }\n        else if (prefix == \"这\") {\n            modifier = \"this\";\n        }\n        let startMoment = (0, dayjs_1.default)(context.refDate);\n        let startMomentFixed = false;\n        const refOffset = startMoment.day();\n        if (modifier == \"last\" || modifier == \"past\") {\n            startMoment = startMoment.day(offset - 7);\n            startMomentFixed = true;\n        }\n        else if (modifier == \"next\") {\n            startMoment = startMoment.day(offset + 7);\n            startMomentFixed = true;\n        }\n        else if (modifier == \"this\") {\n            startMoment = startMoment.day(offset);\n        }\n        else {\n            if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {\n                startMoment = startMoment.day(offset - 7);\n            }\n            else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {\n                startMoment = startMoment.day(offset + 7);\n            }\n            else {\n                startMoment = startMoment.day(offset);\n            }\n        }\n        result.start.assign(\"weekday\", offset);\n        if (startMomentFixed) {\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n            result.start.imply(\"month\", startMoment.month() + 1);\n            result.start.imply(\"year\", startMoment.year());\n        }\n        return result;\n    }\n}\nexports.default = ZHHansRelationWeekdayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst FIRST_REG_PATTERN = new RegExp(\"(?:从|自)?\" +\n    \"(?:\" +\n    \"(今|明|前|大前|后|大后|昨)(早|朝|晚)|\" +\n    \"(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|\" +\n    \"(今|明|前|大前|后|大后|昨)(?:日|天)\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?\" +\n    \")?\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)(?:\\\\s*)(?:点|时|:|：)\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|半|正|整|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:分|:|：)?\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:秒)?)\" +\n    \"(?:\\\\s*(A.M.|P.M.|AM?|PM?))?\", \"i\");\nconst SECOND_REG_PATTERN = new RegExp(\"(?:^\\\\s*(?:到|至|\\\\-|\\\\–|\\\\~|\\\\〜)\\\\s*)\" +\n    \"(?:\" +\n    \"(今|明|前|大前|后|大后|昨)(早|朝|晚)|\" +\n    \"(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|\" +\n    \"(今|明|前|大前|后|大后|昨)(?:日|天)\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?\" +\n    \")?\" +\n    \"(?:[\\\\s,，]*)\" +\n    \"(?:(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)(?:\\\\s*)(?:点|时|:|：)\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|半|正|整|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:分|:|：)?\" +\n    \"(?:\\\\s*)\" +\n    \"(\\\\d+|[\" +\n    Object.keys(constants_1.NUMBER).join(\"\") +\n    \"]+)?(?:\\\\s*)(?:秒)?)\" +\n    \"(?:\\\\s*(A.M.|P.M.|AM?|PM?))?\", \"i\");\nconst DAY_GROUP_1 = 1;\nconst ZH_AM_PM_HOUR_GROUP_1 = 2;\nconst ZH_AM_PM_HOUR_GROUP_2 = 3;\nconst DAY_GROUP_3 = 4;\nconst ZH_AM_PM_HOUR_GROUP_3 = 5;\nconst HOUR_GROUP = 6;\nconst MINUTE_GROUP = 7;\nconst SECOND_GROUP = 8;\nconst AM_PM_HOUR_GROUP = 9;\nclass ZHHansTimeExpressionParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return FIRST_REG_PATTERN;\n    }\n    innerExtract(context, match) {\n        if (match.index > 0 && context.text[match.index - 1].match(/\\w/)) {\n            return null;\n        }\n        const refMoment = (0, dayjs_1.default)(context.refDate);\n        const result = context.createParsingResult(match.index, match[0]);\n        const startMoment = refMoment.clone();\n        if (match[DAY_GROUP_1]) {\n            const day1 = match[DAY_GROUP_1];\n            if (day1 == \"明\") {\n                if (refMoment.hour() > 1) {\n                    startMoment.add(1, \"day\");\n                }\n            }\n            else if (day1 == \"昨\") {\n                startMoment.add(-1, \"day\");\n            }\n            else if (day1 == \"前\") {\n                startMoment.add(-2, \"day\");\n            }\n            else if (day1 == \"大前\") {\n                startMoment.add(-3, \"day\");\n            }\n            else if (day1 == \"后\") {\n                startMoment.add(2, \"day\");\n            }\n            else if (day1 == \"大后\") {\n                startMoment.add(3, \"day\");\n            }\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else if (match[DAY_GROUP_3]) {\n            const day3 = match[DAY_GROUP_3];\n            if (day3 == \"明\") {\n                startMoment.add(1, \"day\");\n            }\n            else if (day3 == \"昨\") {\n                startMoment.add(-1, \"day\");\n            }\n            else if (day3 == \"前\") {\n                startMoment.add(-2, \"day\");\n            }\n            else if (day3 == \"大前\") {\n                startMoment.add(-3, \"day\");\n            }\n            else if (day3 == \"后\") {\n                startMoment.add(2, \"day\");\n            }\n            else if (day3 == \"大后\") {\n                startMoment.add(3, \"day\");\n            }\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n            result.start.imply(\"month\", startMoment.month() + 1);\n            result.start.imply(\"year\", startMoment.year());\n        }\n        let hour = 0;\n        let minute = 0;\n        let meridiem = -1;\n        if (match[SECOND_GROUP]) {\n            let second = parseInt(match[SECOND_GROUP]);\n            if (isNaN(second)) {\n                second = (0, constants_1.zhStringToNumber)(match[SECOND_GROUP]);\n            }\n            if (second >= 60)\n                return null;\n            result.start.assign(\"second\", second);\n        }\n        hour = parseInt(match[HOUR_GROUP]);\n        if (isNaN(hour)) {\n            hour = (0, constants_1.zhStringToNumber)(match[HOUR_GROUP]);\n        }\n        if (match[MINUTE_GROUP]) {\n            if (match[MINUTE_GROUP] == \"半\") {\n                minute = 30;\n            }\n            else if (match[MINUTE_GROUP] == \"正\" || match[MINUTE_GROUP] == \"整\") {\n                minute = 0;\n            }\n            else {\n                minute = parseInt(match[MINUTE_GROUP]);\n                if (isNaN(minute)) {\n                    minute = (0, constants_1.zhStringToNumber)(match[MINUTE_GROUP]);\n                }\n            }\n        }\n        else if (hour > 100) {\n            minute = hour % 100;\n            hour = Math.floor(hour / 100);\n        }\n        if (minute >= 60) {\n            return null;\n        }\n        if (hour > 24) {\n            return null;\n        }\n        if (hour >= 12) {\n            meridiem = 1;\n        }\n        if (match[AM_PM_HOUR_GROUP]) {\n            if (hour > 12)\n                return null;\n            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            if (ampm == \"p\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_1]) {\n            const zhAMPMString1 = match[ZH_AM_PM_HOUR_GROUP_1];\n            const zhAMPM1 = zhAMPMString1[0];\n            if (zhAMPM1 == \"早\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM1 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_2]) {\n            const zhAMPMString2 = match[ZH_AM_PM_HOUR_GROUP_2];\n            const zhAMPM2 = zhAMPMString2[0];\n            if (zhAMPM2 == \"上\" || zhAMPM2 == \"早\" || zhAMPM2 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM2 == \"下\" || zhAMPM2 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_3]) {\n            const zhAMPMString3 = match[ZH_AM_PM_HOUR_GROUP_3];\n            const zhAMPM3 = zhAMPMString3[0];\n            if (zhAMPM3 == \"上\" || zhAMPM3 == \"早\" || zhAMPM3 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM3 == \"下\" || zhAMPM3 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        result.start.assign(\"hour\", hour);\n        result.start.assign(\"minute\", minute);\n        if (meridiem >= 0) {\n            result.start.assign(\"meridiem\", meridiem);\n        }\n        else {\n            if (hour < 12) {\n                result.start.imply(\"meridiem\", 0);\n            }\n            else {\n                result.start.imply(\"meridiem\", 1);\n            }\n        }\n        match = SECOND_REG_PATTERN.exec(context.text.substring(result.index + result.text.length));\n        if (!match) {\n            if (result.text.match(/^\\d+$/)) {\n                return null;\n            }\n            return result;\n        }\n        const endMoment = startMoment.clone();\n        result.end = context.createParsingComponents();\n        if (match[DAY_GROUP_1]) {\n            const day1 = match[DAY_GROUP_1];\n            if (day1 == \"明\") {\n                if (refMoment.hour() > 1) {\n                    endMoment.add(1, \"day\");\n                }\n            }\n            else if (day1 == \"昨\") {\n                endMoment.add(-1, \"day\");\n            }\n            else if (day1 == \"前\") {\n                endMoment.add(-2, \"day\");\n            }\n            else if (day1 == \"大前\") {\n                endMoment.add(-3, \"day\");\n            }\n            else if (day1 == \"后\") {\n                endMoment.add(2, \"day\");\n            }\n            else if (day1 == \"大后\") {\n                endMoment.add(3, \"day\");\n            }\n            result.end.assign(\"day\", endMoment.date());\n            result.end.assign(\"month\", endMoment.month() + 1);\n            result.end.assign(\"year\", endMoment.year());\n        }\n        else if (match[DAY_GROUP_3]) {\n            const day3 = match[DAY_GROUP_3];\n            if (day3 == \"明\") {\n                endMoment.add(1, \"day\");\n            }\n            else if (day3 == \"昨\") {\n                endMoment.add(-1, \"day\");\n            }\n            else if (day3 == \"前\") {\n                endMoment.add(-2, \"day\");\n            }\n            else if (day3 == \"大前\") {\n                endMoment.add(-3, \"day\");\n            }\n            else if (day3 == \"后\") {\n                endMoment.add(2, \"day\");\n            }\n            else if (day3 == \"大后\") {\n                endMoment.add(3, \"day\");\n            }\n            result.end.assign(\"day\", endMoment.date());\n            result.end.assign(\"month\", endMoment.month() + 1);\n            result.end.assign(\"year\", endMoment.year());\n        }\n        else {\n            result.end.imply(\"day\", endMoment.date());\n            result.end.imply(\"month\", endMoment.month() + 1);\n            result.end.imply(\"year\", endMoment.year());\n        }\n        hour = 0;\n        minute = 0;\n        meridiem = -1;\n        if (match[SECOND_GROUP]) {\n            let second = parseInt(match[SECOND_GROUP]);\n            if (isNaN(second)) {\n                second = (0, constants_1.zhStringToNumber)(match[SECOND_GROUP]);\n            }\n            if (second >= 60)\n                return null;\n            result.end.assign(\"second\", second);\n        }\n        hour = parseInt(match[HOUR_GROUP]);\n        if (isNaN(hour)) {\n            hour = (0, constants_1.zhStringToNumber)(match[HOUR_GROUP]);\n        }\n        if (match[MINUTE_GROUP]) {\n            if (match[MINUTE_GROUP] == \"半\") {\n                minute = 30;\n            }\n            else if (match[MINUTE_GROUP] == \"正\" || match[MINUTE_GROUP] == \"整\") {\n                minute = 0;\n            }\n            else {\n                minute = parseInt(match[MINUTE_GROUP]);\n                if (isNaN(minute)) {\n                    minute = (0, constants_1.zhStringToNumber)(match[MINUTE_GROUP]);\n                }\n            }\n        }\n        else if (hour > 100) {\n            minute = hour % 100;\n            hour = Math.floor(hour / 100);\n        }\n        if (minute >= 60) {\n            return null;\n        }\n        if (hour > 24) {\n            return null;\n        }\n        if (hour >= 12) {\n            meridiem = 1;\n        }\n        if (match[AM_PM_HOUR_GROUP]) {\n            if (hour > 12)\n                return null;\n            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();\n            if (ampm == \"a\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            if (ampm == \"p\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n            if (!result.start.isCertain(\"meridiem\")) {\n                if (meridiem == 0) {\n                    result.start.imply(\"meridiem\", 0);\n                    if (result.start.get(\"hour\") == 12) {\n                        result.start.assign(\"hour\", 0);\n                    }\n                }\n                else {\n                    result.start.imply(\"meridiem\", 1);\n                    if (result.start.get(\"hour\") != 12) {\n                        result.start.assign(\"hour\", result.start.get(\"hour\") + 12);\n                    }\n                }\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_1]) {\n            const zhAMPMString1 = match[ZH_AM_PM_HOUR_GROUP_1];\n            const zhAMPM1 = zhAMPMString1[0];\n            if (zhAMPM1 == \"早\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM1 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_2]) {\n            const zhAMPMString2 = match[ZH_AM_PM_HOUR_GROUP_2];\n            const zhAMPM2 = zhAMPMString2[0];\n            if (zhAMPM2 == \"上\" || zhAMPM2 == \"早\" || zhAMPM2 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM2 == \"下\" || zhAMPM2 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        else if (match[ZH_AM_PM_HOUR_GROUP_3]) {\n            const zhAMPMString3 = match[ZH_AM_PM_HOUR_GROUP_3];\n            const zhAMPM3 = zhAMPMString3[0];\n            if (zhAMPM3 == \"上\" || zhAMPM3 == \"早\" || zhAMPM3 == \"凌\") {\n                meridiem = 0;\n                if (hour == 12)\n                    hour = 0;\n            }\n            else if (zhAMPM3 == \"下\" || zhAMPM3 == \"晚\") {\n                meridiem = 1;\n                if (hour != 12)\n                    hour += 12;\n            }\n        }\n        result.text = result.text + match[0];\n        result.end.assign(\"hour\", hour);\n        result.end.assign(\"minute\", minute);\n        if (meridiem >= 0) {\n            result.end.assign(\"meridiem\", meridiem);\n        }\n        else {\n            const startAtPM = result.start.isCertain(\"meridiem\") && result.start.get(\"meridiem\") == 1;\n            if (startAtPM && result.start.get(\"hour\") > hour) {\n                result.end.imply(\"meridiem\", 0);\n            }\n            else if (hour > 12) {\n                result.end.imply(\"meridiem\", 1);\n            }\n        }\n        if (result.end.date().getTime() < result.start.date().getTime()) {\n            result.end.imply(\"day\", result.end.get(\"day\") + 1);\n        }\n        return result;\n    }\n}\nexports.default = ZHHansTimeExpressionParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst dayjs_1 = __importDefault(require(\"dayjs\"));\nconst AbstractParserWithWordBoundary_1 = require(\"../../../../common/parsers/AbstractParserWithWordBoundary\");\nconst constants_1 = require(\"../constants\");\nconst PATTERN = new RegExp(\"(?:星期|礼拜|周)(?<weekday>\" + Object.keys(constants_1.WEEKDAY_OFFSET).join(\"|\") + \")\");\nclass ZHHansWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {\n    innerPattern() {\n        return PATTERN;\n    }\n    innerExtract(context, match) {\n        const result = context.createParsingResult(match.index, match[0]);\n        const dayOfWeek = match.groups.weekday;\n        const offset = constants_1.WEEKDAY_OFFSET[dayOfWeek];\n        if (offset === undefined)\n            return null;\n        let startMoment = (0, dayjs_1.default)(context.refDate);\n        const startMomentFixed = false;\n        const refOffset = startMoment.day();\n        if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {\n            startMoment = startMoment.day(offset - 7);\n        }\n        else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {\n            startMoment = startMoment.day(offset + 7);\n        }\n        else {\n            startMoment = startMoment.day(offset);\n        }\n        result.start.assign(\"weekday\", offset);\n        if (startMomentFixed) {\n            result.start.assign(\"day\", startMoment.date());\n            result.start.assign(\"month\", startMoment.month() + 1);\n            result.start.assign(\"year\", startMoment.year());\n        }\n        else {\n            result.start.imply(\"day\", startMoment.date());\n            result.start.imply(\"month\", startMoment.month() + 1);\n            result.start.imply(\"year\", startMoment.year());\n        }\n        return result;\n    }\n}\nexports.default = ZHHansWeekdayParser;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateRangeRefiner_1 = __importDefault(require(\"../../../../common/refiners/AbstractMergeDateRangeRefiner\"));\nclass ZHHansMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*(至|到|-|~|～|－|ー)\\s*$/i;\n    }\n}\nexports.default = ZHHansMergeDateRangeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst AbstractMergeDateTimeRefiner_1 = __importDefault(require(\"../../../../common/refiners/AbstractMergeDateTimeRefiner\"));\nclass ZHHansMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {\n    patternBetween() {\n        return /^\\s*$/i;\n    }\n}\nexports.default = ZHHansMergeDateTimeRefiner;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = exports.hans = void 0;\nconst chrono_1 = require(\"../../../chrono\");\nconst ExtractTimezoneOffsetRefiner_1 = __importDefault(require(\"../../../common/refiners/ExtractTimezoneOffsetRefiner\"));\nconst configurations_1 = require(\"../../../configurations\");\nconst ZHHansCasualDateParser_1 = __importDefault(require(\"./parsers/ZHHansCasualDateParser\"));\nconst ZHHansDateParser_1 = __importDefault(require(\"./parsers/ZHHansDateParser\"));\nconst ZHHansDeadlineFormatParser_1 = __importDefault(require(\"./parsers/ZHHansDeadlineFormatParser\"));\nconst ZHHansRelationWeekdayParser_1 = __importDefault(require(\"./parsers/ZHHansRelationWeekdayParser\"));\nconst ZHHansTimeExpressionParser_1 = __importDefault(require(\"./parsers/ZHHansTimeExpressionParser\"));\nconst ZHHansWeekdayParser_1 = __importDefault(require(\"./parsers/ZHHansWeekdayParser\"));\nconst ZHHansMergeDateRangeRefiner_1 = __importDefault(require(\"./refiners/ZHHansMergeDateRangeRefiner\"));\nconst ZHHansMergeDateTimeRefiner_1 = __importDefault(require(\"./refiners/ZHHansMergeDateTimeRefiner\"));\nexports.hans = new chrono_1.Chrono(createCasualConfiguration());\nexports.casual = new chrono_1.Chrono(createCasualConfiguration());\nexports.strict = new chrono_1.Chrono(createConfiguration());\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\nfunction createCasualConfiguration() {\n    const option = createConfiguration();\n    option.parsers.unshift(new ZHHansCasualDateParser_1.default());\n    return option;\n}\nexports.createCasualConfiguration = createCasualConfiguration;\nfunction createConfiguration() {\n    const configuration = (0, configurations_1.includeCommonConfiguration)({\n        parsers: [\n            new ZHHansDateParser_1.default(),\n            new ZHHansRelationWeekdayParser_1.default(),\n            new ZHHansWeekdayParser_1.default(),\n            new ZHHansTimeExpressionParser_1.default(),\n            new ZHHansDeadlineFormatParser_1.default(),\n        ],\n        refiners: [new ZHHansMergeDateRangeRefiner_1.default(), new ZHHansMergeDateTimeRefiner_1.default()],\n    });\n    configuration.refiners = configuration.refiners.filter((refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner_1.default));\n    return configuration;\n}\nexports.createConfiguration = createConfiguration;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hans = void 0;\n__exportStar(require(\"./hant\"), exports);\nvar hans_1 = require(\"./hans\");\nObject.defineProperty(exports, \"hans\", { enumerable: true, get: function () { return hans_1.hans; } });\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.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;\nconst en = __importStar(require(\"./locales/en\"));\nexports.en = en;\nconst chrono_1 = require(\"./chrono\");\nObject.defineProperty(exports, \"Chrono\", { enumerable: true, get: function () { return chrono_1.Chrono; } });\nvar Meridiem;\n(function (Meridiem) {\n    Meridiem[Meridiem[\"AM\"] = 0] = \"AM\";\n    Meridiem[Meridiem[\"PM\"] = 1] = \"PM\";\n})(Meridiem = exports.Meridiem || (exports.Meridiem = {}));\nconst de = __importStar(require(\"./locales/de\"));\nexports.de = de;\nconst fr = __importStar(require(\"./locales/fr\"));\nexports.fr = fr;\nconst ja = __importStar(require(\"./locales/ja\"));\nexports.ja = ja;\nconst pt = __importStar(require(\"./locales/pt\"));\nexports.pt = pt;\nconst nl = __importStar(require(\"./locales/nl\"));\nexports.nl = nl;\nconst zh = __importStar(require(\"./locales/zh\"));\nexports.zh = zh;\nexports.strict = en.strict;\nexports.casual = en.casual;\nfunction parse(text, ref, option) {\n    return exports.casual.parse(text, ref, option);\n}\nexports.parse = parse;\nfunction parseDate(text, ref, option) {\n    return exports.casual.parseDate(text, ref, option);\n}\nexports.parseDate = parseDate;\n","import chrono, { Chrono, Parser } from \"chrono-node\";\nimport type { Moment } from \"moment\";\n\nimport { DayOfWeek } from \"./settings\";\nimport {\n  ORDINAL_NUMBER_PATTERN,\n  getLastDayOfMonth,\n  getLocaleWeekStart,\n  getWeekNumber,\n  parseOrdinalNumberPattern,\n} from \"./utils\";\n\nexport interface NLDResult {\n  formattedString: string;\n  date: Date;\n  moment: Moment;\n}\n\nfunction getLocalizedChrono(): Chrono {\n  const locale = window.moment.locale();\n\n  switch (locale) {\n    case \"en-gb\":\n      return new Chrono(chrono.en.createCasualConfiguration(true));\n    default:\n      return new Chrono(chrono.en.createCasualConfiguration(false));\n  }\n}\n\nfunction getConfiguredChrono(): Chrono {\n  const localizedChrono = getLocalizedChrono();\n  localizedChrono.parsers.push({\n    pattern: () => {\n      return /\\bChristmas\\b/i;\n    },\n    extract: () => {\n      return {\n        day: 25,\n        month: 12,\n      };\n    },\n  });\n\n  localizedChrono.parsers.push({\n    pattern: () => new RegExp(ORDINAL_NUMBER_PATTERN),\n    extract: (_context, match) => {\n      return {\n        day: parseOrdinalNumberPattern(match[0]),\n        month: window.moment().month(),\n      };\n    },\n  } as Parser);\n  return localizedChrono;\n}\n\nexport default class NLDParser {\n  chrono: Chrono;\n\n  constructor() {\n    this.chrono = getConfiguredChrono();\n  }\n\n  getParsedDate(selectedText: string, weekStartPreference: DayOfWeek): Date {\n    const parser = this.chrono;\n    const initialParse = parser.parse(selectedText);\n    const weekdayIsCertain = initialParse[0]?.start.isCertain(\"weekday\");\n\n    const weekStart =\n      weekStartPreference === \"locale-default\"\n        ? getLocaleWeekStart()\n        : weekStartPreference;\n\n    const locale = {\n      weekStart: getWeekNumber(weekStart),\n    };\n\n    const thisDateMatch = selectedText.match(/this\\s([\\w]+)/i);\n    const nextDateMatch = selectedText.match(/next\\s([\\w]+)/i);\n    const lastDayOfMatch = selectedText.match(/(last day of|end of)\\s*([^\\n\\r]*)/i);\n    const midOf = selectedText.match(/mid\\s([\\w]+)/i);\n\n    const referenceDate = weekdayIsCertain\n      ? window.moment().weekday(0).toDate()\n      : new Date();\n\n    if (thisDateMatch && thisDateMatch[1] === \"week\") {\n      return parser.parseDate(`this ${weekStart}`, referenceDate);\n    }\n\n    if (nextDateMatch && nextDateMatch[1] === \"week\") {\n      return parser.parseDate(`next ${weekStart}`, referenceDate, {\n        forwardDate: true,\n      });\n    }\n\n    if (nextDateMatch && nextDateMatch[1] === \"month\") {\n      const thisMonth = parser.parseDate(\"this month\", new Date(), {\n        forwardDate: true,\n      });\n      return parser.parseDate(selectedText, thisMonth, {\n        forwardDate: true,\n      });\n    }\n\n    if (nextDateMatch && nextDateMatch[1] === \"year\") {\n      const thisYear = parser.parseDate(\"this year\", new Date(), {\n        forwardDate: true,\n      });\n      return parser.parseDate(selectedText, thisYear, {\n        forwardDate: true,\n      });\n    }\n\n    if (lastDayOfMatch) {\n      const tempDate = parser.parse(lastDayOfMatch[2]);\n      const year = tempDate[0].start.get(\"year\");\n      const month = tempDate[0].start.get(\"month\");\n      const lastDay = getLastDayOfMonth(year, month);\n\n      return parser.parseDate(`${year}-${month}-${lastDay}`, new Date(), {\n        forwardDate: true,\n      });\n    }\n\n    if (midOf) {\n      return parser.parseDate(`${midOf[1]} 15th`, new Date(), {\n        forwardDate: true,\n      });\n    }\n\n    return parser.parseDate(selectedText, referenceDate, { locale });\n  }\n}\n","import { App, PluginSettingTab, Setting } from \"obsidian\";\nimport NaturalLanguageDates from \"./main\";\nimport { getLocaleWeekStart } from \"./utils\";\n\nexport type DayOfWeek =\n  | \"sunday\"\n  | \"monday\"\n  | \"tuesday\"\n  | \"wednesday\"\n  | \"thursday\"\n  | \"friday\"\n  | \"saturday\"\n  | \"locale-default\";\n\nexport interface NLDSettings {\n  autosuggestToggleLink: boolean;\n  autocompleteTriggerPhrase: string;\n  isAutosuggestEnabled: boolean;\n\n  format: string;\n  timeFormat: string;\n  separator: string;\n  weekStart: DayOfWeek;\n\n  modalToggleTime: boolean;\n  modalToggleLink: boolean;\n  modalMomentFormat: string;\n}\n\nexport const DEFAULT_SETTINGS: NLDSettings = {\n  autosuggestToggleLink: true,\n  autocompleteTriggerPhrase: \"@\",\n  isAutosuggestEnabled: true,\n\n  format: \"YYYY-MM-DD\",\n  timeFormat: \"HH:mm\",\n  separator: \" \",\n  weekStart: \"locale-default\",\n\n  modalToggleTime: false,\n  modalToggleLink: false,\n  modalMomentFormat: \"YYYY-MM-DD HH:mm\",\n};\n\nconst weekdays = [\n  \"sunday\",\n  \"monday\",\n  \"tuesday\",\n  \"wednesday\",\n  \"thursday\",\n  \"friday\",\n  \"saturday\",\n];\n\nexport class NLDSettingsTab extends PluginSettingTab {\n  plugin: NaturalLanguageDates;\n\n  constructor(app: App, plugin: NaturalLanguageDates) {\n    super(app, plugin);\n    this.plugin = plugin;\n  }\n\n  display(): void {\n    const { containerEl } = this;\n    const localizedWeekdays = window.moment.weekdays();\n    const localeWeekStart = getLocaleWeekStart();\n\n    containerEl.empty();\n\n    containerEl.createEl(\"h2\", {\n      text: \"Natural Language Dates\",\n    });\n\n    containerEl.createEl(\"h3\", {\n      text: \"Parser settings\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Date format\")\n      .setDesc(\"Output format for parsed dates\")\n      .addMomentFormat((text) =>\n        text\n          .setDefaultFormat(\"YYYY-MM-DD\")\n          .setValue(this.plugin.settings.format)\n          .onChange(async (value) => {\n            this.plugin.settings.format = value || \"YYYY-MM-DD\";\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Week starts on\")\n      .setDesc(\"Which day to consider as the start of the week\")\n      .addDropdown((dropdown) => {\n        dropdown.addOption(\"locale-default\", `Locale default (${localeWeekStart})`);\n        localizedWeekdays.forEach((day, i) => {\n          dropdown.addOption(weekdays[i], day);\n        });\n        dropdown.setValue(this.plugin.settings.weekStart.toLowerCase());\n        dropdown.onChange(async (value: DayOfWeek) => {\n          this.plugin.settings.weekStart = value;\n          await this.plugin.saveSettings();\n        });\n      });\n\n    containerEl.createEl(\"h3\", {\n      text: \"Hotkey formatting settings\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Time format\")\n      .setDesc(\"Format for the hotkeys that include the current time\")\n      .addMomentFormat((text) =>\n        text\n          .setDefaultFormat(\"HH:mm\")\n          .setValue(this.plugin.settings.timeFormat)\n          .onChange(async (value) => {\n            this.plugin.settings.timeFormat = value || \"HH:mm\";\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Separator\")\n      .setDesc(\"Separator between date and time for entries that have both\")\n      .addText((text) =>\n        text\n          .setPlaceholder(\"Separator is empty\")\n          .setValue(this.plugin.settings.separator)\n          .onChange(async (value) => {\n            this.plugin.settings.separator = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    containerEl.createEl(\"h3\", {\n      text: \"Date Autosuggest\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Enable date autosuggest\")\n      .setDesc(\n        `Input dates with natural language. Open the suggest menu with ${this.plugin.settings.autocompleteTriggerPhrase}`\n      )\n      .addToggle((toggle) =>\n        toggle\n          .setValue(this.plugin.settings.isAutosuggestEnabled)\n          .onChange(async (value) => {\n            this.plugin.settings.isAutosuggestEnabled = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Add dates as link?\")\n      .setDesc(\n        \"If enabled, dates created via autosuggest will be wrapped in [[wikilinks]]\"\n      )\n      .addToggle((toggle) =>\n        toggle\n          .setValue(this.plugin.settings.autosuggestToggleLink)\n          .onChange(async (value) => {\n            this.plugin.settings.autosuggestToggleLink = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Trigger phrase\")\n      .setDesc(\"Character(s) that will cause the date autosuggest to open\")\n      .addMomentFormat((text) =>\n        text\n          .setPlaceholder(DEFAULT_SETTINGS.autocompleteTriggerPhrase)\n          .setValue(this.plugin.settings.autocompleteTriggerPhrase || \"@\")\n          .onChange(async (value) => {\n            this.plugin.settings.autocompleteTriggerPhrase = value.trim();\n            await this.plugin.saveSettings();\n          })\n      );\n  }\n}\n","import {\n  App,\n  Editor,\n  EditorPosition,\n  EditorSuggest,\n  EditorSuggestContext,\n  EditorSuggestTriggerInfo,\n  TFile,\n} from \"obsidian\";\nimport type NaturalLanguageDates from \"src/main\";\nimport { generateMarkdownLink } from \"src/utils\";\n\ninterface IDateCompletion {\n  label: string;\n}\n\nexport default class DateSuggest extends EditorSuggest<IDateCompletion> {\n  app: App;\n  private plugin: NaturalLanguageDates;\n\n  constructor(app: App, plugin: NaturalLanguageDates) {\n    super(app);\n    this.app = app;\n    this.plugin = plugin;\n\n    // @ts-ignore\n    this.scope.register([\"Shift\"], \"Enter\", (evt: KeyboardEvent) => {\n      // @ts-ignore\n      this.suggestions.useSelectedItem(evt);\n      return false;\n    });\n\n    if (this.plugin.settings.autosuggestToggleLink) {\n      this.setInstructions([{ command: \"Shift\", purpose: \"Keep text as alias\" }]);\n    }\n  }\n\n  getSuggestions(context: EditorSuggestContext): IDateCompletion[] {\n    const suggestions = this.getDateSuggestions(context);\n    if (suggestions.length) {\n      return suggestions;\n    }\n\n    // catch-all if there are no matches\n    return [{ label: context.query }];\n  }\n\n  getDateSuggestions(context: EditorSuggestContext): IDateCompletion[] {\n    if (context.query.match(/^time/)) {\n      return [\"now\", \"+15 minutes\", \"+1 hour\", \"-15 minutes\", \"-1 hour\"]\n        .map((val) => ({ label: `time:${val}` }))\n        .filter((item) => item.label.toLowerCase().startsWith(context.query));\n    }\n    if (context.query.match(/(next|last|this)/i)) {\n      const reference = context.query.match(/(next|last|this)/i)[1];\n      return [\n        \"week\",\n        \"month\",\n        \"year\",\n        \"Sunday\",\n        \"Monday\",\n        \"Tuesday\",\n        \"Wednesday\",\n        \"Thursday\",\n        \"Friday\",\n        \"Saturday\",\n      ]\n        .map((val) => ({ label: `${reference} ${val}` }))\n        .filter((items) => items.label.toLowerCase().startsWith(context.query));\n    }\n\n    const relativeDate =\n      context.query.match(/^in ([+-]?\\d+)/i) || context.query.match(/^([+-]?\\d+)/i);\n    if (relativeDate) {\n      const timeDelta = relativeDate[1];\n      return [\n        { label: `in ${timeDelta} minutes` },\n        { label: `in ${timeDelta} hours` },\n        { label: `in ${timeDelta} days` },\n        { label: `in ${timeDelta} weeks` },\n        { label: `in ${timeDelta} months` },\n        { label: `${timeDelta} days ago` },\n        { label: `${timeDelta} weeks ago` },\n        { label: `${timeDelta} months ago` },\n      ].filter((items) => items.label.toLowerCase().startsWith(context.query));\n    }\n\n    return [{ label: \"Today\" }, { label: \"Yesterday\" }, { label: \"Tomorrow\" }].filter(\n      (items) => items.label.toLowerCase().startsWith(context.query)\n    );\n  }\n\n  renderSuggestion(suggestion: IDateCompletion, el: HTMLElement): void {\n    el.setText(suggestion.label);\n  }\n\n  selectSuggestion(suggestion: IDateCompletion, event: KeyboardEvent | MouseEvent): void {\n    const { editor } = this.context;\n\n    const includeAlias = event.shiftKey;\n    let dateStr = \"\";\n    let makeIntoLink = this.plugin.settings.autosuggestToggleLink;\n\n    if (suggestion.label.startsWith(\"time:\")) {\n      const timePart = suggestion.label.substring(5);\n      dateStr = this.plugin.parseTime(timePart).formattedString;\n      makeIntoLink = false;\n    } else {\n      dateStr = this.plugin.parseDate(suggestion.label).formattedString;\n    }\n\n    if (makeIntoLink) {\n      dateStr = generateMarkdownLink(\n        this.app,\n        dateStr,\n        includeAlias ? suggestion.label : undefined\n      );\n    }\n\n    editor.replaceRange(dateStr, this.context.start, this.context.end);\n  }\n\n  onTrigger(\n    cursor: EditorPosition,\n    editor: Editor,\n    file: TFile\n  ): EditorSuggestTriggerInfo {\n    if (!this.plugin.settings.isAutosuggestEnabled) {\n      return null;\n    }\n\n    const triggerPhrase = this.plugin.settings.autocompleteTriggerPhrase;\n    const startPos = this.context?.start || {\n      line: cursor.line,\n      ch: cursor.ch - triggerPhrase.length,\n    };\n\n    if (!editor.getRange(startPos, cursor).startsWith(triggerPhrase)) {\n      return null;\n    }\n\n    const precedingChar = editor.getRange(\n      {\n        line: startPos.line,\n        ch: startPos.ch - 1,\n      },\n      startPos\n    );\n\n    // Short-circuit if `@` as a part of a word (e.g. part of an email address)\n    if (precedingChar && /[`a-zA-Z0-9]/.test(precedingChar)) {\n      return null;\n    }\n\n    return {\n      start: startPos,\n      end: cursor,\n      query: editor.getRange(startPos, cursor).substring(triggerPhrase.length),\n    };\n  }\n}\n","import { MarkdownView } from \"obsidian\";\nimport { adjustCursor, getSelectedText } from \"./utils\";\nimport NaturalLanguageDates from \"./main\";\n\nexport function getParseCommand(plugin: NaturalLanguageDates, mode: string): void {\n  const { workspace } = plugin.app;\n  const activeView = workspace.getActiveViewOfType(MarkdownView);\n\n  // The active view might not be a markdown view\n  if (!activeView) {\n    return;\n  }\n\n  const editor = activeView.editor;\n  const cursor = editor.getCursor();\n  const selectedText = getSelectedText(editor);\n\n  const date = plugin.parseDate(selectedText);\n\n  if (!date.moment.isValid()) {\n    // Do nothing\n    editor.setCursor({\n      line: cursor.line,\n      ch: cursor.ch,\n    });\n    return;\n  }\n\n  //mode == \"replace\"\n  let newStr = `[[${date.formattedString}]]`;\n\n  if (mode == \"link\") {\n    newStr = `[${selectedText}](${date.formattedString})`;\n  } else if (mode == \"clean\") {\n    newStr = `${date.formattedString}`;\n  } else if (mode == \"time\") {\n    const time = plugin.parseTime(selectedText);\n\n    newStr = `${time.formattedString}`;\n  }\n\n  editor.replaceSelection(newStr);\n  adjustCursor(editor, cursor, newStr, selectedText);\n  editor.focus();\n}\n\nexport function insertMomentCommand(\n  plugin: NaturalLanguageDates,\n  date: Date,\n  format: string\n) {\n  const { workspace } = plugin.app;\n  const activeView = workspace.getActiveViewOfType(MarkdownView);\n\n  if (activeView) {\n    // The active view might not be a markdown view\n    const editor = activeView.editor;\n    editor.replaceSelection(window.moment(date).format(format));\n  }\n}\n\nexport function getNowCommand(plugin: NaturalLanguageDates): void {\n  const format = `${plugin.settings.format}${plugin.settings.separator}${plugin.settings.timeFormat}`;\n  const date = new Date();\n  insertMomentCommand(plugin, date, format);\n}\n\nexport function getCurrentDateCommand(plugin: NaturalLanguageDates): void {\n  const format = plugin.settings.format;\n  const date = new Date();\n  insertMomentCommand(plugin, date, format);\n}\n\nexport function getCurrentTimeCommand(plugin: NaturalLanguageDates): void {\n  const format = plugin.settings.timeFormat;\n  const date = new Date();\n  insertMomentCommand(plugin, date, format);\n}\n","import { MarkdownView, ObsidianProtocolData, Plugin } from \"obsidian\";\r\n\r\nimport DatePickerModal from \"./modals/date-picker\";\r\nimport NLDParser, { NLDResult } from \"./parser\";\r\nimport { NLDSettingsTab, NLDSettings, DEFAULT_SETTINGS } from \"./settings\";\r\nimport DateSuggest from \"./suggest/date-suggest\";\r\nimport {\r\n  getParseCommand,\r\n  getCurrentDateCommand,\r\n  getCurrentTimeCommand,\r\n  getNowCommand,\r\n} from \"./commands\";\r\nimport { getFormattedDate, getOrCreateDailyNote, parseTruthy } from \"./utils\";\r\n\r\nexport default class NaturalLanguageDates extends Plugin {\r\n  private parser: NLDParser;\r\n  public settings: NLDSettings;\r\n\r\n  async onload(): Promise<void> {\r\n    await this.loadSettings();\r\n\r\n    this.addCommand({\r\n      id: \"nlp-dates\",\r\n      name: \"Parse natural language date\",\r\n      callback: () => getParseCommand(this, \"replace\"),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-dates-link\",\r\n      name: \"Parse natural language date (as link)\",\r\n      callback: () => getParseCommand(this, \"link\"),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-date-clean\",\r\n      name: \"Parse natural language date (as plain text)\",\r\n      callback: () => getParseCommand(this, \"clean\"),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-parse-time\",\r\n      name: \"Parse natural language time\",\r\n      callback: () => getParseCommand(this, \"time\"),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-now\",\r\n      name: \"Insert the current date and time\",\r\n      callback: () => getNowCommand(this),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-today\",\r\n      name: \"Insert the current date\",\r\n      callback: () => getCurrentDateCommand(this),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-time\",\r\n      name: \"Insert the current time\",\r\n      callback: () => getCurrentTimeCommand(this),\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addCommand({\r\n      id: \"nlp-picker\",\r\n      name: \"Date picker\",\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking) {\r\n          return !!this.app.workspace.getActiveViewOfType(MarkdownView);\r\n        }\r\n        new DatePickerModal(this.app, this).open();\r\n      },\r\n      hotkeys: [],\r\n    });\r\n\r\n    this.addSettingTab(new NLDSettingsTab(this.app, this));\r\n    this.registerObsidianProtocolHandler(\"nldates\", this.actionHandler.bind(this));\r\n    this.registerEditorSuggest(new DateSuggest(this.app, this));\r\n\r\n    this.app.workspace.onLayoutReady(() => {\r\n      // initialize the parser when layout is ready so that the correct locale is used\r\n      this.parser = new NLDParser();\r\n    });\r\n  }\r\n\r\n  onunload(): void {\r\n    console.log(\"Unloading natural language date parser plugin\");\r\n  }\r\n\r\n  async loadSettings(): Promise<void> {\r\n    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\r\n  }\r\n\r\n  async saveSettings(): Promise<void> {\r\n    await this.saveData(this.settings);\r\n  }\r\n\r\n  /*\r\n    @param dateString: A string that contains a date in natural language, e.g. today, tomorrow, next week\r\n    @param format: A string that contains the formatting string for a Moment\r\n    @returns NLDResult: An object containing the date, a cloned Moment and the formatted string.\r\n  */\r\n  parse(dateString: string, format: string): NLDResult {\r\n    const date = this.parser.getParsedDate(dateString, this.settings.weekStart);\r\n    const formattedString = getFormattedDate(date, format);\r\n    if (formattedString === \"Invalid date\") {\r\n      console.debug(\"Input date \" + dateString + \" can't be parsed by nldates\");\r\n    }\r\n\r\n    return {\r\n      formattedString,\r\n      date,\r\n      moment: window.moment(date),\r\n    };\r\n  }\r\n\r\n  /*\r\n    @param dateString: A string that contains a date in natural language, e.g. today, tomorrow, next week\r\n    @returns NLDResult: An object containing the date, a cloned Moment and the formatted string.\r\n  */\r\n  parseDate(dateString: string): NLDResult {\r\n    return this.parse(dateString, this.settings.format);\r\n  }\r\n\r\n  parseTime(dateString: string): NLDResult {\r\n    return this.parse(dateString, this.settings.timeFormat);\r\n  }\r\n\r\n  async actionHandler(params: ObsidianProtocolData): Promise<void> {\r\n    const { workspace } = this.app;\r\n\r\n    const date = this.parseDate(params.day);\r\n    const newPane = parseTruthy(params.newPane || \"yes\");\r\n\r\n    if (date.moment.isValid()) {\r\n      const dailyNote = await getOrCreateDailyNote(date.moment);\r\n      workspace.getLeaf(newPane).openFile(dailyNote);\r\n    }\r\n  }\r\n}\r\n"],"names":["require$$0","normalizePath","getDailyNote","getAllDailyNotes","createDailyNote","extractTerms","matchAnyPattern","Modal","Setting","MarkdownView","C.M","C.Y","C.W","C.D","C.DATE","C.H","C.MIN","C.S","C.MS","C.Q","dayjs","C.REGEX_PARSE","C.INVALID_DATE_STRING","C.MILLISECONDS_A_MINUTE","C.MILLISECONDS_A_HOUR","C.MILLISECONDS_A_SECOND","C.FORMAT_DEFAULT","C.REGEX_FORMAT","C.MILLISECONDS_A_WEEK","C.MILLISECONDS_A_DAY","__importDefault","this","dayjs_1","require$$1","index_1","require$$2","dayjs_2","require$$3","require$$4","ENTimeUnitWithinFormatParser_1","constants_1","results_1","AbstractParserWithWordBoundary_1","ENMonthNameLittleEndianParser_1","years_1","constants_2","constants_3","pattern_1","PATTERN","DATE_GROUP","DATE_TO_GROUP","MONTH_NAME_GROUP","YEAR_GROUP","ENMonthNameMiddleEndianParser_1","ENMonthNameParser_1","PREFIX_GROUP","ENCasualYearMonthDayParser_1","YEAR_NUMBER_GROUP","MONTH_NUMBER_GROUP","DATE_NUMBER_GROUP","ENSlashMonthFormatParser_1","MONTH_GROUP","AbstractTimeExpressionParser_1","HOUR_GROUP","MINUTE_GROUP","SECOND_GROUP","AM_PM_HOUR_GROUP","ENTimeExpressionParser_1","ENTimeUnitAgoFormatParser_1","timeunits_1","STRICT_PATTERN","ENTimeUnitLaterFormatParser_1","GROUP_NUM_TIMEUNITS","AbstractMergeDateRangeRefiner_1","abstractRefiners_1","ENMergeDateRangeRefiner_1","ENMergeDateTimeRefiner","ENMergeDateTimeRefiner_1","AbstractMergeDateTimeRefiner_1","ExtractTimezoneAbbrRefiner_1","ExtractTimezoneOffsetRefiner_1","OverlapRemovalRefiner_1","ForwardDateRefiner_1","UnlikelyFormatFilter_1","ISOFormatParser_1","MergeWeekdayComponentRefiner_1","require$$5","require$$6","__createBinding","__setModuleDefault","__importStar","ENCasualDateParser_1","references","ENCasualTimeParser_1","ENWeekdayParser_1","weeks_1","WEEKDAY_GROUP","POSTFIX_GROUP","ENRelativeDateFormatParser_1","MODIFIER_WORD_GROUP","RELATIVE_WORD_GROUP","chrono","SlashDateFormatParser_1","ENTimeUnitCasualRelativeFormatParser_1","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","require$$15","require$$16","require$$17","require$$18","DETimeExpressionParser_1","DEWeekdayParser_1","DEMergeDateRangeRefiner_1","DEMergeDateTimeRefiner_1","DECasualTimeParser_1","DECasualDateParser_1","DEMonthNameLittleEndianParser_1","FRCasualDateParser_1","FRCasualTimeParser_1","FRTimeExpressionParser_1","FRMergeDateTimeRefiner_1","FRMergeDateRangeRefiner_1","FRWeekdayParser_1","FRSpecificTimeExpressionParser_1","FIRST_REG_PATTERN","SECOND_REG_PATTERN","FRMonthNameLittleEndianParser_1","FRTimeUnitAgoFormatParser_1","FRTimeUnitAgoFormatParser","FRTimeUnitWithinFormatParser_1","constants","JPStandardParser_1","DAY_GROUP","JPMergeDateRangeRefiner_1","JPCasualDateParser_1","PTWeekdayParser_1","PTTimeExpressionParser_1","PTMergeDateTimeRefiner_1","PTMergeDateRangeRefiner_1","PTMonthNameLittleEndianParser_1","PTCasualDateParser_1","PTCasualTimeParser_1","NLMergeDateRangeRefiner_1","NLMergeDateTimeRefiner_1","NLCasualDateParser_1","NLCasualTimeParser_1","NLTimeUnitWithinFormatParser_1","NLWeekdayParser_1","NLMonthNameMiddleEndianParser_1","NLMonthNameParser_1","NLSlashMonthFormatParser_1","NLTimeExpressionParser_1","NLCasualYearMonthDayParser_1","NLCasualDateTimeParser_1","NLTimeUnitCasualRelativeFormatParser_1","NLRelativeDateFormatParser_1","NLTimeUnitAgoFormatParser_1","NLTimeUnitLaterFormatParser_1","ZHHantCasualDateParser_1","NOW_GROUP","DAY_GROUP_1","TIME_GROUP_1","TIME_GROUP_2","DAY_GROUP_3","TIME_GROUP_3","ZHHantDateParser_1","ZHHantDeadlineFormatParser_1","NUMBER_GROUP","UNIT_GROUP","ZHHantRelationWeekdayParser_1","ZHHantTimeExpressionParser_1","ZH_AM_PM_HOUR_GROUP_1","ZH_AM_PM_HOUR_GROUP_2","ZH_AM_PM_HOUR_GROUP_3","ZHHantWeekdayParser_1","ZHHantMergeDateRangeRefiner_1","ZHHantMergeDateTimeRefiner_1","ZHHansCasualDateParser_1","ZHHansDateParser_1","ZHHansDeadlineFormatParser_1","ZHHansRelationWeekdayParser_1","ZHHansTimeExpressionParser_1","ZHHansWeekdayParser_1","ZHHansMergeDateRangeRefiner_1","ZHHansMergeDateTimeRefiner_1","de","fr","ja","pt","nl","zh","Chrono","PluginSettingTab","EditorSuggest","Plugin"],"mappings":"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AG;AACb,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,GAAG,EAAE,CAAC,EAAE;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,EAAE;AACX,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,EAAE;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,EAAE,EAAE,CAAC,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC;AACV,IA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IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC;AACV,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,GAAG,EAAE,CAAC,EAAE;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,EAAE;AACX,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,EAAE;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,KAAK,EAAE,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,EAAE,EAAE,CAAC,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,CAAC,GAAG;AACd,IAAI,GAAG,EAAE,CAAC,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,IAAI,EAAE,GAAG;AACb,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,EAAE,GAAG;AACZ,IAAI,GAAG,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"}
|
