@lbd-sh/date-tz 1.0.8 → 1.0.10

package/package.json

@@ -2,15 +2,18 @@
   "name": "@lbd-sh/date-tz",
   "displayName": "Date TZ",
   "engineStrict": false,
-  "version": "1.0.8",
+  "version": "1.0.10",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run"
   },
   "devDependencies": {
-    "typescript": "^5.7.2"
+    "@types/node": "^24.9.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.6"
   },
   "description": "A lightweight JavaScript/TypeScript date-time utility with full timezone support, custom formatting, parsing, and manipulation features.",
   "keywords": [

package/src/date-tz.spec.ts

@@ -1,213 +1,206 @@
+import { describe, expect, it } from 'vitest';
+import { IDateTz } from './idate-tz';
 import { DateTz } from './date-tz';
 
-describe('DateTz', () => {
-  it('should create an instance with the correct date and timezone', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.datetime).toBe(1609459200000);
-    expect(dateTz.timezone).toBe(0);
-  });
-
-  it('should compare two DateTz instances with the same timezone', () => {
-    const dateTz1 = new DateTz(1609459200000, 0);
-    const dateTz2 = new DateTz(1609545600000, 0); // 2021-01-02 00:00:00 UTC
-    expect(dateTz1.compare(dateTz2)).toBeLessThan(0);
-  });
-
-  it('should throw an error when comparing two DateTz instances with different timezones', () => {
-    const dateTz1 = new DateTz(1609459200000, 0);
-    const dateTz2 = new DateTz(1609459200000, 1);
-    expect(() => dateTz1.compare(dateTz2)).toThrow('Cannot compare dates with different timezones');
-  });
-
-  it('should format the date correctly with the default pattern', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.toString()).toBe('2021-01-01 00:00:00');
-  });
-
-  it('should format the date correctly with a custom pattern', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.toString('DD/MM/YYYY')).toBe('01/01/2021');
-  });
-
-  it('should add minutes correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(30, 'minute');
-    expect(dateTz.toString()).toBe('2021-01-01 00:30:00');
-  });
-
-  it('should add hours correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(2, 'hour');
-    expect(dateTz.toString()).toBe('2021-01-01 02:00:00');
-  });
+const BASE_TIMESTAMP = Date.UTC(2021, 0, 1, 0, 0); // 2021-01-01 00:00 UTC
 
-  it('should add days correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(1, 'day');
-    expect(dateTz.toString()).toBe('2021-01-02 00:00:00');
+describe('DateTz', () => {
+  it('creates an instance from a timestamp and timezone', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(dateTz.timestamp).toBe(BASE_TIMESTAMP);
+    expect(dateTz.timezone).toBe('UTC');
   });
 
-  it('should add months correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(1, 'month');
-    expect(dateTz.toString()).toBe('2021-02-01 00:00:00');
+  it('creates an instance from an IDateTz-like object', () => {
+    const dateTz = new DateTz({ timestamp: BASE_TIMESTAMP, timezone: 'Europe/Rome' });
+    expect(dateTz.timestamp).toBe(BASE_TIMESTAMP);
+    expect(dateTz.timezone).toBe('Europe/Rome');
   });
 
-  it('should add years correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(1, 'year');
-    expect(dateTz.toString()).toBe('2022-01-01 00:00:00');
+  it('compares two instances in the same timezone', () => {
+    const earlier = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const later = new DateTz(BASE_TIMESTAMP + 24 * 60 * 60 * 1000, 'UTC');
+    expect(earlier.compare(later)).toBeLessThan(0);
   });
 
-  it('should return the correct year', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.year).toBe(2021);
+  it('returns zero when comparing identical timestamps', () => {
+    const a = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const b = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(a.compare(b)).toBe(0);
   });
 
-  it('should return the correct month', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.month).toBe(0); // January
+  it('compares against plain IDateTz objects', () => {
+    const deltaMinutes = 5;
+    const a = new DateTz(BASE_TIMESTAMP + deltaMinutes * 60_000, 'UTC');
+    const other: IDateTz = { timestamp: BASE_TIMESTAMP, timezone: 'UTC' };
+    expect(a.compare(other)).toBe(deltaMinutes * 60_000);
   });
 
-  it('should return the correct day', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.day).toBe(1);
+  it('throws when comparing instances from different timezones', () => {
+    const utc = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const rome = new DateTz(BASE_TIMESTAMP, 'Europe/Rome');
+    expect(() => utc.compare(rome)).toThrow('Cannot compare dates with different timezones');
   });
 
-  it('should return the correct hour', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.hour).toBe(0);
+  it('formats using the default pattern', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(dateTz.toString()).toBe('2021-01-01 00:00:00');
   });
 
-  it('should return the correct minute', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.minute).toBe(0);
+  it('rounds timestamps down to the nearest minute', () => {
+    const withSeconds = BASE_TIMESTAMP + 45_000 + 500;
+    const dateTz = new DateTz(withSeconds, 'UTC');
+    expect(dateTz.timestamp).toBe(BASE_TIMESTAMP);
+    expect(dateTz.toString()).toBe('2021-01-01 00:00:00');
   });
 
-  it('should create an instance with the correct date and timezone', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.datetime).toBe(1609459200000);
-    expect(dateTz.timezone).toBe(0);
+  it('formats using a custom pattern and timezone token', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'Europe/Rome');
+    expect(dateTz.toString('DD/MM/YYYY HH:mm tz')).toBe('01/01/2021 01:00 Europe/Rome');
   });
 
-  it('should compare two DateTz instances with the same timezone', () => {
-    const dateTz1 = new DateTz(1609459200000, 0);
-    const dateTz2 = new DateTz(1609545600000, 0); // 2021-01-02 00:00:00 UTC
-    expect(dateTz1.compare(dateTz2)).toBeLessThan(0);
+  it('formats using month names and 12-hour tokens', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(dateTz.toString('LM DD, YYYY hh:mm aa')).toBe('January 01, 2021 12:00 am');
   });
 
-  it('should throw an error when comparing two DateTz instances with different timezones', () => {
-    const dateTz1 = new DateTz(1609459200000, 0);
-    const dateTz2 = new DateTz(1609459200000, 1);
-    expect(() => dateTz1.compare(dateTz2)).toThrow('Cannot compare dates with different timezones');
+  it('retains chaining behaviour for add', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const result = dateTz.add(1, 'day');
+    expect(result).toBe(dateTz);
   });
 
-  it('should format the date correctly with the default pattern', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.toString()).toBe('2021-01-01 00:00:00');
-  });
-
-  it('should format the date correctly with a custom pattern', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.toString('DD/MM/YYYY')).toBe('01/01/2021');
+  it('adds time in different units', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    dateTz.add(90, 'minute'); // +1h30
+    expect(dateTz.toString()).toBe('2021-01-01 01:30:00');
+    dateTz.add(1, 'day');
+    expect(dateTz.toString()).toBe('2021-01-02 01:30:00');
+    dateTz.add(1, 'month');
+    expect(dateTz.toString()).toBe('2021-02-02 01:30:00');
+    dateTz.add(1, 'year');
+    expect(dateTz.toString()).toBe('2022-02-02 01:30:00');
   });
 
-  it('should add minutes correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(30, 'minute');
-    expect(dateTz.toString()).toBe('2021-01-01 00:30:00');
+  it('sets specific components of the date', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    dateTz.set(2023, 'year')
+      .set(2, 'month') // February (1-based)
+      .set(15, 'day')
+      .set(9, 'hour')
+      .set(45, 'minute');
+    expect(dateTz.toString()).toBe('2023-02-15 09:45:00');
   });
 
-  it('should add hours correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(2, 'hour');
-    expect(dateTz.toString()).toBe('2021-01-01 02:00:00');
+  it('handles leap year arithmetic when adding days', () => {
+    const leap = new DateTz(Date.UTC(2020, 1, 28, 0, 0), 'UTC');
+    leap.add(1, 'day');
+    expect(leap.toString()).toBe('2020-02-29 00:00:00');
+    leap.add(1, 'day');
+    expect(leap.toString()).toBe('2020-03-01 00:00:00');
   });
 
-  it('should add days correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(1, 'day');
-    expect(dateTz.toString()).toBe('2021-01-02 00:00:00');
+  it('parses a date string with a custom pattern', () => {
+    const parsed = DateTz.parse('2021-01-05 18:30:00', 'YYYY-MM-DD HH:mm:ss', 'UTC');
+    expect(parsed.toString()).toBe('2021-01-05 18:30:00');
+    expect(parsed.timezone).toBe('UTC');
   });
 
-  it('should add months correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(1, 'month');
-    expect(dateTz.toString()).toBe('2021-02-01 00:00:00');
+  it('parses using a non-UTC timezone', () => {
+    const parsed = DateTz.parse('2021-01-05 18:30:00', 'YYYY-MM-DD HH:mm:ss', 'Europe/Rome');
+    expect(parsed.timezone).toBe('Europe/Rome');
+    expect(parsed.toString('YYYY-MM-DD HH:mm tz')).toBe('2021-01-05 18:30 Europe/Rome');
   });
 
-  it('should add years correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.add(1, 'year');
-    expect(dateTz.toString()).toBe('2022-01-01 00:00:00');
+  it('throws when parsing a 12-hour pattern without an AM/PM marker', () => {
+    expect(() => DateTz.parse('2021-01-05 06:30', 'YYYY-MM-DD hh:mm', 'UTC'))
+      .toThrow('AM/PM marker (aa or AA) is required when using 12-hour format (hh)');
   });
 
-  it('should return the correct year', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.year).toBe(2021);
+  it('throws when parsing with an unknown timezone', () => {
+    expect(() => DateTz.parse('2021-01-05 06:30:00', 'YYYY-MM-DD HH:mm:ss', 'Mars/Phobos'))
+      .toThrow('Invalid timezone: Mars/Phobos');
   });
 
-  it('should return the correct month', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.month).toBe(0); // January
+  it('clones to a different timezone without mutating the original', () => {
+    const original = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const clone = original.cloneToTimezone('Europe/Rome');
+    expect(original.timezone).toBe('UTC');
+    expect(clone.timezone).toBe('Europe/Rome');
+    expect(clone.toString()).toBe('2021-01-01 01:00:00');
+    expect(clone.timestamp).toBe(original.timestamp);
+    expect(clone).not.toBe(original);
   });
 
-  it('should return the correct day', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.day).toBe(1);
+  it('converts to a different timezone in place', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const originalTimestamp = dateTz.timestamp;
+    const result = dateTz.convertToTimezone('Europe/Rome');
+    expect(result).toBe(dateTz);
+    expect(dateTz.timezone).toBe('Europe/Rome');
+    expect(dateTz.toString()).toBe('2021-01-01 01:00:00');
+    expect(dateTz.timestamp).toBe(originalTimestamp);
   });
 
-  it('should return the correct hour', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.hour).toBe(0);
+  it('exposes timezone offset information', () => {
+    const la = new DateTz(BASE_TIMESTAMP, 'America/Los_Angeles');
+    expect(la.timezoneOffset).toEqual({ sdt: -28800, dst: -25200 });
   });
 
-  it('should return the correct minute', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    expect(dateTz.minute).toBe(0);
+  it('reports comparability correctly', () => {
+    const utc = new DateTz(BASE_TIMESTAMP, 'UTC');
+    const rome = new DateTz(BASE_TIMESTAMP, 'Europe/Rome');
+    expect(utc.isComparable(rome)).toBe(false);
+    expect(utc.isComparable(new DateTz(BASE_TIMESTAMP, 'UTC'))).toBe(true);
+    const plain: IDateTz = { timestamp: BASE_TIMESTAMP, timezone: 'UTC' };
+    expect(utc.isComparable(plain)).toBe(true);
   });
 
-  it('should parse a date string correctly', () => {
-    const dateTz = DateTz.parse('2021--01-01 00:00:00', 'YYYY--MM-DD HH:mm', 0);
-    expect(dateTz.datetime).toBe(1609459200000);
-    expect(dateTz.timezone).toBe(0);
+  it('exposes date parts adjusted for timezone', () => {
+    const rome = new DateTz(BASE_TIMESTAMP, 'Europe/Rome');
+    expect(rome.year).toBe(2021);
+    expect(rome.month).toBe(0);
+    expect(rome.day).toBe(1);
+    expect(rome.hour).toBe(1);
+    expect(rome.minute).toBe(0);
+    expect(rome.dayOfWeek).toBe(5);
   });
 
-  it('should set the year correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.set(2022, 'year');
-    expect(dateTz.toString()).toBe('2022-01-01 00:00:00');
+  it('detects daylight saving time boundaries', () => {
+    const winter = new DateTz(Date.UTC(2021, 0, 1, 20, 0), 'America/Los_Angeles');
+    const summer = new DateTz(Date.UTC(2021, 6, 1, 19, 0), 'America/Los_Angeles');
+    expect(winter.isDst).toBe(false);
+    expect(summer.isDst).toBe(true);
   });
 
-  it('should set the month correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.set(2, 'month');
-    expect(dateTz.toString()).toBe('2021-02-01 00:00:00');
+  it('reports isDst as false for timezones without daylight saving time', () => {
+    const accra = new DateTz(BASE_TIMESTAMP, 'Africa/Accra');
+    expect(accra.isDst).toBe(false);
   });
 
-  it('should set the day correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.set(2, 'day');
-    expect(dateTz.toString()).toBe('2021-01-02 00:00:00');
+  it('instantiates via now with the requested timezone', () => {
+    const current = DateTz.now('Europe/Rome');
+    expect(current.timezone).toBe('Europe/Rome');
   });
 
-  it('should set the hour correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.set(2, 'hour');
-    expect(dateTz.toString()).toBe('2021-01-01 02:00:00');
+  it('defaults to UTC when calling now without arguments', () => {
+    const current = DateTz.now();
+    expect(current.timezone).toBe('UTC');
   });
 
-  it('should set the minute correctly', () => {
-    const dateTz = new DateTz(1609459200000, 0); // 2021-01-01 00:00:00 UTC
-    dateTz.set(30, 'minute');
-    expect(dateTz.toString()).toBe('2021-01-01 00:30:00');
+  it('rejects unknown timezones on construction and conversion', () => {
+    expect(() => new DateTz(BASE_TIMESTAMP, 'Mars/Phobos')).toThrow('Invalid timezone: Mars/Phobos');
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(() => dateTz.convertToTimezone('Mars/Phobos')).toThrow('Invalid timezone: Mars/Phobos');
   });
 
-  it('should convert timezone name to offset correctly', () => {
-    expect(DateTz.tzNameToOffset('PST')).toBe(-8);
+  it('rejects unknown timezones when cloning', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(() => dateTz.cloneToTimezone('Mars/Phobos')).toThrow('Invalid timezone: Mars/Phobos');
   });
 
-  it('should convert timezone offset to name correctly', () => {
-    expect(DateTz.tzOffsetToName(-8)).toBe('PST');
+  it('rejects conversion to plain offsets by id mismatch', () => {
+    const dateTz = new DateTz(BASE_TIMESTAMP, 'UTC');
+    expect(() => dateTz.convertToTimezone('GMT+1')).toThrow('Invalid timezone: GMT+1');
   });
-});
+});

package/src/timezones.ts

@@ -96,6 +96,7 @@ export const timezones: Timezone = {
   "America/Cayman": { sdt: -18000, dst: -18000 },
   "America/Chicago": { sdt: -21600, dst: -18000 },
   "America/Chihuahua": { sdt: -21600, dst: -21600 },
+  "America/Ciudad_Juarez": { sdt: -25200, dst: -21600 },
   "America/Coral_Harbour": { sdt: -18000, dst: -18000 },
   "America/Cordoba": { sdt: -10800, dst: -10800 },
   "America/Costa_Rica": { sdt: -21600, dst: -21600 },
@@ -186,6 +187,7 @@ export const timezones: Timezone = {
   "America/Porto_Acre": { sdt: -18000, dst: -18000 },
   "America/Porto_Velho": { sdt: -14400, dst: -14400 },
   "America/Puerto_Rico": { sdt: -14400, dst: -14400 },
+  "America/Punta_Arenas": { sdt: -10800, dst: -10800 },
   "America/Rainy_River": { sdt: -21600, dst: -18000 },
   "America/Rankin_Inlet": { sdt: -21600, dst: -18000 },
   "America/Recife": { sdt: -10800, dst: -10800 },
@@ -241,10 +243,12 @@ export const timezones: Timezone = {
   "Asia/Aqtobe": { sdt: 18000, dst: 18000 },
   "Asia/Ashgabat": { sdt: 18000, dst: 18000 },
   "Asia/Ashkhabad": { sdt: 18000, dst: 18000 },
+  "Asia/Atyrau": { sdt: 18000, dst: 18000 },
   "Asia/Baghdad": { sdt: 10800, dst: 10800 },
   "Asia/Bahrain": { sdt: 10800, dst: 10800 },
   "Asia/Baku": { sdt: 14400, dst: 14400 },
   "Asia/Bangkok": { sdt: 25200, dst: 25200 },
+  "Asia/Barnaul": { sdt: 25200, dst: 25200 },
   "Asia/Beirut": { sdt: 7200, dst: 10800 },
   "Asia/Bishkek": { sdt: 21600, dst: 21600 },
   "Asia/Brunei": { sdt: 28800, dst: 28800 },
@@ -260,6 +264,7 @@ export const timezones: Timezone = {
   "Asia/Dili": { sdt: 32400, dst: 32400 },
   "Asia/Dubai": { sdt: 14400, dst: 14400 },
   "Asia/Dushanbe": { sdt: 18000, dst: 18000 },
+  "Asia/Famagusta": { sdt: 7200, dst: 10800 },
   "Asia/Gaza": { sdt: 7200, dst: 10800 },
   "Asia/Harbin": { sdt: 28800, dst: 28800 },
   "Asia/Hebron": { sdt: 7200, dst: 10800 },
@@ -298,6 +303,7 @@ export const timezones: Timezone = {
   "Asia/Pontianak": { sdt: 25200, dst: 25200 },
   "Asia/Pyongyang": { sdt: 32400, dst: 32400 },
   "Asia/Qatar": { sdt: 10800, dst: 10800 },
+  "Asia/Qostanay": { sdt: 18000, dst: 21600 },
   "Asia/Qyzylorda": { sdt: 18000, dst: 18000 },
   "Asia/Rangoon": { sdt: 23400, dst: 23400 },
   "Asia/Riyadh": { sdt: 10800, dst: 10800 },
@@ -319,10 +325,12 @@ export const timezones: Timezone = {
   "Asia/Thimbu": { sdt: 21600, dst: 21600 },
   "Asia/Thimphu": { sdt: 21600, dst: 21600 },
   "Asia/Tokyo": { sdt: 32400, dst: 32400 },
+  "Asia/Tomsk": { sdt: 25200, dst: 25200 },
   "Asia/Ujung_Pandang": { sdt: 28800, dst: 28800 },
   "Asia/Ulaanbaatar": { sdt: 28800, dst: 28800 },
   "Asia/Ulan_Bator": { sdt: 28800, dst: 28800 },
   "Asia/Urumqi": { sdt: 21600, dst: 21600 },
+  "Asia/Ust-Nera": { sdt: 36000, dst: 36000 },
   "Asia/Vientiane": { sdt: 25200, dst: 25200 },
   "Asia/Vladivostok": { sdt: 36000, dst: 36000 },
   "Asia/Yakutsk": { sdt: 32400, dst: 32400 },
@@ -423,6 +431,7 @@ export const timezones: Timezone = {
   "Etc/Zulu": { sdt: 0, dst: 0 },
   "Europe/Amsterdam": { sdt: 3600, dst: 7200 },
   "Europe/Andorra": { sdt: 3600, dst: 7200 },
+  "Europe/Astrakhan": { sdt: 14400, dst: 14400 },
   "Europe/Athens": { sdt: 7200, dst: 10800 },
   "Europe/Belfast": { sdt: 0, dst: 3600 },
   "Europe/Belgrade": { sdt: 3600, dst: 7200 },
@@ -443,6 +452,7 @@ export const timezones: Timezone = {
   "Europe/Jersey": { sdt: 0, dst: 3600 },
   "Europe/Kaliningrad": { sdt: 7200, dst: 7200 },
   "Europe/Kiev": { sdt: 7200, dst: 10800 },
+  "Europe/Kirov": { sdt: 10800, dst: 10800 },
   "Europe/Lisbon": { sdt: 0, dst: 3600 },
   "Europe/Ljubljana": { sdt: 3600, dst: 7200 },
   "Europe/London": { sdt: 0, dst: 3600 },
@@ -463,6 +473,7 @@ export const timezones: Timezone = {
   "Europe/Samara": { sdt: 14400, dst: 14400 },
   "Europe/San_Marino": { sdt: 3600, dst: 7200 },
   "Europe/Sarajevo": { sdt: 3600, dst: 7200 },
+  "Europe/Saratov": { sdt: 14400, dst: 14400 },
   "Europe/Simferopol": { sdt: 10800, dst: 10800 },
   "Europe/Skopje": { sdt: 3600, dst: 7200 },
   "Europe/Sofia": { sdt: 7200, dst: 10800 },
@@ -470,6 +481,7 @@ export const timezones: Timezone = {
   "Europe/Tallinn": { sdt: 7200, dst: 10800 },
   "Europe/Tirane": { sdt: 3600, dst: 7200 },
   "Europe/Tiraspol": { sdt: 7200, dst: 10800 },
+  "Europe/Ulyanovsk": { sdt: 14400, dst: 14400 },
   "Europe/Uzhgorod": { sdt: 7200, dst: 10800 },
   "Europe/Vaduz": { sdt: 3600, dst: 7200 },
   "Europe/Vatican": { sdt: 3600, dst: 7200 },