chrono-node - npm Package Compare versions

src/calculation/mergingCalculation.ts

src/calculation/yearCalculation.ts

src/chrono.ts

src/common/abstractRefiners.ts

src/common/parsers/ISOFormatParser.ts

src/common/refiners/AbstractMergeDateRangeRefiner.ts

src/common/refiners/AbstractMergeDateTimeRefiner.ts

src/common/refiners/ExtractTimezoneAbbrRefiner.ts

src/common/refiners/ExtractTimezoneOffsetRefiner.ts

src/common/refiners/ForwardDateRefiner.ts

src/common/refiners/OverlapRemovalRefiner.ts

src/common/refiners/UnlikelyFormatFilter.ts

src/configurations.ts

src/debugging.ts

src/index.ts

src/locales/en/constants.ts

src/locales/en/index.ts

src/locales/en/parsers/ENCasualDateParser.ts

src/locales/en/parsers/ENCasualTimeParser.ts

src/locales/en/parsers/ENMonthNameLittleEndianParser.ts

src/locales/en/parsers/ENMonthNameMiddleEndianParser.ts

src/locales/en/parsers/ENMonthNameParser.ts

src/locales/en/parsers/ENRelativeDateFormatParser.ts

src/locales/en/parsers/ENSlashDateFormatParser.ts

src/locales/en/parsers/ENSlashDateFormatStartWithYearParser.ts

src/locales/en/parsers/ENSlashMonthFormatParser.ts

src/locales/en/parsers/ENTimeExpressionParser.ts

src/locales/en/parsers/ENTimeUnitAgoFormatParser.ts

src/locales/en/parsers/ENTimeUnitDeadlineFormatParser.ts

src/locales/en/parsers/ENTimeUnitLaterFormatParser.ts

src/locales/en/parsers/ENWeekdayParser.ts

src/locales/en/refiners/ENMergeDateRangeRefiner.ts

src/locales/en/refiners/ENMergeDateTimeRefiner.ts

src/locales/ja/constants.ts

src/locales/ja/index.ts

src/locales/ja/parsers/JPCasualDateParser.ts

src/locales/ja/parsers/JPStandardParser.ts

src/locales/ja/refiners/JPMergeDateRangeRefiner.ts

src/results.ts

src/utils/pattern.ts

test/en/en_month_name_little_endian.test.js

test/en/en_month_name_middle_endian.test.js

test/en/en_time_units_ago.test.js

test/en/en_time_units_deadline.test.js

test/en/en_time_units_later.test.js

test/result.test.js

test/test_util.ts

10

dist/chrono.min.js.LICENSE.txt

		@@ -10,11 +10,1 @@ /**
		*/

		/**
		* to-zenkaku.js
		* convert to multi byte strings.
		*
		* @version 1.0.2
		* @author think49
		* @url https://gist.github.com/964592
		* @license http://www.opensource.org/licenses/mit-license.php (The MIT License)
		*/

39

package.json

		@@ -14,3 +14,3 @@ {
		"license": "MIT",
		"version": "1.4.6",
		"version": "2.0.0",
		"directories": {
		@@ -21,10 +21,37 @@ "source": "./src",
		"main": "./dist/chrono.js",
		"babel": {
		"presets": [
		"@babel/preset-env",
		"@babel/preset-typescript"
		],
		"plugins": [
		"@babel/plugin-proposal-export-namespace-from"
		]
		},
		"eslintConfig": {
		"parser": "@typescript-eslint/parser",
		"plugins": [
		"@typescript-eslint"
		],
		"extends": [
		"plugin:@typescript-eslint/recommended"
		],
		"rules": {
		"@typescript-eslint/explicit-module-boundary-types": "off"
		}
		},
		"devDependencies": {
		"@babel/core": "^7.8.4",
		"@babel/preset-env": "^7.8.4",
		"babel-jest": "^25.3.0",
		"@babel/core": "^7.9.6",
		"@babel/plugin-proposal-export-namespace-from": "^7.8.3",
		"@babel/preset-env": "^7.9.6",
		"@babel/preset-typescript": "^7.9.0",
		"@typescript-eslint/eslint-plugin": "^3.0.0",
		"@typescript-eslint/parser": "^3.0.0",
		"babel-jest": "^25.5.1",
		"babel-loader": "^8.0.6",
		"coveralls": "^3.0.2",
		"jest": "^25.3.0",
		"eslint": "^7.0.0",
		"jest": "^25.5.4",
		"terser-webpack-plugin": "^2.3.4",
		"typescript": "^3.9.3",
		"webpack": "^4.41.5",
		@@ -41,4 +68,4 @@ "webpack-cli": "^3.3.10"
		"dependencies": {
		"dayjs": "^1.8.19"
		"dayjs": "^1.8.26"
		}
		}

270

README.md

		@@ -1,4 +0,4 @@
		# Chrono
		# Chrono (v2)

		A natural language date parser in Javascript, designed for extracting date information from any given text. (Java version is also available [here](https://github.com/wanasit/chrono-java))
		A natural language date parser in Javascript.

		@@ -8,37 +8,43 @@ [![Build Status](https://travis-ci.org/wanasit/chrono.svg?branch=master)](https://travis-ci.org/wanasit/chrono)

		Chrono supports most date and time formats, such as :
		It is designed to handle most date/time format and extract information from any given text:

		* Today, Tomorrow, Yesterday, Last Friday, etc
		* 17 August 2013 - 19 August 2013
		* This Friday from 13:00 - 16.00
		* 5 days ago
		* 2 weeks from now
		* Sat Aug 17 2013 18:40:39 GMT+0900 (JST)
		* 2014-11-30T08:15:30-05:30
		* _Today_, _Tomorrow_, _Yesterday_, _Last Friday_, etc
		* _17 August 2013 - 19 August 2013_
		* _This Friday from 13:00 - 16.00_
		* _5 days ago_
		* _2 weeks from now_
		* _Sat Aug 17 2013 18:40:39 GMT+0900 (JST)_
		* _2014-11-30T08:15:30-05:30_

		## Installation
		### Installation

		Just run:
		With npm:
		```bash
		$ npm i --save chrono-node
		$ npm install --save chrono-node
		```

		And start using chrono:
		```js
		var chrono = require('chrono-node');
		```javascript
		import * as chrono from 'chrono-node';

		chrono.parseDate('An appointment on Sep 12-13');
		```

		### Swift
		### What's changed in the v2
		For Users
		* Chrono’s default now handles only international English. While in the previous version, it tried to parse with all known languages.
		* The current supported languages are only `en` and `ja`. Other languages from v1 (`de`, `fr`, `nl`, `pt`, and `zh`) are under development.

		Try using the community-made [chrono-swift] wrapper.
		For contributors and advanced users
		* The project is rewritten in TypeScript
		* New [Parser](#parser) and [Refiner](#refiner) interface
		* New source code structure. All parsers, refiners, and configuration should be under a locale directory (See. `locales/en`)

		[chrono-swift]: https://github.com/neilsardesai/chrono-swift
		Note: [v1.x.x](https://github.com/wanasit/chrono/tree/v1) will still be supported for the time being.

		## Usage

		Simply pass a string to function `chrono.parseDate` or `chrono.parse`.
		Simply pass a `string` to functions `chrono.parseDate` or `chrono.parse`.

		```js
		var chrono = require('chrono-node');
		```javascript
		import * as chrono from 'chrono-node';

		@@ -49,15 +55,16 @@ chrono.parseDate('An appointment on Sep 12-13');
		chrono.parse('An appointment on Sep 12-13');
		/* [ { index: 18,
		/* [{
		index: 18,
		text: 'Sep 12-13',
		tags: { ENMonthNameMiddleEndianParser: true },
		start:
		{ knownValues: [Object],
		impliedValues: [Object] },
		end:
		{ knownValues: [Object],
		impliedValues: [Object] } } ] */
		start: ...
		}] */
		```

		### Reference Date
		For more advanced usage, here is the typescript definition of the `parse` function:
		```typescript
		parse(text: string, refDate?: Date, option?: ParsingOption): ParsedResult[] {...}
		```

		#### Reference Date

		Today's "Friday" is different from last month's "Friday".
		@@ -67,3 +74,3 @@ The meaning of the referenced dates depends on when they are mentioned.

		```js
		```javascript
		chrono.parseDate('Friday', new Date(2012, 7, 23));
		@@ -78,6 +85,6 @@ // Fri Aug 24 2012 12:00:00 GMT+0700 (ICT)

		* `forwardDate` (boolean) to assume the results should happen after the reference date (forward into the future)
		`forwardDate` (boolean) to assume the results should happen after the reference date (forward into the future)

		```js
		var referenceDate = new Date(2012, 7, 25);
		```javascript
		const referenceDate = new Date(2012, 7, 25);
		// Sat Aug 25 2012 00:00:00 GMT+0900 -- The reference date was Saturday
		@@ -92,55 +99,35 @@

		* `timezones` (Map) to override Chrono's default timezone abbriviation mapping. The value should be the timezone offset in minutes (between -720 to 720).
		### Parsed Results and Components

		```js
		chrono.parse('Friday at 2 pm IST', refDate, { timezones: { 'IST': 330 } })[0].start.get('timezoneOffset');
		// 330 (IST – India Standard Time +0530)

		chrono.parse('Friday at 2 pm IST', refDate, { timezones: {'IST': 60 } })[0].start.get('timezoneOffset');
		// 60 (IST - Irish Standard Time +0100)
		```

		### Detailed Parsed Results

		The function `chrono.parse` returns detailed parsing results as objects of class `chrono.ParsedResult`.

		```js
		var results = chrono.parse('I have an appointment tomorrow from 10 to 11 AM');

		results[0].index; // 15
		results[0].text; // 'tomorrow from 10 to 11 AM'
		results[0].ref; // Sat Dec 13 2014 21:50:14 GMT-0600 (CST)

		results[0].start.date(); // Sun Dec 14 2014 10:00:00 GMT-0600 (CST)
		results[0].end.date(); // Sun Dec 14 2014 11:00:00 GMT-0600 (CST)
		```

		#### ParsedResult
		* `refDate: Date` The [reference date](#reference-date) of this result
		* `index: number` The location within the input text of this result
		* `text: string` The text this result that appears in the input
		* `start: ParsedComponents` The parsed date components as a [ParsedComponents](#parsedcomponents) object
		* `end?: ParsedComponents` Similar to `start`
		* `date: () => Date` Create a javascript Date

		* `start` The parsed date components as a [ParsedComponents](#parsedcomponents) object
		* `end` Similar to `start` but can be null.
		* `index` The location within the input text of this result
		* `text` The text this result that appears in the input
		* `ref` The [reference date](#reference-date) of this result

		#### ParsedComponents

		A group of found date and time components (year, month, hour, etc). ParsedComponents objects consist of `knownValues` and `impliedValues`.

		* `assign(component, value)` Set known value to the component
		* `imply(component, value)` Set implied value to the component
		* `get(component)` Get known or implied value for the component
		* `isCertain(component)` return true if the value of the component is known.
		* `date()` Create a javascript Date

		For example:
		```js
		// Remove the timezone offset of a parsed date and then create the Date object
		var results = new chrono.parse('2016-03-08T01:16:07+02:00'); // Create new ParsedResult Object
		results[0].start.assign('timezoneOffset', 0); // Change value in ParsedComponents Object 'start'
		const results = chrono.parse('I have an appointment tomorrow from 10 to 11 AM');

		var d = results[0].start.date(); // Create a Date object
		d.toString(); // 'Tue Mar 08 2016 01:16:07 GMT+0000 (GMT)'
		results[0].index; // 15
		results[0].text; // 'tomorrow from 10 to 11 AM'
		results[0].refDate; // Sat Dec 13 2014 21:50:14 GMT-0600 (CST)

		// `start` is Sat Dec 14 2014 10:00:00
		results[0].start.get('day'); // 14 (the 14th, the day after refDate)
		results[0].start.get('month'); // 12 (or December)
		results[0].start.get('hour'); // 10
		results[0].start.date(); // Sun Dec 14 2014 10:00:00 GMT-0600 (CST)

		...
		results[0].end.date(); // Sun Dec 14 2014 11:00:00 GMT-0600 (CST)
		```

		### Strict vs Casual
		### Strict vs Casual configuration

		@@ -163,90 +150,85 @@ Chrono comes with `strict` mode that parse only formal date patterns.

		### Choosing Locale
		### Locales

		By default, Chrono is configurated to parse different date formats from muliple languages out-off-box. However, by using predefined locale options, you can increase parsing accuracy.
		By default, Chrono is configured to handle only international English.
		This differs from the previous version of Chrono that would try all locales by default.

		Handling different date format for UK / US is a good example.
		There are several locales supported contributed by multiple developers under `./locales` directory.

		```js
		// default English (US)
		chrono.parseDate('6/10/2018'); // Sun Jun 10 2018 12:00:00 ...
		chrono.en.parseDate('6/10/2018'); // Sun Jun 10 2018 12:00:00 ...
		chrono.parseDate('6/10/2018');

		// UK English or German
		chrono.en_GB.parseDate('6/10/2018'); // Sat Oct 06 2018 12:00:00 ...
		chrono.de.parseDate('6/10/2018'); // Sat Oct 06 2018 12:00:00 ...
		chrono.en.parseDate('6/10/2018');
		chrono.ja.parseDate('昭和６４年１月７日');
		```

		Current supported locale options are: `en`, `en_GB`, `de`, `pt`, `es`, `fr`, `ja`
		Current supported locale options are: `en`, `ja`

		## Customize Chrono

		Chrono’s extraction pipeline are mainly separated into 'parse' and ‘refine’ phases. During parsing, ‘parsers’ (`Parser`) are used to extract patterns from the input text. The parsed results ([ParsedResult](#parsedresult)) are the combined, sorted, then refine using ‘refiners’ (`Refiner`). In the refining phase, the results can be combined, filtered-out, or attached with additional information.
		Chrono’s extraction pipeline configuration consists of `parsers: Parser[]` and `refiners: Refiner[]`.

		* First, each parser independently extracts patterns from input text input and create parsing results ([ParsingResult](#parsedresult)).
		* Then, the parsing results are combined, sorted, and refined with the refiners. In the refining phase, the results can be filtered-out, merged, or attached with additional information.

		### Parser

		Parser is a module for low-level pattern-based parsing. Ideally, each parser should be designed to handle a single specific date format. User can add new type of parsers for supporting new date formats or languages.
		```typescript
		interface Parser {
		pattern: (context: ParsingContext) => RegExp,
		extract: (context: ParsingContext, match: RegExpMatchArray) =>
		(ParsingComponents \| ParsingResult \| {[c: Component]: string\|number} \| null)
		}
		```

		```js
		var christmasParser = new chrono.Parser();
		Parser is a module for low-level pattern-based parsing.
		Ideally, each parser should be designed to handle a single specific date format.

		// Provide search pattern
		christmasParser.pattern = function () { return /Christmas/i; };
		User can create a new parser for supporting new date formats or languages
		by providing RegExp pattern `pattern()` and extracting result or components from the RegExp match `extract()`.

		// This function will be called when matched pattern is found
		christmasParser.extract = function(text, ref, match, opt) {

		// Return a parsed result, that is 25 December
		return new chrono.ParsedResult({
		ref: ref,
		text: match[0],
		index: match.index,
		start: {
		day: 25,
		month: 12,
		```javascript
		const custom = chrono.casual.copy();
		custom.parsers.push({
		pattern: () => { return /\bChristmas\b/i },
		extract: (context, match) => {
		return {
		day: 25, month: 12
		}
		});
		};
		}
		});

		// Create a new custom Chrono. The initial pipeline 'option' can also be specified as
		// - new chrono.Chrono(exports.options.strictOption())
		// - new chrono.Chrono(exports.options.casualOption())
		var custom = new chrono.Chrono();
		custom.parsers.push(christmasParser);

		custom.parseDate("I'll arrive at 2.30AM on Christmas night");
		// Wed Dec 25 2013 02:30:00 GMT+0900 (JST)

		// 'at 2.30AM on Christmas'
		```

		To create a custom parser, override `pattern` and `extract` methods on an object of class `chrono.Parser`.
		* The `pattern` method must return `RegExp` object of searching pattern.
		* The `extract` method will be called with the
		[match](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) object when the pattern is found. This function must create and return a [result](#parsedresult) (or null to skip).

		### Refiner

		```typescript
		interface Refiner {
		refine: (context: ParsingContext, results: ParsingResult[]) => ParsingResult[]
		}
		```

		Refiner is a higher level module for improving or manipulating the results. User can add a new type of refiner to customize Chrono's results or to add some custom logic to Chrono.

		```js
		var guessPMRefiner = new chrono.Refiner();
		guessPMRefiner.refine = function(text, results, opt) {
		// If there is no AM/PM (meridiem) specified,
		// let all time between 1:00 - 4:00 be PM (13.00 - 16.00)
		results.forEach(function (result) {
		if (!result.start.isCertain('meridiem') &&
		result.start.get('hour') >= 1 && result.start.get('hour') < 4) {

		result.start.assign('meridiem', 1);
		result.start.assign('hour', result.start.get('hour') + 12);
		}
		});
		return results;
		};
		```javascript
		const custom = chrono.casual.copy();
		custom.refiners.push({
		refine: (context, results) => {
		// If there is no AM/PM (meridiem) specified,
		// let all time between 1:00 - 4:00 be PM (13.00 - 16.00)
		results.forEach((result) => {
		if (!result.start.isCertain('meridiem') &&
		result.start.get('hour') >= 1 && result.start.get('hour') < 4) {

		// Create a new custom Chrono. The initial pipeline 'option' can also be specified as
		// - new chrono.Chrono(exports.options.strictOption())
		// - new chrono.Chrono(exports.options.casualOption())
		var custom = new chrono.Chrono();
		custom.refiners.push(guessPMRefiner);
		result.start.assign('meridiem', 1);
		result.start.assign('hour', result.start.get('hour') + 12);
		}
		});
		return results;
		}
		});

		@@ -262,8 +244,9 @@ // This will be parsed as PM.

		In the example, a custom refiner is created for assigning PM to parsing results with ambiguous [meridiem](http://en.wikipedia.org/wiki/12-hour_clock). The `refine` method of the refiner class will be called with parsing [results](#parsedresult) (from [parsers](#parser) or other previous refiners). The method must return an array of the new results (which, in this case, we modified those results in place).
		In the example, the custom refiner assigns PM to parsing results with ambiguous [meridiem](http://en.wikipedia.org/wiki/12-hour_clock).
		The `refine` method of the refiner class will be called with parsing [results](#parsedresult) (from [parsers](#parser) or other previous refiners).
		The method must return an array of the new results (which, in this case, we modified those results in place).


		## Development Guides

		This guide explains how to setup chrono project for prospective contributors.
		This guide explains how to set up chrono project for prospective contributors.

		@@ -278,3 +261,5 @@ ```bash

		Parsing date from text is complicated. Sometimes, a small change can have effects on unexpected places. So, Chrono is a heavily tested library. Commits that break a test shouldn't be allowed in any condition.
		Parsing date from text is complicated. A small change can have effects on unexpected places.
		So, Chrono is a heavily tested library.
		Commits that break a test shouldn't be allowed in any condition.

		@@ -291,3 +276,4 @@ Chrono's unit testing is based-on [Jest](https://facebook.github.io/jest/).

		Chrono's source files is in `src` directory. The built bundle (`dist/*`) is created by running [Webpack](https://webpack.js.org/) via the following command
		Chrono's source files is in `src` directory.
		The built bundle (`dist/*`) is created by running [Webpack](https://webpack.js.org/) via the following command

		@@ -294,0 +280,0 @@ ```bash

252

test/en/en_casual.test.js

		@@ -1,3 +0,4 @@
		import * as chrono from '../../src/chrono';
		import * as chrono from '../../src/';
		import {testSingleCase, testUnexpectedResult} from '../test_util';
		import {Meridiem} from "../../src/";

		@@ -20,5 +21,3 @@ test("Test - Single Expression", function() {

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 8, 9, 10, 11);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 8, 9, 10, 11));
		});
		@@ -35,5 +34,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
		});
		@@ -51,5 +48,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 11, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 11, 12));
		});
		@@ -59,5 +54,3 @@
		testSingleCase(chrono.casual, 'The Deadline is Tomorrow', new Date(2012, 7, 10, 1), (result) => {
		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
		});
		@@ -75,5 +68,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 9, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 9, 12));
		});
		@@ -92,5 +83,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 9, 0);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 9, 0));
		});
		@@ -109,5 +98,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 6);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 6));
		});
		@@ -126,5 +113,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 15);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 15));
		});
		@@ -143,5 +128,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 20);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 20));
		});
		@@ -164,5 +147,3 @@ });

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 17);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 17));
		});
		@@ -184,5 +165,3 @@ });

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 4, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 4, 12));

		@@ -196,5 +175,3 @@

		var resultDate = result.end.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.end).toBeDate(new Date(2012, 7, 10, 12));
		});
		@@ -214,5 +191,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 12));

		@@ -226,5 +201,3 @@

		var resultDate = result.end.date();
		var expectDate = new Date(2012, 7, 17, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.end).toBeDate(new Date(2012, 7, 17, 12));
		});
		@@ -268,109 +241,122 @@ });

		var text = "tonight";
		var result = chrono.parse(text, new Date(2012, 1-1, 1, 12))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(22);
		expect(result.start.get('meridiem') ).toBe(1);
		testSingleCase(chrono, 'tonight', new Date(2012, 1-1, 1, 12), (result, text) => {

		var text = "tonight 8pm";
		var result = chrono.parse(text, new Date(2012, 1-1, 1, 12))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(20);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(1);
		expect(result.start.get('meridiem') ).toBe(1);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(22);
		expect(result.start.get('meridiem') ).toBe(Meridiem.PM);
		});

		testSingleCase(chrono, 'tonight 8pm', new Date(2012, 1-1, 1, 12), (result, text) => {

		var text = "tonight at 8";
		var result = chrono.parse(text, new Date(2012, 1-1, 1, 12))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(20);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(1);
		expect(result.start.get('meridiem') ).toBe(1);
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(20);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(1);
		expect(result.start.get('meridiem') ).toBe(Meridiem.PM);
		});


		var text = "tomorrow before 4pm";
		var result = chrono.parse(text, new Date(2012, 1-1, 1, 12))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(16);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(2);
		expect(result.start.get('meridiem') ).toBe(1);
		testSingleCase(chrono, 'tonight at 8', new Date(2012, 1-1, 1, 12), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(20);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(1);
		expect(result.start.get('meridiem') ).toBe(Meridiem.PM);
		});

		var text = "tomorrow after 4pm";
		var result = chrono.parse(text, new Date(2012, 1-1, 1, 12))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(16);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(2);
		expect(result.start.get('meridiem') ).toBe(1);

		testSingleCase(chrono, 'tomorrow before 4pm', new Date(2012, 1-1, 1, 12), (result, text) => {

		var text = "thurs";
		var result = chrono.parse(text)[0];
		expect(result.text).toBe(text);
		expect(result.start.get('weekday')).toBe(4);
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(16);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(2);
		expect(result.start.get('meridiem') ).toBe(Meridiem.PM);
		});


		var text = "thurs";
		var result = chrono.parse(text)[0];
		expect(result.text).toBe(text);
		expect(result.start.get('weekday')).toBe(4);
		testSingleCase(chrono, 'tomorrow after 4pm', new Date(2012, 1-1, 1, 12), (result, text) => {

		var text = "this evening";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(20);
		expect(result.text).toBe(text);
		expect(result.start.get('hour') ).toBe(16);
		expect(result.start.get('year') ).toBe(2012);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day') ).toBe(2);
		expect(result.start.get('meridiem') ).toBe(Meridiem.PM);
		});

		var text = "yesterday afternoon";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(30);
		expect(result.start.get('hour')).toBe(15);

		var text = "tomorrow morning";
		var result = chrono.parse(text, new Date(2016, 10-1, 1, 8))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(2);
		expect(result.start.get('hour')).toBe(6);
		testSingleCase(chrono, 'thurs', (result, text) => {

		var text = "this afternoon at 3";
		var result = chrono.parse(text, new Date(2016, 10-1, 1, 8))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(15);
		expect(result.text).toBe(text);
		expect(result.start.get('weekday')).toBe(4);
		});

		var text = "11 at night";
		var result = chrono.parse(text, new Date(2016, 10-1, 1, 8))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(23);

		var text = "11 tonight";
		var result = chrono.parse(text, new Date(2016, 10-1, 1, 8))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(23);
		testSingleCase(chrono, 'thurs', (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('weekday')).toBe(4);
		});

		testSingleCase(chrono, 'this evening', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(20);
		});

		testSingleCase(chrono, 'yesterday afternoon', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(30);
		expect(result.start.get('hour')).toBe(15);
		});

		testSingleCase(chrono, 'tomorrow morning', new Date(2016, 10-1, 1, 8), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(2);
		expect(result.start.get('hour')).toBe(6);
		});

		testSingleCase(chrono, 'this afternoon at 3', new Date(2016, 10-1, 1, 8), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(15);
		});

		testSingleCase(chrono, '11 at night', new Date(2016, 10-1, 1, 8), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(23);
		});

		testSingleCase(chrono, '11 tonight', new Date(2016, 10-1, 1, 8), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(23);
		});
		});
		@@ -377,0 +363,0 @@

67

test/en/en_inter_std.test.js

		@@ -1,2 +0,2 @@
		import * as chrono from '../../src/chrono';
		import * as chrono from '../../src/';
		import { testSingleCase, testWithExpectedDate } from '../test_util';
		@@ -29,6 +29,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(784043130000);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(784043130000));
		});
		@@ -47,6 +44,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(784041330000);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(784041330000));
		});
		@@ -65,6 +59,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(1438344000000);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(1438344000000));
		});
		@@ -84,6 +75,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(784041330000);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(784041330000));
		});
		@@ -102,6 +90,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(784041330000);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(784041330000));
		});
		@@ -123,6 +108,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(784041330000);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(784041330000));
		});
		@@ -142,38 +124,5 @@

		var resultDate = result.start.date();
		var expectDate = new Date(1462661100487);

		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(1462661100487));
		});
		});


		test("Test - Compare with native js", function() {

		const testByCompareWithNative = (text) => {
		const expectedDate = new Date(text);
		testWithExpectedDate(chrono, text, expectedDate)
		};

		testByCompareWithNative('1994-11-05T13:15:30Z');

		testByCompareWithNative('1994-02-28T08:15:30-05:30');

		testByCompareWithNative('1994-11-05T08:15:30-05:30');

		testByCompareWithNative('1994-11-05T08:15:30+11:30');

		testByCompareWithNative('2014-11-30T08:15:30-05:30');

		testByCompareWithNative('Sat, 21 Feb 2015 11:50:48 -0500');

		testByCompareWithNative('22 Feb 2015 04:12:00 -0000');

		testByCompareWithNative('1900-01-01T00:00:00-01:00');

		testByCompareWithNative('1900-01-01T00:00:00-00:00');

		testByCompareWithNative('9999-12-31T23:59:00-00:00');

		testByCompareWithNative('09/25/2017 10:31:50.522 PM');
		});

14

test/en/en_month.test.js

		@@ -1,3 +0,3 @@
		import * as chrono from '../../src/chrono';
		import { testSingleCase } from '../test_util';
		import * as chrono from '../../src';
		import {testSingleCase, testWithExpectedDate, testUnexpectedResult} from '../test_util';

		@@ -68,3 +68,2 @@ test("Test - Month expression", function() {


		test("Test - Month expression in context", function() {
		@@ -101,3 +100,2 @@


		testSingleCase(chrono, '9/2012', new Date(2012,7,10), (result) => {
		@@ -111,5 +109,3 @@ expect(result.start).not.toBeNull();

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 9-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 9-1, 1, 12));
		});
		@@ -125,5 +121,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 9-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 9-1, 1, 12));
		});
		@@ -130,0 +124,0 @@

300

test/en/en_relative.test.js

		@@ -1,179 +0,129 @@
		import * as chrono from '../../src/chrono';
		import { testSingleCase } from '../test_util';
		import * as chrono from '../../src';
		import {testSingleCase} from '../test_util';

		test("Test - Single Expression", function() {
		test("Test - Single Expression", () => {

		var text = "this week";
		var result = chrono.parse(text, new Date(2017, 11-1, 19))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(19);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'this week', new Date(2017, 11-1, 19), (result, text) => {

		var text = "this month";
		var result = chrono.parse(text, new Date(2017, 11-1, 19))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(19);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "this month";
		var result = chrono.parse(text, new Date(2017, 11-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'this month', new Date(2017, 11-1, 19), (result, text) => {

		var text = "this year";
		var result = chrono.parse(text, new Date(2017, 11-1, 19))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'this month', new Date(2017, 11-1, 1), (result, text) => {

		var text = "next week";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(8);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "next 2 weeks";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(15);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'this year', new Date(2017, 11-1, 19), (result, text) => {

		var text = "last week";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(24);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "last 2 weeks";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(17);
		expect(result.start.get('hour')).toBe(12);

		var text = "next day";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(2);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'next week', new Date(2016, 10-1, 1), (result, text) => {

		var text = "next 2 days";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(3);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(8);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "last day";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(30);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'next 2 weeks', new Date(2016, 10-1, 1), (result, text) => {

		var text = "last 2 days";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(29);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(15);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "next month";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'last week', new Date(2016, 10-1, 1), (result, text) => {

		var text = "next 2 months";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(12);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(24);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "last month";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'last 2 weeks', new Date(2016, 10-1, 1), (result, text) => {

		var text = "last 2 months";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(17);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "next few weeks";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(22);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'last two weeks', new Date(2016, 10-1, 1), (result, text) => {

		var text = "next four weeks";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(29);
		expect(result.start.get('hour')).toBe(12);
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(17);
		expect(result.start.get('hour')).toBe(12);
		});

		var text = "past week";
		var result = chrono.parse(text, new Date(2016, 10-1, 1))[0];
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(24);
		expect(result.start.get('hour')).toBe(12);
		testSingleCase(chrono, 'next day', new Date(2016, 10-1, 1), (result, text) => {

		testSingleCase(chrono.en, 'next week at 10-06-2016', new Date(2016, 10-1, 1), (result) => {
		expect(result.text).toBe('next week at 10-06-2016');
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(6);
		expect(result.start.get('day')).toBe(2);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono.en, 'next month at 11-06-2016', new Date(2016, 10-1, 1), (result) => {
		expect(result.text).toBe('next month at 11-06-2016');
		testSingleCase(chrono, 'next 2 days', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(6);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(3);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'next year at Feb-2017', new Date(2016, 10, 10), (result) => {
		expect(result.text).toBe('next year at Feb-2017');
		expect(result.start.get('year')).toBe(2017);
		expect(result.start.get('month')).toBe(2);
		testSingleCase(chrono, 'last day', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(30);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'last 2 days', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(29);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'next month', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(1);
		@@ -183,4 +133,5 @@ expect(result.start.get('hour')).toBe(12);

		testSingleCase(chrono, 'next week (Dec 2016)', new Date(2016, 11, 27), (result) => {
		expect(result.text).toBe('next week (Dec 2016')
		testSingleCase(chrono, 'next 2 months', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		@@ -192,15 +143,46 @@ expect(result.start.get('month')).toBe(12);

		testSingleCase(chrono, 'She is getting married next year (July 2013).', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2013)
		expect(result.start.get('month')).toBe(7)
		expect(result.start.get('day')).toBe(1)
		testSingleCase(chrono, 'last month', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.index).toBe(23)
		expect(result.text).toBe('next year (July 2013')
		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		});

		var resultDate = result.start.date();
		var expectDate = new Date(2013, 7-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		testSingleCase(chrono, 'last 2 months', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(1);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'next few weeks', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(22);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'next four weeks', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(29);
		expect(result.start.get('hour')).toBe(12);
		});

		testSingleCase(chrono, 'past week', new Date(2016, 10-1, 1), (result, text) => {

		expect(result.text).toBe(text);
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(24);
		expect(result.start.get('hour')).toBe(12);
		});
		});

397

test/en/en_slash.test.js

		@@ -1,41 +0,38 @@
		import * as chrono from '../../src/chrono';
		import { testSingleCase } from '../test_util';
		import * as chrono from '../../src';
		import {testSingleCase, testUnexpectedResult, testWithExpectedDate} from '../test_util';

		test("Test - Single Expression", function() {

		testSingleCase(chrono, 'The event is going ahead (04/2016)', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2016)
		expect(result.start.get('month')).toBe(4)
		expect(result.start.get('day')).toBe(1)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2016);
		expect(result.start.get('month')).toBe(4);
		expect(result.start.get('day')).toBe(1);

		expect(result.index).toBe(26)
		expect(result.text).toBe('04/2016')
		expect(result.index).toBe(26);
		expect(result.text).toBe('04/2016');

		var resultDate = result.start.date();
		var expectDate = new Date(2016, 4-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2016, 4-1, 1, 12));
		});

		testSingleCase(chrono, 'Published: 06/2004', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2004)
		expect(result.start.get('month')).toBe(6)
		expect(result.start.get('day')).toBe(1)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2004);
		expect(result.start.get('month')).toBe(6);
		expect(result.start.get('day')).toBe(1);

		expect(result.index).toBe(11)
		expect(result.text).toBe('06/2004')
		expect(result.index).toBe(11);
		expect(result.text).toBe('06/2004');

		var resultDate = result.start.date();
		var expectDate = new Date(2004, 6-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2004, 6-1, 1, 12));
		});

		testSingleCase(chrono, '8/10/2012', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(10)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(10);

		expect(result.index).toBe(0)
		expect(result.text).toBe('8/10/2012')
		expect(result.index).toBe(0);
		expect(result.text).toBe('8/10/2012');

		@@ -46,29 +43,25 @@ expect(result.start.isCertain('day')).toBe(true);

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 8-1, 10, 12));
		});

		testSingleCase(chrono, ': 8/1/2012', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(1)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(1);

		expect(result.index).toBe(2)
		expect(result.text).toBe('8/1/2012')
		expect(result.index).toBe(2);
		expect(result.text).toBe('8/1/2012');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 8-1, 1, 12));
		});

		testSingleCase(chrono, '8/10', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(10)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(10);

		expect(result.index).toBe(0)
		expect(result.text).toBe('8/10')
		expect(result.index).toBe(0);
		expect(result.text).toBe('8/10');

		@@ -79,26 +72,29 @@ expect(result.start.isCertain('day')).toBe(true);

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 8-1, 10, 12));
		});


		testSingleCase(chrono, 'The Deadline is 8/10/2012', new Date(2012,7,10), (result) => {
		expect(result.index).toBe(16)
		expect(result.text).toBe('8/10/2012')
		expect(result.index).toBe(16);
		expect(result.text).toBe('8/10/2012');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
		});

		testSingleCase(chrono, 'The Deadline is Tuesday 11/3/2015', new Date(2015,10,3), (result) => {
		expect(result.index).toBe(16)
		expect(result.text).toBe('Tuesday 11/3/2015')
		expect(result.index).toBe(16);
		expect(result.text).toBe('Tuesday 11/3/2015');

		var resultDate = result.start.date();
		var expectDate = new Date(2015, 10, 3, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2015, 10, 3, 12));
		});

		testSingleCase(chrono.strict, '2/28/2014', (result) => {
		expect(result.text).toBe('2/28/2014')
		})

		testWithExpectedDate(chrono.strict, '12-30-16', new Date(2016,12-1,30, 12));

		testSingleCase(chrono.strict, 'Friday 12-30-16', (result) => {
		expect(result.text).toBe('Friday 12-30-16');
		expect(result).toBeDate(new Date(2016,12-1,30, 12))
		})
		});
		@@ -108,15 +104,20 @@

		testSingleCase(chrono.en_GB, '8/10/2012', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(10)
		expect(result.start.get('day')).toBe(8)
		testSingleCase(chrono.en.GB, '8/10/2012', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(8);

		expect(result.index).toBe(0)
		expect(result.text).toBe('8/10/2012')
		expect(result.index).toBe(0);
		expect(result.text).toBe('8/10/2012');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 10-1, 8, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 10-1, 8, 12));
		});

		testWithExpectedDate(chrono.strict, '30-12-16', new Date(2016,12-1,30, 12));

		testSingleCase(chrono.strict, 'Friday 30-12-16', (result) => {
		expect(result.text).toBe('Friday 30-12-16');
		expect(result).toBeDate(new Date(2016,12-1,30, 12))
		})
		});
		@@ -126,43 +127,43 @@

		testSingleCase(chrono.en_GB, '8/Oct/2012', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(10)
		expect(result.start.get('day')).toBe(8)
		testSingleCase(chrono.en.GB, '8/Oct/2012', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(10);
		expect(result.start.get('day')).toBe(8);

		expect(result.index).toBe(0)
		expect(result.text).toBe('8/Oct/2012')
		expect(result.index).toBe(0);
		expect(result.text).toBe('8/Oct/2012');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 10-1, 8, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 10-1, 8, 12));
		});
		});


		test("Test - Single Expression Start with Year", function() {

		testSingleCase(chrono, '2012/8/10', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(10)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(10);

		expect(result.index).toBe(0)
		expect(result.text).toBe('2012/8/10')
		expect(result.index).toBe(0);
		expect(result.text).toBe('2012/8/10');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 8-1, 10, 12));
		});


		testSingleCase(chrono, 'The Deadline is 2012/8/10', new Date(2012,7,10), (result) => {
		expect(result.index).toBe(16)
		expect(result.text).toBe('2012/8/10')
		expect(result.index).toBe(16);
		expect(result.text).toBe('2012/8/10');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
		});

		testSingleCase(chrono.strict, '2014/2/28', (result) => {
		expect(result.text).toBe('2014/2/28')
		})

		testSingleCase(chrono.strict, '2014/12/28', (result) => {
		expect(result.text).toBe('2014/12/28')
		})
		});
		@@ -173,26 +174,21 @@
		testSingleCase(chrono, '2012/Aug/10', new Date(2012,7,10), (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(10)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(10);

		expect(result.index).toBe(0)
		expect(result.text).toBe('2012/Aug/10')
		expect(result.index).toBe(0);
		expect(result.text).toBe('2012/Aug/10');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 8-1, 10, 12));
		});

		testSingleCase(chrono, 'The Deadline is 2012/aug/10', new Date(2012,7,10), (result) => {
		expect(result.index).toBe(16)
		expect(result.text).toBe('2012/aug/10')
		expect(result.index).toBe(16);
		expect(result.text).toBe('2012/aug/10');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
		});
		});


		test("Test - Range Expression", function() {
		@@ -203,22 +199,18 @@

		expect(result.index).toBe(0)
		expect(result.text).toBe('8/10/2012 - 8/15/2012')
		expect(result.index).toBe(0);
		expect(result.text).toBe('8/10/2012 - 8/15/2012');

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(10)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(10);

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 8-1, 10, 12));

		expect(result.end).not.toBeNull()
		expect(result.end.get('year')).toBe(2012)
		expect(result.end.get('month')).toBe(8)
		expect(result.end.get('day')).toBe(15)
		expect(result.end).not.toBeNull();
		expect(result.end.get('year')).toBe(2012);
		expect(result.end.get('month')).toBe(8);
		expect(result.end.get('day')).toBe(15);

		var resultDate = result.end.date();
		var expectDate = new Date(2012, 8-1, 15, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.end).toBeDate(new Date(2012, 8-1, 15, 12));

		@@ -228,146 +220,42 @@ });

		test('Test - Random date patterns', function() {
		var expectDate = new Date(2015, 4, 25, 12, 0);
		test('Test - Splitter variances patterns', function() {
		const expectDate = new Date(2015, 5-1, 25, 12, 0);

		text = "2015-05-25";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
		testWithExpectedDate(chrono, '2015-05-25', expectDate);
		testWithExpectedDate(chrono, '2015/05/25', expectDate);
		testWithExpectedDate(chrono, '2015.05.25', expectDate);
		testWithExpectedDate(chrono, '05-25-2015', expectDate);
		testWithExpectedDate(chrono, '05/25/2015', expectDate);
		testWithExpectedDate(chrono, '05.25.2015', expectDate);

		text = "2015/05/25";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		var text = "05-25-2015";
		var results = chrono.parse(text);
		var resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		text = "05/25/2015";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		text = "05.25.2015";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		// unambiguous date pattern
		text = "25/05/2015";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		// ambiguous US date pattern, expected 5th of June
		expectDate = new Date(2015, 5, 5, 12, 0);
		text = "06/05/2015";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		expectDate = new Date(2015, 7, 13, 12, 0);
		text = "2015.8.13";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		expectDate = new Date(2015, 7, 13, 12, 0);
		text = "2015.08.13";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		expectDate = new Date(2015, 7, 13, 12, 0);
		text = "2015.08.13";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		expectDate = new Date(2007, 7, 13, 12, 0);
		text = "2007/8/13";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		expectDate = new Date(2007, 7, 13, 12, 0);
		text = "2007/08/13";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());


		expectDate = new Date(1999, 7, 13, 12, 0);
		text = "8/13/99";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());

		expectDate = new Date(1989, 7, 13, 12, 0);
		text = "8/13/89";
		results = chrono.parse(text);
		resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
		// Also, guessing ambiguous date
		testWithExpectedDate(chrono, '25/05/2015', expectDate);
		});

		test("Test - Impossible Dates and Unexpected Results", function() {

		test("Test - Impossible Date (Strict Mode)", function() {
		testUnexpectedResult(chrono, '8/32/2014', new Date(2012,7,10));

		var text = "8/32/2014";
		var results = chrono.strict.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '8/32', new Date(2012,7,10));

		var text = "8/32";
		var results = chrono.strict.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '2/29/2014', new Date(2012,7,10));

		var text = "2/29/2014";
		var results = chrono.strict.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '2014/22/29', new Date(2012,7,10));

		var text = "2014/22/29";
		var results = chrono.strict.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '2014/13/22', new Date(2012,7,10));

		var text = "2014/13/22";
		var results = chrono.strict.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '80-32-89-89', new Date(2012,7,10));
		});


		test("Test - Impossible Dates (Casual Mode)", function() {

		var text = "9/31/2015";
		var expectDate = new Date(2015, 9, 1, 12, 0);
		var results = chrono.parse(text);
		var resultDate = results[0].start.date();
		expect(results.length).toBe(1)
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
		});

		test('Test - forward dates only option', function () {

		testSingleCase(chrono, '5/31', new Date(1999, 6-1, 1), {forwardDate: true}, (result) => {
		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2000)
		expect(result.start.get('month')).toBe(5)
		expect(result.start.get('day')).toBe(31)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2000);
		expect(result.start.get('month')).toBe(5);
		expect(result.start.get('day')).toBe(31);

		expect(result.index).toBe(0)
		expect(result.text).toBe('5/31')
		expect(result.index).toBe(0);
		expect(result.text).toBe('5/31');

		@@ -378,7 +266,6 @@ expect(result.start.isCertain('day')).toBe(true);

		var resultDate = result.start.date();
		var expectDate = new Date(2000, 5-1, 31, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2000, 5-1, 31, 12));
		});

		});

56

test/en/en_weekday.test.js

		@@ -1,3 +0,3 @@
		import * as chrono from '../../src/chrono';
		import { testSingleCase } from '../test_util';
		import * as chrono from '../../src';
		import {testSingleCase, testWithExpectedDate, testUnexpectedResult} from '../test_util';

		@@ -22,5 +22,3 @@ test("Test - Single Expression", function () {

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 6, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 6, 12));
		});
		@@ -44,5 +42,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 13, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 13, 12));
		});
		@@ -60,5 +56,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 9, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 9, 12));
		});
		@@ -76,5 +70,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 12, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 12, 12));
		});
		@@ -93,5 +85,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 3, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 3, 12));
		});
		@@ -109,5 +99,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7, 3, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2012, 7, 3, 12));
		});
		@@ -126,5 +114,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2015, 3, 24, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2015, 3, 24, 12));
		});
		@@ -143,5 +129,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2015, 3, 21, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2015, 3, 21, 12));
		});
		@@ -162,5 +146,3 @@ });

		var resultDate = result.start.date();
		var expectDate = new Date(2015, 3, 21, 6);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2015, 3, 21, 6));
		});
		@@ -187,5 +169,3 @@ });

		var resultDate = result.start.date();
		var expectDate = new Date(2014, 12 - 1, 7, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2014, 12 - 1, 7, 12));
		});
		@@ -210,5 +190,3 @@

		var resultDate = result.start.date();
		var expectDate = new Date(2014, 12 - 1, 7, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2014, 12 - 1, 7, 12));
		});
		@@ -235,5 +213,3 @@ });

		var resultDate = result.start.date();
		var expectDate = new Date(2016, 8-1, 5, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.start).toBeDate(new Date(2016, 8-1, 5, 12));

		@@ -252,6 +228,4 @@

		var resultDate = result.end.date();
		var expectDate = new Date(2016, 8-1, 8, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		expect(result.end).toBeDate(new Date(2016, 8-1, 8, 12));
		});
		});

268

test/en/en.test.js

		@@ -1,2 +0,3 @@
		var chrono = require('../../src/chrono');
		import * as chrono from '../../src';
		import {testSingleCase, testUnexpectedResult} from '../test_util';

		@@ -6,211 +7,85 @@

		var text = "Something happen on 2014-04-18 13:00 - 16:00 as";
		var results = chrono.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(1)
		expect(results[0].text).toBe('2014-04-18 13:00 - 16:00')

		});
		testSingleCase(chrono, 'Something happen on 2014-04-18 13:00 - 16:00 as', (result) => {
		expect(result.text).toBe('2014-04-18 13:00 - 16:00')


		test("Test - Compare with native js", function() {

		var text = 'Sat Nov 05 1994 22:45:30 GMT+0900 (JST)';
		var result = chrono.parse(text)[0];
		var expected = new Date(text);

		expect(result.text).toBe(text);
		expect(expected.getTime()).toBeCloseTo(result.start.date().getTime())


		var text = 'Fri, 31 Mar 2000 07:00:00 UTC';
		var result = chrono.parse(text)[0];
		var expected = new Date(text);

		expect(result.text).toBe(text);
		expect(expected.getTime()).toBeCloseTo(result.start.date().getTime())

		var text = '2014-12-14T18:22:14.759Z';
		var result = chrono.parse(text)[0];
		var expected = new Date(text);

		expect(result.text).toBe(text);
		expect(Math.abs(expected.getTime() - result.start.date().getTime())).toBe(0)
		expect(result.start).toBeDate(new Date(2014, 4-1, 18, 13))
		expect(result.end).toBeDate(new Date(2014, 4-1, 18, 16))
		})
		});

		test("Test - Implying timezeon", function() {

		var text = 'Sat Nov 05 1994 22:45:30 GMT+0900 (JST)';
		var result = chrono.parse(text)[0];
		var expected = new Date(text);

		expect(result.text).toBe(text);
		expect(expected.getTime()).toBeCloseTo(result.start.date().getTime())

		var impliedResult = chrono.parse('Sat Nov 05 1994 22:45:30')[0];
		impliedResult.start.imply('timezoneOffset', 540);

		expect(expected.getTime()).toBeCloseTo(impliedResult.start.date().getTime());
		});
		test('Test - Random text', function() {

		test('Test - Random text', function() {
		testSingleCase(chrono, 'Adam <Adam@supercalendar.com> написал(а):\nThe date is 02.07.2013', (result) => {
		expect(result.text).toBe('02.07.2013');
		});

		var text = "Adam <Adam@supercalendar.com> написал(а):\nThe date is 02.07.2013";
		var result = chrono.parse(text, new Date(2013,5,22,3,33))[0];
		expect(result.text).toBe('02.07.2013')
		testSingleCase(chrono, '174 November 1,2001- March 31,2002', (result) => {
		expect(result.text).toBe('November 1,2001- March 31,2002');
		})

		var text = "174 November 1,2001- March 31,2002";
		var results = chrono.parse(text);
		expect(results.length).toBe(1)
		expect(results[0].text).toBe('November 1,2001- March 31,2002')
		testSingleCase(chrono, '...Thursday, December 15, 2011 Best Available Rate ', (result) => {
		expect(result.text).toBe('Thursday, December 15, 2011');
		expect(result.start.get('year')).toBe(2011);
		})

		testSingleCase(chrono, 'SUN 15SEP 11:05 AM - 12:50 PM', (result) => {
		expect(result.text).toBe('SUN 15SEP 11:05 AM - 12:50 PM');

		var text = "...Thursday, December 15, 2011 Best Available Rate "
		var results = chrono.parse(text);
		expect(results.length).toBe(1)
		expect(results[0].start.get('year')).toBe(2011)
		expect(result.end.get('hour', 12))
		expect(result.end.get('minute', 50))
		})


		var text = "SUN 15SEP 11:05 AM - 12:50 PM"
		var results = chrono.parse(text);
		expect(results.length).toBe(1)
		expect(results[0].text.length).toBe(29)

		var text = "SUN 15SEP 11:05 AM – 12:50 PM"
		var results = chrono.parse(text);
		expect(results.length).toBe(1)
		expect(results[0].end).not.toBeNull()

		var text = "FRI 13SEP 1:29 PM - FRI 13SEP 3:29 PM"
		var results = chrono.parse(text);
		expect(results.length).toBe(1)
		expect(results[0].start.get('hour')).toBe(13)
		expect(results[0].end.get('hour')).toBe(15)
		testSingleCase(chrono, 'FRI 13SEP 1:29 PM - FRI 13SEP 3:29 PM', (result) => {
		expect(result.text).toBe('FRI 13SEP 1:29 PM - FRI 13SEP 3:29 PM');

		var text = "9:00 AM to 5:00 PM, Tuesday, 20 May 2013"
		var results = chrono.parse(text);
		expect(results.length).toBe(1)
		expect(results[0].start.get('hour')).toBe(9)
		expect(results[0].end.get('hour')).toBe(17)
		expect(results[0].end.get('meridiem')).toBe(1)
		expect(result.start.get('day', 13))
		expect(result.start.get('hour', 13))
		expect(result.start.get('minute', 29))

		expect(result.end.get('day', 13))
		expect(result.end.get('hour', 15))
		expect(result.end.get('minute', 29))
		})

		var resultDate = results[0].start.date();
		var expectDate = new Date(2013, 4, 20, 9, 0);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())

		var resultDate = results[0].end.date();
		var expectDate = new Date(2013, 4, 20, 17, 0);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		testSingleCase(chrono, '9:00 AM to 5:00 PM, Tuesday, 20 May 2013', (result) => {
		expect(result.text).toBe('9:00 AM to 5:00 PM, Tuesday, 20 May 2013');

		var text = "2014-07-07T04:00:00Z"
		var results = chrono.parse(text);
		expect(result.start).toBeDate(new Date(2013, 4, 20, 9, 0));
		expect(result.end).toBeDate(new Date(2013, 4, 20, 17, 0));
		})

		expect(results.length).toBe(1)
		expect(results[0].text).toBe('2014-07-07T04:00:00Z')
		testSingleCase(chrono, 'Monday afternoon to last night', new Date(2017, 7-1, 7), (result) => {
		expect(result.text).toBe('Monday afternoon to last night');
		expect(result.start.get('day')).toBe(3);
		expect(result.start.get('month')).toBe(7);
		})
		});


		var text = "1.5.3 - 2015-09-24";
		var results = chrono.parse(text);

		expect(results.length).toBe(1)
		expect(results[0].text).toBe('2015-09-24')


		var text = "1.5.30 - 2015-09-24";
		var results = chrono.parse(text);

		expect(results.length).toBe(1)
		expect(results[0].text).toBe('2015-09-24')


		var text = "1.50.30 - 2015-09-24";
		var results = chrono.parse(text);

		expect(results.length).toBe(1)
		expect(results[0].text).toBe('2015-09-24')

		var text = "Monday afternoon to last night";
		var results = chrono.parse(text, new Date(2017, 7-1, 7));

		expect(results.length).toBe(1);
		expect(results[0].text).toBe('Monday afternoon to last night');
		expect(results[0].start.get('day')).toBe(3);
		expect(results[0].start.get('month')).toBe(7);

		var text = "tonight to Thursday";
		var results = chrono.parse(text, new Date(2017, 7-1, 7));

		expect(results.length).toBe(1);
		expect(results[0].text).toBe('tonight to Thursday');
		expect(results[0].end.get('day')).toBe(13);
		expect(results[0].end.get('month')).toBe(7);

		var text = 'August 12, 2015 to 13 September';
		var results = chrono.parse(text, new Date(2017, 7-1, 7));

		expect(results.length).toBe(1);
		expect(results[0].text).toBe('August 12, 2015 to 13 September');
		expect(results[0].end.get('day')).toBe(13);
		expect(results[0].end.get('month')).toBe(9);
		expect(results[0].end.get('year')).toBe(2015);

		var text = 'from 10am to now';
		var results = chrono.parse(text, new Date(2017, 7-1, 7, 15));

		expect(results.length).toBe(1);
		expect(results[0].text).toBe('from 10am to now');
		expect(results[0].end.get('hour')).toBe(15);
		expect(results[0].end.get('minute')).toBe(0);
		})

		test("Test - Random non-date patterns", function() {

		var text = ' 3'
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, ' 3');

		var text = ' 1'
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, ' 1');

		var text = ' 11 '
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, ' 11 ');

		var text = ' 0.5 '
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, ' 0.5 ');

		var text = ' 35.49 '
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, ' 35.49 ');

		var text = '12.53%'
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '12.53%');

		var text = "6358fe2310> 5.0 / 5 Outstanding";
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '6358fe2310> 5.0 / 5 Outstanding');

		var text = "6358fe2310> 1.5 / 5 Outstanding";
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, '6358fe2310> 1.5 / 5 Outstanding');

		var text = "Total: $1,194.09 [image: View Reservation";
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, 'Total: $1,194.09 [image: View Reservation');

		var text = "Version: 1.1.3";
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, 'Version: 1.1.3');

		var text = "Version: 1.1.30";
		var results = chrono.parse(text);
		expect(results.length).toBe(0)
		testUnexpectedResult(chrono, 'Version: 1.1.30');

		var text = "Version: 1.10.30";
		var results = chrono.parse(text);
		expect(results.length).toBe(0)

		testUnexpectedResult(chrono, 'Version: 1.10.30');
		});
		@@ -220,11 +95,13 @@
		test("Test - Wikipedia Texts", function() {

		var text = 'October 7, 2011, of which details were not revealed out of respect to Jobs\'s family.[239] Apple announced on the same day that they had no plans for a public service, but were encouraging "well-wishers" to send their remembrance messages to an email address created to receive such messages.[240] Sunday, October 16, 2011';
		var results = chrono.parse(text, new Date(2012,7,10));

		expect(results.length).toBe(2)
		expect(results.length).toBe(2)

		var result = results[0];
		if(result){
		const text = 'October 7, 2011, of which details were not revealed out of respect to Jobs\'s family.[239] ' +
		'Apple announced on the same day that they had no plans for a public service, but were encouraging ' +
		'"well-wishers" to send their remembrance messages to an email address created to receive such messages.[240] ' +
		'Sunday, October 16, 2011';

		const results = chrono.parse(text, new Date(2012,7,10));
		expect(results.length).toBe(2);

		{
		const result = results[0];
		expect(result.start.get('year')).toBe(2011);
		@@ -234,8 +111,8 @@ expect(result.start.get('month')).toBe(10);

		expect(result.index).toBe(0)
		expect(result.text).toBe('October 7, 2011')
		expect(result.index).toBe(0);
		expect(result.text).toBe('October 7, 2011');
		}

		var result = results[1];
		if(result){

		{
		const result = results[1];
		expect(result.start.get('year')).toBe(2011);
		@@ -245,6 +122,5 @@ expect(result.start.get('month')).toBe(10);

		expect(result.index).toBe(297)
		expect(result.text).toBe('Sunday, October 16, 2011')
		expect(result.index).toBe(297);
		expect(result.text).toBe('Sunday, October 16, 2011');
		}

		});
		@@ -251,0 +127,0 @@

55

test/ja/ja_casual.test.js

		@@ -1,2 +0,3 @@
		var chrono = require('../../src/chrono');
		import * as chrono from '../../src/';
		import { testSingleCase } from '../test_util';

		@@ -6,42 +7,26 @@

		var text = "今日感じたことを忘れずに";
		var results = chrono.parse(text, new Date(2012, 8-1, 10, 12));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '今日感じたことを忘れずに', new Date(2012, 8-1, 10, 12), (result) => {
		expect(result.index).toBe(0);
		expect(result.text).toBe('今日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(0)
		expect(result.text).toBe('今日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(10);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(10)

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 10, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2012, 8-1, 10, 12));
		});


		var text = "昨日の全国観測値ランキング";
		var results = chrono.parse(text, new Date(2012,8-1, 10, 12));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '昨日の全国観測値ランキング', new Date(2012,8-1, 10, 12), (result) => {
		expect(result.index).toBe(0);
		expect(result.text).toBe('昨日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(0)
		expect(result.text).toBe('昨日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(8);
		expect(result.start.get('day')).toBe(9);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(8)
		expect(result.start.get('day')).toBe(9)

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 8-1, 9, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}


		expect(result.start).toBeDate(new Date(2012, 8-1, 9, 12));
		});
		});
		@@ -48,0 +33,0 @@

435

test/ja/ja_standard.test.js

		@@ -1,2 +0,3 @@
		var chrono = require('../../src/chrono');
		import * as chrono from '../../src/';
		import { testSingleCase } from '../test_util';

		@@ -6,335 +7,219 @@

		var text = "主な株主（2012年3月31日現在）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（2012年3月31日現在）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('2012年3月31日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('2012年3月31日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(3);
		expect(result.start.get('day')).toBe(31);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(3)
		expect(result.start.get('day')).toBe(31)

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 3-1, 31, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2012, 3-1, 31, 12));
		});


		var text = "主な株主（2012年９月3日現在）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（2012年９月3日現在）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('2012年９月3日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('2012年９月3日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(3);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(9)
		expect(result.start.get('day')).toBe(3)

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 9-1, 3, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2012, 9-1, 3, 12));
		});

		var text = "主な株主（2020年2月29日現在）";
		var results = chrono.parse(text, new Date(2019,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（2020年2月29日現在）', new Date(2019,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('2020年2月29日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('2020年2月29日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2020);
		expect(result.start.get('month')).toBe(2);
		expect(result.start.get('day')).toBe(29);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2020)
		expect(result.start.get('month')).toBe(2)
		expect(result.start.get('day')).toBe(29)

		var resultDate = result.start.date();
		var expectDate = new Date(2020, 2-1, 29, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2020, 2-1, 29, 12));
		});

		var text = "主な株主（９月3日現在）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（９月3日現在）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('９月3日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('９月3日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(9);
		expect(result.start.get('day')).toBe(3);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(9)
		expect(result.start.get('day')).toBe(3)

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 9-1, 3, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2012, 9-1, 3, 12));
		});

		var text = "主な株主（平成26年12月29日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（平成26年12月29日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('平成26年12月29日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('平成26年12月29日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2014);
		expect(result.start.get('month')).toBe(12);
		expect(result.start.get('day')).toBe(29);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2014)
		expect(result.start.get('month')).toBe(12)
		expect(result.start.get('day')).toBe(29)

		var resultDate = result.start.date();
		var expectDate = new Date(2014, 12-1, 29, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2014, 12-1, 29, 12));
		});

		var text = "主な株主（昭和６４年１月７日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（昭和６４年１月７日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('昭和６４年１月７日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('昭和６４年１月７日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(1989);
		expect(result.start.get('month')).toBe(1);
		expect(result.start.get('day')).toBe(7);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(1989)
		expect(result.start.get('month')).toBe(1)
		expect(result.start.get('day')).toBe(7)

		var resultDate = result.start.date();
		var expectDate = new Date(1989, 1-1, 7, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(1989, 1-1, 7, 12));
		});


		var text = "主な株主（令和元年5月1日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（令和元年5月1日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('令和元年5月1日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('令和元年5月1日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2019);
		expect(result.start.get('month')).toBe(5);
		expect(result.start.get('day')).toBe(1);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2019)
		expect(result.start.get('month')).toBe(5)
		expect(result.start.get('day')).toBe(1)

		var resultDate = result.start.date();
		var expectDate = new Date(2019, 5-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2019, 5-1, 1, 12));
		});

		var text = "主な株主（令和2年5月1日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（令和2年5月1日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('令和2年5月1日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('令和2年5月1日')
		expect(result.start).not.toBeNull();
		expect(result.start.knownValues.year).toBe(2020);
		expect(result.start.get('month')).toBe(5);
		expect(result.start.get('day')).toBe(1);

		expect(result.start).not.toBeNull()
		expect(result.start.knownValues.year).toBe(2020)
		expect(result.start.get('month')).toBe(5)
		expect(result.start.get('day')).toBe(1)

		var resultDate = result.start.date();
		var expectDate = new Date(2020, 5-1, 1, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2020, 5-1, 1, 12));
		});

		var text = "主な株主（同年7月27日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '主な株主（同年7月27日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('同年7月27日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('同年7月27日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(7);
		expect(result.start.get('day')).toBe(27);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(7)
		expect(result.start.get('day')).toBe(27)
		expect(result.start).toBeDate(new Date(2012, 7-1, 27, 12));
		});

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7-1, 27, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		testSingleCase(chrono.ja, '主な株主（本年7月27日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('本年7月27日');

		var text = "主な株主（本年7月27日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(7);
		expect(result.start.get('day')).toBe(27);

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('本年7月27日')
		expect(result.start).toBeDate(new Date(2012, 7-1, 27, 12));
		});

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(7)
		expect(result.start.get('day')).toBe(27)
		testSingleCase(chrono.ja, '主な株主（今年7月27日）', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('今年7月27日');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7-1, 27, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(7);
		expect(result.start.get('day')).toBe(27);

		var text = "主な株主（今年7月27日）";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		expect(result.start).toBeDate(new Date(2012, 7-1, 27, 12));
		});

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('今年7月27日')
		testSingleCase(chrono.ja, '主な株主（今年11月27日）', new Date(2012,1-1,10), (result) => {
		expect(result.index).toBe(5);
		expect(result.text).toBe('今年11月27日');

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(7)
		expect(result.start.get('day')).toBe(27)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(27);

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7-1, 27, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.start).toBeDate(new Date(2012, 11-1, 27, 12));
		});
		});

		var text = "主な株主（今年11月27日）";
		var results = chrono.parse(text, new Date(2012,1-1,10));
		expect(results.length).toBe(1)

		var result = results[0];
		if (result) {
		expect(result.index).toBe(5)
		expect(result.text).toBe('今年11月27日')
		test("Test - Single Expression without year", function() {

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(11)
		expect(result.start.get('day')).toBe(27)
		testSingleCase(chrono.ja, '7月27日', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(0);
		expect(result.text).toBe('7月27日');

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 11-1, 27, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		});
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2012);
		expect(result.start.get('month')).toBe(7);
		expect(result.start.get('day')).toBe(27);

		expect(result.start).toBeDate(new Date(2012, 7-1, 27, 12));
		});

		test("Test - Single Expression without year", function() {
		testSingleCase(chrono.ja, '11月27日', new Date(2012,1-1,10), (result) => {
		expect(result.index).toBe(0);
		expect(result.text).toBe('11月27日');

		var text = "7月27日";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2011);
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(27);

		var result = results[0];
		if (result) {
		expect(result.index).toBe(0)
		expect(result.text).toBe('7月27日')
		expect(result.start).toBeDate(new Date(2011, 11-1, 27, 12));
		});
		});

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2012)
		expect(result.start.get('month')).toBe(7)
		expect(result.start.get('day')).toBe(27)

		var resultDate = result.start.date();
		var expectDate = new Date(2012, 7-1, 27, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		test("Test - Range Expression", function() {

		var text = "11月27日";
		var results = chrono.parse(text, new Date(2012,1-1,10));
		expect(results.length).toBe(1)
		testSingleCase(chrono.ja, '2013年12月26日-2014年1月7日', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(0);
		expect(result.text).toBe('2013年12月26日-2014年1月7日');

		var result = results[0];
		if (result) {
		expect(result.index).toBe(0)
		expect(result.text).toBe('11月27日')
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2013);
		expect(result.start.get('month')).toBe(12);
		expect(result.start.get('day')).toBe(26);

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2011)
		expect(result.start.get('month')).toBe(11)
		expect(result.start.get('day')).toBe(27)
		expect(result.start).toBeDate(new Date(2013, 12-1, 26, 12));

		var resultDate = result.start.date();
		var expectDate = new Date(2011, 11-1, 27, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		});
		expect(result.end).not.toBeNull();
		expect(result.end.get('year')).toBe(2014);
		expect(result.end.get('month')).toBe(1);
		expect(result.end.get('day')).toBe(7);

		expect(result.end).toBeDate(new Date(2014, 1-1, 7, 12));
		});

		test("Test - Range Expression", function() {
		testSingleCase(chrono.ja, '２０１３年１２月２６日ー2014年1月7日', new Date(2012,8-1,10), (result) => {
		expect(result.index).toBe(0);
		expect(result.text).toBe('２０１３年１２月２６日ー2014年1月7日');

		var text = "2013年12月26日-2014年1月7日";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		expect(result.start).not.toBeNull();
		expect(result.start.get('year')).toBe(2013);
		expect(result.start.get('month')).toBe(12);
		expect(result.start.get('day')).toBe(26);

		var result = results[0];
		if (result) {
		expect(result.index).toBe(0)
		expect(result.text).toBe('2013年12月26日-2014年1月7日')
		expect(result.start).toBeDate(new Date(2013, 12-1, 26, 12));

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2013)
		expect(result.start.get('month')).toBe(12)
		expect(result.start.get('day')).toBe(26)

		var resultDate = result.start.date();
		var expectDate = new Date(2013, 12-1, 26, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())

		expect(result.end).not.toBeNull()
		expect(result.end.get('year')).toBe(2014)
		expect(result.end.get('month')).toBe(1)
		expect(result.end.get('day')).toBe(7)

		var resultDate = result.end.date();
		var expectDate = new Date(2014, 1-1, 7, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}
		expect(result.end).not.toBeNull();
		expect(result.end.get('year')).toBe(2014);
		expect(result.end.get('month')).toBe(1);
		expect(result.end.get('day')).toBe(7);

		var text = "２０１３年１２月２６日ー2014年1月7日";
		var results = chrono.parse(text, new Date(2012,8-1,10));
		expect(results.length).toBe(1)
		expect(result.end).toBeDate(new Date(2014, 1-1, 7, 12));
		});

		var result = results[0];
		if (result) {
		expect(result.index).toBe(0)
		expect(result.text).toBe('２０１３年１２月２６日ー2014年1月7日')

		expect(result.start).not.toBeNull()
		expect(result.start.get('year')).toBe(2013)
		expect(result.start.get('month')).toBe(12)
		expect(result.start.get('day')).toBe(26)

		var resultDate = result.start.date();
		var expectDate = new Date(2013, 12-1, 26, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())

		expect(result.end).not.toBeNull()
		expect(result.end.get('year')).toBe(2014)
		expect(result.end.get('month')).toBe(1)
		expect(result.end.get('day')).toBe(7)

		var resultDate = result.end.date();
		var expectDate = new Date(2014, 1-1, 7, 12);
		expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
		}


		});
		@@ -341,0 +226,0 @@

287

test/system.test.js

		@@ -1,2 +0,4 @@
		import * as chrono from '../src/chrono';
		import * as chrono from '../src/';
		import {testSingleCase} from "./test_util";
		import {Meridiem} from "../src";

		@@ -11,12 +13,2 @@ //-------------------------------------

		expect(chrono.Chrono).toBeDefined();

		expect(chrono.Parser).toBeDefined();

		expect(chrono.Refiner).toBeDefined();

		expect(chrono.ParsedResult).toBeDefined();

		expect(chrono.ParsedComponents).toBeDefined();

		expect(chrono.parse).toBeDefined();
		@@ -26,4 +18,2 @@

		expect(chrono.options).toBeDefined();

		expect(chrono.casual).toBeDefined();
		@@ -34,191 +24,158 @@

		test("Test - Basic parse date functions", function() {

		test("Test - Create & manipulate date results", () => {
		expect(chrono.parseDate("7:00PM July 5th, 2020"))
		.toStrictEqual(new Date(2020, 7-1, 5, 19))

		const components = new chrono.ParsedComponents( {year: 2014, month: 11, day: 24});
		expect(components.get('year')).toBe(2014);
		expect(components.get('month')).toBe(11);
		expect(components.get('day')).toBe(24);
		expect(components.date()).toBeDefined();
		expect(chrono.en.parseDate("7:00PM July 5th, 2020"))
		.toStrictEqual(new Date(2020, 7-1, 5, 19))

		// undefined
		expect(components.get('dayOfWeek')).toBeUndefined(undefined);
		expect(components.isCertain('dayOfWeek')).toBe(false);
		expect(chrono.strict.parseDate("7:00PM July 5th, 2020"))
		.toStrictEqual(new Date(2020, 7-1, 5, 19))

		// "imply"
		components.imply('dayOfWeek', 1);
		expect(components.get('dayOfWeek')).toBe(1);
		expect(components.isCertain('dayOfWeek')).toBe(false);

		// "assign" overrides "imply"
		components.assign('dayOfWeek', 2);
		expect(components.get('dayOfWeek')).toBe(2);
		expect(components.isCertain('dayOfWeek')).toBe(true);
		expect(chrono.casual.parseDate("7:00PM July 5th, 2020"))
		.toStrictEqual(new Date(2020, 7-1, 5, 19))
		});

		// "imply" doesn't overrides "assign"
		components.imply('year', 2013);
		expect(components.get('year')).toBe(2014);
		test("Test - Add custom parser", () => {
		const customParser = {
		pattern: () => { return /(\d{1,2})(st\|nd\|rd\|th)/i },
		extract: (context, match) => {

		// "assign" overrides "assign"
		components.assign('year', 2013);
		expect(components.get('year')).toBe(2013);
		expect(match[0]).toBe('25th')
		expect(context.refDate).toBeTruthy()

		return {
		day: parseInt(match[1])
		}
		}
		};

		const custom = new chrono.Chrono();
		custom.parsers.push(customParser);
		testSingleCase(custom, 'meeting on 25th', new Date(2017,11 -1, 19), (result) => {

		expect(result.text).toBe('25th');
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(25);
		});
		});

		test("Test - Calendar Checking", () => {
		test("Test - Add custom parser example", () => {

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24});
		expect(components.isPossibleDate()).toBe(true);
		}

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12});
		expect(components.isPossibleDate()).toBe(true);
		}
		const custom = chrono.casual.clone();
		custom.parsers.push({
		pattern: () => { return /\bChristmas\b/i },
		extract: () => {
		return {
		day: 25, month: 12
		}
		}
		});

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 30});
		expect(components.isPossibleDate()).toBe(true);
		}
		testSingleCase(custom, "I'll arrive at 2.30AM on Christmas", (result) => {
		expect(result.text).toBe('at 2.30AM on Christmas');
		expect(result.start.get('month')).toBe(12);
		expect(result.start.get('day')).toBe(25);
		expect(result.start.get('hour')).toBe(2);
		expect(result.start.get('minute')).toBe(30);
		})

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 30, second: 30});
		expect(components.isPossibleDate()).toBe(true);
		}
		testSingleCase(custom, "I'll arrive at Christmas night", (result) => {
		expect(result.text).toBe('Christmas night');
		expect(result.start.get('month')).toBe(12);
		expect(result.start.get('day')).toBe(25);
		expect(result.start.get('meridiem')).toBe(Meridiem.PM);
		expect(result.start.get('meridiem')).toBe(1);
		})

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 13, day: 24});
		expect(components.isPossibleDate()).toBe(false);
		}
		testSingleCase(custom, "Doing something tomorrow", (result) => {
		expect(result.text).toBe('tomorrow');
		})
		});

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 32});
		expect(components.isPossibleDate()).toBe(false);
		}
		test("Test - Add custom refiner example", () => {

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:24});
		expect(components.isPossibleDate()).toBe(false);
		}
		const custom = chrono.casual.clone();
		custom.refiners.push({
		refine: (context, results) => {
		// If there is no AM/PM (meridiem) specified,
		// let all time between 1:00 - 4:00 be PM (13.00 - 16.00)
		results.forEach((result) => {
		if (!result.start.isCertain('meridiem') &&
		result.start.get('hour') >= 1 && result.start.get('hour') < 4) {

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 60});
		expect(components.isPossibleDate()).toBe(false);
		}
		result.start.assign('meridiem', Meridiem.PM);
		result.start.assign('hour', result.start.get('hour') + 12);
		}
		});
		return results;
		}
		});

		{
		const components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 30, second: 60});
		expect(components.isPossibleDate()).toBe(false);
		}
		testSingleCase(custom, 'This is at 2.30', (result) => {
		expect(result.text).toBe('at 2.30');
		expect(result.start.get('hour')).toBe(14);
		expect(result.start.get('minute')).toBe(30);
		})

		testSingleCase(custom, 'This is at 2.30 AM', (result) => {
		expect(result.text).toBe('at 2.30 AM');
		expect(result.start.get('hour')).toBe(2);
		expect(result.start.get('minute')).toBe(30);
		})
		});

		test("Test - Override parser", () => {
		test("Test - Compare with native js", ()=> {

		var originalText = '01234-pattern-01234-pattern';
		var originalOpt = { some: 'thing'};
		var extractCalled = 0;
		const testByCompareWithNative = (text) => {
		const expectedDate = new Date(text);
		testSingleCase(chrono, text, (result) => {
		expect(result.text).toBe(text);
		expect(result).toBeDate(expectedDate);
		})
		};

		function CustomParser() {
		chrono.Parser.apply(this, arguments);
		testByCompareWithNative('1994-11-05T13:15:30Z');

		this.pattern = function () { return /pattern/; };
		this.extract = function(text, ref, match, opt){
		testByCompareWithNative('1994-02-28T08:15:30-05:30');

		if(extractCalled === 0){
		expect(text).toBe(originalText);
		expect(opt).toBe(originalOpt);
		expect(match.index).toBe(6);
		} else if(extractCalled === 1){
		expect(text).toBe(originalText);
		expect(opt).toBe(originalOpt);
		expect(match.index).toBe(20);
		}
		testByCompareWithNative('1994-11-05T08:15:30-05:30');

		extractCalled += 1;
		return null;
		}
		}
		testByCompareWithNative('1994-11-05T08:15:30+11:30');

		var customParser = new CustomParser();
		var results = customParser.execute(originalText, new Date(), originalOpt);
		expect(extractCalled).toBe(2);
		});
		testByCompareWithNative('2014-11-30T08:15:30-05:30');

		test("Test - Add custom parser", () => {
		var customParser = new chrono.Parser();
		testByCompareWithNative('Sat, 21 Feb 2015 11:50:48 -0500');

		customParser.pattern = function () { return /(\d{1,2})(st\|nd\|rd\|th)/i };
		customParser.extract = function(text, ref, match, opt) {
		return new chrono.ParsedResult({
		ref: ref,
		text: match[0],
		index: match.index,
		start: {
		day: parseInt(match[1])
		}
		});
		};

		var custom = new chrono.Chrono();
		custom.parsers.push(customParser);
		testByCompareWithNative('22 Feb 2015 04:12:00 -0000');

		var text = "meeting on 25th";
		var result = custom.parse(text, new Date(2017,11 -1, 19))[0];

		expect(result.text).toBe('25th');
		expect(result.start.get('month')).toBe(11);
		expect(result.start.get('day')).toBe(25);
		});
		testByCompareWithNative('1900-01-01T00:00:00-01:00');

		test("Test - combining options", function() {
		testByCompareWithNative('1900-01-01T00:00:00-00:00');

		let firstOption = {
		parsers: [
		new chrono.parser.ENISOFormatParser(),
		],
		refiners: [
		new chrono.refiner.OverlapRemovalRefiner(),
		]
		};
		testByCompareWithNative('9999-12-31T23:59:00-00:00');

		let secondOption = {
		parsers: [
		new chrono.parser.ENISOFormatParser(),
		new chrono.parser.JPStandardParser(),
		],
		refiners: []
		};
		testByCompareWithNative('09/25/2017 10:31:50.522 PM');

		let mergedOption = chrono.options.mergeOptions([
		firstOption,
		secondOption
		]);
		testByCompareWithNative('Sat Nov 05 1994 22:45:30 GMT+0900 (JST)');

		expect(mergedOption).toBeTruthy();
		expect(mergedOption.parsers.length).toBe(2);
		expect(mergedOption.refiners.length).toBe(1);
		testByCompareWithNative('Fri, 31 Mar 2000 07:00:00 UTC');

		var customChrono = new chrono.Chrono(mergedOption);
		expect(customChrono.parseDate('2012-9-3')).not.toBeNull();
		expect(customChrono.parseDate('2012年９月3日')).not.toBeNull();
		expect(customChrono.parseDate('Tuesday')).toBeNull();
		testByCompareWithNative('2014-12-14T18:22:14.759Z');
		});

		test("Test - default language options", function() {
		test("Test - Skip version-number-like pattern", () => {

		expect(chrono.ja.parseDate('2012-9-3')).not.toBeNull();
		expect(chrono.ja.parseDate('2012年９月3日')).not.toBeNull();
		expect(chrono.ja.parseDate('Lundi')).toBeNull();
		testSingleCase(chrono, '1.5.3 - 2015-09-24', (result) => {
		expect(result.text).toBe('2015-09-24');
		})

		expect(chrono.fr.parseDate('2012-9-3')).not.toBeNull();
		expect(chrono.fr.parseDate('Lundi')).not.toBeNull();
		expect(chrono.fr.parseDate('2012年９月3日')).toBeNull();
		testSingleCase(chrono, '1.5.30 - 2015-09-24', (result) => {
		expect(result.text).toBe('2015-09-24');
		})

		expect(chrono.en.parseDate("04/12/1993"))
		.toEqual(chrono.parseDate("1993-04-12"));

		expect(chrono.en_GB.parseDate("04/12/1993"))
		.toEqual(chrono.parseDate("1993-12-04"));
		});


		testSingleCase(chrono, '1.50.30 - 2015-09-24', (result) => {
		expect(result.text).toBe('2015-09-24');
		})
		})

29

webpack.config.js

		@@ -7,4 +7,4 @@ const path = require('path');
		entry: {
		'chrono': path.resolve(__dirname, 'src/chrono.js'),
		'chrono.min': path.resolve(__dirname, 'src/chrono.js')
		'chrono': path.resolve(__dirname, 'src/chrono.ts'),
		'chrono.min': path.resolve(__dirname, 'src/chrono.ts')
		},
		@@ -18,14 +18,14 @@ output: {
		},
		resolve: {
		extensions: ['.ts', '.js' ],
		},
		module: {
		rules: [
		{
		test: /\.m?js$/,
		exclude: /(node_modules\|bower_components)/,
		use: {
		loader: 'babel-loader',
		options: {
		presets: ['@babel/preset-env']
		}
		{
		test: /\.(ts\|m?js)$/,
		exclude: /(node_modules\|bower_components)/,
		use: {
		loader: 'babel-loader'
		}
		}
		}
		]
		@@ -36,7 +36,8 @@ },
		minimize: true,
		minimizer: [new TerserPlugin({
		include: /\.min\.js$/
		})
		minimizer: [
		new TerserPlugin({
		include: /\.min\.js$/
		})
		],
		},
		};

babel.config.js

src/chrono.js

src/options.js

src/parsers/de/DECasualDateParser.js

src/parsers/de/DEDeadlineFormatParser.js

src/parsers/de/DEMonthNameLittleEndianParser.js

src/parsers/de/DEMonthNameParser.js

src/parsers/de/DESlashDateFormatParser.js

src/parsers/de/DETimeAgoFormatParser.js

src/parsers/de/DETimeExpressionParser.js

src/parsers/de/DEWeekdayParser.js

src/parsers/en/ENCasualDateParser.js

src/parsers/en/ENCasualTimeParser.js

src/parsers/en/ENDeadlineFormatParser.js

src/parsers/en/ENISOFormatParser.js

src/parsers/en/ENMonthNameLittleEndianParser.js

src/parsers/en/ENMonthNameMiddleEndianParser.js

src/parsers/en/ENMonthNameParser.js

src/parsers/en/ENRelativeDateFormatParser.js

src/parsers/en/ENSlashDateFormatParser.js

src/parsers/en/ENSlashDateFormatStartWithYearParser.js

src/parsers/en/ENSlashMonthFormatParser.js

src/parsers/en/ENTimeAgoFormatParser.js

src/parsers/en/ENTimeExpressionParser.js

src/parsers/en/ENTimeLaterFormatParser.js

src/parsers/en/ENWeekdayParser.js

src/parsers/es/ESCasualDateParser.js

src/parsers/es/ESDeadlineFormatParser.js

src/parsers/es/ESMonthNameLittleEndianParser.js

src/parsers/es/ESSlashDateFormatParser.js

src/parsers/es/ESTimeAgoFormatParser.js

src/parsers/es/ESTimeExpressionParser.js

src/parsers/es/ESWeekdayParser.js

src/parsers/fr/FRCasualDateParser.js

src/parsers/fr/FRDeadlineFormatParser.js

src/parsers/fr/FRMonthNameLittleEndianParser.js

src/parsers/fr/FRRelativeDateFormatParser.js

src/parsers/fr/FRSlashDateFormatParser.js

src/parsers/fr/FRTimeAgoFormatParser.js

src/parsers/fr/FRTimeExpressionParser.js

src/parsers/fr/FRWeekdayParser.js

src/parsers/ja/JPCasualDateParser.js

src/parsers/ja/JPStandardParser.js

src/parsers/nl/NLCasualDateParser.js

src/parsers/nl/NLCasualTimeParser.js

src/parsers/nl/NLMonthNameLittleEndianParser.js

src/parsers/nl/NLMonthNameParser.js

src/parsers/nl/NLSlashDateFormatParser.js

src/parsers/nl/NLTimeExpressionParser.js

src/parsers/nl/NLWeekdayParser.js

src/parsers/parser.js

src/parsers/pt/PTCasualDateParser.js

src/parsers/pt/PTDeadlineFormatParser.js

src/parsers/pt/PTMonthNameLittleEndianParser.js

src/parsers/pt/PTSlashDateFormatParser.js

src/parsers/pt/PTTimeAgoFormatParser.js

src/parsers/pt/PTTimeExpressionParser.js

src/parsers/pt/PTWeekdayParser.js

src/parsers/zh-Hant/ZHHantCasualDateParser.js

src/parsers/zh-Hant/ZHHantDateParser.js

src/parsers/zh-Hant/ZHHantDeadlineFormatParser.js

src/parsers/zh-Hant/ZHHantTimeExpressionParser.js

src/parsers/zh-Hant/ZHHantWeekdayParser.js

src/refiners/ConcordanceTimezoneRefiner.js

src/refiners/de/DEMergeDateRangeRefiner.js

src/refiners/de/DEMergeDateTimeRefiner.js

src/refiners/en/ENMergeDateRangeRefiner.js

src/refiners/en/ENMergeDateTimeRefiner.js

src/refiners/en/ENMergeWeekdayRefiner.js

src/refiners/en/ENPrioritizeSpecificDateRefiner.js

src/refiners/ExtractTimezoneAbbrRefiner.js

src/refiners/ExtractTimezoneOffsetRefiner.js

src/refiners/ForwardDateRefiner.js

src/refiners/fr/FRMergeDateRangeRefiner.js

src/refiners/fr/FRMergeDateTimeRefiner.js

src/refiners/ja/JPMergeDateRangeRefiner.js

src/refiners/nl/NLMergeDateRangeRefiner.js

src/refiners/nl/NLMergeDateTimeRefiner.js

src/refiners/OverlapRemovalRefiner.js

src/refiners/refiner.js

src/refiners/UnlikelyFormatFilter.js

src/result.js

src/timezone.js

src/utils/DE.js

src/utils/EN.js

src/utils/ES.js

src/utils/FR.js

src/utils/JP.js

src/utils/NL.js

src/utils/PT.js

src/utils/ZH-Hant.js

test/de/de_casual.test.js

test/de/de_dash.test.js

test/de/de_deadline.test.js

test/de/de_little_endian.test.js

test/de/de_time_ago.test.js

test/de/de_time_exp.test.js

test/de/de_weekday.test.js

test/de/de.test.js

test/en/en_dash.test.js

test/en/en_deadline.test.js

test/en/en_example.test.js

test/en/en_little_endian.test.js

test/en/en_middle_endian.test.js

test/en/en_option_forward.test.js

test/en/en_time_ago.test.js

test/en/en_time_exp.test.js

test/en/en_time_from_now.test.js

test/en/en_time_later.test.js

test/es/es_casual.test.js

test/es/es_dash.test.js

test/es/es_deadline.test.js

test/es/es_little_endian.test.js

test/es/es_slash.test.js

test/es/es_time_ago.test.js

test/es/es_time_exp.test.js

test/fr/fr_casual.test.js

test/fr/fr_dash.test.js

test/fr/fr_deadline.test.js

test/fr/fr_little_endian.test.js

test/fr/fr_relative.test.js

test/fr/fr_slash.test.js

test/fr/fr_time_ago.test.js

test/fr/fr_time_exp.test.js

test/fr/fr_weekday.test.js

test/nl/nl_dash.test.js

test/nl/nl_little_endian.test.js

test/nl/nl_time_exp.test.js

test/nl/nl_weekday.test.js

test/nl/nl.test.js

test/pt/pt_casual.test.js

test/pt/pt_dash.test.js

test/pt/pt_deadline.test.js

test/pt/pt_little_endian.test.js

test/pt/pt_slash.test.js

test/pt/pt_time_ago.test.js

test/pt/pt_time_exp.test.js

test/test_util.js

test/zh/zh_hant_casual.test.js

test/zh/zh_hant_date.test.js

test/zh/zh_hant_deadline.test.js

test/zh/zh_hant_time_exp.test.js

test/zh/zh_hant_weekday.test.js

dist/chrono.js

Sorry, the diff of this file is too big to display

dist/chrono.js.map

Sorry, the diff of this file is not supported yet

dist/chrono.min.js

Sorry, the diff of this file is too big to display

dist/chrono.min.js.map

Sorry, the diff of this file is not supported yet

chrono-node - npm Package Compare versions

New alerts

Fixed alerts

Worsened metrics

Dependency changes