@remato/personal-code-to-birthday 1.0.0 → 1.1.1

package/README.md

@@ -28,21 +28,21 @@ console.log(birthday) // outputs { day: 26, month: 9, year: 1993 }
 -   🇸🇪 Sweden
 -   🇳🇴 Norway
 -   🇩🇰 Denmark
+-   🇺🇦 Ukraine
+-   🇵🇱 Poland
 
 Countries we would like to support (PRs are welcome):
 
 -   Iceland
--   South Africa
 -   Romania
 -   Hungary
 -   Bulgaria
+-   Moldova
+-   Azerbaijan
 -   North Macedonia
 -   Czech Republic
 -   Slovakia
--   Poland
 -   South Korea
 -   Turkey
--   Moldova
--   Azerbaijan
+-   South Africa
 -   Russia
--   Ukraine

package/package.json

@@ -1,11 +1,14 @@
 {
 	"name": "@remato/personal-code-to-birthday",
-	"version": "1.0.0",
+	"version": "1.1.1",
 	"description": "Converts personal identification codes from various countries into birthdate",
 	"license": "MIT",
-	"main": "index.ts",
+	"main": "src/index.ts",
+	"repository": {
+		"url": "https://github.com/rematocorp/personal-code-to-birthday"
+	},
 	"scripts": {
-		"build": "ncc build index.ts",
+		"build": "ncc build src/index.ts",
 		"test": "jest",
 		"prettier": "prettier --list-different \"**/*.ts\"",
 		"lint": "eslint \"**/*.ts\""
@@ -40,12 +43,13 @@
 		},
 		"collectCoverage": true,
 		"collectCoverageFrom": [
-			"index.ts"
+			"src/**"
 		]
 	},
 	"eslintConfig": {
 		"extends": [
 			"@remato/eslint-config/typescript"
 		]
-	}
+	},
+	"prettier": "@remato/prettier-config"
 }

package/src/index.test.ts

@@ -0,0 +1,114 @@
+import personalCodeToBirthday from './index'
+
+describe('valid codes', () => {
+	test('Estonia', () => {
+		expect(personalCodeToBirthday('39309262754')).toEqual({ day: 26, month: 9, year: 1993 })
+		expect(personalCodeToBirthday('49111012217')).toEqual({ day: 1, month: 11, year: 1991 })
+		expect(personalCodeToBirthday('30001010060')).toEqual({ day: 1, month: 1, year: 1900 })
+		expect(personalCodeToBirthday('62305060020')).toEqual({ day: 6, month: 5, year: 2023 })
+	})
+
+	test('Latvia', () => {
+		expect(personalCodeToBirthday('240860-28074')).toEqual({ day: 24, month: 8, year: 1960 })
+		expect(personalCodeToBirthday('071023-38935')).toEqual({ day: 7, month: 10, year: 2023 })
+		expect(personalCodeToBirthday('240860-20090')).toEqual({ day: 24, month: 8, year: 1960 })
+	})
+
+	test('Lithuania', () => {
+		expect(personalCodeToBirthday('39905280216')).toEqual({ day: 28, month: 5, year: 1999 })
+	})
+
+	test('Finland', () => {
+		expect(personalCodeToBirthday('101085-7001')).toEqual({ day: 10, month: 10, year: 1985 })
+		expect(personalCodeToBirthday('150752-308N')).toEqual({ day: 15, month: 7, year: 1952 })
+		expect(personalCodeToBirthday('010100A123D')).toEqual({ day: 1, month: 1, year: 2000 })
+	})
+
+	test('Sweden', () => {
+		expect(personalCodeToBirthday('8112289874')).toEqual({ day: 28, month: 12, year: 1981 })
+		expect(personalCodeToBirthday('811228-9874')).toEqual({ day: 28, month: 12, year: 1981 })
+		expect(personalCodeToBirthday('670919-9530')).toEqual({ day: 19, month: 9, year: 1967 })
+		expect(personalCodeToBirthday('230919-9533')).toEqual({ day: 19, month: 9, year: 2023 })
+		expect(personalCodeToBirthday('196709199530')).toEqual({ day: 19, month: 9, year: 1967 })
+		expect(personalCodeToBirthday('19670919-9530')).toEqual({ day: 19, month: 9, year: 1967 })
+		expect(personalCodeToBirthday('20230919-9533')).toEqual({ day: 19, month: 9, year: 2023 })
+	})
+
+	test('Norway', () => {
+		expect(personalCodeToBirthday('10021559844')).toEqual({ day: 10, month: 2, year: 2015 })
+		expect(personalCodeToBirthday('100215 59844')).toEqual({ day: 10, month: 2, year: 2015 })
+		expect(personalCodeToBirthday('10028439895')).toEqual({ day: 10, month: 2, year: 1984 })
+		expect(personalCodeToBirthday('27081439368')).toEqual({ day: 27, month: 8, year: 2014 })
+	})
+
+	test('Denmark', () => {
+		expect(personalCodeToBirthday('070589-8901')).toEqual({ day: 7, month: 5, year: 1989 })
+		expect(personalCodeToBirthday('230309-4456')).toEqual({ day: 23, month: 3, year: 2009 })
+		expect(personalCodeToBirthday('050384-4567')).toEqual({ day: 5, month: 3, year: 1984 })
+		expect(personalCodeToBirthday('230309-3020')).toEqual({ day: 23, month: 3, year: 1909 })
+	})
+
+	test('Ukraine', () => {
+		expect(personalCodeToBirthday('3406105372')).toEqual({ day: 3, month: 4, year: 1993 })
+		expect(personalCodeToBirthday('3406105350')).toEqual({ day: 3, month: 4, year: 1993 })
+	})
+
+	test('Poland', () => {
+		expect(personalCodeToBirthday('44051401359')).toEqual({ day: 14, month: 5, year: 1944 })
+		expect(personalCodeToBirthday('02070803628')).toEqual({ day: 8, month: 7, year: 1902 })
+		expect(personalCodeToBirthday('24231012344')).toEqual({ day: 10, month: 3, year: 2024 })
+	})
+})
+
+describe('invalid personal code', () => {
+	test('Estonia', () => {
+		expect(personalCodeToBirthday('39911025555')).toBeNull()
+		expect(personalCodeToBirthday('39913035552')).toBeNull()
+	})
+
+	test('Latvia', () => {
+		expect(personalCodeToBirthday('071023-38934')).toBeNull()
+		expect(personalCodeToBirthday('071523-38937')).toBeNull()
+	})
+
+	test('Lithuania', () => {
+		expect(personalCodeToBirthday('99905280217')).toBeNull()
+	})
+
+	test('Finland', () => {
+		expect(personalCodeToBirthday('999999A123T')).toBeNull()
+		expect(personalCodeToBirthday('131052Z3087')).toBeNull()
+		expect(personalCodeToBirthday('321052A3087')).toBeNull()
+		expect(personalCodeToBirthday('910100A123F')).toBeNull()
+	})
+
+	test('Sweden', () => {
+		expect(personalCodeToBirthday('8112289875')).toBeNull()
+		expect(personalCodeToBirthday('8115289871')).toBeNull()
+	})
+
+	test('Norway', () => {
+		expect(personalCodeToBirthday('32129999999')).toBeNull()
+		expect(personalCodeToBirthday('32132811465')).toBeNull()
+		expect(personalCodeToBirthday('32112812600')).toBeNull()
+	})
+
+	test('Denmark', () => {
+		expect(personalCodeToBirthday('999999-1234')).toBeNull()
+		expect(personalCodeToBirthday('051484-4569')).toBeNull()
+		expect(personalCodeToBirthday('230309-3080')).toBeNull()
+	})
+
+	test('Ukraine', () => {
+		expect(personalCodeToBirthday('3416105373')).toBeNull()
+	})
+
+	test('Poland', () => {
+		expect(personalCodeToBirthday('24231012343')).toBeNull()
+		expect(personalCodeToBirthday('24234012341')).toBeNull()
+	})
+
+	test('unidentified personal code format', () => {
+		expect(personalCodeToBirthday('abcd1234')).toBeNull()
+	})
+})

package/src/index.ts

@@ -0,0 +1,33 @@
+import denmarkParser from './parsers/denmark'
+import estoniaLithuaniaParser from './parsers/estoniaLithuania'
+import finlandParser from './parsers/finland'
+import latviaParser from './parsers/latvia'
+import norwayParser from './parsers/norway'
+import polandParser from './parsers/poland'
+import swedenParser from './parsers/sweden'
+import ukraineParser from './parsers/ukraine'
+import { ParsedDate } from './types'
+
+export default function personalCodeToBirthday(code: string): ParsedDate | null {
+	code = code.replace(' ', '')
+
+	if (/^\d{10}$/.test(code)) {
+		return ukraineParser(code) || swedenParser(code)
+	} else if (/^\d{11}$/.test(code)) {
+		return estoniaLithuaniaParser(code) || polandParser(code) || norwayParser(code)
+	} else if (/^\d{12}$/.test(code)) {
+		return swedenParser(code)
+	} else if (/^\d{6}-\d{5}$/.test(code)) {
+		return latviaParser(code)
+	} else if (/^\d{6}[+-A]\d{3}[A-Za-z]$/.test(code)) {
+		return finlandParser(code)
+	} else if (/^\d{6}[-]\d{4}$/.test(code)) {
+		return finlandParser(code) || swedenParser(code) || denmarkParser(code)
+	} else if (/^\d{6}[A]\d{4}$/.test(code)) {
+		return finlandParser(code)
+	} else if (/^\d{8}[-]\d{4}$/.test(code)) {
+		return swedenParser(code)
+	}
+
+	return null
+}

package/src/parsers/denmark.ts

@@ -0,0 +1,54 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function denmarkParser(code: string): ParsedDate | null {
+	code = code.replace('-', '')
+
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(4, 6), 10)
+	const centuryIndicator = parseInt(code.slice(6, 7), 10)
+
+	// Determine century based on the 7th digit and the year
+	if (centuryIndicator >= 0 && centuryIndicator <= 3) {
+		year += 1900
+	} else if (centuryIndicator >= 4 && centuryIndicator <= 9) {
+		if (year >= 0 && year <= 36) {
+			year += 2000
+		} else {
+			year += 1900
+		}
+	}
+
+	// Checksum was dropped in 2007
+	// https://en.wikipedia.org/wiki/Personal_identification_number_(Denmark)#New_development_in_2007
+	if (year < 2007 && !isValidChecksum(code)) {
+		return null
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const weights = [4, 3, 2, 7, 6, 5, 4, 3, 2] // Weights for the first 9 digits
+
+	// Convert the first 9 digits to an array of numbers
+	const digits = code.substring(0, 9).split('').map(Number)
+
+	// Calculate the weighted sum
+	const sum = digits.reduce((acc, digit, index) => acc + digit * weights[index], 0)
+
+	// Calculate the check digit (modulo 11)
+	const checksum = sum % 11 === 0 ? 0 : 11 - (sum % 11)
+
+	// If the modulo result is 10, it's considered invalid (CPR could not use this number)
+	if (checksum === 10) {
+		return false
+	}
+
+	return checksum === parseInt(code[9], 10)
+}

package/src/parsers/estoniaLithuania.ts

@@ -0,0 +1,52 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function estoniaLithuaniaParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const centuryCode = parseInt(code[0], 10)
+	const day = parseInt(code.slice(5, 7), 10)
+	const month = parseInt(code.slice(3, 5), 10)
+	let year = parseInt(code.slice(1, 3), 10)
+
+	if (centuryCode === 3 || centuryCode === 4) {
+		year += 1900
+	}
+	if (centuryCode === 5 || centuryCode === 6) {
+		year += 2000
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const weights1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1]
+	const weights2 = [3, 4, 5, 6, 7, 8, 9, 1, 2, 3]
+	let checksum = 0
+	let total = 0
+
+	for (let i = 0; i < 10; ++i) {
+		total += Number(code.charAt(i)) * weights1[i]
+	}
+	checksum = total % 11
+
+	total = 0
+	if (checksum === 10) {
+		for (let i = 0; i < 10; ++i) {
+			total += Number(code.charAt(i)) * weights2[i]
+		}
+		checksum = total % 11
+
+		if (10 === checksum) {
+			checksum = 0
+		}
+	}
+
+	return checksum === Number(code[10])
+}

package/src/parsers/finland.ts

@@ -0,0 +1,40 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function finlandParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	const yearSuffix = parseInt(code.slice(4, 6), 10)
+	const centuryMarker = code[6]
+
+	let year = yearSuffix
+
+	// Handle the century based on the marker
+	if (centuryMarker === '-') {
+		year += 1900
+	} else if (centuryMarker === 'A') {
+		year += 2000
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const validChars = '0123456789ABCDEFHJKLMNPRSTUVWXY'
+
+	const serial = code.slice(0, 6) + code.slice(7, 10)
+	const checksum = code[10]
+	const num = parseInt(serial, 10)
+	const remainder = num % 31
+	const expectedChecksum = validChars.charAt(remainder)
+
+	return expectedChecksum === checksum.toUpperCase()
+}

package/src/parsers/latvia.ts

@@ -0,0 +1,48 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+// Correct old school format is DDMMYY-CXXXX
+export default function latviaParser(code: string): ParsedDate | null {
+	code = code.replace('-', '')
+
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(4, 6), 10)
+	const centuryCode = parseInt(code[6], 10)
+
+	if (centuryCode === 3) {
+		year += 2000
+	} else {
+		year += 1900
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+// Function to validate the check digit of a Latvian personal code
+function isValidChecksum(personalCode: string): boolean {
+	const weights = [1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
+
+	// Convert the first 10 digits to an array of numbers
+	const digits = personalCode.substring(0, 10).split('').map(Number)
+
+	// Calculate the weighted sum
+	const sum = digits.reduce((acc, digit, index) => acc + digit * weights[index], 0)
+
+	// Calculate the check digit
+	let checksum = sum % 11
+	if (checksum === 10) {
+		checksum = 0 // If modulo result is 10, check digit is 0
+	}
+
+	// Return true if the calculated check digit matches the provided check digit
+	return checksum === parseInt(personalCode[10], 10)
+}

package/src/parsers/norway.ts

@@ -0,0 +1,65 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function norwayParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const day = parseInt(code.slice(0, 2), 10)
+	const month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(4, 6), 10)
+
+	const centuryMarker = parseInt(code.slice(6, 7), 10)
+
+	// Read more https://en.wikipedia.org/wiki/National_identity_number_(Norway)#Numerical_components
+	if (centuryMarker <= 4 || centuryMarker === 9) {
+		year += year >= 40 ? 1900 : 2000
+	} else if (centuryMarker >= 5 && centuryMarker <= 8) {
+		year += 2000
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+// Function to validate the check digits of a Norwegian personal code
+function isValidChecksum(code: string): boolean {
+	const weights1 = [3, 7, 6, 1, 8, 9, 4, 5, 2] // Weights for the first checksum
+	const weights2 = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] // Weights for the second checksum, including first checksum
+
+	// Extract the first 9 digits for checksum calculation
+	const digits = code.substring(0, 9).split('').map(Number)
+
+	// Extract the check digits provided in the input
+	const providedFirstCheckDigit = parseInt(code[9], 10)
+	const providedSecondCheckDigit = parseInt(code[10], 10)
+
+	// First checksum calculation
+	const sum1 = digits.reduce((sum, digit, index) => sum + digit * weights1[index], 0)
+	let firstCheckDigit = 11 - (sum1 % 11)
+	if (firstCheckDigit === 11) {
+		firstCheckDigit = 0 // Handle special case where remainder is 11
+	}
+	if (firstCheckDigit === 10) {
+		return false // Invalid first check digit
+	}
+
+	// Add the first check digit for the second checksum calculation
+	const digitsWithFirstCheck = [...digits, firstCheckDigit]
+
+	// Second checksum calculation
+	const sum2 = digitsWithFirstCheck.reduce((sum, digit, index) => sum + digit * weights2[index], 0)
+	let secondCheckDigit = 11 - (sum2 % 11)
+	if (secondCheckDigit === 11) {
+		secondCheckDigit = 0 // Handle special case where remainder is 11
+	}
+	if (secondCheckDigit === 10) {
+		return false // Invalid second check digit
+	}
+
+	return firstCheckDigit === providedFirstCheckDigit && secondCheckDigit === providedSecondCheckDigit
+}

package/src/parsers/poland.ts

@@ -0,0 +1,37 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function polandParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	const day = parseInt(code.slice(4, 6), 10)
+	let month = parseInt(code.slice(2, 4), 10)
+	let year = parseInt(code.slice(0, 2), 10)
+
+	// Determine the century based on the month encoding
+	if (month >= 1 && month <= 12) {
+		year += 1900
+	} else if (month >= 21 && month <= 32) {
+		year += 2000
+		month -= 20
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3]
+	const digits = code.slice(0, 10).split('').map(Number)
+
+	const sum = digits.reduce((acc, digit, index) => acc + digit * weights[index], 0)
+
+	const expectedChecksum = (10 - (sum % 10)) % 10
+
+	return expectedChecksum === parseInt(code[10], 10)
+}

package/src/parsers/sweden.ts

@@ -0,0 +1,59 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function swedenParser(code: string): ParsedDate | null {
+	code = code.replace('-', '')
+
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	let year: number
+	let month: number
+	let day: number
+
+	if (code.length === 12) {
+		year = parseInt(code.slice(0, 4), 10)
+		month = parseInt(code.slice(4, 6), 10)
+		day = parseInt(code.slice(6, 8), 10)
+	} else {
+		year = parseInt(code.slice(0, 2), 10)
+		month = parseInt(code.slice(2, 4), 10)
+		day = parseInt(code.slice(4, 6), 10)
+
+		if (new Date().getFullYear() - (1900 + year) > 99) {
+			year += 2000
+		} else {
+			year += 1900
+		}
+	}
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string) {
+	// Use the last 9 digits without checksum number
+	const digits = code.length === 12 ? code.slice(2, 11) : code.slice(0, 9)
+
+	let sum = 0
+	for (let i = 0; i < digits.length; i++) {
+		let digit = parseInt(digits[i])
+
+		if (i % 2 === 0) {
+			digit *= 2
+
+			if (digit > 9) {
+				digit -= 9
+			}
+		}
+
+		sum += digit
+	}
+	const expectedChecksum = (10 - (sum % 10)) % 10
+
+	return expectedChecksum === Number(code[code.length - 1])
+}

package/src/parsers/ukraine.ts

@@ -0,0 +1,40 @@
+import { ParsedDate } from '../types'
+import { isValidDate } from '../utils'
+
+export default function ukrainianParser(code: string): ParsedDate | null {
+	if (!isValidChecksum(code)) {
+		return null
+	}
+
+	// The first 5 digits represent the number of days since 31-12-1899
+	const daysSinceBaseDate = parseInt(code.slice(0, 5), 10)
+	const baseDate = new Date(1899, 11, 31) // Dec 31, 1899
+
+	// Calculate the birthdate from the number of days since the base date
+	const birthDate = new Date(baseDate.getTime() + daysSinceBaseDate * 24 * 60 * 60 * 1000)
+
+	const day = birthDate.getDate()
+	const month = birthDate.getMonth() + 1 // getMonth is zero-based
+	const year = birthDate.getFullYear()
+
+	if (!isValidDate(day, month, year)) {
+		return null
+	}
+
+	return { day, month, year }
+}
+
+function isValidChecksum(code: string): boolean {
+	const digits = code.slice(0, 9).split('').map(Number)
+
+	const weights = [-1, 5, 7, 9, 4, 6, 10, 5, 7]
+	const controlSum = digits.reduce((sum, digit, index) => sum + digit * weights[index], 0)
+
+	let controlNumber = controlSum % 11
+
+	if (controlNumber === 10) {
+		controlNumber = 0
+	}
+
+	return controlNumber === parseInt(code[9], 10)
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+export interface ParsedDate {
+	day: number
+	month: number
+	year: number
+}

package/src/utils.ts

@@ -0,0 +1,9 @@
+export function isValidDate(day: number, month: number, year: number): boolean {
+	const date = new Date(year, month - 1, day) // month is zero-indexed in JS Date
+
+	if (year < 1900 || year > new Date().getFullYear()) {
+		return false
+	}
+
+	return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day
+}

package/tsconfig.json

@@ -3,7 +3,7 @@
 	"compilerOptions": {
 		"target": "ES2022",
 		"module": "NodeNext",
-		"rootDir": "./",
+		"rootDir": "./src",
 		"moduleResolution": "NodeNext",
 		"baseUrl": "./",
 		"sourceMap": true,

package/index.test.ts

@@ -1,79 +0,0 @@
-import personalCodeToBirthday from './index'
-
-describe('valid codes', () => {
-	test('Estonia', () => {
-		expect(personalCodeToBirthday('39405280299')).toEqual({ day: 28, month: 5, year: 1994 })
-		expect(personalCodeToBirthday('60105280299')).toEqual({ day: 28, month: 5, year: 2001 })
-	})
-
-	test('Latvia', () => {
-		expect(personalCodeToBirthday('050393-12344')).toEqual({ day: 5, month: 3, year: 1993 })
-		expect(personalCodeToBirthday('050303-22344')).toEqual({ day: 5, month: 3, year: 2003 })
-	})
-
-	test('Lithuania', () => {
-		expect(personalCodeToBirthday('39905280217')).toEqual({ day: 28, month: 5, year: 1999 })
-	})
-
-	test('Finland', () => {
-		expect(personalCodeToBirthday('101085-7001')).toEqual({ day: 10, month: 10, year: 1985 })
-		expect(personalCodeToBirthday('101085+789W')).toEqual({ day: 10, month: 10, year: 1885 })
-		expect(personalCodeToBirthday('150752-308N')).toEqual({ day: 15, month: 7, year: 1952 })
-		expect(personalCodeToBirthday('010100A123D')).toEqual({ day: 1, month: 1, year: 2000 })
-	})
-
-	test('Sweden', () => {
-		expect(personalCodeToBirthday('199001011234')).toEqual({ day: 1, month: 1, year: 1990 })
-	})
-
-	test('Norway', () => {
-		expect(personalCodeToBirthday('01020352345')).toEqual({ day: 1, month: 2, year: 2003 })
-	})
-
-	test('Denmark', () => {
-		expect(personalCodeToBirthday('0503054567')).toEqual({ day: 5, month: 3, year: 2005 })
-		expect(personalCodeToBirthday('0503841235')).toEqual({ day: 5, month: 3, year: 1984 })
-		expect(personalCodeToBirthday('050384-1235')).toEqual({ day: 5, month: 3, year: 1984 })
-		expect(personalCodeToBirthday('0503844567')).toEqual({ day: 5, month: 3, year: 1984 })
-	})
-})
-
-describe('invalid personal code', () => {
-	test('Estonia', () => {
-		const result = personalCodeToBirthday('39913025555')
-		expect(result).toBeNull()
-	})
-
-	test('Latvia', () => {
-		expect(personalCodeToBirthday('123456-12345')).toBeNull()
-	})
-
-	test('Lithuania', () => {
-		expect(personalCodeToBirthday('99905280217')).toBeNull()
-	})
-
-	test('Finland', () => {
-		expect(personalCodeToBirthday('999999A123T')).toBeNull()
-		expect(personalCodeToBirthday('131052Z3087')).toBeNull()
-		expect(personalCodeToBirthday('321052A3087')).toBeNull()
-	})
-
-	test('Sweden', () => {
-		expect(personalCodeToBirthday('1990010123456')).toBeNull()
-		expect(personalCodeToBirthday('199013011234')).toBeNull()
-		expect(personalCodeToBirthday('199001341234')).toBeNull()
-	})
-
-	test('Norway', () => {
-		expect(personalCodeToBirthday('32129999999')).toBeNull()
-	})
-
-	test('Denmark', () => {
-		expect(personalCodeToBirthday('9999991234')).toBeNull()
-	})
-
-	test('unsupported personal code format', () => {
-		const result = personalCodeToBirthday('abcd1234')
-		expect(result).toBeNull()
-	})
-})

package/index.ts

@@ -1,192 +0,0 @@
-interface ParsedDate {
-	day: number
-	month: number
-	year: number
-}
-
-export default function personalCodeToBirthday(code: string): ParsedDate | null {
-	if (/^\d{11}$/.test(code)) {
-		// Could be Estonia, Lithuania, or Norway
-		const birthday = estonianLithuanianParser(code)
-		if (birthday) {
-			return birthday
-		}
-
-		return norwayParser(code)
-	} else if (/^\d{6}-\d{5}$/.test(code)) {
-		return latvianParser(code)
-	} else if (/^\d{6}[+-A]\d{3}[A-Za-z]$/.test(code)) {
-		return finlandParser(code)
-	} else if (/^\d{6}[+-A]\d{4}$/.test(code)) {
-		// Could be Finland or Denmark
-		const birthday = finlandParser(code)
-		if (birthday) {
-			return birthday
-		}
-
-		return denmarkParser(code)
-	} else if (/^\d{12}$/.test(code)) {
-		return swedenParser(code)
-	} else if (/^\d{10}$/.test(code)) {
-		return denmarkParser(code)
-	}
-
-	return null
-}
-
-// Estonia (EE) and Lithuanian (LT) Parser
-function estonianLithuanianParser(code: string): ParsedDate | null {
-	const centuryCode = parseInt(code[0], 10)
-	const day = parseInt(code.slice(5, 7), 10)
-	const month = parseInt(code.slice(3, 5), 10)
-	let year = parseInt(code.slice(1, 3), 10)
-
-	if (centuryCode === 3 || centuryCode === 4) {
-		year += 1900
-	}
-	if (centuryCode === 5 || centuryCode === 6) {
-		year += 2000
-	}
-
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Latvia (LV) Parser
-// Correct old school format is DDMMYY-CXXXX
-function latvianParser(code: string): ParsedDate | null {
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	let year = parseInt(code.slice(4, 6), 10)
-	const centuryCode = parseInt(code[7], 10)
-
-	// Latvian codes are always from the 20th century, so add 1900
-	if (centuryCode === 2) {
-		year += 2000
-	} else {
-		year += 1900
-	}
-
-	// Validate the parsed date
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Finland (FI) Parser
-function finlandParser(code: string): ParsedDate | null {
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	const yearSuffix = parseInt(code.slice(4, 6), 10)
-	const centuryMarker = code[6]
-
-	let year = yearSuffix
-
-	// Handle the century based on the marker
-	if (centuryMarker === '+') {
-		year += 1800
-	} else if (centuryMarker === '-') {
-		year += 1900
-	} else if (centuryMarker === 'A') {
-		year += 2000
-	}
-
-	// Validate the parsed date
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	if (!isValidFinnishChecksum(code)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-function isValidFinnishChecksum(code: string): boolean {
-	const validChars = '0123456789ABCDEFHJKLMNPRSTUVWXY'
-
-	const serial = code.slice(0, 6) + code.slice(7, 10)
-	const checksum = code[10]
-	const num = parseInt(serial, 10)
-	const remainder = num % 31
-	const expectedChecksum = validChars.charAt(remainder)
-
-	return expectedChecksum === checksum.toUpperCase()
-}
-
-// Sweden (SE) Parser
-function swedenParser(code: string): ParsedDate | null {
-	const year = parseInt(code.slice(0, 4), 10)
-	const month = parseInt(code.slice(4, 6), 10)
-	const day = parseInt(code.slice(6, 8), 10)
-
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Norway (NO) Parser
-function norwayParser(code: string): ParsedDate | null {
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	let year = parseInt(code.slice(4, 6), 10)
-
-	const individual = parseInt(code.slice(6, 9), 10)
-
-	// Determine century based on individual number and year
-	if (individual <= 499 || (individual >= 500 && year >= 40)) {
-		year += 1900
-	} else if (individual <= 999 && year <= 39) {
-		year += 2000
-	}
-
-	// Now validate the date after adjusting the century
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-// Denmark (DK) Parser
-function denmarkParser(code: string): ParsedDate | null {
-	if (code.includes('-')) {
-		code = code.replace('-', '')
-	}
-
-	const day = parseInt(code.slice(0, 2), 10)
-	const month = parseInt(code.slice(2, 4), 10)
-	let year = parseInt(code.slice(4, 6), 10)
-	const centuryIndicator = parseInt(code.slice(6, 7), 10)
-
-	// Determine century based on the 7th digit and the year
-	if (centuryIndicator >= 0 && centuryIndicator <= 3) {
-		year += 1900
-	} else if (centuryIndicator >= 4 && centuryIndicator <= 9) {
-		if (year >= 0 && year <= 36) {
-			year += 2000
-		} else {
-			year += 1900
-		}
-	}
-
-	if (!isValidDate(day, month, year)) {
-		return null
-	}
-
-	return { day, month, year }
-}
-
-function isValidDate(day: number, month: number, year: number): boolean {
-	const date = new Date(year, month - 1, day) // month is zero-indexed in JS Date
-
-	return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day
-}

package/prettier.config.js

@@ -1 +0,0 @@
-module.exports = require("@remato/prettier-config");