@handijit/tr 0.0.0-stage → 1.0.0

package/build/index.cjs

@@ -0,0 +1,789 @@
+'use strict';
+
+/** Names a value for an error message; `typeof null` alone would say "object". */
+const describeValue = (value) => value === null ? "null" : typeof value;
+
+/** Throws when a required text argument is not a primitive string. */
+const assertString = (value, source) => {
+    if (typeof value !== "string") {
+        throw new TypeError(`${source}: expected a string, received ${describeValue(value)}`);
+    }
+};
+
+const DOTTED_SMALL_I = /i/g;
+/** Upper-cases text by the Turkish rule: "i" becomes "İ" and "ı" becomes "I". */
+const toUpperCase = (text) => {
+    assertString(text, "toUpperCase");
+    // Only the dotted "i" differs from the default mapping ("ı" already maps to "I"), so the
+    // result does not depend on the locale data the engine was built with.
+    return text.replace(DOTTED_SMALL_I, "İ").toUpperCase();
+};
+
+/** Upper-cases the first letter by the Turkish rule and leaves the rest as written. */
+const capitalize = (text) => {
+    assertString(text, "capitalize");
+    const firstCodePoint = text.codePointAt(0);
+    if (firstCodePoint === undefined)
+        return "";
+    // By code point, so a first character outside the BMP is not cut in half.
+    const first = String.fromCodePoint(firstCodePoint);
+    return toUpperCase(first) + text.slice(first.length);
+};
+
+// "İ" and its decomposed spelling "I" + combining dot above. The default mapping would turn
+// "İ" into "i" followed by a stray combining dot.
+const DOTTED_CAPITAL_I = /İ|İ/g;
+const DOTLESS_CAPITAL_I = /I/g;
+/** Lower-cases text by the Turkish rule: "I" becomes "ı" and "İ" becomes "i". */
+const toLowerCase = (text) => {
+    assertString(text, "toLowerCase");
+    return text
+        .replace(DOTTED_CAPITAL_I, "i")
+        .replace(DOTLESS_CAPITAL_I, "ı")
+        .toLowerCase();
+};
+
+// The 29 letters in dictionary order, with q, w and x where Latin loanwords put them.
+const ALPHABET = "abcçdefgğhıijklmnoöpqrsştuüvwxyz";
+const COMBINING_MARK = /\p{M}/u;
+const FIRST_NON_ASCII = 128;
+const DIGIT_ZERO$3 = 48;
+const DIGIT_NINE = 57;
+// Weight bands: ASCII punctuation, then digits, then letters, then every other character.
+const DIGIT_BAND = 1_000;
+const LETTER_BAND = 2_000;
+const OTHER_BAND = 3_000;
+// A combining mark that survived composition weighs nothing at the letter level.
+const IGNORED = -1;
+const weightOf = (character) => {
+    const rank = ALPHABET.indexOf(character);
+    if (rank >= 0)
+        return LETTER_BAND + rank;
+    const codePoint = character.codePointAt(0);
+    if (codePoint < FIRST_NON_ASCII) {
+        return codePoint >= DIGIT_ZERO$3 && codePoint <= DIGIT_NINE
+            ? DIGIT_BAND + codePoint
+            : codePoint;
+    }
+    if (COMBINING_MARK.test(character))
+        return IGNORED;
+    // An accented letter sorts with its base letter ("â" with "a"); the accent only breaks ties.
+    const baseRank = ALPHABET.indexOf(character.normalize("NFD").charAt(0));
+    return baseRank >= 0 ? LETTER_BAND + baseRank : OTHER_BAND + codePoint;
+};
+const weigh = (text) => {
+    const weights = [];
+    for (const character of text) {
+        const weight = weightOf(character);
+        if (weight !== IGNORED)
+            weights.push(weight);
+    }
+    return weights;
+};
+// "0" for a character that is already lower case, "1" otherwise: lower case sorts first.
+const caseKeyOf = (text) => {
+    let caseKey = "";
+    for (const character of text) {
+        caseKey += toLowerCase(character) === character ? "0" : "1";
+    }
+    return caseKey;
+};
+/**
+ * Compares two texts in Turkish alphabetical order ("ç" after "c", "ı" before "i") for
+ * `Array.prototype.sort`; case and accents only break ties, lower case first.
+ */
+const compareTurkish = (left, right) => {
+    assertString(left, "compareTurkish");
+    assertString(right, "compareTurkish");
+    // Composed form, so "ö" typed as "o" + diaeresis is the same letter.
+    const leftText = left.normalize("NFC");
+    const rightText = right.normalize("NFC");
+    if (leftText === rightText)
+        return 0;
+    const leftLower = toLowerCase(leftText);
+    const rightLower = toLowerCase(rightText);
+    const leftWeights = weigh(leftLower);
+    const rightWeights = weigh(rightLower);
+    const sharedLength = Math.min(leftWeights.length, rightWeights.length);
+    for (let i = 0; i < sharedLength; i += 1) {
+        const difference = leftWeights[i] - rightWeights[i];
+        if (difference !== 0)
+            return difference < 0 ? -1 : 1;
+    }
+    if (leftWeights.length !== rightWeights.length) {
+        return leftWeights.length < rightWeights.length ? -1 : 1;
+    }
+    // Same letters. An accent decides next ("kar" before "kâr"), then case ("ali" before "Ali").
+    if (leftLower !== rightLower)
+        return leftLower < rightLower ? -1 : 1;
+    const leftCase = caseKeyOf(leftText);
+    const rightCase = caseKeyOf(rightText);
+    if (leftCase !== rightCase)
+        return leftCase < rightCase ? -1 : 1;
+    // Two capital forms of one letter ("DŽ" and "Dž"): code units keep the order total.
+    return leftText < rightText ? -1 : 1;
+};
+
+/**
+ * Turkish day names, Monday first as on a Turkish calendar: `DAY_NAMES[0]` is "Pazartesi".
+ * This is not the order of `Date.prototype.getDay`, where 0 is Sunday.
+ */
+const DAY_NAMES = /* @__PURE__ */ Object.freeze([
+    "Pazartesi",
+    "Salı",
+    "Çarşamba",
+    "Perşembe",
+    "Cuma",
+    "Cumartesi",
+    "Pazar",
+]);
+
+const DOTLESS_SMALL_I = /ı/g;
+const COMBINING_MARKS = /[̀-ͯ]/g;
+/** Folds text to a search key: Turkish lower case, then "ç ğ ı ö ş ü" and accents to plain letters. */
+const foldText = (text) => {
+    assertString(text, "foldText");
+    // "ı" has no decomposition, so it is mapped by hand; the other letters lose their marks.
+    return toLowerCase(text)
+        .replace(DOTLESS_SMALL_I, "i")
+        .normalize("NFD")
+        .replace(COMBINING_MARKS, "");
+};
+
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const isLeapYear = (year) => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+/** Tells whether year, month and day name a day that exists (years 1 to 9999). */
+const isRealDate = (year, month, day) => {
+    if (year < 1 || year > 9999 || month < 1 || month > 12 || day < 1) {
+        return false;
+    }
+    const lastDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= lastDay;
+};
+
+/** Left-pads a non-negative whole number with zeros: (7, 2) → "07". */
+const padNumber = (value, length) => String(value).padStart(length, "0");
+
+const DEFAULT_TIME_ZONE = "Europe/Istanbul";
+const ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+// 0001-01-02T00:00Z and 9999-12-30T23:59:59.999Z. The one-day margin keeps the year inside
+// 1 to 9999 in every time zone, so the text never needs an era or a fifth year digit.
+const MIN_TIMESTAMP = -621355104e5;
+const MAX_TIMESTAMP = 253402214399999;
+// Building an Intl.DateTimeFormat costs far more than using one, so they are reused; the cap
+// keeps a caller that walks every zone from growing the cache without bound.
+const MAX_CACHED_FORMATTERS = 8;
+const MAX_ECHOED_LENGTH = 32;
+const formatters = /* @__PURE__ */ new Map();
+const getFormatter = (timeZone, source) => {
+    const cached = formatters.get(timeZone);
+    if (cached !== undefined)
+        return cached;
+    let formatter;
+    try {
+        // Intl only moves the instant into the zone; the fixed locale, calendar, digits and hour
+        // cycle make the parts plain numbers that read the same on every engine.
+        formatter = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            calendar: "gregory",
+            numberingSystem: "latn",
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+    }
+    catch {
+        throw new RangeError(`${source}: unknown time zone "${timeZone.slice(0, MAX_ECHOED_LENGTH)}", expected an IANA name like "Europe/Istanbul"`);
+    }
+    if (formatters.size >= MAX_CACHED_FORMATTERS) {
+        formatters.delete(formatters.keys().next().value);
+    }
+    formatters.set(timeZone, formatter);
+    return formatter;
+};
+const toTimestamp = (date, source) => {
+    let timestamp;
+    if (typeof date === "number") {
+        timestamp = date;
+    }
+    else {
+        try {
+            // Reads the internal time value, so a Date from another realm (an iframe, an Electron
+            // context) passes and a look-alike object does not.
+            timestamp = Date.prototype.getTime.call(date);
+        }
+        catch {
+            throw new TypeError(`${source}: expected a Date or a timestamp in milliseconds, received ${describeValue(date)}`);
+        }
+    }
+    if (Number.isNaN(timestamp)) {
+        throw new RangeError(`${source}: received an invalid date`);
+    }
+    if (timestamp < MIN_TIMESTAMP || timestamp > MAX_TIMESTAMP) {
+        throw new RangeError(`${source}: the date is outside the supported years 0001 to 9999`);
+    }
+    return timestamp;
+};
+/** Reads the wall-clock date and time an instant has in a time zone. */
+const readInstant = (date, timeZone, source) => {
+    const timestamp = toTimestamp(date, source);
+    if (typeof timeZone !== "string") {
+        throw new TypeError(`${source}: expected timeZone to be a string, received ${describeValue(timeZone)}`);
+    }
+    const fields = {};
+    for (const part of getFormatter(timeZone, source).formatToParts(timestamp)) {
+        fields[part.type] = part.value;
+    }
+    return {
+        year: Number(fields.year),
+        month: Number(fields.month),
+        day: Number(fields.day),
+        hour: Number(fields.hour),
+        minute: Number(fields.minute),
+    };
+};
+/**
+ * Reads a calendar date: a "yyyy-MM-dd" string is taken as written (a business date has no
+ * time zone), anything else is an instant read in `timeZone`.
+ */
+const readCalendarDate = (date, timeZone, source) => {
+    if (typeof date !== "string")
+        return readInstant(date, timeZone, source);
+    const match = ISO_DATE_PATTERN.exec(date);
+    if (match !== null) {
+        const year = Number(match[1]);
+        const month = Number(match[2]);
+        const day = Number(match[3]);
+        if (isRealDate(year, month, day))
+            return { year, month, day };
+    }
+    throw new RangeError(`${source}: expected a real calendar date like "2026-11-10", received "${date.slice(0, MAX_ECHOED_LENGTH)}"`);
+};
+/** Writes a calendar date as "dd.MM.yyyy". */
+const toDottedDate = ({ year, month, day }) => `${padNumber(day, 2)}.${padNumber(month, 2)}.${padNumber(year, 4)}`;
+
+/**
+ * Writes a date as "dd.MM.yyyy". A `Date` or a timestamp is read in `timeZone`; a
+ * "yyyy-MM-dd" string is a calendar date already and is written as it stands.
+ */
+const formatDate = (date, { timeZone = DEFAULT_TIME_ZONE } = {}) => toDottedDate(readCalendarDate(date, timeZone, "formatDate"));
+
+/** Writes an instant as "dd.MM.yyyy HH:mm" on the 24-hour clock of `timeZone`. */
+const formatDateTime = (date, { timeZone = DEFAULT_TIME_ZONE } = {}) => {
+    const instant = readInstant(date, timeZone, "formatDateTime");
+    return `${toDottedDate(instant)} ${padNumber(instant.hour, 2)}:${padNumber(instant.minute, 2)}`;
+};
+
+const WHITESPACE = /\s+/g;
+/** Drops every whitespace character, including the no-break spaces of pasted text. */
+const stripWhitespace = (value) => value.replace(WHITESPACE, "");
+
+const TR_IBAN_PATTERN = /^TR\d{24}$/;
+// "TR" as IBAN letter values: T = 29, R = 27.
+const COUNTRY_DIGITS = "2927";
+const DIGIT_ZERO$2 = 48;
+/** Returns the compact upper-case form of a valid Turkish IBAN, or `null`. */
+const parseIban = (value) => {
+    const iban = stripWhitespace(value).toUpperCase();
+    if (!TR_IBAN_PATTERN.test(iban))
+        return null;
+    // ISO 13616: move the first four characters to the end and read the result as one number mod 97.
+    // The number has 30 digits, so the remainder is carried digit by digit instead of parsing it.
+    const rearranged = `${iban.slice(4)}${COUNTRY_DIGITS}${iban.slice(2, 4)}`;
+    let remainder = 0;
+    for (let i = 0; i < rearranged.length; i += 1) {
+        remainder = (remainder * 10 + rearranged.charCodeAt(i) - DIGIT_ZERO$2) % 97;
+    }
+    return remainder === 1 ? iban : null;
+};
+
+const FOUR_CHARACTERS = /.{4}(?=.)/g;
+/** Returns a valid Turkish IBAN in printed groups of four ("TR33 0006 1005 …"), or `null`. */
+const formatIban = (value) => {
+    assertString(value, "formatIban");
+    const iban = parseIban(value);
+    return iban === null ? null : iban.replace(FOUR_CHARACTERS, "$& ");
+};
+
+/** Throws unless the amount is a whole number of kuruş that a double holds exactly. */
+const assertKurus = (value, source) => {
+    if (typeof value !== "number") {
+        throw new TypeError(`${source}: expected an amount in kuruş as a number, received ${describeValue(value)}`);
+    }
+    // A fraction or an unsafe integer has already lost kuruş; printing it would invent an amount.
+    if (!Number.isSafeInteger(value)) {
+        throw new RangeError(`${source}: expected a whole number of kuruş within the safe integer range, received ${value}`);
+    }
+};
+
+const GROUP_SIZE = 3;
+const groupThousands = (digits) => {
+    let grouped = "";
+    for (let end = digits.length; end > 0; end -= GROUP_SIZE) {
+        const group = digits.slice(Math.max(0, end - GROUP_SIZE), end);
+        grouped = grouped === "" ? group : `${group}.${grouped}`;
+    }
+    return grouped;
+};
+/** Writes an amount held in whole kuruş as Turkish lira: 349000 → "3.490,00 TL". */
+const formatMoney = (kurus, { symbol = false } = {}) => {
+    assertKurus(kurus, "formatMoney");
+    const absolute = Math.abs(kurus);
+    // Remainder first, then an exact subtraction: dividing a large amount by 100 directly
+    // rounds, and a rounded lira part would print a different number.
+    const kurusPart = absolute % 100;
+    const liraPart = (absolute - kurusPart) / 100;
+    const amount = `${groupThousands(String(liraPart))},${padNumber(kurusPart, 2)}`;
+    // `kurus < 0` is false for -0, so a zero never carries a sign.
+    const sign = kurus < 0 ? "-" : "";
+    return symbol === true ? `${sign}₺${amount}` : `${sign}${amount} TL`;
+};
+
+const ALLOWED_CHARACTERS = /^\+?[\d\s().-]+$/;
+const NON_DIGITS = /\D/g;
+// With "+" the country code is mandatory; without it the trunk "0", "90" and "0090" are optional.
+const INTERNATIONAL_DIGITS = /^90([2-58]\d{9})$/;
+const DOMESTIC_DIGITS = /^(?:0090|90|0)?([2-58]\d{9})$/;
+const typeOf = (national) => {
+    const leadingDigit = national.charAt(0);
+    if (leadingDigit === "5")
+        return "mobile";
+    if (leadingDigit === "8")
+        return "nonGeographic";
+    return "landline";
+};
+/** Reads a Turkish phone number in any common spelling, or returns `null`. */
+const parsePhone = (value) => {
+    const trimmed = value.trim();
+    if (!ALLOWED_CHARACTERS.test(trimmed))
+        return null;
+    const digits = trimmed.replace(NON_DIGITS, "");
+    const pattern = trimmed.startsWith("+")
+        ? INTERNATIONAL_DIGITS
+        : DOMESTIC_DIGITS;
+    const national = pattern.exec(digits)?.[1];
+    if (national === undefined)
+        return null;
+    return { national, type: typeOf(national) };
+};
+
+/** Returns a Turkish phone number in its printed form, or `null`. */
+const formatPhone = (value, { style = "national" } = {}) => {
+    assertString(value, "formatPhone");
+    const phone = parsePhone(value);
+    if (phone === null)
+        return null;
+    const areaCode = phone.national.slice(0, 3);
+    const subscriber = `${phone.national.slice(3, 6)} ${phone.national.slice(6, 8)} ${phone.national.slice(8)}`;
+    // Any style other than "international" is the documented default, never a third layout.
+    return style === "international"
+        ? `+90 ${areaCode} ${subscriber}`
+        : `0 (${areaCode}) ${subscriber}`;
+};
+
+/** Returns the Turkish name of the day of the week a date falls on, such as "Salı". */
+const getDayName = (date, { timeZone = DEFAULT_TIME_ZONE } = {}) => {
+    const { year, month, day } = readCalendarDate(date, timeZone, "getDayName");
+    // setUTCFullYear, because Date.UTC reads the years 0 to 99 as 1900 to 1999.
+    const calendarDay = new Date(0);
+    calendarDay.setUTCFullYear(year, month - 1, day);
+    // getUTCDay counts from Sunday, DAY_NAMES from Monday.
+    return DAY_NAMES[(calendarDay.getUTCDay() + 6) % 7];
+};
+
+/** Turkish month names, January first: `MONTH_NAMES[0]` is "Ocak". */
+const MONTH_NAMES = /* @__PURE__ */ Object.freeze([
+    "Ocak",
+    "Şubat",
+    "Mart",
+    "Nisan",
+    "Mayıs",
+    "Haziran",
+    "Temmuz",
+    "Ağustos",
+    "Eylül",
+    "Ekim",
+    "Kasım",
+    "Aralık",
+]);
+
+/** Returns the Turkish name of the month a date falls in, such as "Kasım". */
+const getMonthName = (date, { timeZone = DEFAULT_TIME_ZONE } = {}) => {
+    const { month } = readCalendarDate(date, timeZone, "getMonthName");
+    return MONTH_NAMES[month - 1];
+};
+
+/** Tells a mobile number (5XX) from a landline (2XX to 4XX) and a service number (8XX), or returns `null`. */
+const getPhoneType = (value) => {
+    assertString(value, "getPhoneType");
+    return parsePhone(value)?.type ?? null;
+};
+
+// In plate-code order: the name at index 0 belongs to code 01.
+const PROVINCE_NAMES = [
+    "Adana",
+    "Adıyaman",
+    "Afyonkarahisar",
+    "Ağrı",
+    "Amasya",
+    "Ankara",
+    "Antalya",
+    "Artvin",
+    "Aydın",
+    "Balıkesir",
+    "Bilecik",
+    "Bingöl",
+    "Bitlis",
+    "Bolu",
+    "Burdur",
+    "Bursa",
+    "Çanakkale",
+    "Çankırı",
+    "Çorum",
+    "Denizli",
+    "Diyarbakır",
+    "Edirne",
+    "Elazığ",
+    "Erzincan",
+    "Erzurum",
+    "Eskişehir",
+    "Gaziantep",
+    "Giresun",
+    "Gümüşhane",
+    "Hakkari",
+    "Hatay",
+    "Isparta",
+    "Mersin",
+    "İstanbul",
+    "İzmir",
+    "Kars",
+    "Kastamonu",
+    "Kayseri",
+    "Kırklareli",
+    "Kırşehir",
+    "Kocaeli",
+    "Konya",
+    "Kütahya",
+    "Malatya",
+    "Manisa",
+    "Kahramanmaraş",
+    "Mardin",
+    "Muğla",
+    "Muş",
+    "Nevşehir",
+    "Niğde",
+    "Ordu",
+    "Rize",
+    "Sakarya",
+    "Samsun",
+    "Siirt",
+    "Sinop",
+    "Sivas",
+    "Tekirdağ",
+    "Tokat",
+    "Trabzon",
+    "Tunceli",
+    "Şanlıurfa",
+    "Uşak",
+    "Van",
+    "Yozgat",
+    "Zonguldak",
+    "Aksaray",
+    "Bayburt",
+    "Karaman",
+    "Kırıkkale",
+    "Batman",
+    "Şırnak",
+    "Bartın",
+    "Ardahan",
+    "Iğdır",
+    "Yalova",
+    "Karabük",
+    "Kilis",
+    "Osmaniye",
+    "Düzce",
+];
+// Frozen all the way down: every consumer shares this one list, so nobody may edit it.
+const buildProvinces = () => Object.freeze(PROVINCE_NAMES.map((name, index) => Object.freeze({ code: index + 1, name })));
+/** The 81 provinces of Turkey in plate-code order: `PROVINCES[0]` is Adana, code 1. */
+const PROVINCES = /* @__PURE__ */ buildProvinces();
+
+const CODE_PATTERN = /^\d{1,2}$/;
+/** Finds a province by its plate code, given as a number (6) or as text ("06"), or returns `null`. */
+const getProvinceByCode = (code) => {
+    if (typeof code === "string") {
+        const text = code.trim();
+        return CODE_PATTERN.test(text)
+            ? (PROVINCES[Number(text) - 1] ?? null)
+            : null;
+    }
+    if (typeof code !== "number") {
+        throw new TypeError(`getProvinceByCode: expected a plate code as a number or a string, received ${describeValue(code)}`);
+    }
+    // A fraction, NaN or a code outside 1 to 81 names no index of the list.
+    return PROVINCES[code - 1] ?? null;
+};
+
+// Built on the first lookup and never grown: 81 entries. Building it at import time would
+// run code in every bundle that merely imports the package.
+let provincesByFoldedName;
+/**
+ * Finds a province by name without regard to case or Turkish letters ("istanbul", "ISTANBUL"
+ * and "İstanbul" all match), or returns `null`.
+ */
+const getProvinceByName = (name) => {
+    assertString(name, "getProvinceByName");
+    provincesByFoldedName ??= new Map(PROVINCES.map((province) => [foldText(province.name), province]));
+    return provincesByFoldedName.get(foldText(name.trim())) ?? null;
+};
+
+/** Checks a Turkish IBAN: "TR", 24 digits and the ISO 13616 mod-97 checksum. */
+const isValidIban = (value) => typeof value === "string" && parseIban(value) !== null;
+
+// Province code 01 to 81, then one of the six civil layouts: one letter with four or five
+// digits, two letters with three or four, three letters with two or three. Plates use the
+// 23 letters left after Ç, Ğ, İ, Ö, Ş, Ü and Q, W, X are taken out.
+const LICENSE_PLATE_PATTERN = /^(?:0[1-9]|[1-7]\d|8[01])\s*(?:[A-PR-VYZa-pr-vyz]\s*\d{4,5}|[A-PR-VYZa-pr-vyz]{2}\s*\d{3,4}|[A-PR-VYZa-pr-vyz]{3}\s*\d{2,3})$/;
+/**
+ * Checks that a value has the shape of a civil Turkish licence plate ("34 ABC 123"). Only
+ * the shape is checked: whether the plate was ever issued is not something a format can tell.
+ */
+const isValidLicensePlate = (value) => typeof value === "string" && LICENSE_PLATE_PATTERN.test(value.trim());
+
+/** Checks that a value is a Turkish mobile, landline or 8XX service number. */
+const isValidPhone = (value) => typeof value === "string" && parsePhone(value) !== null;
+
+const TCKN_PATTERN = /^[1-9]\d{10}$/;
+const DIGIT_ZERO$1 = 48;
+/** Checks the two check digits of a T.C. identity number (11 digits, the first not 0). */
+const isValidTckn = (value) => {
+    if (typeof value !== "string")
+        return false;
+    const tckn = stripWhitespace(value);
+    if (!TCKN_PATTERN.test(tckn))
+        return false;
+    const digitAt = (index) => tckn.charCodeAt(index) - DIGIT_ZERO$1;
+    const oddSum = digitAt(0) + digitAt(2) + digitAt(4) + digitAt(6) + digitAt(8);
+    const evenSum = digitAt(1) + digitAt(3) + digitAt(5) + digitAt(7);
+    // The subtraction can go below zero; a plain % would then hand back a negative digit.
+    const tenth = (((oddSum * 7 - evenSum) % 10) + 10) % 10;
+    const eleventh = (oddSum + evenSum + digitAt(9)) % 10;
+    return digitAt(9) === tenth && digitAt(10) === eleventh;
+};
+
+const VKN_PATTERN = /^\d{10}$/;
+const DIGIT_ZERO = 48;
+/** Checks the check digit of a tax identification number (VKN, 10 digits). */
+const isValidVkn = (value) => {
+    if (typeof value !== "string")
+        return false;
+    const vkn = stripWhitespace(value);
+    if (!VKN_PATTERN.test(vkn))
+        return false;
+    let sum = 0;
+    for (let i = 0; i < 9; i += 1) {
+        const shifted = (vkn.charCodeAt(i) - DIGIT_ZERO + 9 - i) % 10;
+        const weighted = (shifted * 2 ** (9 - i)) % 9;
+        // A shifted 9 is a multiple of nine; the algorithm counts it as 9, not as 0.
+        sum += shifted !== 0 && weighted === 0 ? 9 : weighted;
+    }
+    return (10 - (sum % 10)) % 10 === vkn.charCodeAt(9) - DIGIT_ZERO;
+};
+
+const ONES = [
+    "",
+    "bir",
+    "iki",
+    "üç",
+    "dört",
+    "beş",
+    "altı",
+    "yedi",
+    "sekiz",
+    "dokuz",
+];
+const TENS = [
+    "",
+    "on",
+    "yirmi",
+    "otuz",
+    "kırk",
+    "elli",
+    "altmış",
+    "yetmiş",
+    "seksen",
+    "doksan",
+];
+// The largest safe amount is about 90 trilyon lira, so the list never runs out.
+const SCALES = ["", "bin", "milyon", "milyar", "trilyon"];
+const groupToWords = (group) => {
+    const hundreds = Math.floor(group / 100);
+    const tens = Math.floor((group % 100) / 10);
+    const ones = group % 10;
+    const words = [];
+    // Turkish says "yüz", never "bir yüz".
+    if (hundreds > 1)
+        words.push(ONES[hundreds]);
+    if (hundreds > 0)
+        words.push("yüz");
+    if (tens > 0)
+        words.push(TENS[tens]);
+    if (ones > 0)
+        words.push(ONES[ones]);
+    return words;
+};
+const numberToWords = (value) => {
+    if (value === 0)
+        return "sıfır";
+    const words = [];
+    let remaining = value;
+    for (let scale = 0; remaining > 0; scale += 1) {
+        const group = remaining % 1000;
+        remaining = (remaining - group) / 1000;
+        if (group === 0)
+            continue;
+        const groupWords = groupToWords(group);
+        // "bin", never "bir bin"; every larger scale keeps its "bir" ("bir milyon").
+        if (scale === 1 && group === 1)
+            groupWords.length = 0;
+        if (scale > 0)
+            groupWords.push(SCALES[scale]);
+        words.unshift(...groupWords);
+    }
+    return words.join(" ");
+};
+/**
+ * Writes an amount held in whole kuruş in Turkish words, the way an invoice spells it:
+ * 349050 → "üç bin dört yüz doksan Türk lirası elli kuruş".
+ */
+const moneyToWords = (kurus) => {
+    assertKurus(kurus, "moneyToWords");
+    const absolute = Math.abs(kurus);
+    const kurusPart = absolute % 100;
+    const liraPart = (absolute - kurusPart) / 100;
+    const parts = [];
+    if (kurus < 0)
+        parts.push("eksi");
+    // An amount below one lira is read by its kuruş alone; zero still needs a unit to stand on.
+    if (liraPart > 0 || kurusPart === 0) {
+        parts.push(`${numberToWords(liraPart)} Türk lirası`);
+    }
+    if (kurusPart > 0)
+        parts.push(`${numberToWords(kurusPart)} kuruş`);
+    return parts.join(" ");
+};
+
+/** Returns the storage form of a valid Turkish IBAN (upper case, no spaces), or `null`. */
+const normalizeIban = (value) => {
+    assertString(value, "normalizeIban");
+    return parseIban(value);
+};
+
+/** Returns a Turkish phone number in E.164 form ("+905321234567"), or `null`. */
+const normalizePhone = (value) => {
+    assertString(value, "normalizePhone");
+    const phone = parsePhone(value);
+    return phone === null ? null : `+90${phone.national}`;
+};
+
+const DOTTED_DATE_PATTERN = /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/;
+/**
+ * Reads a "dd.MM.yyyy" date into the ISO calendar date "yyyy-MM-dd", or returns `null` when
+ * the text is not a date or names a day that does not exist (31.02.2026).
+ */
+const parseDate = (text) => {
+    assertString(text, "parseDate");
+    const match = DOTTED_DATE_PATTERN.exec(text.trim());
+    if (match === null)
+        return null;
+    const day = Number(match[1]);
+    const month = Number(match[2]);
+    const year = Number(match[3]);
+    if (!isRealDate(year, month, day))
+        return null;
+    return `${padNumber(year, 4)}-${padNumber(month, 2)}-${padNumber(day, 2)}`;
+};
+
+// sign, currency, sign, lira (grouped by dots or plain), kuruş after a comma, currency.
+// The lira part takes dots only as complete thousands groups: "1.250" is 1250 lira, while
+// "1250.50" is not read at all, because guessing what that dot means would invent money.
+const MONEY_PATTERN = /^([+\-−]?)(₺|[Tt][Ll]|[Tt][Rr][Yy])?([+\-−]?)([1-9]\d{0,2}(?:\.\d{3})+|\d+)(?:,(\d{1,2}))?(₺|[Tt][Ll]|[Tt][Rr][Yy])?$/;
+const DOTS = /\./g;
+/** Reads a Turkish-formatted amount into whole kuruş: "3.490,50" → 349050, or `null`. */
+const parseMoney = (text) => {
+    assertString(text, "parseMoney");
+    const match = MONEY_PATTERN.exec(stripWhitespace(text));
+    if (match === null)
+        return null;
+    // The two sign groups always take part in a match, as an empty string when no sign is written.
+    const outerSign = match[1];
+    const innerSign = match[3];
+    const lira = match[4];
+    const kurus = match[5] ?? "";
+    if (outerSign !== "" && innerSign !== "")
+        return null;
+    if (match[2] !== undefined && match[6] !== undefined)
+        return null;
+    // Digits are joined as text and converted once, so no float arithmetic touches the amount.
+    const amount = Number(lira.replace(DOTS, "") + kurus.padEnd(2, "0"));
+    if (!Number.isSafeInteger(amount))
+        return null;
+    const sign = outerSign + innerSign;
+    // A negative zero would print as "-0" in some places and equal 0 in others.
+    return sign !== "" && sign !== "+" && amount !== 0 ? -amount : amount;
+};
+
+const NON_SLUG_CHARACTERS = /[^a-z0-9]+/g;
+// After the pass above a slug holds single hyphens only, so at most one sits at each end.
+const EDGE_HYPHENS = /^-|-$/g;
+/** Builds a URL and file name safe slug: "Şırnak İl Özel İdaresi" → "sirnak-il-ozel-idaresi". */
+const slugify = (text) => {
+    assertString(text, "slugify");
+    return foldText(text)
+        .replace(NON_SLUG_CHARACTERS, "-")
+        .replace(EDGE_HYPHENS, "");
+};
+
+// A letter that starts a word: nothing before it, or something that is not a letter, a digit,
+// a combining mark (a decomposed "ü" must not split its word) or an apostrophe ("Ankara'da").
+const WORD_START = /(?<![\p{L}\p{N}\p{M}'’])\p{L}/gu;
+/** Writes every word with a Turkish upper-case first letter and lower-case rest. */
+const toTitleCase = (text) => {
+    assertString(text, "toTitleCase");
+    return toLowerCase(text).replace(WORD_START, toUpperCase);
+};
+
+exports.DAY_NAMES = DAY_NAMES;
+exports.MONTH_NAMES = MONTH_NAMES;
+exports.PROVINCES = PROVINCES;
+exports.capitalize = capitalize;
+exports.compareTurkish = compareTurkish;
+exports.foldText = foldText;
+exports.formatDate = formatDate;
+exports.formatDateTime = formatDateTime;
+exports.formatIban = formatIban;
+exports.formatMoney = formatMoney;
+exports.formatPhone = formatPhone;
+exports.getDayName = getDayName;
+exports.getMonthName = getMonthName;
+exports.getPhoneType = getPhoneType;
+exports.getProvinceByCode = getProvinceByCode;
+exports.getProvinceByName = getProvinceByName;
+exports.isValidIban = isValidIban;
+exports.isValidLicensePlate = isValidLicensePlate;
+exports.isValidPhone = isValidPhone;
+exports.isValidTckn = isValidTckn;
+exports.isValidVkn = isValidVkn;
+exports.moneyToWords = moneyToWords;
+exports.normalizeIban = normalizeIban;
+exports.normalizePhone = normalizePhone;
+exports.parseDate = parseDate;
+exports.parseMoney = parseMoney;
+exports.slugify = slugify;
+exports.toLowerCase = toLowerCase;
+exports.toTitleCase = toTitleCase;
+exports.toUpperCase = toUpperCase;
+//# sourceMappingURL=index.cjs.map