airport-utils 1.0.0 → 1.0.1

package/dist/esm/converter.js

@@ -0,0 +1,75 @@
+import { parseISO } from 'date-fns';
+import { TZDate } from '@date-fns/tz';
+import { timezones } from './mapping/timezones.js';
+import { UnknownAirportError, InvalidTimestampError, UnknownTimezoneError } from './errors.js';
+
+const ISO_LOCAL_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/;
+function parseLocalIso(localIso) {
+    const m = ISO_LOCAL_RE.exec(localIso);
+    if (!m)
+        throw new InvalidTimestampError(localIso);
+    const [, Y, Mo, D, h, mi, s] = m;
+    return [
+        Number(Y),
+        Number(Mo) - 1,
+        Number(D),
+        Number(h),
+        Number(mi),
+        s ? Number(s) : 0
+    ];
+}
+/**
+ * Convert a local ISO‐8601 string at an airport (IATA) into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
+ */
+function convertToUTC(localIso, iata) {
+    const tz = timezones[iata];
+    if (!tz)
+        throw new UnknownAirportError(iata);
+    // Quick semantic check
+    const base = parseISO(localIso);
+    if (isNaN(base.getTime()))
+        throw new InvalidTimestampError(localIso);
+    const [year, month, day, hour, minute, second] = parseLocalIso(localIso);
+    let zoned;
+    try {
+        zoned = TZDate.tz(tz, year, month, day, hour, minute, second);
+    }
+    catch {
+        throw new InvalidTimestampError(localIso);
+    }
+    if (isNaN(zoned.getTime()))
+        throw new InvalidTimestampError(localIso);
+    // Strip ".000" from the ISO string
+    return new Date(zoned.getTime()).toISOString().replace('.000Z', 'Z');
+}
+/**
+ * Convert a local ISO‐8601 string in any IANA timezone into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
+ */
+function convertLocalToUTCByZone(localIso, timeZone) {
+    // Validate timezone
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone }).format();
+    }
+    catch {
+        throw new UnknownTimezoneError(timeZone);
+    }
+    // Quick semantic check
+    const base = parseISO(localIso);
+    if (isNaN(base.getTime()))
+        throw new InvalidTimestampError(localIso);
+    const [year, month, day, hour, minute, second] = parseLocalIso(localIso);
+    let zoned;
+    try {
+        zoned = TZDate.tz(timeZone, year, month, day, hour, minute, second);
+    }
+    catch {
+        throw new UnknownTimezoneError(timeZone);
+    }
+    if (isNaN(zoned.getTime()))
+        throw new InvalidTimestampError(localIso);
+    return new Date(zoned.getTime()).toISOString().replace('.000Z', 'Z');
+}
+
+export { convertLocalToUTCByZone, convertToUTC };

package/dist/{src → esm}/errors.js

@@ -1,18 +1,20 @@
-export class UnknownAirportError extends Error {
+class UnknownAirportError extends Error {
     constructor(iata) {
         super(`Unknown airport IATA code: ${iata}`);
         this.name = 'UnknownAirportError';
     }
 }
-export class InvalidTimestampError extends Error {
+class InvalidTimestampError extends Error {
     constructor(ts) {
         super(`Invalid ISO 8601 timestamp: ${ts}`);
         this.name = 'InvalidTimestampError';
     }
 }
-export class UnknownTimezoneError extends Error {
+class UnknownTimezoneError extends Error {
     constructor(tz) {
         super(`Unknown timezone: ${tz}`);
         this.name = 'UnknownTimezoneError';
     }
 }
+
+export { InvalidTimestampError, UnknownAirportError, UnknownTimezoneError };

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export { convertLocalToUTCByZone, convertToUTC } from './converter.js';
+export { getAirportInfo } from './info.js';
+export { InvalidTimestampError, UnknownAirportError, UnknownTimezoneError } from './errors.js';

package/dist/esm/info.js

@@ -0,0 +1,14 @@
+import { timezones } from './mapping/timezones.js';
+import { geo } from './mapping/geo.js';
+import { UnknownAirportError } from './errors.js';
+
+/** @throws UnknownAirportError */
+function getAirportInfo(iata) {
+    const tz = timezones[iata];
+    const g = geo[iata];
+    if (!tz || !g)
+        throw new UnknownAirportError(iata);
+    return { timezone: tz, ...g };
+}
+
+export { getAirportInfo };

package/dist/{src → esm}/mapping/geo.js

@@ -1,4 +1,4 @@
-export const geo = {
+const geo = {
     "AAA": { "latitude": -17.41667, "longitude": -145.5, "name": "Anaa", "city": "Anaa", "country": "PF" },
     "AAB": { "latitude": -26.76408, "longitude": 141.02853, "name": "Arrabury", "city": "Arrabury", "country": "AU" },
     "AAC": { "latitude": 31.13159, "longitude": 33.79844, "name": "Arīsh", "city": "Arīsh", "country": "EG" },
@@ -4754,7 +4754,7 @@ export const geo = {
     "LDA": { "latitude": 25.00447, "longitude": 88.14573, "name": "Malda", "city": "Malda", "country": "IN" },
     "LDB": { "latitude": -23.31028, "longitude": -51.16278, "name": "Londrina", "city": "Londrina", "country": "BR" },
     "LDC": { "latitude": -20.45, "longitude": 149.1, "name": "Lindeman Island Airport", "city": "Lindeman Island Airport", "country": "AU" },
-    "LDE": { "latitude": 43.178675, "longitude": -0.006439, "name": "Tarbes-Lourdes-Pyrénées Airport", "city": "Tarbes-Lourdes-Pyrénées Airport", "country": "FR" },
+    "LDE": { "latitude": 43.178675, "longitude": -6439e-6, "name": "Tarbes-Lourdes-Pyrénées Airport", "city": "Tarbes-Lourdes-Pyrénées Airport", "country": "FR" },
     "LDG": { "latitude": 64.8977, "longitude": 45.7655, "name": "Leshukonskoye", "city": "Leshukonskoye", "country": "RU" },
     "LDH": { "latitude": -31.55938, "longitude": 159.08581, "name": "Lord Howe Island", "city": "Lord Howe Island", "country": "AU" },
     "LDI": { "latitude": -10, "longitude": 39.71667, "name": "Lindi", "city": "Lindi", "country": "TZ" },
@@ -10490,7 +10490,7 @@ export const geo = {
     "XOC": { "latitude": 40.40402, "longitude": -3.68823, "name": "Madrid Atocha Railway Station", "city": "Madrid", "country": "ES" },
     "XOD": { "latitude": 62.6, "longitude": 9.683, "name": "Oppdal NO Railway Station", "city": "Oppdal NO Railway Station", "country": "NO" },
     "XOE": { "latitude": -26.93, "longitude": -49.05, "name": "Sao Jose", "city": "Sao Jose", "country": "BR" },
-    "XOF": { "latitude": 51.5448, "longitude": -0.00875, "name": "Stratford International Station", "city": "London", "country": "GB" },
+    "XOF": { "latitude": 51.5448, "longitude": -875e-5, "name": "Stratford International Station", "city": "London", "country": "GB" },
     "XOG": { "latitude": 44.140481, "longitude": 4.866717, "name": "Orange-Caritat", "city": "Orange-Caritat", "country": "FR" },
     "XOH": { "latitude": 47.45, "longitude": 12.39, "name": "Kitzbuehel AT Bus Station", "city": "Salzburg AT Kitzbuehel Rail", "country": "AT" },
     "XOI": { "latitude": 47.01257, "longitude": 10.29179, "name": "Ischgl", "city": "Ischgl", "country": "AT" },
@@ -11985,3 +11985,5 @@ export const geo = {
     "ZZW": { "latitude": -32, "longitude": 147, "name": "Day Trip Mystery", "city": "Day Trip Mystery", "country": "AU" },
     "ZZZ": { "latitude": 51.88, "longitude": 0.2333, "name": "Greenwich mean TM", "city": "London", "country": "GB" }
 };
+
+export { geo };

package/dist/{src → esm}/mapping/timezones.js

@@ -1,5 +1,5 @@
 // generated — do not edit
-export const timezones = {
+const timezones = {
     "AAA": "Pacific/Tahiti",
     "AAB": "Australia/Brisbane",
     "AAC": "Africa/Cairo",
@@ -11999,3 +11999,5 @@ export const timezones = {
     "ZZW": "Australia/Sydney",
     "ZZZ": "Europe/London"
 };
+
+export { timezones };

package/dist/types/converter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Convert a local ISO‐8601 string at an airport (IATA) into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
+ */
+export declare function convertToUTC(localIso: string, iata: string): string;
+/**
+ * Convert a local ISO‐8601 string in any IANA timezone into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
+ */
+export declare function convertLocalToUTCByZone(localIso: string, timeZone: string): string;

package/jest.config.js

@@ -7,5 +7,9 @@ export default {
     global: { branches: 100, functions: 100, lines: 100, statements: 100 }
   },
   moduleFileExtensions: ['ts', 'js', 'json'],
-  transform: { '^.+\\.ts$': 'ts-jest' }
+  transform: { '^.+\\.ts$': 'ts-jest' },
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/dist/'
+  ]
 };

package/package.json

@@ -1,12 +1,26 @@
 {
   "name": "airport-utils",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Convert local ISO 8601 timestamps to UTC using airport IATA codes, with airport geo-data",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    "require": "./dist/cjs/index.js",
+    "import": "./dist/esm/index.js"
+  },
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elipeF/airport-utils.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
-    "build": "tsc",
+    "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist/types",
+    "build:js": "rollup -c",
+    "build": "npm run build:types && npm run build:js",
     "test": "jest --coverage",
     "prepublishOnly": "npm run build",
     "update:mapping": "node --loader ts-node/esm scripts/generateMapping.ts"
@@ -22,9 +36,12 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "dayjs": "^1.11.7"
+    "@date-fns/tz": "^1.2.0",
+    "date-fns": "^4.1.0"
   },
   "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/github": "^11.0.2",
     "@semantic-release/npm": "^12.0.1",
@@ -34,9 +51,11 @@
     "conventional-changelog-conventionalcommits": "^8.0.0",
     "jest": "^29.0.0",
     "node-fetch": "^3.3.2",
+    "rollup": "^4.40.2",
     "semantic-release": "^24.2.3",
     "ts-jest": "^29.0.0",
     "ts-node": "^10.9.1",
+    "tslib": "^2.8.1",
     "typescript": "^5.0.0"
   }
 }

package/rollup.config.js

@@ -0,0 +1,53 @@
+import resolve from '@rollup/plugin-node-resolve';
+import typescript from '@rollup/plugin-typescript';
+import pkg from './package.json' assert { type: 'json' };
+
+
+const external = [
+  ...Object.keys(pkg.dependencies || {}),
+  ...Object.keys(pkg.peerDependencies || {}),
+];
+
+export default [
+  // ESM build
+  {
+    input: 'src/index.ts',
+    external,
+    plugins: [
+      resolve(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        declaration: false,
+        compilerOptions: { outDir: undefined }
+      })
+    ],
+    output: {
+      dir: 'dist/esm',
+      format: 'esm',
+      preserveModules: true,
+      preserveModulesRoot: 'src',
+      entryFileNames: '[name].js'
+    }
+  },
+
+  // CJS build
+  {
+    input: 'src/index.ts',
+    external,
+    plugins: [
+      resolve(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        declaration: false,
+        compilerOptions: { outDir: undefined }
+      })
+    ],
+    output: {
+      dir: 'dist/cjs',
+      format: 'cjs',
+      preserveModules: true,
+      preserveModulesRoot: 'src',
+      entryFileNames: '[name].js'
+    }
+  }
+];

package/src/converter.ts

@@ -1,6 +1,5 @@
-import dayjs from 'dayjs';
-import utc from 'dayjs/plugin/utc';
-import timezone from 'dayjs/plugin/timezone';
+import { parseISO } from 'date-fns';
+import { TZDate } from '@date-fns/tz';
 import { timezones } from './mapping/timezones';
 import {
   UnknownAirportError,
@@ -8,53 +7,78 @@ import {
   UnknownTimezoneError
 } from './errors';
 
-// Initialize plugins
-dayjs.extend(utc);
-dayjs.extend(timezone);
+const ISO_LOCAL_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/;
+
+function parseLocalIso(
+    localIso: string
+): [number, number, number, number, number, number] {
+  const m = ISO_LOCAL_RE.exec(localIso);
+  if (!m) throw new InvalidTimestampError(localIso);
+  const [, Y, Mo, D, h, mi, s] = m;
+  return [
+    Number(Y),
+    Number(Mo) - 1,
+    Number(D),
+    Number(h),
+    Number(mi),
+    s ? Number(s) : 0
+  ];
+}
 
 /**
- * Convert local ISO 8601 (YYYY-MM-DDTHH:mm) at an airport into UTC ISO string.
- * @throws UnknownAirportError | InvalidTimestampError
+ * Convert a local ISO‐8601 string at an airport (IATA) into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
  */
 export function convertToUTC(localIso: string, iata: string): string {
   const tz = timezones[iata];
   if (!tz) throw new UnknownAirportError(iata);
 
-  // 1) Pre-validate timestamp
-  const localDt = dayjs(localIso, /* no format, ISO parse */);
-  if (!localDt.isValid()) throw new InvalidTimestampError(localIso);
+  // Quick semantic check
+  const base = parseISO(localIso);
+  if (isNaN(base.getTime())) throw new InvalidTimestampError(localIso);
+
+  const [year, month, day, hour, minute, second] = parseLocalIso(localIso);
 
-  // 2) Then apply timezone conversion
-  let dt;
+  let zoned: TZDate;
   try {
-    dt = dayjs.tz(localIso, tz);
+    zoned = TZDate.tz(tz, year, month, day, hour, minute, second);
   } catch {
-    // Shouldn't happen for valid tz, but just in case:
     throw new InvalidTimestampError(localIso);
   }
+  if (isNaN(zoned.getTime())) throw new InvalidTimestampError(localIso);
 
-  return dt.utc().format(); // "YYYY-MM-DDTHH:mm:ssZ"
+  // Strip ".000" from the ISO string
+  return new Date(zoned.getTime()).toISOString().replace('.000Z', 'Z');
 }
 
 /**
- * Convert local ISO 8601 string in any IANA timezone to UTC ISO string.
- * @throws UnknownTimezoneError | InvalidTimestampError
+ * Convert a local ISO‐8601 string in any IANA timezone into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
  */
 export function convertLocalToUTCByZone(
     localIso: string,
     timeZone: string
 ): string {
-  // 1) Validate timestamp first
-  const localDt = dayjs(localIso);
-  if (!localDt.isValid()) throw new InvalidTimestampError(localIso);
+  // Validate timezone
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone }).format();
+  } catch {
+    throw new UnknownTimezoneError(timeZone);
+  }
+
+  // Quick semantic check
+  const base = parseISO(localIso);
+  if (isNaN(base.getTime())) throw new InvalidTimestampError(localIso);
+
+  const [year, month, day, hour, minute, second] = parseLocalIso(localIso);
 
-  // 2) Apply timezone, catching only invalid timezone errors
-  let dt;
+  let zoned: TZDate;
   try {
-    dt = dayjs.tz(localIso, timeZone);
+    zoned = TZDate.tz(timeZone, year, month, day, hour, minute, second);
   } catch {
     throw new UnknownTimezoneError(timeZone);
   }
+  if (isNaN(zoned.getTime())) throw new InvalidTimestampError(localIso);
 
-  return dt.utc().format();
+  return new Date(zoned.getTime()).toISOString().replace('.000Z', 'Z');
 }

package/tests/built.test.ts

@@ -0,0 +1,52 @@
+import { execSync } from 'child_process';
+import path from 'path';
+
+// Test CommonJS build
+describe('CommonJS build (dist/cjs)', () => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const cjs = require('../dist/cjs/index.js') as any;
+    const { convertToUTC, convertLocalToUTCByZone, getAirportInfo } = cjs;
+
+    it('convertToUTC works in CommonJS build', () => {
+        expect(convertToUTC('2025-05-02T14:30', 'JFK')).toBe('2025-05-02T18:30:00Z');
+    });
+
+    it('convertLocalToUTCByZone works in CommonJS build', () => {
+        expect(convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London'))
+            .toBe('2025-05-02T13:30:00Z');
+    });
+
+    it('getAirportInfo works in CommonJS build', () => {
+        const info = getAirportInfo('JFK');
+        expect(info).toHaveProperty('timezone');
+        expect(info).toHaveProperty('latitude');
+        expect(info).toHaveProperty('longitude');
+    });
+});
+
+// Test ESM build using a subprocess to dynamically import the file
+describe('ESM build (dist/esm)', () => {
+    const esmPath = path.resolve(__dirname, '../dist/esm/index.js');
+    const fileUrl = 'file://' + esmPath;
+
+    it('convertToUTC works in ESM build', () => {
+        const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(m.convertToUTC('2025-05-02T14:30','JFK')); })()"`;
+        const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+        expect(result).toBe('2025-05-02T18:30:00Z');
+    });
+
+    it('convertLocalToUTCByZone works in ESM build', () => {
+        const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(m.convertLocalToUTCByZone('2025-05-02T14:30:00','Europe/London')); })()"`;
+        const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+        expect(result).toBe('2025-05-02T13:30:00Z');
+    });
+
+    it('getAirportInfo works in ESM build', () => {
+        const cmd = `node -e "(async()=>{ const m = await import('${fileUrl}'); console.log(JSON.stringify(m.getAirportInfo('JFK'))); })()"`;
+        const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+        const info = JSON.parse(result);
+        expect(info).toHaveProperty('timezone');
+        expect(info).toHaveProperty('latitude');
+        expect(info).toHaveProperty('longitude');
+    });
+});

package/tests/converter.test.ts

@@ -1,4 +1,3 @@
-import dayjs from 'dayjs';
 import { convertToUTC, convertLocalToUTCByZone } from '../src/converter';
 import {
   UnknownAirportError,
@@ -7,7 +6,9 @@ import {
 } from '../src/errors';
 import { timezones } from '../src/mapping/timezones';
 
-// Dynamically find the first 3-letter code not in our mapping
+const { TZDate } = require('@date-fns/tz');
+
+// Dynamically find an invalid 3-letter IATA
 function getInvalidIata(): string {
   const existing = new Set(Object.keys(timezones));
   for (let a = 65; a <= 90; a++) {
@@ -18,12 +19,11 @@ function getInvalidIata(): string {
       }
     }
   }
-  throw new Error('All 3-letter codes are taken?!');
+  throw new Error('All codes taken?!');
 }
-
 const invalidIata = getInvalidIata();
 
-describe('convertToUTC (Day.js)', () => {
+describe('convertToUTC', () => {
   it('converts JFK local time (UTC–4 in May) correctly', () => {
     expect(convertToUTC('2025-05-02T14:30', 'JFK'))
         .toBe('2025-05-02T18:30:00Z');
@@ -35,19 +35,34 @@ describe('convertToUTC (Day.js)', () => {
   });
 
   it('throws InvalidTimestampError for malformed timestamp', () => {
-    expect(() => convertToUTC('invalid-format', 'JFK'))
+    expect(() => convertToUTC('not-a-timestamp', 'JFK'))
+        .toThrow(InvalidTimestampError);
+  });
+
+  it('throws InvalidTimestampError for fractional seconds format', () => {
+    expect(() => convertToUTC('2025-05-02T14:30:00.123', 'JFK'))
         .toThrow(InvalidTimestampError);
   });
 
-  it('throws InvalidTimestampError if dayjs.tz unexpectedly throws', () => {
-    const orig = (dayjs as any).tz;
-    (dayjs as any).tz = () => { throw new Error(); };
-    try {
+  describe('error branches', () => {
+    const original = TZDate.tz;
+    afterEach(() => { TZDate.tz = original; });
+
+    it('throws InvalidTimestampError if TZDate.tz throws', () => {
+      TZDate.tz = () => { throw new Error('forced'); };
       expect(() => convertToUTC('2025-05-02T14:30', 'JFK'))
           .toThrow(InvalidTimestampError);
-    } finally {
-      (dayjs as any).tz = orig;
-    }
+    });
+
+    it('throws InvalidTimestampError if TZDate.tz returns invalid Date', () => {
+      TZDate.tz = () => {
+        const d = new Date(NaN);
+        Object.setPrototypeOf(d, TZDate.prototype);
+        return d;
+      };
+      expect(() => convertToUTC('2025-05-02T14:30', 'JFK'))
+          .toThrow(InvalidTimestampError);
+    });
   });
 });
 
@@ -59,7 +74,7 @@ describe('convertLocalToUTCByZone', () => {
 
   it('throws UnknownTimezoneError for invalid tz', () => {
     expect(() =>
-        convertLocalToUTCByZone('2025-05-02T14:30:00', 'Invalid/Zone')
+        convertLocalToUTCByZone('2025-05-02T14:30:00', 'Not/A_Zone')
     ).toThrow(UnknownTimezoneError);
   });
 
@@ -68,4 +83,33 @@ describe('convertLocalToUTCByZone', () => {
         convertLocalToUTCByZone('bad-format', 'Europe/London')
     ).toThrow(InvalidTimestampError);
   });
+
+  it('throws InvalidTimestampError for fractional seconds format', () => {
+    expect(() =>
+        convertLocalToUTCByZone('2025-05-02T14:30:00.123', 'Europe/London')
+    ).toThrow(InvalidTimestampError);
+  });
+
+  describe('error branches', () => {
+    const original = TZDate.tz;
+    afterEach(() => { TZDate.tz = original; });
+
+    it('throws UnknownTimezoneError if TZDate.tz throws for valid zone', () => {
+      TZDate.tz = () => { throw new RangeError('forced'); };
+      expect(() =>
+          convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')
+      ).toThrow(UnknownTimezoneError);
+    });
+
+    it('throws InvalidTimestampError if TZDate.tz returns invalid Date', () => {
+      TZDate.tz = () => {
+        const d = new Date(NaN);
+        Object.setPrototypeOf(d, TZDate.prototype);
+        return d;
+      };
+      expect(() =>
+          convertLocalToUTCByZone('2025-05-02T14:30:00', 'Europe/London')
+      ).toThrow(InvalidTimestampError);
+    });
+  });
 });

package/tsconfig.json

@@ -4,11 +4,14 @@
     "module": "ESNext",
     "moduleResolution": "node",
     "declaration": true,
+    "rootDir": "src",
     "outDir": "dist",
     "strict": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true
   },
-  "include": ["src/**/*", "scripts/**/*", "tests/**/*"]
-}
+  "include": [
+    "src/**/*"
+  ]
+}

package/dist/scripts/generateMapping.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};