@naturalcycles/js-lib 14.242.0 → 14.243.1

package/dist/datetime/localDate.js

@@ -7,7 +7,7 @@ const is_util_1 = require("../is.util");
 const iterable2_1 = require("../iter/iterable2");
 const localTime_1 = require("./localTime");
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)/;
 /**
  * LocalDate represents a date without time.
  * It is timezone-independent.
@@ -452,12 +452,12 @@ class LocalDateFactory {
         if (d instanceof Date) {
             return this.fromDate(d);
         }
-        const matches = typeof d === 'string' && DATE_REGEX.exec(d.slice(0, 10));
-        if (!matches)
+        const m = typeof d === 'string' && DATE_REGEX.exec(d);
+        if (!m)
             return null;
-        const year = Number(matches[1]);
-        const month = Number(matches[2]);
-        const day = Number(matches[3]);
+        const year = Number(m[1]);
+        const month = Number(m[2]);
+        const day = Number(m[3]);
         if (!year ||
             !month ||
             month < 1 ||

package/dist/datetime/localTime.d.ts

@@ -228,8 +228,7 @@ declare class LocalTimeFactory {
      * Returns null if invalid
      */
     parseOrNull(d: LocalTimeInputNullable): LocalTime | null;
-    parseToDate(d: LocalTimeInput): Date;
-    parseToUnixTimestamp(d: LocalTimeInput): UnixTimestampNumber;
+    private parseStringToDateOrNull;
     isValid(d: LocalTimeInputNullable): boolean;
     /**
      * Returns the IANA timezone e.g `Europe/Stockholm`.

package/dist/datetime/localTime.js

@@ -23,6 +23,10 @@ const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
+// It supports 2 forms:
+// 1. 2023-03-03
+// 2. 2023-03-03T05:10:02
+const DATE_TIME_REGEX = /^(\d{4})-(\d{2})-(\d{2})([T\s](\d{2}):(\d{2}):(\d{2}))?/;
 class LocalTime {
     constructor($date) {
         this.$date = $date;
@@ -266,7 +270,7 @@ class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = exports.localTime.parseToDate(other);
+        const date2 = exports.localTime.of(other).$date;
         const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
         if (!secDiff)
             return 0;
@@ -448,7 +452,7 @@ class LocalTime {
      */
     cmp(d) {
         const t1 = this.$date.valueOf();
-        const t2 = exports.localTime.parseToDate(d).valueOf();
+        const t2 = exports.localTime.of(d).$date.valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
@@ -474,7 +478,7 @@ class LocalTime {
         };
     }
     fromNow(now = new Date()) {
-        const msDiff = exports.localTime.parseToDate(now).valueOf() - this.$date.valueOf();
+        const msDiff = exports.localTime.of(now).$date.valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
@@ -619,41 +623,63 @@ class LocalTimeFactory {
             return null;
         }
         else {
-            // Slicing removes the "timezone component", and makes the date "local"
-            // e.g 2022-04-06T23:15:00+09:00
-            // becomes 2022-04-06T23:15:00
-            date = new Date(d.slice(0, 19));
-            // We used to slice to remove the timezone information, now we don't
-            // date = new Date(d)
-        }
-        // validation
-        if (isNaN(date.getDate())) {
-            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
-            return null;
+            date = this.parseStringToDateOrNull(d);
+            if (date === null)
+                return null;
         }
         return new LocalTime(date);
     }
-    parseToDate(d) {
-        if (d instanceof LocalTime)
-            return d.$date;
-        if (d instanceof Date)
-            return d;
-        const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
-        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
-            input: d,
-        });
-        return date;
-    }
-    parseToUnixTimestamp(d) {
-        if (typeof d === 'number')
-            return d;
-        if (d instanceof LocalTime)
-            return d.unix();
-        const date = d instanceof Date ? d : new Date(d);
-        (0, assert_1._assert)(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
-            input: d,
-        });
-        return date.valueOf() / 1000;
+    parseStringToDateOrNull(s) {
+        // Slicing removes the "timezone component", and makes the date "local"
+        // e.g 2022-04-06T23:15:00+09:00
+        // becomes 2022-04-06T23:15:00
+        // date = new Date(d.slice(0, 19))
+        // Parsing is inspired by how Day.js does it
+        // Specifically, it ensures that `localTime('2023-03-03')` returns the expected Date, and not a day before
+        // Because `new Date('2023-03-03')` in NewYork gives you '2023-03-02 19:00:00 GMT-0500'
+        const m = s.match(DATE_TIME_REGEX);
+        // Validate in 3 ways:
+        // 1. Should match Regex.
+        // In some ways it's stricter than Date constructor, e.g it doesn't allow 2023/05/05
+        // In other ways it's looser, e.g it allows `2023-05-05T`, while Date constructor doesn't.
+        // 2. Date constructor (of Node/v8 implementation, which we know is different from e.g WebKit/Safari)
+        // should not return `Invalid Date`.
+        // 3. Year, month and day should be valid, e.g 2023-01-32 should not be allowed.
+        // UPD: Actually, 3 can be skipped, because 2 is catching it already
+        // UPD: 2 is skipped, 1 and 3 are kept
+        // if (!m || isNaN(new Date(s).getDate())) return null
+        if (!m)
+            return null;
+        const year = Number(m[1]);
+        const month = Number(m[2]);
+        const day = Number(m[3]);
+        const hour = Number(m[5]);
+        const minute = Number(m[6]);
+        const second = Number(m[7]);
+        // Validation for just the Date part
+        if (!year ||
+            !month ||
+            month < 1 ||
+            month > 12 ||
+            !day ||
+            day < 1 ||
+            day > localDate_1.localDate.getMonthLength(year, month)) {
+            return null;
+        }
+        // Validation for Date+Time string, since the string is longer than YYYY-MM-DD
+        if (s.length > 10 &&
+            (isNaN(hour) ||
+                isNaN(minute) ||
+                isNaN(second) ||
+                hour < 0 ||
+                hour > 23 ||
+                minute < 0 ||
+                minute > 59 ||
+                second < 0 ||
+                second > 59)) {
+            return null;
+        }
+        return new Date(year, month - 1, day, hour || 0, minute || 0, second || 0, 0);
     }
     isValid(d) {
         return this.parseOrNull(d) !== null;

package/dist/datetime/timeInterval.js

@@ -14,7 +14,7 @@ class TimeInterval {
         this.$end = $end;
     }
     static of(start, end) {
-        return new TimeInterval(localTime_1.localTime.parseToUnixTimestamp(start), localTime_1.localTime.parseToUnixTimestamp(end));
+        return new TimeInterval(localTime_1.localTime.of(start).unix(), localTime_1.localTime.of(end).unix());
     }
     get start() {
         return this.$start;
@@ -58,7 +58,7 @@ class TimeInterval {
         return this.cmp(d) >= 0;
     }
     includes(d, incl = '[)') {
-        d = localTime_1.localTime.parseToUnixTimestamp(d);
+        d = localTime_1.localTime.of(d).unix();
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (d < this.$start || (d === this.$start && incl[0] === '('))
             return false;

package/dist/types.d.ts

@@ -180,10 +180,18 @@ export type NumberOfHours = number;
 export type NumberOfMinutes = number;
 export type NumberOfSeconds = number;
 export type NumberOfMilliseconds = number;
+/**
+ * Integer between 0 and 100 (inclusive).
+ */
+export type NumberOfPercent = number;
 /**
  * Same as `number`, but with semantic meaning that it's an Integer.
  */
 export type Integer = number;
+export type PositiveInteger = number;
+export type NonNegativeInteger = number;
+export type PositiveNumber = number;
+export type NonNegativeNumber = number;
 /**
  * Convenience type alias, that allows to write this:
  *

package/dist-esm/datetime/localDate.js

@@ -3,7 +3,7 @@ import { _isTruthy } from '../is.util';
 import { Iterable2 } from '../iter/iterable2';
 import { localTime } from './localTime';
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)/;
 /**
  * LocalDate represents a date without time.
  * It is timezone-independent.
@@ -447,12 +447,12 @@ class LocalDateFactory {
         if (d instanceof Date) {
             return this.fromDate(d);
         }
-        const matches = typeof d === 'string' && DATE_REGEX.exec(d.slice(0, 10));
-        if (!matches)
+        const m = typeof d === 'string' && DATE_REGEX.exec(d);
+        if (!m)
             return null;
-        const year = Number(matches[1]);
-        const month = Number(matches[2]);
-        const day = Number(matches[3]);
+        const year = Number(m[1]);
+        const month = Number(m[2]);
+        const day = Number(m[3]);
         if (!year ||
             !month ||
             month < 1 ||

package/dist-esm/datetime/localTime.js

@@ -19,6 +19,10 @@ const SECONDS_IN_DAY = 86400;
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7]);
+// It supports 2 forms:
+// 1. 2023-03-03
+// 2. 2023-03-03T05:10:02
+const DATE_TIME_REGEX = /^(\d{4})-(\d{2})-(\d{2})([T\s](\d{2}):(\d{2}):(\d{2}))?/;
 export class LocalTime {
     constructor($date) {
         this.$date = $date;
@@ -262,7 +266,7 @@ export class LocalTime {
         return Math.abs(this.diff(other, unit));
     }
     diff(other, unit) {
-        const date2 = localTime.parseToDate(other);
+        const date2 = localTime.of(other).$date;
         const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000;
         if (!secDiff)
             return 0;
@@ -444,7 +448,7 @@ export class LocalTime {
      */
     cmp(d) {
         const t1 = this.$date.valueOf();
-        const t2 = localTime.parseToDate(d).valueOf();
+        const t2 = localTime.of(d).$date.valueOf();
         if (t1 === t2)
             return 0;
         return t1 < t2 ? -1 : 1;
@@ -470,7 +474,7 @@ export class LocalTime {
         };
     }
     fromNow(now = new Date()) {
-        const msDiff = localTime.parseToDate(now).valueOf() - this.$date.valueOf();
+        const msDiff = localTime.of(now).$date.valueOf() - this.$date.valueOf();
         if (msDiff === 0)
             return 'now';
         if (msDiff >= 0) {
@@ -614,41 +618,63 @@ class LocalTimeFactory {
             return null;
         }
         else {
-            // Slicing removes the "timezone component", and makes the date "local"
-            // e.g 2022-04-06T23:15:00+09:00
-            // becomes 2022-04-06T23:15:00
-            date = new Date(d.slice(0, 19));
-            // We used to slice to remove the timezone information, now we don't
-            // date = new Date(d)
-        }
-        // validation
-        if (isNaN(date.getDate())) {
-            // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
-            return null;
+            date = this.parseStringToDateOrNull(d);
+            if (date === null)
+                return null;
         }
         return new LocalTime(date);
     }
-    parseToDate(d) {
-        if (d instanceof LocalTime)
-            return d.$date;
-        if (d instanceof Date)
-            return d;
-        const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d);
-        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
-            input: d,
-        });
-        return date;
-    }
-    parseToUnixTimestamp(d) {
-        if (typeof d === 'number')
-            return d;
-        if (d instanceof LocalTime)
-            return d.unix();
-        const date = d instanceof Date ? d : new Date(d);
-        _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
-            input: d,
-        });
-        return date.valueOf() / 1000;
+    parseStringToDateOrNull(s) {
+        // Slicing removes the "timezone component", and makes the date "local"
+        // e.g 2022-04-06T23:15:00+09:00
+        // becomes 2022-04-06T23:15:00
+        // date = new Date(d.slice(0, 19))
+        // Parsing is inspired by how Day.js does it
+        // Specifically, it ensures that `localTime('2023-03-03')` returns the expected Date, and not a day before
+        // Because `new Date('2023-03-03')` in NewYork gives you '2023-03-02 19:00:00 GMT-0500'
+        const m = s.match(DATE_TIME_REGEX);
+        // Validate in 3 ways:
+        // 1. Should match Regex.
+        // In some ways it's stricter than Date constructor, e.g it doesn't allow 2023/05/05
+        // In other ways it's looser, e.g it allows `2023-05-05T`, while Date constructor doesn't.
+        // 2. Date constructor (of Node/v8 implementation, which we know is different from e.g WebKit/Safari)
+        // should not return `Invalid Date`.
+        // 3. Year, month and day should be valid, e.g 2023-01-32 should not be allowed.
+        // UPD: Actually, 3 can be skipped, because 2 is catching it already
+        // UPD: 2 is skipped, 1 and 3 are kept
+        // if (!m || isNaN(new Date(s).getDate())) return null
+        if (!m)
+            return null;
+        const year = Number(m[1]);
+        const month = Number(m[2]);
+        const day = Number(m[3]);
+        const hour = Number(m[5]);
+        const minute = Number(m[6]);
+        const second = Number(m[7]);
+        // Validation for just the Date part
+        if (!year ||
+            !month ||
+            month < 1 ||
+            month > 12 ||
+            !day ||
+            day < 1 ||
+            day > localDate.getMonthLength(year, month)) {
+            return null;
+        }
+        // Validation for Date+Time string, since the string is longer than YYYY-MM-DD
+        if (s.length > 10 &&
+            (isNaN(hour) ||
+                isNaN(minute) ||
+                isNaN(second) ||
+                hour < 0 ||
+                hour > 23 ||
+                minute < 0 ||
+                minute > 59 ||
+                second < 0 ||
+                second > 59)) {
+            return null;
+        }
+        return new Date(year, month - 1, day, hour || 0, minute || 0, second || 0, 0);
     }
     isValid(d) {
         return this.parseOrNull(d) !== null;

package/dist-esm/datetime/timeInterval.js

@@ -11,7 +11,7 @@ export class TimeInterval {
         this.$end = $end;
     }
     static of(start, end) {
-        return new TimeInterval(localTime.parseToUnixTimestamp(start), localTime.parseToUnixTimestamp(end));
+        return new TimeInterval(localTime.of(start).unix(), localTime.of(end).unix());
     }
     get start() {
         return this.$start;
@@ -55,7 +55,7 @@ export class TimeInterval {
         return this.cmp(d) >= 0;
     }
     includes(d, incl = '[)') {
-        d = localTime.parseToUnixTimestamp(d);
+        d = localTime.of(d).unix();
         // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
         if (d < this.$start || (d === this.$start && incl[0] === '('))
             return false;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.242.0",
+  "version": "14.243.1",
   "scripts": {
     "prepare": "husky",
     "build-prod": "build-prod-esm-cjs",
     "test-tz1": "TZ=Europe/Stockholm yarn test local",
     "test-tz2": "TZ=JST-9 yarn test local",
+    "test-ny": "TZ=GMT-0500 yarn test localTime",
     "docs-dev": "vitepress dev docs --open",
     "docs-build": "vitepress build docs",
     "docs-preview": "vitepress preview docs"

package/src/datetime/localDate.ts

@@ -16,7 +16,7 @@ export type LocalDateUnit = LocalDateUnitStrict | 'week'
 export type LocalDateUnitStrict = 'year' | 'month' | 'day'
 
 const MDAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
+const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)/
 
 export type LocalDateInput = LocalDate | Date | IsoDateString
 export type LocalDateInputNullable = LocalDateInput | null | undefined
@@ -526,12 +526,12 @@ class LocalDateFactory {
       return this.fromDate(d)
     }
 
-    const matches = typeof (d as any) === 'string' && DATE_REGEX.exec(d.slice(0, 10))
-    if (!matches) return null
+    const m = typeof (d as any) === 'string' && DATE_REGEX.exec(d)
+    if (!m) return null
 
-    const year = Number(matches[1])
-    const month = Number(matches[2])
-    const day = Number(matches[3])
+    const year = Number(m[1])
+    const month = Number(m[2])
+    const day = Number(m[3])
 
     if (
       !year ||

package/src/datetime/localTime.ts

@@ -51,6 +51,10 @@ const SECONDS_IN_DAY = 86400
 // const MILLISECONDS_IN_DAY = 86400000
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7])
+// It supports 2 forms:
+// 1. 2023-03-03
+// 2. 2023-03-03T05:10:02
+const DATE_TIME_REGEX = /^(\d{4})-(\d{2})-(\d{2})([T\s](\d{2}):(\d{2}):(\d{2}))?/
 
 export class LocalTime {
   constructor(public $date: Date) {}
@@ -337,7 +341,7 @@ export class LocalTime {
   }
 
   diff(other: LocalTimeInput, unit: LocalTimeUnit): number {
-    const date2 = localTime.parseToDate(other)
+    const date2 = localTime.of(other).$date
 
     const secDiff = (this.$date.valueOf() - date2.valueOf()) / 1000
     if (!secDiff) return 0
@@ -531,7 +535,7 @@ export class LocalTime {
    */
   cmp(d: LocalTimeInput): -1 | 0 | 1 {
     const t1 = this.$date.valueOf()
-    const t2 = localTime.parseToDate(d).valueOf()
+    const t2 = localTime.of(d).$date.valueOf()
     if (t1 === t2) return 0
     return t1 < t2 ? -1 : 1
   }
@@ -560,7 +564,7 @@ export class LocalTime {
   }
 
   fromNow(now: LocalTimeInput = new Date()): string {
-    const msDiff = localTime.parseToDate(now).valueOf() - this.$date.valueOf()
+    const msDiff = localTime.of(now).$date.valueOf() - this.$date.valueOf()
 
     if (msDiff === 0) return 'now'
 
@@ -729,47 +733,72 @@ class LocalTimeFactory {
       // unexpected type, e.g Function or something
       return null
     } else {
-      // Slicing removes the "timezone component", and makes the date "local"
-      // e.g 2022-04-06T23:15:00+09:00
-      // becomes 2022-04-06T23:15:00
-      date = new Date(d.slice(0, 19))
-      // We used to slice to remove the timezone information, now we don't
-      // date = new Date(d)
-    }
-
-    // validation
-    if (isNaN(date.getDate())) {
-      // throw new TypeError(`Cannot parse "${d}" into LocalTime`)
-      return null
+      date = this.parseStringToDateOrNull(d)
+      if (date === null) return null
     }
 
     return new LocalTime(date)
   }
 
-  parseToDate(d: LocalTimeInput): Date {
-    if (d instanceof LocalTime) return d.$date
-    if (d instanceof Date) return d
-
-    const date = typeof d === 'number' ? new Date(d * 1000) : new Date(d)
-
-    _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to Date`, {
-      input: d,
-    })
-
-    return date
-  }
-
-  parseToUnixTimestamp(d: LocalTimeInput): UnixTimestampNumber {
-    if (typeof d === 'number') return d
-    if (d instanceof LocalTime) return d.unix()
-
-    const date = d instanceof Date ? d : new Date(d)
+  private parseStringToDateOrNull(s: string): Date | null {
+    // Slicing removes the "timezone component", and makes the date "local"
+    // e.g 2022-04-06T23:15:00+09:00
+    // becomes 2022-04-06T23:15:00
+    // date = new Date(d.slice(0, 19))
+
+    // Parsing is inspired by how Day.js does it
+    // Specifically, it ensures that `localTime('2023-03-03')` returns the expected Date, and not a day before
+    // Because `new Date('2023-03-03')` in NewYork gives you '2023-03-02 19:00:00 GMT-0500'
+
+    const m = s.match(DATE_TIME_REGEX)
+    // Validate in 3 ways:
+    // 1. Should match Regex.
+    // In some ways it's stricter than Date constructor, e.g it doesn't allow 2023/05/05
+    // In other ways it's looser, e.g it allows `2023-05-05T`, while Date constructor doesn't.
+    // 2. Date constructor (of Node/v8 implementation, which we know is different from e.g WebKit/Safari)
+    // should not return `Invalid Date`.
+    // 3. Year, month and day should be valid, e.g 2023-01-32 should not be allowed.
+    // UPD: Actually, 3 can be skipped, because 2 is catching it already
+    // UPD: 2 is skipped, 1 and 3 are kept
+    // if (!m || isNaN(new Date(s).getDate())) return null
+    if (!m) return null
+    const year = Number(m[1])
+    const month = Number(m[2])
+    const day = Number(m[3])
+    const hour = Number(m[5])
+    const minute = Number(m[6])
+    const second = Number(m[7])
+
+    // Validation for just the Date part
+    if (
+      !year ||
+      !month ||
+      month < 1 ||
+      month > 12 ||
+      !day ||
+      day < 1 ||
+      day > localDate.getMonthLength(year, month)
+    ) {
+      return null
+    }
 
-    _assert(!isNaN(date.getDate()), `Cannot parse "${d}" to UnixTimestamp`, {
-      input: d,
-    })
+    // Validation for Date+Time string, since the string is longer than YYYY-MM-DD
+    if (
+      s.length > 10 &&
+      (isNaN(hour) ||
+        isNaN(minute) ||
+        isNaN(second) ||
+        hour < 0 ||
+        hour > 23 ||
+        minute < 0 ||
+        minute > 59 ||
+        second < 0 ||
+        second > 59)
+    ) {
+      return null
+    }
 
-    return date.valueOf() / 1000
+    return new Date(year, month - 1, day, hour || 0, minute || 0, second || 0, 0)
   }
 
   isValid(d: LocalTimeInputNullable): boolean {

package/src/datetime/timeInterval.ts

@@ -17,10 +17,7 @@ export class TimeInterval {
   ) {}
 
   static of(start: LocalTimeInput, end: LocalTimeInput): TimeInterval {
-    return new TimeInterval(
-      localTime.parseToUnixTimestamp(start),
-      localTime.parseToUnixTimestamp(end),
-    )
+    return new TimeInterval(localTime.of(start).unix(), localTime.of(end).unix())
   }
 
   get start(): UnixTimestampNumber {
@@ -77,7 +74,7 @@ export class TimeInterval {
   }
 
   includes(d: LocalTimeInput, incl: Inclusiveness = '[)'): boolean {
-    d = localTime.parseToUnixTimestamp(d)
+    d = localTime.of(d).unix()
     // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
     if (d < this.$start || (d === this.$start && incl[0] === '(')) return false
     if (d > this.$end || (d === this.$end && incl[1] === ')')) return false

package/src/types.ts

@@ -237,11 +237,19 @@ export type NumberOfHours = number
 export type NumberOfMinutes = number
 export type NumberOfSeconds = number
 export type NumberOfMilliseconds = number
+/**
+ * Integer between 0 and 100 (inclusive).
+ */
+export type NumberOfPercent = number
 
 /**
  * Same as `number`, but with semantic meaning that it's an Integer.
  */
 export type Integer = number
+export type PositiveInteger = number
+export type NonNegativeInteger = number
+export type PositiveNumber = number
+export type NonNegativeNumber = number
 
 /**
  * Convenience type alias, that allows to write this: